Adsk Contrib - Detect C/F order, if not C order : RuntimeError shown, test is still not passing

Author: Asheikhm

src/bindings/python/PyCPUProcessor.cpp

@@ -92,28 +92,34 @@ written to the dstImgDesc image, leaving srcImgDesc unchanged.
 
 )doc")
         .def("applyRGB", [](CPUProcessorRcPtr & self, py::buffer & data) 
-            {
+        {
                 py::buffer_info info = data.request();
                 checkBufferDivisible(info, 3);
 
-                // Interpret as single row of RGB pixels
-                BitDepth bitDepth = getBufferBitDepth(info);
+                // --- detect C-contiguous ---
+                bool isC = true;
+                ptrdiff_t itemsize = info.itemsize;
+                auto shape = info.shape;
+                auto strides = info.strides;
+                py::ssize_t ndim = info.ndim;
 
-                py::gil_scoped_release release;
-                bool isCContiguous = true;
-                if (info.ndim >= 2) 
+                ptrdiff_t expected = itemsize;
+                for (py::ssize_t i = ndim - 1; i >= 0; --i)
                 {
-                    // last dimension stride should be itemsize
-                    if (info.strides.back() != info.itemsize) 
-                    {
-                        isCContiguous = false;
-                    }
+                    if (strides[i] != expected) { isC = false; break; }
+                    expected *= shape[i];
                 }
-                if (!isCContiguous) 
+
+                if (!isC)
                 {
                     throw std::runtime_error("applyRGB only supports C-contiguous (row-major) arrays");
                 }
 
+                // --- proceed normally ---
+                BitDepth bitDepth = getBufferBitDepth(info);
+
+                py::gil_scoped_release release;
+
                 long numChannels = 3;
                 long width = (long)info.size / numChannels;
                 long height = 1;
@@ -128,8 +134,9 @@ written to the dstImgDesc image, leaving srcImgDesc unchanged.
                                     chanStrideBytes, 
                                     xStrideBytes, 
                                     yStrideBytes);
+
                 self->apply(img);
-            },
+        },
              "data"_a, 
              R"doc(
 Apply to a packed RGB array adhering to the Python buffer protocol. 

tests/python/CPUProcessorTest.py

@@ -19,7 +19,7 @@
 
 
 class CPUProcessorTest(unittest.TestCase):
-    FLOAT_DELTA = 1e+5
+    FLOAT_DELTA = 1e-5
     UINT_DELTA = 1
 
     @classmethod
@@ -391,79 +391,53 @@ def test_apply_rgb_buffer_column_major(self):
             return
 
         for arr, cpu_proc_fwd, cpu_proc_inv in [
-            (
-                self.float_rgb_2d,
-                self.default_cpu_proc_fwd,
-                self.default_cpu_proc_inv
-            ),
-            (
-                self.float_rgb_3d,
-                self.default_cpu_proc_fwd,
-                self.default_cpu_proc_inv
-            ),
-            (
-                self.half_rgb_2d, 
-                self.half_cpu_proc_fwd, 
-                self.half_cpu_proc_inv
-            ),
-            (
-                self.half_rgb_3d, 
-                self.half_cpu_proc_fwd, 
-                self.half_cpu_proc_inv
-            ),
-            (
-                self.uint16_rgb_2d, 
-                self.uint16_cpu_proc_fwd, 
-                self.uint16_cpu_proc_inv
-            ),
-            (
-                self.uint16_rgb_3d, 
-                self.uint16_cpu_proc_fwd, 
-                self.uint16_cpu_proc_inv
-            ),
-            (
-                self.uint8_rgb_2d, 
-                self.uint8_cpu_proc_fwd, 
-                self.uint8_cpu_proc_inv
-            ),
-            (
-                self.uint8_rgb_3d, 
-                self.uint8_cpu_proc_fwd, 
-                self.uint8_cpu_proc_inv
-            ),
+            (self.float_rgb_2d, self.default_cpu_proc_fwd, self.default_cpu_proc_inv),
+            (self.float_rgb_3d, self.default_cpu_proc_fwd, self.default_cpu_proc_inv),
+            (self.half_rgb_2d, self.half_cpu_proc_fwd, self.half_cpu_proc_inv),
+            (self.half_rgb_3d, self.half_cpu_proc_fwd, self.half_cpu_proc_inv),
+            (self.uint16_rgb_2d, self.uint16_cpu_proc_fwd, self.uint16_cpu_proc_inv),
+            (self.uint16_rgb_3d, self.uint16_cpu_proc_fwd, self.uint16_cpu_proc_inv),
+            (self.uint8_rgb_2d, self.uint8_cpu_proc_fwd, self.uint8_cpu_proc_inv),
+            (self.uint8_rgb_3d, self.uint8_cpu_proc_fwd, self.uint8_cpu_proc_inv),
         ]:
-            # Transpose to column-major format and
-            # Process duplicate array
+            # Transpose to F-order (column-major)
             arr_copy = arr.copy().T
 
-            cpu_proc_fwd.applyRGB(arr_copy)
-            for i in range(arr_copy.size):
+            # Expect runtime error for non-C-contiguous array
+            with self.assertRaises(RuntimeError):
+                cpu_proc_fwd.applyRGB(arr_copy)
+
+            # Convert back to C-order and retry
+            arr_copy_c = np.ascontiguousarray(arr_copy)
+            cpu_proc_fwd.applyRGB(arr_copy_c)
+
+            # Check forward transform
+            for i in range(arr_copy_c.size):
                 if arr.dtype in (np.float32, np.float16):
                     self.assertAlmostEqual(
-                        arr_copy.flat[i], 
+                        arr_copy_c.flat[i],
                         arr.flat[i] * 0.5,
                         delta=self.FLOAT_DELTA
                     )
                 else:
                     self.assertAlmostEqual(
-                        arr_copy.flat[i], 
+                        arr_copy_c.flat[i],
                         arr.flat[i] // 2,
                         delta=self.UINT_DELTA
                     )
 
-            # Inverse transform roundtrips values in place
-            cpu_proc_inv.applyRGB(arr_copy)
-
-            for i in range(arr_copy.size):
+            # Inverse transform
+            cpu_proc_inv.applyRGB(arr_copy_c)
+            for i in range(arr_copy_c.size):
                 if arr.dtype in (np.float32, np.float16):
                     self.assertAlmostEqual(
-                        arr_copy.flat[i], 
+                        arr_copy_c.flat[i],
                         arr.flat[i],
                         delta=self.FLOAT_DELTA
                     )
                 else:
                     self.assertAlmostEqual(
-                        arr_copy.flat[i], 
+                        arr_copy_c.flat[i],
                         arr.flat[i],
                         delta=self.UINT_DELTA
                     )