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

Commit 113a006

Browse files
nicholascnicholasc
committed
Updated Facemark API to match newer node utils
1 parent e73b493 commit 113a006

File tree

7 files changed

+231
-210
lines changed

7 files changed

+231
-210
lines changed

‎binding.gyp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -68,6 +68,7 @@
6868
"cc/modules/face/LBPHFaceRecognizer.cc",
6969
"cc/modules/face/Facemark.cc",
7070
"cc/modules/face/FacemarkAAM.cc",
71+
"cc/modules/face/FacemarkAAMData.cc",
7172
"cc/modules/face/FacemarkAAMParams.cc",
7273
"cc/modules/face/FacemarkLBF.cc",
7374
"cc/modules/face/FacemarkLBFParams.cc",

‎cc/modules/face/Facemark.cc

Lines changed: 88 additions & 187 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,19 @@
11
#ifdef HAVE_FACE
22

33
#include "Facemark.h"
4-
#include "FacemarkAAMData.h"
4+
#include "FacemarkBindings.h"
5+
6+
NAN_METHOD(Facemark::Save) {
7+
FF_METHOD_CONTEXT("Facemark::Save");
8+
FF_ARG_STRING(0, std::string path);
9+
FF_UNWRAP(info.This(), Facemark)->save(path);
10+
}
11+
12+
NAN_METHOD(Facemark::Load) {
13+
FF_METHOD_CONTEXT("Facemark::Load");
14+
FF_ARG_STRING(0, std::string path);
15+
FF_UNWRAP(info.This(), Facemark)->load(path);
16+
}
517

618
void Facemark::Init(v8::Local<v8::FunctionTemplate> ctor) {
719
Nan::SetPrototypeMethod(ctor, "addTrainingSample", AddTrainingSample);
@@ -22,156 +34,68 @@ void Facemark::Init(v8::Local<v8::FunctionTemplate> ctor) {
2234
Nan::SetPrototypeMethod(ctor, "load", Load);
2335
};
2436

25-
struct Facemark::AddTrainingSampleWorker : public SimpleWorker {
26-
public:
27-
cv::Ptr<cv::face::Facemark> self;
28-
AddTrainingSampleWorker(cv::Ptr<cv::face::Facemark> self) {
29-
this->self = self;
30-
}
31-
32-
bool results;
33-
cv::Mat image;
34-
std::vector<cv::Point2f> landmarks;
35-
36-
const char *execute() {
37-
results = self->addTrainingSample(image, landmarks);
38-
return "";
39-
}
40-
41-
v8::Local<v8::Value> getReturnValue() {
42-
v8::Local<v8::Value> ret = Nan::New<v8::Boolean>(results);
43-
return ret;
44-
}
45-
46-
bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
47-
return (Mat::Converter::arg(0, &image, info) ||
48-
ObjectArrayConverter<Point2, cv::Point2d, cv::Point2f>::arg(
49-
1, &landmarks, info));
50-
}
51-
};
52-
5337
NAN_METHOD(Facemark::AddTrainingSample) {
54-
AddTrainingSampleWorker worker(
55-
FF_UNWRAP(info.This(), Facemark)->getFacemark());
56-
FF_WORKER_SYNC("Facemark::AddTrainingSample", worker);
57-
info.GetReturnValue().Set(worker.getReturnValue());
38+
FF::SyncBinding(
39+
std::make_shared<FacemarkBindings::AddTrainingSampleWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
40+
"Facemark::AddTrainingSample",
41+
info
42+
);
5843
}
5944

6045
NAN_METHOD(Facemark::AddTrainingSampleAsync) {
61-
AddTrainingSampleWorker worker(
62-
FF_UNWRAP(info.This(), Facemark)->getFacemark());
63-
FF_WORKER_ASYNC("Facemark::AddTrainingSampleAsync", AddTrainingSampleWorker,
64-
worker);
46+
FF::AsyncBinding(
47+
std::make_shared<FacemarkBindings::AddTrainingSampleWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
48+
"Facemark::AddTrainingSampleAsync",
49+
info
50+
);
6551
}
6652

