Merge pull request justadudewhohacks#425 from oyyd/colormap

justadudewhohacks · web-flow · commit 069a26dc8ba9 · 2018-10-07T20:52:27.000+02:00
imgproc: implement applyColorMap
diff --git a/cc/cvTypes/cvTypes.cc b/cc/cvTypes/cvTypes.cc
@@ -209,4 +209,18 @@ void CvTypes::Init(v8::Local<v8::Object> target) {
 	FF_SET_CV_CONSTANT(target, ROTATE_180);
 	FF_SET_CV_CONSTANT(target, ROTATE_90_COUNTERCLOCKWISE);
 #endif
+
+	FF_SET_CV_CONSTANT(target, COLORMAP_AUTUMN);
+	FF_SET_CV_CONSTANT(target, COLORMAP_BONE);
+	FF_SET_CV_CONSTANT(target, COLORMAP_JET);
+	FF_SET_CV_CONSTANT(target, COLORMAP_WINTER);
+	FF_SET_CV_CONSTANT(target, COLORMAP_RAINBOW);
+	FF_SET_CV_CONSTANT(target, COLORMAP_OCEAN);
+	FF_SET_CV_CONSTANT(target, COLORMAP_SUMMER);
+	FF_SET_CV_CONSTANT(target, COLORMAP_SPRING);
+	FF_SET_CV_CONSTANT(target, COLORMAP_COOL);
+	FF_SET_CV_CONSTANT(target, COLORMAP_HSV);
+	FF_SET_CV_CONSTANT(target, COLORMAP_PINK);
+	FF_SET_CV_CONSTANT(target, COLORMAP_HOT);
+	FF_SET_CV_CONSTANT(target, COLORMAP_PARULA);
 }
