Skip to content
This repository was archived by the owner on Oct 18, 2023. It is now read-only.

Commit d7bacab

Browse files
justadudewhohacksjustadudewhohacks
authored
Merge pull request justadudewhohacks#65 from justadudewhohacks/deepneuralnets
deep neural nets
2 parents 39b83b0 + f695c0e commit d7bacab

File tree

20 files changed

+783
-1
lines changed

20 files changed

+783
-1
lines changed

‎.gitignore

+2-1
Original file line numberDiff line numberDiff line change
@@ -7,4 +7,5 @@ node_modules
77
crash.log
88
coverage
99
coverage-report
10-
tmpdata
10+
tmpdata
11+
data/dnn

‎binding.gyp

+2
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,8 @@
5353
"cc/modules/machinelearning/StatModel.cc",
5454
"cc/modules/machinelearning/SVM.cc",
5555
"cc/modules/machinelearning/TrainData.cc",
56+
"cc/modules/dnn/dnn.cc",
57+
"cc/modules/dnn/Net.cc",
5658
"cc/modules/face/face.cc",
5759
"cc/modules/face/FaceRecognizer.cc",
5860
"cc/modules/face/EigenFaceRecognizer.cc",

‎cc/core/Mat.cc

+81
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,10 @@ NAN_MODULE_INIT(Mat::Init) {
4646
Nan::SetPrototypeMethod(ctor, "addWeightedAsync", AddWeightedAsync);
4747
Nan::SetPrototypeMethod(ctor, "minMaxLoc", MinMaxLoc);
4848
Nan::SetPrototypeMethod(ctor, "minMaxLocAsync", MinMaxLocAsync);
49+
Nan::SetPrototypeMethod(ctor, "findNonZero", FindNonZero);
50+
Nan::SetPrototypeMethod(ctor, "findNonZeroAsync", FindNonZeroAsync);
51+
Nan::SetPrototypeMethod(ctor, "padToSquare", PadToSquare);
52+
Nan::SetPrototypeMethod(ctor, "padToSquareAsync", PadToSquareAsync);
4953
Nan::SetPrototypeMethod(ctor, "dct", Dct);
5054
Nan::SetPrototypeMethod(ctor, "dctAsync", DctAsync);
5155
Nan::SetPrototypeMethod(ctor, "idct", Idct);
@@ -652,6 +656,83 @@ NAN_METHOD(Mat::MinMaxLocAsync) {
652656
FF_WORKER_ASYNC("Mat::MinMaxLocAsync", MinMaxLocWorker, worker);
653657
}
654658

659+
struct Mat::FindNonZeroWorker : public SimpleWorker {
660+
public:
661+
cv::Mat self;
662+
FindNonZeroWorker(cv::Mat self) {
663+
this->self = self;
664+
}
665+
666+
std::vector<cv::Point> idx;
667+
668+
const char* execute() {
669+
cv::findNonZero(self, idx);
670+
return "";
671+
}
672+
673+
v8::Local<v8::Value> getReturnValue() {
674+
return ObjectArrayConverter<Point2, cv::Point2d, cv::Point>::wrap(idx);
675+
}
676+
};
677+
678+
NAN_METHOD(Mat::FindNonZero) {
679+
FindNonZeroWorker worker(Mat::Converter::unwrap(info.This()));
680+
FF_WORKER_SYNC("Mat::FindNonZero", worker);
681+
info.GetReturnValue().Set(worker.getReturnValue());
682+
}
683+
684+
NAN_METHOD(Mat::FindNonZeroAsync) {
685+
FindNonZeroWorker worker(Mat::Converter::unwrap(info.This()));
686+
FF_WORKER_ASYNC("Mat::FindNonZeroAsync", FindNonZeroWorker, worker);
687+
}
688+
689+
690+
struct Mat::PadToSquareWorker : public SimpleWorker {
691+
public:
692+
cv::Mat self;
693+
PadToSquareWorker(cv::Mat self) {
694+
this->self = self;
695+
}
696+
697+
cv::Vec3d fillVec = cv::Vec3d();
698+
cv::Mat out;
699+
const char* execute() {
700+
int maxDim = (std::max)(self.cols, self.rows);
701+
out = cv::Mat(maxDim, maxDim, self.type(), (cv::Vec3b)fillVec);
702+
703+
int offX = 0, offY = 0;
704+
if (self.cols > self.rows) {
705+
offY = (self.cols - self.rows) / 2;
706+
}
707+
else {
708+
offX = (self.rows - self.cols) / 2;
709+
}
710+
cv::Mat roi = out(cv::Rect(offX, offY, self.cols, self.rows));
711+
self.copyTo(roi);
712+
713+
return "";
714+
}
715+
716+
v8::Local<v8::Value> getReturnValue() {
717+
return Mat::Converter::wrap(out);
718+
}
719+
720+
bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
721+
return Vec3::Converter::optArg(0, &fillVec, info);
722+
}
723+
};
724+
725+
NAN_METHOD(Mat::PadToSquare) {
726+
PadToSquareWorker worker(Mat::Converter::unwrap(info.This()));
727+
FF_WORKER_SYNC("Mat::PadToSquare", worker);
728+
info.GetReturnValue().Set(worker.getReturnValue());
729+
}
730+
731+
NAN_METHOD(Mat::PadToSquareAsync) {
732+
PadToSquareWorker worker(Mat::Converter::unwrap(info.This()));
733+
FF_WORKER_ASYNC("Mat::PadToSquareAsync", PadToSquareWorker, worker);
734+
}
735+
655736
struct Mat::DTWorker : public SimpleWorker {
656737
public:
657738
cv::Mat mat;

‎cc/core/Mat.h

+9
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,15 @@ class Mat : public Nan::ObjectWrap {
6464
static NAN_METHOD(MinMaxLoc);
6565
static NAN_METHOD(MinMaxLocAsync);
6666

67+
struct FindNonZeroWorker;
68+
static NAN_METHOD(FindNonZero);
69+
static NAN_METHOD(FindNonZeroAsync);
70+
71+
struct PadToSquareWorker;
72+
static NAN_METHOD(PadToSquare);
73+
static NAN_METHOD(PadToSquareAsync);
74+
75+
6776
FF_INIT_MAT_OPERATIONS();
6877
static NAN_METHOD(Dot) {
6978
FF_OPERATOR_RET_SCALAR(&cv::Mat::dot, FF_APPLY_CLASS_FUNC, FF_UNWRAP_MAT_AND_GET, Mat);

‎cc/modules/dnn/Net.cc

+114
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,114 @@
1+
#include "opencv2/core.hpp"
2+
3+
#if CV_VERSION_MINOR > 2
4+
5+
#ifdef HAVE_DNN
6+
7+
#include "Net.h"
8+
#include "Workers.h"
9+
#include "Mat.h"
10+
11+
Nan::Persistent<v8::FunctionTemplate> Net::constructor;
12+
13+
NAN_MODULE_INIT(Net::Init) {
14+
v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(Net::New);
15+
Net::constructor.Reset(ctor);
16+
ctor->InstanceTemplate()->SetInternalFieldCount(1);
17+
ctor->SetClassName(Nan::New("Net").ToLocalChecked());
18+
19+
Nan::SetPrototypeMethod(ctor, "setInput", SetInput);
20+
Nan::SetPrototypeMethod(ctor, "setInputAsync", SetInputAsync);
21+
Nan::SetPrototypeMethod(ctor, "forward", Forward);
22+
Nan::SetPrototypeMethod(ctor, "forwardAsync", ForwardAsync);
23+
24+
target->Set(Nan::New("Net").ToLocalChecked(), ctor->GetFunction());
25+
};
26+
27+
NAN_METHOD(Net::New) {
28+
Net* self = new Net();
29+
self->Wrap(info.Holder());
30+
info.GetReturnValue().Set(info.Holder());
31+
}
32+
33+
struct Net::SetInputWorker : public SimpleWorker {
34+
public:
35+
cv::dnn::Net self;
36+
SetInputWorker(cv::dnn::Net self) {
37+
this->self = self;
38+
}
39+
40+
cv::Mat blob;
41+
std::string name = "";
42+
43+
44+
const char* execute() {
45+
self.setInput(blob, name);
46+
return "";
47+
}
48+
49+
bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
50+
return (
51+
Mat::Converter::arg(0, &blob, info)
52+
);
53+
}
54+
55+
bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
56+
return (
57+
StringConverter::optArg(1, &name, info)
58+
);
59+
}
60+
};
61+
62+
NAN_METHOD(Net::SetInput) {
63+
SetInputWorker worker(Net::Converter::unwrap(info.This()));
64+
FF_WORKER_SYNC("Net::SetInput", worker);
65+
info.GetReturnValue().Set(worker.getReturnValue());
66+
}
67+
68+
NAN_METHOD(Net::SetInputAsync) {
69+
SetInputWorker worker(Net::Converter::unwrap(info.This()));
70+
FF_WORKER_ASYNC("Net::SetInputAsync", SetInputWorker, worker);
71+
}
72+
73+
74+
struct Net::ForwardWorker : public SimpleWorker {
75+
public:
76+
cv::dnn::Net self;
77+
ForwardWorker(cv::dnn::Net self) {
78+
this->self = self;
79+
}
80+
81+
std::string outputName = "";
82+
83+
cv::Mat returnValue;
84+
85+
const char* execute() {
86+
returnValue = self.forward(outputName);
87+
return "";
88+
}
89+
90+
v8::Local<v8::Value> getReturnValue() {
91+
return Mat::Converter::wrap(returnValue);
92+
}
93+
94+
bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
95+
return (
96+
StringConverter::optArg(0, &outputName, info)
97+
);
98+
}
99+
};
100+
101+
NAN_METHOD(Net::Forward) {
102+
ForwardWorker worker(Net::Converter::unwrap(info.This()));
103+
FF_WORKER_SYNC("Net::Forward", worker);
104+
info.GetReturnValue().Set(worker.getReturnValue());
105+
}
106+
107+
NAN_METHOD(Net::ForwardAsync) {
108+
ForwardWorker worker(Net::Converter::unwrap(info.This()));
109+
FF_WORKER_ASYNC("Net::ForwardAsync", ForwardWorker, worker);
110+
}
111+
112+
#endif
113+
114+
#endif

‎cc/modules/dnn/Net.h

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
#include "Converters.h"
2+
#include "opencv2/dnn.hpp"
3+
4+
#ifndef __FF_NET_H__
5+
#define __FF_NET_H__
6+
7+
class Net : public Nan::ObjectWrap {
8+
public:
9+
cv::dnn::Net net;
10+
11+
static NAN_MODULE_INIT(Init);
12+
static NAN_METHOD(New);
13+
14+
struct SetInputWorker;
15+
static NAN_METHOD(SetInput);
16+
static NAN_METHOD(SetInputAsync);
17+
18+
struct ForwardWorker;
19+
static NAN_METHOD(Forward);
20+
static NAN_METHOD(ForwardAsync);
21+
22+
static Nan::Persistent<v8::FunctionTemplate> constructor;
23+
24+
cv::dnn::Net* getNativeObjectPtr() { return &net; }
25+
cv::dnn::Net getNativeObject() { return net; }
26+
27+
typedef InstanceConverter<Net, cv::dnn::Net> Converter;
28+
29+
static const char* getClassName() {
30+
return "Net";
31+
}
32+
};
33+
34+
#endif

0 commit comments

Comments
 (0)