67-
struct Facemark::LoadModelWorker : public SimpleWorker {
68-
public:
69-
cv::Ptr<cv::face::Facemark> self;
70-
LoadModelWorker(cv::Ptr<cv::face::Facemark> self) { this->self = self; }
71-
72-
std::string model;
73-
74-
const char *execute() {
75-
self->loadModel(model);
76-
return "";
77-
}
78-
79-
bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
80-
return (StringConverter::arg(0, &model, info));
81-
}
82-
};
83-
8453
NAN_METHOD(Facemark::LoadModel) {
85-
LoadModelWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
86-
FF_WORKER_SYNC("Facemark::LoadModel", worker);
87-
info.GetReturnValue().Set(worker.getReturnValue());
54+
FF::SyncBinding(
55+
std::make_shared<FacemarkBindings::LoadModelWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
56+
"Facemark::LoadModel",
57+
info
58+
);
8859
}
8960

9061
NAN_METHOD(Facemark::LoadModelAsync) {
91-
LoadModelWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
92-
FF_WORKER_ASYNC("Facemark::LoadModelAsync", LoadModelWorker, worker);
62+
FF::AsyncBinding(
63+
std::make_shared<FacemarkBindings::LoadModelWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
64+
"Facemark::LoadModelAsync",
65+
info
66+
);
9367
}
9468

95-
struct Facemark::GetDataWorker : public SimpleWorker {
96-
public:
97-
cv::Ptr<cv::face::Facemark> self;
98-
GetDataWorker(cv::Ptr<cv::face::Facemark> self) { this->self = self; }
99-
100-
cv::face::FacemarkAAM::Data data;
101-
102-
const char *execute() {
103-
self->getData(&data);
104-
return "";
105-
}
106-
107-
v8::Local<v8::Value> getReturnValue() {
108-
v8::Local<v8::Value> ret = InstanceConverter<FacemarkAAMData, cv::face::FacemarkAAM::Data>::wrap(data);
109-
return ret;
110-
}
111-
};
112-
11369
NAN_METHOD(Facemark::GetData) {
114-
GetDataWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
115-
FF_WORKER_SYNC("Facemark::GetData", worker);
116-
info.GetReturnValue().Set(worker.getReturnValue());
70+
FF::SyncBinding(
71+
std::make_shared<FacemarkBindings::GetDataWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
72+
"Facemark::GetData",
73+
info
74+
);
11775
}
11876

11977
NAN_METHOD(Facemark::GetDataAsync) {
120-
GetDataWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
121-
FF_WORKER_ASYNC("Facemark::GetDataAsync", GetDataWorker, worker);
78+
FF::AsyncBinding(
79+
std::make_shared<FacemarkBindings::GetDataWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
80+
"Facemark::GetDataAsync",
81+
info
82+
);
12283
}
12384

124-
struct Facemark::GetFacesWorker : public SimpleWorker {
125-
public:
126-
cv::Ptr<cv::face::Facemark> self;
127-
GetFacesWorker(cv::Ptr<cv::face::Facemark> self) { this->self = self; }
128-
129-
cv::Mat image;
130-
std::vector<cv::Rect> faces;
131-
132-
const char *execute() {
133-
self->getFaces(image, faces);
134-
return "";
135-
}
136-
137-
v8::Local<v8::Value> getReturnValue() {
138-
v8::Local<v8::Value> ret =
139-
ObjectArrayConverter<Rect, cv::Rect>::wrap(faces);
140-
return ret;
141-
}
142-
143-
bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
144-
return (Mat::Converter::arg(0, &image, info));
145-
}
146-
};
147-
14885
NAN_METHOD(Facemark::GetFaces) {
149-
GetFacesWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
150-
FF_WORKER_SYNC("Facemark::GetFaces", worker);
151-
info.GetReturnValue().Set(worker.getReturnValue());
86+
FF::SyncBinding(
87+
std::make_shared<FacemarkBindings::GetFacesWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
88+
"Facemark::GetFaces",
89+
info
90+
);
15291
}
15392

