Return contour from processImage

Author: taylorjg

src/hello.cpp

@@ -103,7 +103,7 @@ int *processImage(uchar *array, int width, int height) {
   findContours(matBinary, contours, hierarchy, mode, method);
 
   if (contours.empty()) {
-    return 0;
+    return nullptr;
   }
 
   auto areas = vector<double>(contours.size());
@@ -115,9 +115,10 @@ int *processImage(uchar *array, int width, int height) {
 
   auto itMaxArea = max_element(areas.cbegin(), areas.cend());
   auto indexMaxArea = distance(areas.cbegin(), itMaxArea);
-  auto bb = boundingRect(contours[indexMaxArea]);
+  auto contour = contours[indexMaxArea]; // vector<Point>
+  auto bb = boundingRect(contour);
 
-  auto corners = findCorners(contours[indexMaxArea]);
+  auto corners = findCorners(contour);
   Mat matUnwarped;
   applyWarpPerspective(matNormalised, matUnwarped, corners);
 
@@ -131,13 +132,22 @@ int *processImage(uchar *array, int width, int height) {
   int return_image_2_channels = matUnwarped.channels();
   int return_image_2_size = return_image_2_width * return_image_2_height * return_image_2_channels;
 
-  int return_data_size = 20 * sizeof(int) + return_image_1_size + return_image_2_size;
-  int *return_data = reinterpret_cast<int*>(malloc(return_data_size));
-  uchar *return_image_1_addr = reinterpret_cast<uchar*>(&return_data[20]);
+  int numContourPoints = contour.size();
+  int return_contour_size = numContourPoints * 2 * sizeof(int);
+
+  int return_data_size = 22 * sizeof(int) + return_image_1_size + return_image_2_size + return_contour_size;
+  int *return_data = static_cast<int*>(malloc(return_data_size));
+  uchar *return_image_1_addr = reinterpret_cast<uchar*>(&return_data[22]);
   uchar *return_image_2_addr = return_image_1_addr + return_image_1_size;
+  int *return_contour_addr = reinterpret_cast<int*>(return_image_2_addr + return_image_2_size);
   memcpy(return_image_1_addr, matNormalised.data, return_image_1_size);
   memcpy(return_image_2_addr, matUnwarped.data, return_image_2_size);
 
+  for (auto i = 0; i < numContourPoints; i++) {
+    return_contour_addr[i * 2] = contour[i].x;
+    return_contour_addr[i * 2 + 1] = contour[i].y;
+  }
+
   return_data[0] = bb.x;
   return_data[1] = bb.y;
   return_data[2] = bb.width;
@@ -158,6 +168,9 @@ int *processImage(uchar *array, int width, int height) {
   return_data[17] = corners[2].y;
   return_data[18] = corners[3].x;
   return_data[19] = corners[3].y;
+  return_data[20] = numContourPoints;
+  return_data[21] = reinterpret_cast<int>(return_contour_addr);
+
   return return_data;
 }
 

src/index.js

@@ -159,18 +159,26 @@ const onProcessImage = (module, processImage) => () => {
   const elapsedTime = document.getElementById('elapsed-time')
   elapsedTime.innerText = (endTime - startTime).toFixed(2)
   const returnDataAddr = addr / module.HEAP32.BYTES_PER_ELEMENT
-  const returnData = module.HEAP32.slice(returnDataAddr, returnDataAddr + 20)
+  const returnData = module.HEAP32.slice(returnDataAddr, returnDataAddr + 22)
   const [
     bbx, bby, bbw, bbh,
     outImage1Width, outImage1Height, outImage1Channels, outImage1Addr,
-    outImage2Width, outImage2Height, outImage2Channels, outImage2Addr
+    outImage2Width, outImage2Height, outImage2Channels, outImage2Addr,
+    , , , , , , , , // corners
+    numContourPoints, contourAddr
   ] = returnData
   const boundingBox1 = [bbx, bby, bbw, bbh]
   const corners = range(4).map(cornerIndex => ({
     x: returnData[12 + cornerIndex * 2],
     y: returnData[12 + cornerIndex * 2 + 1]
   }))
 
+  console.log('numContourPoints:', numContourPoints)
+  console.log('contourAddr:', contourAddr)
+  const contourAddr32 = contourAddr / module.HEAP32.BYTES_PER_ELEMENT
+  const contourPointsData = module.HEAP32.slice(contourAddr32, contourAddr32 + numContourPoints)
+  console.dir(contourPointsData)
+
   const outImage1DataSize = outImage1Width * outImage1Height * outImage1Channels
   const outImage1Data = module.HEAPU8.slice(outImage1Addr, outImage1Addr + outImage1DataSize)
   const imageData1 = outImage1Channels === 1