remove 1d arrays from the test, since even after Transpose, 1d arrays are still contiguous

Signed-off-by: Afsaneh Sheikhmiri <[email protected]>

Author: Asheikhm

src/bindings/python/PyCPUProcessor.cpp

@@ -92,28 +92,12 @@ 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);
 
                 // --- 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;
-
-                ptrdiff_t expected = itemsize;
-                for (py::ssize_t i = ndim - 1; i >= 0; --i)
-                {
-                    if (strides[i] != expected) { isC = false; break; }
-                    expected *= shape[i];
-                }
-
-                if (!isC)
-                {
-                    throw std::runtime_error("applyRGB only supports C-contiguous (row-major) arrays");
-                }
+                checkCContiguousArray(info);
 
                 // --- proceed normally ---
                 BitDepth bitDepth = getBufferBitDepth(info);
@@ -136,7 +120,7 @@ written to the dstImgDesc image, leaving srcImgDesc unchanged.
                                     yStrideBytes);
 
                 self->apply(img);
-        },
+            },
              "data"_a, 
              R"doc(
 Apply to a packed RGB array adhering to the Python buffer protocol. 
@@ -191,6 +175,8 @@ float values is returned, leaving the input list unchanged.
                 py::buffer_info info = data.request();
                 checkBufferDivisible(info, 4);
 
+                // --- detect C-contiguous ---
+                checkCContiguousArray(info);
                 // Interpret as single row of RGBA pixels
                 BitDepth bitDepth = getBufferBitDepth(info);
 

src/bindings/python/PyUtils.cpp

@@ -179,6 +179,27 @@ void checkBufferType(const py::buffer_info & info, BitDepth bitDepth)
     checkBufferType(info, bitDepthToDtype(bitDepth));
 }
 
+void checkCContiguousArray(const py::buffer_info & info)
+{
+    bool isC = true;
+    ptrdiff_t itemsize = info.itemsize;
+    auto shape = info.shape;
+    auto strides = info.strides;
+    py::ssize_t ndim = info.ndim;
+
+    ptrdiff_t expected = itemsize;
+    for (py::ssize_t i = ndim - 1; i >= 0; --i)
+    {
+        if (strides[i] != expected) { isC = false; break; }
+        expected *= shape[i];
+    }
+
+    if (!isC)
+    {
+        throw std::runtime_error("function only supports C-contiguous (row-major) arrays");
+    }
+}
+
 void checkBufferDivisible(const py::buffer_info & info, py::ssize_t numChannels)
 {
     if (info.size % numChannels != 0)

src/bindings/python/PyUtils.h

@@ -89,6 +89,9 @@ unsigned long getBufferLut3DGridSize(const py::buffer_info & info);
 // Throw if vector size is not divisible by channel count
 void checkVectorDivisible(const std::vector<float> & pixel, size_t numChannels);
 
+// Throw if array is not C-contiguous
+void checkCContiguousArray(const py::buffer_info & info);
+
 } // namespace OCIO_NAMESPACE
 
 #endif // INCLUDED_OCIO_PYUTILS_H

tests/python/CPUProcessorTest.py

@@ -390,15 +390,15 @@ def test_apply_rgb_buffer_column_major(self):
             logger.warning("NumPy not found. Skipping test!")
             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),
+        for arr, cpu_proc_fwd in [
+            (self.float_rgb_2d, self.default_cpu_proc_fwd),
+            (self.float_rgb_3d, self.default_cpu_proc_fwd),
+            (self.half_rgb_2d, self.half_cpu_proc_fwd),
+            (self.half_rgb_3d, self.half_cpu_proc_fwd),
+            (self.uint16_rgb_2d, self.uint16_cpu_proc_fwd),
+            (self.uint16_rgb_3d, self.uint16_cpu_proc_fwd),
+            (self.uint8_rgb_2d, self.uint8_cpu_proc_fwd),
+            (self.uint8_rgb_3d, self.uint8_cpu_proc_fwd),
         ]:
             # Transpose to F-order (column-major)
             arr_copy = arr.copy().T
@@ -407,41 +407,6 @@ def test_apply_rgb_buffer_column_major(self):
             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_c.flat[i],
-                        arr.flat[i] * 0.5,
-                        delta=self.FLOAT_DELTA
-                    )
-                else:
-                    self.assertAlmostEqual(
-                        arr_copy_c.flat[i],
-                        arr.flat[i] // 2,
-                        delta=self.UINT_DELTA
-                    )
-
-            # 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_c.flat[i],
-                        arr.flat[i],
-                        delta=self.FLOAT_DELTA
-                    )
-                else:
-                    self.assertAlmostEqual(
-                        arr_copy_c.flat[i],
-                        arr.flat[i],
-                        delta=self.UINT_DELTA
-                    )
-
     def test_apply_rgb_buffer(self):
         if not np:
             logger.warning("NumPy not found. Skipping test!")
@@ -684,3 +649,48 @@ def test_apply_rgba_buffer(self):
                         arr.flat[i],
                         delta=self.UINT_DELTA
                     )
+
+    def test_apply_rgba_buffer_column_major(self):
+        if not np:
+            logger.warning("NumPy not found. Skipping test!")
+            return
+
+        for arr, cpu_proc_fwd in [
+            (
+                self.float_rgba_2d, 
+                self.default_cpu_proc_fwd
+            ),
+            (
+                self.float_rgba_3d, 
+                self.default_cpu_proc_fwd
+            ),
+            (
+                self.half_rgba_2d, 
+                self.half_cpu_proc_fwd
+            ),
+            (
+                self.half_rgba_3d, 
+                self.half_cpu_proc_fwd
+            ),
+            (
+                self.uint16_rgba_2d, 
+                self.uint16_cpu_proc_fwd
+            ),
+            (
+                self.uint16_rgba_3d, 
+                self.uint16_cpu_proc_fwd
+            ),
+            (
+                self.uint8_rgba_2d, 
+                self.uint8_cpu_proc_fwd
+            ),
+            (
+                self.uint8_rgba_3d, 
+                self.uint8_cpu_proc_fwd,
+            ),
+        ]:
+            # Transpose to F-order (column-major)
+            arr_copy = arr.copy().T
+            # Expect runtime error for non-C-contiguous array
+            with self.assertRaises(RuntimeError):
+                cpu_proc_fwd.applyRGBA(arr_copy)