feat: change width to differe from height

Author: edmBernard

CMakeLists.txt

@@ -48,7 +48,11 @@ SET(SOURCES
 
 #**************************************************************************************************
 # Set compiler **************************************************************************************************
-SET(CMAKE_CXX_FLAGS "-std=c++11 -Wall -O3 -fPIC")
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+  add_compile_options(/std:c++latest /Oy /utf-8)
+else()
+  add_compile_options(-std=c++2a -fPIC -O3)
+endif()
 
 #**************************************************************************************************
 # Linker **************************************************************************************************

tests/cpp/test.cpp

@@ -27,15 +27,45 @@ void show_image(cv::Mat image) {
   cv::waitKey(0);
 }
 
-constexpr int width = 10;
-constexpr int height = 10;
-constexpr int channel = 3;
+constexpr int kWidth = 12;
+constexpr int kHeight = 10;
+constexpr int kChannel = 3;
+
+
+// Return the depth of the matrice element
+// cf. https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a8da9f853b6f3a29d738572fd1ffc44c0
+std::string checkDepth(const cv::Mat& mat) {
+  int depth = mat.depth();
+  switch (depth) {
+    case CV_8U:
+      return "CV_8U";
+    case CV_8S:
+      return "CV_8S";
+    case CV_16U:
+      return "CV_16U";
+    case CV_16S:
+      return "CV_16S";
+    case CV_32S:
+      return "CV_32S";
+    case CV_32F:
+      return "CV_32F";
+    case CV_64F:
+      return "CV_64F";
+    default:
+      throw std::runtime_error("Unknown element type");
+  }
+}
+
+std::tuple<int, int, int> getShape(const cv::Mat& mat) {
+  cv::Size s = mat.size();
+  return {s.height, s.width, mat.channels()};
+}
 
 
 // Generate buffer for a matrix 10x10x3
 std::vector<uint16_t> generateBuffer() {
   std::vector<uint16_t> matrice;
-  const uint16_t size = width * height * channel;
+  const uint16_t size = kWidth * kHeight * kChannel;
   matrice.reserve(size);
   for (uint16_t i = 0; i < size; ++i) {
     matrice.push_back(i);
@@ -48,53 +78,47 @@ std::vector<uint16_t> generateBuffer() {
 // Example of function that return a matrix by value
 cv::Mat generateMatrix() {
   const std::vector<uint16_t> buffer = generateBuffer();
-  return cv::Mat(buffer, true).reshape(3, {10, 10});
+  return cv::Mat(buffer, true).reshape(kChannel, {kHeight, kWidth});
 }
 
 // Example of function that take a matrix as argument
 bool checkMatrixContent(const cv::Mat& mat) {
-  // I don't compare buffer from the matrix with expected buffer to correctly manage slicing.
+  // I don't compare buffer from the matrix with expected buffer to correctly manage non contiguous matrices.
   const std::vector<uint16_t> expectedBuffer = generateBuffer();
+
+  auto [height, width, channel] = getShape(mat);
+  assert(height * width * channel == expectedBuffer.size());
+
   bool match = true;
-  for (int j = 0; j < height; ++j) {
-    for (int i = 0; i < width; ++i) {
-      const cv::Vec3w values = mat.at<cv::Vec3w>(cv::Point(i,j));
-      match &= values(0) == expectedBuffer[j * width * 3 + i * 3 + 0];
-      match &= values(1) == expectedBuffer[j * width * 3 + i * 3 + 1];
-      match &= values(2) == expectedBuffer[j * width * 3 + i * 3 + 2];
+  for (uint16_t i = 0; i < height; ++i) {
+    for (uint16_t j = 0; j < width; ++j) {
+      for (uint16_t c = 0; c < channel; ++c) {
+        const cv::Vec3w values = mat.at<cv::Vec3w>(cv::Point(j,i));
+         match &= values(c) == expectedBuffer[i * width * channel + j * channel + c];
+      }
     }
   }
+
   return match;
 }
 
-// Return the depth of the matrice element
-// cf. https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a8da9f853b6f3a29d738572fd1ffc44c0
-std::string checkDepth(const cv::Mat& mat) {
-  int depth = mat.depth();
-  switch (depth) {
-    case CV_8U:
-      return "CV_8U";
-    case CV_8S:
-      return "CV_8S";
-    case CV_16U:
-      return "CV_16U";
-    case CV_16S:
-      return "CV_16S";
-    case CV_32S:
-      return "CV_32S";
-    case CV_32F:
-      return "CV_32F";
-    case CV_64F:
-      return "CV_64F";
-    default:
-      throw std::runtime_error("Unknown element type");
+// Convert the matrice in a vector to compare
+std::vector<uint16_t> getContentAsVector(const cv::Mat &mat) {
+  auto [height, width, channel] = getShape(mat);
+  int size = height*width*channel;
+  std::vector<uint16_t> buffer;
+  buffer.reserve(size);
+  for (uint16_t i = 0; i < height; ++i) {
+    for (uint16_t j = 0; j < width; ++j) {
+      for (uint16_t c = 0; c < channel; ++c) {
+        const cv::Vec3w values = mat.at<cv::Vec3w>(cv::Point(i,j));
+        buffer.push_back(values(channel));
+      }
+    }
   }
+  return buffer;
 }
 
-std::tuple<int, int, int> getShape(const cv::Mat& mat) {
-  cv::Size s = mat.size();
-  return {s.width, s.height, mat.channels()};
-}
 
 cv::Mat passthru(cv::Mat image) {
   return image;

tests/test_binding.py

@@ -5,23 +5,24 @@
 
 def test_pass_py2cpp():
   mat = generate_matrix()
-  assert(mat.shape == (10, 10, 3))
+  assert(mat.shape == (10, 12, 3))
   assert(mat.flags['C_CONTIGUOUS'])
   assert(mat.dtype == np.uint16)
   assert(tm.check_matrix_content(mat))
+  assert(tm.get_shape(mat) == (10, 12, 3))
 
 
 def test_pass_cpp2py():
   mat =  tm.generate_matrix()
-  assert(mat.shape == (10, 10, 3))
+  assert(mat.shape == (10, 12, 3))
   assert(mat.flags['C_CONTIGUOUS'])
   assert(mat.dtype == np.uint16)
   assert(check_matrix_content(mat))
 
 
 def test_passthough_cpp2cpp():
   mat =  tm.generate_matrix()
-  assert(mat.shape == (10, 10, 3))
+  assert(mat.shape == (10, 12, 3))
   assert(mat.flags['C_CONTIGUOUS'])
   assert(check_matrix_content(mat))
   assert(tm.check_matrix_content(mat))
@@ -31,7 +32,7 @@ def test_passthough_py2py():
   mat =  generate_matrix()
   returned_mat = tm.passthru(mat)
   assert(returned_mat.flags['C_CONTIGUOUS'])
-  assert(returned_mat.shape == (10, 10, 3))
+  assert(returned_mat.shape == (10, 12, 3))
   assert(check_matrix_content(returned_mat))
 
 

tests/utils.py

@@ -2,7 +2,7 @@
 
 
 def generate_matrix():
-  return np.arange(10*10*3, dtype=np.uint16).reshape((10, 10, 3))
+  return np.arange(10*12*3, dtype=np.uint16).reshape((10, 12, 3))
 
 
 def check_matrix_content(mat):