Merge pull request #291 from plarsson/master

Fixed return of hog groupRectangles and added getDecisionFunction to svm

Author: justadudewhohacks

cc/modules/machinelearning/SVM.cc

@@ -26,6 +26,7 @@ NAN_MODULE_INIT(SVM::Init) {
   Nan::SetPrototypeMethod(ctor, "predict", Predict);
   Nan::SetPrototypeMethod(ctor, "getSupportVectors", GetSupportVectors);
   Nan::SetPrototypeMethod(ctor, "getUncompressedSupportVectors", GetUncompressedSupportVectors);
+  Nan::SetPrototypeMethod(ctor, "getDecisionFunction", GetDecisionFunction);
   Nan::SetPrototypeMethod(ctor, "calcError", CalcError);
   Nan::SetPrototypeMethod(ctor, "save", Save);
   Nan::SetPrototypeMethod(ctor, "load", Load);
@@ -139,6 +140,25 @@ NAN_METHOD(SVM::GetUncompressedSupportVectors) {
 #endif
 }
 
+NAN_METHOD(SVM::GetDecisionFunction) {
+  FF_METHOD_CONTEXT("SVM::GetDecisionFunction");
+
+  if (!info[0]->IsNumber()) {
+    FF_THROW("expected arg 0 to be a Int");
+  }
+
+  FF_OBJ alpha = FF_NEW_INSTANCE(Mat::constructor);
+  FF_OBJ svidx = FF_NEW_INSTANCE(Mat::constructor);
+  FF_ARG_INT(0, int i);
+  double rho = FF_UNWRAP(info.This(), SVM)->svm->getDecisionFunction(i, FF_UNWRAP_MAT_AND_GET(alpha), FF_UNWRAP_MAT_AND_GET(svidx));
+
+  FF_OBJ ret = FF_NEW_OBJ();
+  Nan::Set(ret, FF_NEW_STRING("rho"), Nan::New((double)rho));
+  Nan::Set(ret, FF_NEW_STRING("alpha"), alpha);
+  Nan::Set(ret, FF_NEW_STRING("svidx"), svidx);
+  FF_RETURN(ret);
+}
+
 NAN_METHOD(SVM::CalcError) {
   FF_METHOD_CONTEXT("SVM::CalcError");
   FF_ARG_INSTANCE(0, cv::Ptr<cv::ml::TrainData> trainData, TrainData::constructor, FF_UNWRAP_TRAINDATA_AND_GET);

cc/modules/machinelearning/SVM.h

@@ -44,6 +44,7 @@ class SVM: public Nan::ObjectWrap {
 	static NAN_METHOD(Predict);
 	static NAN_METHOD(GetSupportVectors);
 	static NAN_METHOD(GetUncompressedSupportVectors);
+	static NAN_METHOD(GetDecisionFunction);
 	static NAN_METHOD(CalcError);
 	static NAN_METHOD(Save);
 	static NAN_METHOD(Load);

cc/modules/objdetect/HOGDescriptorBindings.h

@@ -356,8 +356,7 @@ namespace HOGDescriptorBindings {
     }
 
     v8::Local<v8::Value> getReturnValue() {
-      v8::Local<v8::Object> ret = Nan::New<v8::Object>();
-      return ret;
+      return ObjectArrayConverter<Rect, cv::Rect2d, cv::Rect>::wrap(rectList);
     }
 
     bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {

lib/typings/HOGDescriptor.d.ts

@@ -33,8 +33,8 @@ export class HOGDescriptor {
   detectROIAsync(img: Mat, locations: Point2[], hitThreshold?: number, winStride?: Size, padding?: Size): Promise<{ foundLocations: Point2[], confidences: number[] }>;
   getDaimlerPeopleDetector(): number[];
   getDefaultPeopleDetector(): number[];
-  groupRectangles(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): void;
-  groupRectanglesAsync(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): Promise<void>;
+  groupRectangles(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): Rect[];
+  groupRectanglesAsync(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): Promise<Rect[]>;
   load(path: string): void;
   save(path: string): void;
   setSVMDetector(detector: number[]): void;

lib/typings/SVM.d.ts

@@ -17,6 +17,7 @@ export class SVM {
   constructor(params: { c?: number, coef0?: number, degree?: number, gamma?: number, nu?: number, p?: number, kernelType?: number, classWeights?: Mat });
   calcError(trainData: TrainData, test: boolean): { error: number, responses: Mat };
   getSupportVectors(): Mat;
+  getDecisionFunction(): { rho: number, alpha: Mat, svidx: Mat };
   load(file: string): void;
   predict(sample: number[], flags?: number): number;
   predict(samples: Mat, flags?: number): number[];

test/tests/modules/machinelearning/SVMTests.js

@@ -190,6 +190,15 @@ module.exports = () => {
         });
       });
 
+      describe('getDecisionFunction', () => {
+        it('should return decision function', () => {
+          const ret = svm.getDecisionFunction(0);
+          expect(ret).to.have.property('rho').to.be.a('number');
+          expect(ret).to.have.property('alpha').to.be.instanceOf(cv.Mat);
+          expect(ret).to.have.property('svidx').to.be.instanceOf(cv.Mat);
+        });
+      });
+
       describe('calcError', () => {
         it.skip('calcError', () => {});
       });

test/tests/modules/objdetect/HOGDescriptorTests.js

@@ -412,14 +412,14 @@ module.exports = () => {
     });
 
     describe('groupRectangles', () => {
-      const expectOutput = () => {
-        // expect to not throw
+      const expectOutput = (result) => {
+        expect(result).to.be.an('array');
+        result.forEach(rect => expect(rect).instanceOf(cv.Rect));
       };
-
       const rectList = [new cv.Rect(0, 0, 10, 10), new cv.Rect(0, 0, 20, 20)];
       const weights = [0.5, 1.0];
       const groupThreshold = 1;
-      const eps = 0.5;
+      const eps = 2.0;
 
       generateAPITests({
         getDut: () => getTestHOG(),