diff --git a/cc/modules/imgproc/imgproc.cc b/cc/modules/imgproc/imgproc.cc
@@ -29,6 +29,8 @@ NAN_MODULE_INIT(Imgproc::Init) {
   Nan::SetMethod(target, "getPerspectiveTransform", GetPerspectiveTransform);
   Nan::SetMethod(target, "getTextSize", GetTextSize);
   Nan::SetMethod(target, "getTextSizeAsync", GetTextSizeAsync);
+  Nan::SetMethod(target, "applyColorMap", ApplyColorMap);
+  Nan::SetMethod(target, "applyColorMapAsync", ApplyColorMapAsync);
 #if CV_VERSION_MINOR > 1
   Nan::SetMethod(target, "canny", Canny);
 #endif
@@ -171,10 +173,10 @@ NAN_METHOD(Imgproc::Plot1DHist) {
 
   FF_ARG_INSTANCE(0, cv::Mat hist, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
   FF_ARG_INSTANCE(1, cv::Mat plot, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
-  FF_ARG_INSTANCE(2, cv::Vec3d color, Vec3::constructor, FF_UNWRAP_VEC3_AND_GET);											
-  if (1 != hist.cols) {																													
-	return Nan::ThrowError(FF_NEW_STRING("Plot1DHist - hist rows mismatch, expected "	
-	  + std::to_string(1) + ", have " + std::to_string(hist.cols)));		
+  FF_ARG_INSTANCE(2, cv::Vec3d color, Vec3::constructor, FF_UNWRAP_VEC3_AND_GET);
+  if (1 != hist.cols) {
+	return Nan::ThrowError(FF_NEW_STRING("Plot1DHist - hist rows mismatch, expected "
+	  + std::to_string(1) + ", have " + std::to_string(hist.cols)));
   }
   if (hist.channels() != 1) {
     FF_THROW("expected hist to be single channeled");
@@ -292,3 +294,14 @@ NAN_METHOD(Imgproc::Canny) {
 	FF_RETURN(jsMat);
 }
 #endif
+
+
+NAN_METHOD(Imgproc::ApplyColorMap) {
+  FF::SyncBinding(std::make_shared<ImgprocBindings::ApplyColorMapWorker>(),
+                  "Imgproc::ApplyColorMap", info);
+}
+
+NAN_METHOD(Imgproc::ApplyColorMapAsync) {
+  FF::AsyncBinding(std::make_shared<ImgprocBindings::ApplyColorMapWorker>(),
+                   "Imgproc::ApplyColorMapAsync", info);
+}
diff --git a/cc/modules/imgproc/imgproc.h b/cc/modules/imgproc/imgproc.h
@@ -26,6 +26,8 @@ class Imgproc {
 #if CV_VERSION_MINOR > 1
   static NAN_METHOD(Canny);
 #endif
+  static NAN_METHOD(ApplyColorMap);
+  static NAN_METHOD(ApplyColorMapAsync);
 };
 
 #endif
diff --git a/cc/modules/imgproc/imgprocBindings.h b/cc/modules/imgproc/imgprocBindings.h
@@ -1,4 +1,5 @@
 #include "imgproc.h"
+#include <opencv2/imgproc.hpp>
 
 #ifndef __FF_IMGPROCBINDINGS_H_
 #define __FF_IMGPROCBINDINGS_H_
@@ -11,22 +12,22 @@ namespace ImgprocBindings {
     int fontFace;
     double fontScale;
     int thickness;
-  
+
     cv::Size2d returnValue;
     int baseLine;
-  
+
     std::string executeCatchCvExceptionWorker() {
       returnValue = cv::getTextSize(text, fontFace, fontScale, thickness, &baseLine);
       return "";
     }
-  
+
     v8::Local<v8::Value> getReturnValue() {
       v8::Local<v8::Object> ret = Nan::New<v8::Object>();
       Nan::Set(ret, Nan::New("size").ToLocalChecked(), Size::Converter::wrap(returnValue));
       Nan::Set(ret, Nan::New("baseLine").ToLocalChecked(), IntConverter::wrap(baseLine));
       return ret;
     }
-  
+
     bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
       return (
         StringConverter::arg(0, &text, info) ||
@@ -36,8 +37,52 @@ namespace ImgprocBindings {
       );
     }
   };
-  
 
+  struct ApplyColorMapWorker : public CatchCvExceptionWorker {
+  public:
+    cv::Mat src;
+    cv::Mat dst;
+    cv::Mat userColor;
+    int colormap;
+    bool useUserColor = 0;
+
+    bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+#if CV_VERSION_MINOR < 3
+      return (Mat::Converter::arg(0, &src, info) ||
+              IntConverter::optArg(1, &colormap, info));
+#endif
+
+#if CV_VERSION_MINOR >= 3
+      if (info[1]->IsNumber()) {
+        return (Mat::Converter::arg(0, &src, info) ||
+                IntConverter::optArg(1, &colormap, info));
+      }
+
+      useUserColor = 1;
+
+      return (Mat::Converter::arg(0, &src, info) ||
+              Mat::Converter::arg(1, &userColor, info));
+#endif
+    }
+
+    std::string executeCatchCvExceptionWorker() {
+#if CV_VERSION_MINOR < 3
+      cv::applyColorMap(src, dst, colormap);
+      return "";
+#endif
+
+#if CV_VERSION_MINOR >= 3
+      if (useUserColor) {
+        cv::applyColorMap(src, dst, userColor);
+      } else {
+        cv::applyColorMap(src, dst, colormap);
+      }
+      return "";
+#endif
+    }
+
+    v8::Local<v8::Value> getReturnValue() { return Mat::Converter::wrap(dst); }
+  };
 }
 
-#endif
+#endif
diff --git a/examples/applyColorMap.js b/examples/applyColorMap.js
@@ -0,0 +1,8 @@
+const path = require('path');
+const cv = require('../');
+
+const image = cv.imread(path.resolve(__dirname, '../data/Lenna.png'));
+
+const processedImage = cv.applyColorMap(image, cv.COLORMAP_AUTUMN);
+
+cv.imshowWait("applyColorMap", processedImage);
diff --git a/lib/typings/constants.d.ts b/lib/typings/constants.d.ts
@@ -352,6 +352,19 @@ export const COLOR_YUV420sp2GRAY: number;
 export const COLOR_YUV420sp2RGB: number;
 export const COLOR_YUV420sp2RGBA: number;
 export const COLOR_mRGBA2RGBA: number;
+export const COLORMAP_AUTUMN: number;
+export const COLORMAP_BONE: number;
+export const COLORMAP_JET: number;
+export const COLORMAP_WINTER: number;
+export const COLORMAP_RAINBOW: number;
+export const COLORMAP_OCEAN: number;
+export const COLORMAP_SUMMER: number;
+export const COLORMAP_SPRING: number;
+export const COLORMAP_COOL: number;
+export const COLORMAP_HSV: number;
+export const COLORMAP_PINK: number;
+export const COLORMAP_HOT: number;
+export const COLORMAP_PARULA: number;
 export const CV_CONTOURS_MATCH_I1: number;
 export const CV_CONTOURS_MATCH_I2: number;
 export const CV_CONTOURS_MATCH_I3: number;
diff --git a/lib/typings/cv.d.ts b/lib/typings/cv.d.ts
@@ -18,6 +18,7 @@ export interface HistAxes {
   ranges: number[];
 }
 
+export function applyColorMap(src: Mat, colormap: number | Mat): Mat;
 export function blobFromImage(image: Mat, scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean): Mat;
 export function blobFromImageAsync(image: Mat, scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean): Promise<Mat>;
 export function blobFromImages(image: Mat[], scaleFactor?: number, size?: Size, mean?: Vec3, swapRB?: boolean): Mat;
@@ -162,4 +163,4 @@ export function drawTextBox(img: Mat, upperLeft: { x: number, y: number }, textL
 export function isCustomMatAllocatorEnabled(): boolean;
 export function dangerousEnableCustomMatAllocator(): boolean;
 export function dangerousDisableCustomMatAllocator(): boolean;
-export function getMemMetrics(): { TotalAlloc: number, TotalKnownByJS: number, NumAllocations: number, NumDeAllocations: number };
+export function getMemMetrics(): { TotalAlloc: number, TotalKnownByJS: number, NumAllocations: number, NumDeAllocations: number };
diff --git a/test/tests/modules/imgproc/colormapTests.js b/test/tests/modules/imgproc/colormapTests.js
@@ -0,0 +1,63 @@
+const cv = global.dut;
+const { generateAPITests } = global.utils;
+const { expect } = require('chai');
+
+module.exports = () => {
+  describe('applyColorMap', () => {
+    it('should have all colormap types in the "cv" object', () => {
+      const COLORMAP_TYPE_NAMES = [
+        'COLORMAP_AUTUMN',
+        'COLORMAP_BONE',
+        'COLORMAP_JET',
+        'COLORMAP_WINTER',
+        'COLORMAP_RAINBOW',
+        'COLORMAP_OCEAN',
+        'COLORMAP_SUMMER',
+        'COLORMAP_SPRING',
+        'COLORMAP_COOL',
+        'COLORMAP_HSV',
+        'COLORMAP_PINK',
+        'COLORMAP_HOT',
+        'COLORMAP_PARULA',
+      ];
+
+      COLORMAP_TYPE_NAMES.forEach((name) => {
+        expect(typeof cv[name]).to.be.equal('number');
+      });
+    });
+
+    it('should process an image with a type of colormap integer', () => {
+      generateAPITests({
+        getDut: () => cv,
+        methodName: 'applyColorMap',
+        getRequiredArgs: () => ([
+          new cv.Mat([[0, 1, 100]], cv.CV_8UC1),
+          cv.COLORMAP_HOT,
+        ]),
+        hasAsync: true,
+        usesMacroInferno: false,
+        expectOutput: res => {
+          return expect(res).to.be.instanceOf(cv.Mat)
+        },
+      });
+    });
+
+    if (cv.version.minor >= 3) {
+      it('should process an image with a customized colormap', () => {
+        generateAPITests({
+          getDut: () => cv,
+          methodName: 'applyColorMap',
+          getRequiredArgs: () => ([
+            new cv.Mat([[0, 1, 100]], cv.CV_8UC1),
+            new cv.Mat(256, 1, cv.CV_8UC3),
+          ]),
+          hasAsync: true,
+          usesMacroInferno: false,
+          expectOutput: res => {
+            return expect(res).to.be.instanceOf(cv.Mat)
+          },
+        });
+      });
+    }
+  });
+};
diff --git a/test/tests/modules/imgproc/imgproc.test.js b/test/tests/modules/imgproc/imgproc.test.js
@@ -9,6 +9,7 @@ const {
 } = global.utils;
 const { expect } = require('chai');
 const contourTests = require('./contourTests');
+const colormapTests = require('./colormapTests');
 
 describe('imgproc', () => {
   let testImg;
@@ -18,6 +19,7 @@ describe('imgproc', () => {
   });
 
   contourTests();
+  colormapTests();
 
   describe('getStructuringElement', () => {
     const rows = 4;