15493
NAN_METHOD(Facemark::GetFacesAsync) {
155-
GetFacesWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
156-
FF_WORKER_ASYNC("Facemark::GetFacesAsync", GetFacesWorker, worker);
157-
}
158-
159-
bool Facemark::detector(cv::InputArray image, cv::OutputArray faces,
160-
Nan::Callback *callback) {
161-
Nan::HandleScope scope;
162-
163-
cv::Mat frame = image.getMat().clone();
164-
v8::Local<v8::Value> jsMat = Mat::Converter::wrap(frame);
165-
166-
v8::Local<v8::Value> argv[] = {jsMat};
167-
FF_OBJ jsObject = callback->Call(1, argv)->ToObject();
168-
169-
std::vector<cv::Rect> _faces;
170-
ObjectArrayConverter<Rect, cv::Rect>::unwrap(&_faces, jsObject);
171-
172-
cv::Mat(_faces).copyTo(faces);
173-
174-
return true;
94+
FF::AsyncBinding(
95+
std::make_shared<FacemarkBindings::GetFacesWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
96+
"Facemark::GetFacesAsync",
97+
info
98+
);
17599
}
176100

177101
NAN_METHOD(Facemark::SetFaceDetector) {
@@ -184,7 +108,6 @@ NAN_METHOD(Facemark::SetFaceDetector) {
184108
}
185109

186110
FF_ARG_FUNC(0, v8::Local<v8::Function> cbFunc);
187-
188111
Nan::Callback *callback = new Nan::Callback(cbFunc);
189112

190113
bool results = FF_UNWRAP(info.This(), Facemark)
@@ -194,76 +117,54 @@ NAN_METHOD(Facemark::SetFaceDetector) {
194117
info.GetReturnValue().Set(Nan::New<v8::Boolean>(results));
195118
}
196119

197-
struct Facemark::TrainingWorker : public SimpleWorker {
198-
public:
199-
cv::Ptr<cv::face::Facemark> self;
200-
TrainingWorker(cv::Ptr<cv::face::Facemark> self) { this->self = self; }
201-
202-
const char *execute() {
203-
self->training();
204-
return "";
205-
}
206-
};
207-
208120
NAN_METHOD(Facemark::Training) {
209-
TrainingWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
210-
FF_WORKER_SYNC("Facemark::Train", worker);
211-
info.GetReturnValue().Set(worker.getReturnValue());
121+
FF::SyncBinding(
122+
std::make_shared<FacemarkBindings::TrainingWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
123+
"Facemark::Train",
124+
info
125+
);
212126
}
213127

214128
NAN_METHOD(Facemark::TrainingAsync) {
215-
TrainingWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
216-
FF_WORKER_ASYNC("Facemark::TrainAsync", TrainingWorker, worker);
129+
FF::AsyncBinding(
130+
std::make_shared<FacemarkBindings::TrainingWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
131+
"Facemark::TrainAsync",
132+
info
133+
);
217134
}
218135

219-
struct Facemark::FitWorker : public SimpleWorker {
220-
public:
221-
cv::Ptr<cv::face::Facemark> self;
222-
FitWorker(cv::Ptr<cv::face::Facemark> self) { this->self = self; }
223-
224-
cv::Mat image;
225-
std::vector<cv::Rect> faces;
226-
std::vector<std::vector<cv::Point2f>> landmarks;
227-
228-
const char *execute() {
229-
self->fit(image, faces, landmarks);
230-
return "";
231-
}
232-
233-
v8::Local<v8::Value> getReturnValue() {
234-
v8::Local<v8::Value> ret =
235-
ObjectArrayOfArraysConverter<Point2, cv::Point2d, cv::Point2f>::wrap(
236-
landmarks);
237-
return ret;
238-
}
239-
240-
bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
241-
return (Mat::Converter::arg(0, &image, info) ||
242-
ObjectArrayConverter<Rect, cv::Rect>::arg(1, &faces, info));
243-
}
244-
};
245-
246136
NAN_METHOD(Facemark::Fit) {
247-
FitWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
248-
FF_WORKER_SYNC("Facemark::Fit", worker);
249-
info.GetReturnValue().Set(worker.getReturnValue());
137+
FF::SyncBinding(
138+
std::make_shared<FacemarkBindings::FitWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
139+
"Facemark::Fit",
140+
info
141+
);
250142
}
251143

