Merge pull request justadudewhohacks#404 from findie/feature/bfmatcher

ADD BFMatcher Class with match, matchAsync, knnMatch and knnMatchAsync

Author: justadudewhohacks

binding.gyp

@@ -91,6 +91,7 @@
 			"cc/modules/features2d/KeyPoint.cc",
 			"cc/modules/features2d/KeyPointMatch.cc",
 			"cc/modules/features2d/DescriptorMatch.cc",
+			"cc/modules/features2d/BFMatcher.cc",
 			"cc/modules/features2d/FeatureDetector.cc",
 			"cc/modules/features2d/descriptorMatching.cc",
 			"cc/modules/features2d/descriptorMatchingKnn.cc",

cc/modules/features2d/BFMatcher.cc

@@ -0,0 +1,82 @@
+#include "BFMatcher.h"
+#include "BFMatcherBindings.h"
+
+Nan::Persistent<v8::FunctionTemplate> BFMatcher::constructor;
+
+NAN_MODULE_INIT(BFMatcher::Init) {
+  v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(BFMatcher::New);
+	v8::Local<v8::ObjectTemplate> instanceTemplate = ctor->InstanceTemplate();
+
+  constructor.Reset(ctor);
+  instanceTemplate->SetInternalFieldCount(1);
+
+   ctor->SetClassName(Nan::New("BFMatcher").ToLocalChecked());
+
+	Nan::SetAccessor(instanceTemplate, Nan::New("normType").ToLocalChecked(), BFMatcher::GetNormType);
+  Nan::SetAccessor(instanceTemplate, Nan::New("crossCheck").ToLocalChecked(), BFMatcher::GetCrossCheck);
+
+    Nan::SetPrototypeMethod(ctor, "match", match);
+    Nan::SetPrototypeMethod(ctor, "matchAsync", matchAsync);
+    Nan::SetPrototypeMethod(ctor, "knnMatch", knnMatch);
+    Nan::SetPrototypeMethod(ctor, "knnMatchAsync", knnMatchAsync);
+
+    target->Set(Nan::New("BFMatcher").ToLocalChecked(), ctor->GetFunction());
+};
+
+NAN_METHOD(BFMatcher::New) {
+	FF_METHOD_CONTEXT("BFMatcher::New");
+	BFMatcher* self = new BFMatcher();
+
+    // optional args
+    bool hasOptArgsObj = FF_HAS_ARG(0) && info[0]->IsObject();
+    FF_OBJ optArgs = hasOptArgsObj ? info[0]->ToObject() : FF_NEW_OBJ();
+
+	FF_GET_NUMBER_IFDEF(optArgs, self->normType, "normType", cv::NORM_L2);
+		FF_GET_BOOL_IFDEF(optArgs, self->crossCheck, "crossCheck", false);
+
+	if (!hasOptArgsObj) {
+		FF_ARG_INT_IFDEF(0, self->normType, self->normType);
+		FF_ARG_BOOL_IFDEF(1, self->crossCheck, self->crossCheck);
+	}
+
+	self->Wrap(info.Holder());
+	self->bfmatcher = cv::BFMatcher(
+		self->normType,
+		self->crossCheck
+	);
+
+  info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(BFMatcher::match) {
+  FF::SyncBinding(
+    std::make_shared<BFMatcherBindings::MatchWorker>(BFMatcher::Converter::unwrap(info.This())),
+    "BFMatcher::match",
+    info
+  );
+}
+
+NAN_METHOD(BFMatcher::matchAsync) {
+  FF::AsyncBinding(
+    std::make_shared<BFMatcherBindings::MatchWorker>(BFMatcher::Converter::unwrap(info.This())),
+    "BFMatcher::matchAsync",
+    info
+  );
+}
+
+NAN_METHOD(BFMatcher::knnMatch) {
+  FF::SyncBinding(
+    std::make_shared<BFMatcherBindings::MatchKnnWorker>(BFMatcher::Converter::unwrap(info.This())),
+    "BFMatcher::knnMatch",
+    info
+  );
+}
+
+
+NAN_METHOD(BFMatcher::knnMatchAsync) {
+  FF::AsyncBinding(
+    std::make_shared<BFMatcherBindings::MatchKnnWorker>(BFMatcher::Converter::unwrap(info.This())),
+    "BFMatcher::knnMatchAsync",
+    info
+  );
+}

cc/modules/features2d/BFMatcher.h

@@ -0,0 +1,41 @@
+#include "macros.h"
+#include <opencv2/core.hpp>
+#include <opencv2/features2d.hpp>
+#include "KeyPoint.h"
+#include "Mat.h"
+#include "CatchCvExceptionWorker.h"
+
+#ifndef __FF_BFMATCHER_H__
+#define __FF_BFMATCHER_H__
+
+class BFMatcher : public Nan::ObjectWrap {
+public:
+    cv::BFMatcher bfmatcher;
+
+	int normType;
+	bool crossCheck;
+
+	static FF_GETTER(BFMatcher, GetNormType, normType)
+	static FF_GETTER(BFMatcher, GetCrossCheck, crossCheck)
+
+  static Nan::Persistent<v8::FunctionTemplate> constructor;
+
+	cv::BFMatcher* getNativeObjectPtr() { return &bfmatcher; }
+	cv::BFMatcher getNativeObject() { return bfmatcher; }
+
+	typedef InstanceConverter<BFMatcher, cv::BFMatcher> Converter;
+
+	static NAN_MODULE_INIT(Init);
+
+    static NAN_METHOD(New);
+    static NAN_METHOD(match);
+    static NAN_METHOD(matchAsync);
+    static NAN_METHOD(knnMatch);
+    static NAN_METHOD(knnMatchAsync);
+
+    static const char* getClassName() {
+        return "BFMatcher";
+    }
+};
+
+#endif

cc/modules/features2d/BFMatcherBindings.h

@@ -0,0 +1,68 @@
+#include "BFMatcher.h"
+#include "DescriptorMatch.h"
+
+#ifndef __FF_BFMATCHERBINDINGS_H_
+#define __FF_BFMATCHERBINDINGS_H_
+
+namespace BFMatcherBindings {
+
+struct MatchWorker : public CatchCvExceptionWorker {
+    public:
+        cv::BFMatcher bfmatcher;
+
+        MatchWorker(cv::BFMatcher _bfmatcher) {
+            this->bfmatcher = _bfmatcher;
+        }
+
+        cv::Mat descFrom;
+        cv::Mat descTo;
+        std::vector<cv::DMatch> dmatches;
+
+        std::string executeCatchCvExceptionWorker() {
+            bfmatcher.match(descFrom, descTo, dmatches);
+            return "";
+        }
+
+        bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+            return Mat::Converter::arg(0, &descFrom, info)
+                || Mat::Converter::arg(1, &descTo, info);
+        }
+
+        FF_VAL getReturnValue() {
+            return ObjectArrayConverter<DescriptorMatch, cv::DMatch>::wrap(dmatches);
+        }
+    };
+
+
+struct MatchKnnWorker : public CatchCvExceptionWorker {
+    public:
+        cv::BFMatcher bfmatcher;
+
+        MatchKnnWorker(cv::BFMatcher _bfmatcher) {
+            this->bfmatcher = _bfmatcher;
+        }
+
+        cv::Mat descFrom;
+        cv::Mat descTo;
+        int k;
+        std::vector<std::vector<cv::DMatch>> dmatches;
+
+        std::string executeCatchCvExceptionWorker() {
+            bfmatcher.knnMatch(descFrom, descTo, dmatches, k);
+            return "";
+        }
+
+        bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+            return Mat::Converter::arg(0, &descFrom, info)
+                || Mat::Converter::arg(1, &descTo, info)
+                || IntConverter::arg(2, &k, info);
+        }
+
+        FF_VAL getReturnValue() {
+            return ObjectArrayOfArraysConverter<DescriptorMatch, cv::DMatch>::wrap(dmatches);
+        }
+};
+
+}
+
+#endif

cc/modules/features2d/features2d.cc

@@ -2,6 +2,7 @@
 #include "KeyPoint.h"
 #include "KeyPointMatch.h"
 #include "DescriptorMatch.h"
+#include "BFMatcher.h"
 #include "descriptorMatching.h"
 #include "descriptorMatchingKnn.h"
 #include "detectors/AGASTDetector.h"
@@ -23,6 +24,7 @@ NAN_MODULE_INIT(Features2d::Init) {
 	AGASTDetector::Init(target);
 	AKAZEDetector::Init(target);
 	BRISKDetector::Init(target);
+	BFMatcher::Init(target);
 	FASTDetector::Init(target);
 	GFTTDetector::Init(target);
 	KAZEDetector::Init(target);
@@ -102,4 +104,4 @@ NAN_METHOD(Features2d::DrawMatches) {
 	FF_OBJ jsMat = FF_NEW_INSTANCE(Mat::constructor);
 	cv::drawMatches(img1, kps1, img2, kps2, dMatches, FF_UNWRAP_MAT_AND_GET(jsMat));
 	FF_RETURN(jsMat);
-}
+}

examples/matchFeatures.js

@@ -51,3 +51,13 @@ const orbMatchesImg = matchFeatures({
 });
 cv.imshowWait('ORB matches', orbMatchesImg);
 
+// Match using the BFMatcher with crossCheck true
+const bf = new cv.BFMatcher(cv.NORM_L2, true);
+const orbBFMatchIMG = matchFeatures({
+    img1,
+    img2,
+    detector: new cv.ORBDetector(),
+    matchFunc: (desc1, desc2) => bf.match(desc1, desc2)
+});
+cv.imshowWait('ORB with BFMatcher - crossCheck true', orbBFMatchIMG);
+

lib/index.d.ts

@@ -23,6 +23,7 @@ export * from './typings/FisherFaceRecognizer.d';
 export * from './typings/KeyPointDetector.d';
 export * from './typings/FeatureDetector.d';
 export * from './typings/AGASTDetector.d';
+export * from './typings/BFMatcher.d';
 export * from './typings/AKAZEDetector.d';
 export * from './typings/BRISKDetector.d';
 export * from './typings/DescriptorMatch.d';

lib/typings/BFMatcher.d.ts

@@ -0,0 +1,11 @@
+import {Mat} from "./Mat";
+import {DescriptorMatch} from "./DescriptorMatch";
+
+export class BFMatcher {
+    constructor(normType: number, crossCheck?: boolean);
+    constructor(params: { normType: number, crossCheck?: boolean });
+    match(descriptors1: Mat, descriptors2: Mat): DescriptorMatch[];
+    matchAsync(descriptors1: Mat, descriptors2: Mat): Promise<DescriptorMatch[]>;
+    knnMatch(descriptors1: Mat, descriptors2: Mat, k: number): Array<[DescriptorMatch]|[]>;
+    knnMatchAsync(descriptors1: Mat, descriptors2: Mat, k: number): Promise<Array<[DescriptorMatch]|[]>>;
+}

package.json

@@ -39,7 +39,7 @@
   "gypfile": true,
   "dependencies": {
     "macro-inferno": "^0.2.1",
-    "nan": "^2.10.0",
+    "nan": "^2.11.0",
     "native-node-utils": "0.1.2",
     "opencv-build": "0.0.14"
   },