252144
NAN_METHOD(Facemark::FitAsync) {
253-
FitWorker worker(FF_UNWRAP(info.This(), Facemark)->getFacemark());
254-
FF_WORKER_ASYNC("Facemark::FitAsync", FitWorker, worker);
145+
FF::AsyncBinding(
146+
std::make_shared<FacemarkBindings::FitWorker>(FF_UNWRAP(info.This(), Facemark)->getFacemark()),
147+
"Facemark::FitAsync",
148+
info
149+
);
255150
}
256151

257-
NAN_METHOD(Facemark::Save) {
258-
FF_METHOD_CONTEXT("Facemark::Save");
259-
FF_ARG_STRING(0, std::string path);
260-
FF_UNWRAP(info.This(), Facemark)->save(path);
261-
}
152+
bool Facemark::detector(cv::InputArray image, cv::OutputArray faces,
153+
Nan::Callback *callback) {
154+
Nan::HandleScope scope;
262155

263-
NAN_METHOD(Facemark::Load) {
264-
FF_METHOD_CONTEXT("Facemark::Load");
265-
FF_ARG_STRING(0, std::string path);
266-
FF_UNWRAP(info.This(), Facemark)->load(path);
156+
cv::Mat frame = image.getMat().clone();
157+
v8::Local<v8::Value> jsMat = Mat::Converter::wrap(frame);
158+
159+
v8::Local<v8::Value> argv[] = {jsMat};
160+
FF_OBJ jsObject = callback->Call(1, argv)->ToObject();
161+
162+
std::vector<cv::Rect> _faces;
163+
ObjectArrayConverter<Rect, cv::Rect>::unwrap(&_faces, jsObject);
164+
165+
cv::Mat(_faces).copyTo(faces);
166+
167+
return true;
267168
}
268169

269170
#endif

‎cc/modules/face/Facemark.h

Lines changed: 5 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
1-
#include "Converters.h"
1+
#include "NativeNodeUtils.h"
22
#include "Mat.h"
33
#include "Point.h"
44
#include "Rect.h"
5-
#include "Workers.h"
65
#include "macros.h"
76
#include <iostream>
87
#include <opencv2/face.hpp>
@@ -17,39 +16,25 @@ class Facemark : public Nan::ObjectWrap {
1716
virtual void load(std::string) = 0;
1817

1918
static void Init(v8::Local<v8::FunctionTemplate>);
20-
21-
struct AddTrainingSampleWorker;
19+
2220
static NAN_METHOD(AddTrainingSample);
2321
static NAN_METHOD(AddTrainingSampleAsync);
24-
25-
struct LoadModelWorker;
2622
static NAN_METHOD(LoadModel);
2723
static NAN_METHOD(LoadModelAsync);
28-
29-
struct GetDataWorker;
3024
static NAN_METHOD(GetData);
3125
static NAN_METHOD(GetDataAsync);
32-
33-
struct GetFacesWorker;
3426
static NAN_METHOD(GetFaces);
3527
static NAN_METHOD(GetFacesAsync);
36-
37-
static bool detector(cv::InputArray image, cv::OutputArray faces,
38-
Nan::Callback *callback);
39-
40-
struct SetFaceDetectorWorker;
4128
static NAN_METHOD(SetFaceDetector);
42-
43-
struct TrainingWorker;
4429
static NAN_METHOD(Training);
4530
static NAN_METHOD(TrainingAsync);
46-
47-
struct FitWorker;
4831
static NAN_METHOD(Fit);
4932
static NAN_METHOD(FitAsync);
50-
5133
static NAN_METHOD(Save);
5234
static NAN_METHOD(Load);
35+
36+
static bool detector(cv::InputArray image, cv::OutputArray faces,
37+
Nan::Callback *callback);
5338
};
5439

5540
#endif

0 commit comments

Comments
 (0)