From dc77bcd30a90869fd8fd54beafb6057e48251bfc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=94=D0=B0=D0=BD=D0=B8=D0=B8=D0=BB=20=D0=9A=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=D0=BA=D0=BE=D0=B2=D1=86=D0=B5=D0=B2?=
 <korekovtsevda@lad24.ru>
Date: Tue, 17 Sep 2019 13:17:47 +0300
Subject: [PATCH 01/36] Add libopenblas

---
 face.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/face.go b/face.go
index b59010a..9b31286 100644
--- a/face.go
+++ b/face.go
@@ -3,6 +3,7 @@ package face
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
+// #cgo LDFLAGS: -lopenblas
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "facerec.h"

From e394049d511d06d75109f810bd5dae351538107c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=94=D0=B0=D0=BD=D0=B8=D0=B8=D0=BB=20=D0=9A=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=D0=BA=D0=BE=D0=B2=D1=86=D0=B5=D0=B2?=
 <korekovtsevda@lad24.ru>
Date: Tue, 17 Sep 2019 13:31:29 +0300
Subject: [PATCH 02/36] Add libs

---
 face.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/face.go b/face.go
index 9b31286..e54852a 100644
--- a/face.go
+++ b/face.go
@@ -4,6 +4,7 @@ package face
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
+// #cgo LDFLAGS: -llapack
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "facerec.h"

From afd80302f12f3c1ec426d8aa10f30f870931db31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=94=D0=B0=D0=BD=D0=B8=D0=B8=D0=BB=20=D0=9A=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=D0=BA=D0=BE=D0=B2=D1=86=D0=B5=D0=B2?=
 <korekovtsevda@lad24.ru>
Date: Tue, 17 Sep 2019 13:42:51 +0300
Subject: [PATCH 03/36] Math lib

---
 face.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/face.go b/face.go
index e54852a..3160f1e 100644
--- a/face.go
+++ b/face.go
@@ -4,7 +4,7 @@ package face
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
-// #cgo LDFLAGS: -llapack
+// #cgo LDFLAGS: -lquadmath
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "facerec.h"

From 0ecff40ce133ec492413df57df6552c2395063c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=94=D0=B0=D0=BD=D0=B8=D0=B8=D0=BB=20=D0=9A=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=D0=BA=D0=BE=D0=B2=D1=86=D0=B5=D0=B2?=
 <korekovtsevda@lad24.ru>
Date: Tue, 17 Sep 2019 13:43:24 +0300
Subject: [PATCH 04/36] lgfortran

---
 face.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/face.go b/face.go
index 3160f1e..39fdfc9 100644
--- a/face.go
+++ b/face.go
@@ -5,6 +5,7 @@ package face
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
 // #cgo LDFLAGS: -lquadmath
+// #cgo LDFLAGS: -lgfortran
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "facerec.h"

From 88ec5d100b9472b58dbed1b5629c2153db1218c7 Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Tue, 11 Feb 2020 12:25:00 +0300
Subject: [PATCH 05/36] Update

---
 Makefile          |  34 ++++++++++++++-
 classify.h        |   3 ++
 face.go           |  38 +++++++++++++---
 facerec.cc        | 108 ++++++++--------------------------------------
 facerec.h         |  90 +++++++++++++++++++++++++++++++++++++-
 jpeg_mem_loader.h |   4 ++
 6 files changed, 177 insertions(+), 100 deletions(-)

diff --git a/Makefile b/Makefile
index efacfdb..f520858 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,17 @@
+.ONESHELL:
+.PHONY: all download build sudo_install precommit gofmt-staged testdata
+
 # Should contain src/github.com/Kagami/go-face or tests won't work
 # properly (multiple definition of C functions).
+
+# Temporary directory to put files into.
+TMP_DIR?=/tmp/
+
+BRANCH?=19.19
+
 export GOPATH = $(PWD)/../../../..
 
-all: test
+all: download build sudo_install test clean
 precommit: gofmt-staged
 
 gofmt-staged:
@@ -11,5 +20,26 @@ gofmt-staged:
 testdata:
 	git clone https://github.com/Kagami/go-face-testdata testdata
 
+download:
+	curl -Lo $(TMP_DIR)dlib.tar.gz https://github.com/davisking/dlib/archive/v${BRANCH}.tar.gz
+	cd $(TMP_DIR)
+	tar xf dlib.tar.gz
+	rm -rf dlib.tar.gz
+
+build:
+	cd $(TMP_DIR)dlib-${BRANCH}
+	mkdir build
+	cd build
+	cmake -DCMAKE_BUILD_TYPE=Release -DDLIB_JPEG_SUPPORT=ON -DBUILD_SHARED_LIBS=YES -DDLIB_USE_BLAS=ON  -DDLIB_USE_LAPACK=ON  ..
+	cmake --build . --config Release -- -j $(nproc --all)
+
+sudo_install:
+	cd $(TMP_DIR)dlib-${BRANCH}/build
+	sudo make install
+
+clean:
+	rm -rf $(TMP_DIR)dlib-${BRANCH}
+	rm -rf testdata
+
 test: testdata
-	go test -v
+	go test -v
\ No newline at end of file
diff --git a/classify.h b/classify.h
index ddc4642..c0a81ac 100644
--- a/classify.h
+++ b/classify.h
@@ -1,4 +1,6 @@
 #pragma once
+#ifndef CLASSIFY_H
+#define CLASSIFY_H
 
 typedef dlib::matrix<float,0,1> descriptor;
 
@@ -8,3 +10,4 @@ int classify(
 	const descriptor& test_sample,
 	float tolerance
 );
+#endif /* CLASSIFY_H */
diff --git a/face.go b/face.go
index 39fdfc9..eb50044 100644
--- a/face.go
+++ b/face.go
@@ -11,6 +11,7 @@ package face
 // #include "facerec.h"
 import "C"
 import (
+	"fmt"
 	"image"
 	"io/ioutil"
 	"math"
@@ -60,10 +61,27 @@ func NewWithShape(r image.Rectangle, s []image.Point, d Descriptor) Face {
 // NewRecognizer returns a new recognizer interface. modelDir points to
 // directory with shape_predictor_5_face_landmarks.dat and
 // dlib_face_recognition_resnet_model_v1.dat files.
-func NewRecognizer(modelDir string) (rec *Recognizer, err error) {
-	cModelDir := C.CString(modelDir)
-	defer C.free(unsafe.Pointer(cModelDir))
-	ptr := C.facerec_init(cModelDir)
+func NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath string) (rec *Recognizer, err error) {
+	if !fileExists(resnetPath) {
+		fmt.Errorf("File '%s' not found!", resnetPath)
+		os.Exit(1)
+	}
+	if !fileExists(cnnResnetPath) {
+		fmt.Errorf("File '%s' not found!", cnnResnetPath)
+		os.Exit(1)
+	}
+	if !fileExists(shapePredictorPath) {
+		fmt.Errorf("File '%s' not found!", shapePredictorPath)
+		os.Exit(1)
+	}
+	cResnetPath := C.CString(resnetPath)
+	defer C.free(unsafe.Pointer(cResnetPath))
+	cCnnResnetPath := C.CString(cnnResnetPath)
+	defer C.free(unsafe.Pointer(cCnnResnetPath))
+	cShapePredictorPath := C.CString(shapePredictorPath)
+	defer C.free(unsafe.Pointer(cShapePredictorPath))
+
+	ptr := C.facerec_init(cResnetPath, cCnnResnetPath, cShapePredictorPath)
 
 	if ptr.err_str != nil {
 		defer C.facerec_free(ptr)
@@ -76,8 +94,8 @@ func NewRecognizer(modelDir string) (rec *Recognizer, err error) {
 	return
 }
 
-func NewRecognizerWithConfig(modelDir string, size int, padding float32, jittering int) (rec *Recognizer, err error) {
-	rec, err = NewRecognizer(modelDir)
+func NewRecognizerWithConfig(resnetPath, cnnResnetPath, shapePredictorPath string, size int, padding float32, jittering int) (rec *Recognizer, err error) {
+	rec, err = NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath)
 	cSize := C.ulong(size)
 	cPadding := C.double(padding)
 	cJittering := C.int(jittering)
@@ -250,3 +268,11 @@ func (rec *Recognizer) Close() {
 	C.facerec_free(rec.ptr)
 	rec.ptr = nil
 }
+
+func fileExists(filename string) bool {
+	info, err := os.Stat(filename)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return !info.IsDir()
+}
diff --git a/facerec.cc b/facerec.cc
index cd09c54..7f6ce45 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -9,75 +9,16 @@
 
 using namespace dlib;
 
-template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
-using residual = add_prev1<block<N,BN,1,tag1<SUBNET>>>;
-
-template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
-using residual_down = add_prev2<avg_pool<2,2,2,2,skip1<tag2<block<N,BN,2,tag1<SUBNET>>>>>>;
-
-template <int N, template <typename> class BN, int stride, typename SUBNET>
-using block  = BN<con<N,3,3,1,1,relu<BN<con<N,3,3,stride,stride,SUBNET>>>>>;
-
-template <int N, typename SUBNET> using ares      = relu<residual<block,N,affine,SUBNET>>;
-template <int N, typename SUBNET> using ares_down = relu<residual_down<block,N,affine,SUBNET>>;
-
-template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
-template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
-template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
-template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
-template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
-
-template <long num_filters, typename SUBNET> using con5d = con<num_filters,5,5,2,2,SUBNET>;
-template <long num_filters, typename SUBNET> using con5  = con<num_filters,5,5,1,1,SUBNET>;
-
-template <typename SUBNET> using downsampler  = relu<affine<con5d<32, relu<affine<con5d<32, relu<affine<con5d<16,SUBNET>>>>>>>>>;
-template <typename SUBNET> using rcon5  = relu<affine<con5<45,SUBNET>>>;
-
-using cnn_anet_type = loss_mmod<con<1,9,9,1,1,rcon5<rcon5<rcon5<downsampler<input_rgb_image_pyramid<pyramid_down<6>>>>>>>>;
-
-using anet_type = loss_metric<fc_no_bias<128,avg_pool_everything<
-                            alevel0<
-                            alevel1<
-                            alevel2<
-                            alevel3<
-                            alevel4<
-                            max_pool<3,3,2,2,relu<affine<con<32,7,7,2,2,
-                            input_rgb_image_sized<150>
-                            >>>>>>>>>>>>;
-
-static const size_t RECT_LEN = 4;
-static const size_t DESCR_LEN = 128;
-static const size_t SHAPE_LEN = 2;
-static const size_t RECT_SIZE = RECT_LEN * sizeof(long);
-static const size_t DESCR_SIZE = DESCR_LEN * sizeof(float);
-static const size_t SHAPE_SIZE = SHAPE_LEN * sizeof(long);
-
-static std::vector<matrix<rgb_pixel>> jitter_image(
-    const matrix<rgb_pixel>& img,
-    int count
-);
-
-class FaceRec {
-public:
-	FaceRec(const char* model_dir) {
+FaceRec::FaceRec(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path) {
 		detector_ = get_frontal_face_detector();
 
-		std::string dir = model_dir;
-		std::string shape_predictor_path = dir + "/shape_predictor_5_face_landmarks.dat";
-		std::string resnet_path = dir + "/dlib_face_recognition_resnet_model_v1.dat";
-		std::string cnn_resnet_path = dir + "/mmod_human_face_detector.dat";
-
-		deserialize(shape_predictor_path) >> sp_;
-		deserialize(resnet_path) >> net_;
-		deserialize(cnn_resnet_path) >> cnn_net_;
-
-		jittering = 0;
-		size = 150;
-		padding = 0.25;
+		deserialize(std::string(shape_predictor_path)) >> sp_;
+		deserialize(std::string(resnet_path)) >> net_;
+		deserialize(std::string(cnn_resnet_path)) >> cnn_net_;
 	}
 
-	std::tuple<std::vector<rectangle>, std::vector<descriptor>, std::vector<full_object_detection>>
-	Recognize(const matrix<rgb_pixel>& img,int max_faces,int type) {
+std::tuple<std::vector<rectangle>, std::vector<descriptor>, std::vector<full_object_detection>>
+	FaceRec::Recognize(const matrix<rgb_pixel>& img,int max_faces,int type) {
 		std::vector<rectangle> rects;
 		std::vector<descriptor> descrs;
 		std::vector<full_object_detection> shapes;
@@ -115,44 +56,29 @@ class FaceRec {
 		return {std::move(rects), std::move(descrs), std::move(shapes)};
 	}
 
-	void SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
+	void FaceRec::SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
 		std::unique_lock<std::shared_mutex> lock(samples_mutex_);
 		samples_ = std::move(samples);
 		cats_ = std::move(cats);
 	}
 
-	int Classify(const descriptor& test_sample, float tolerance) {
+	int FaceRec::Classify(const descriptor& test_sample, float tolerance) {
 		std::shared_lock<std::shared_mutex> lock(samples_mutex_);
 		return classify(samples_, cats_, test_sample, tolerance);
 	}
 
-    void Config(unsigned long new_size, double new_padding, int new_jittering) {
+    void FaceRec::Config(unsigned long new_size, double new_padding, int new_jittering) {
         size = new_size;
         padding = new_padding;
         jittering = new_jittering;
     }
-private:
-	std::mutex detector_mutex_;
-	std::mutex net_mutex_;
-	std::mutex cnn_net_mutex_;
-	std::shared_mutex samples_mutex_;
-	frontal_face_detector detector_;
-	shape_predictor sp_;
-	anet_type net_;
-	cnn_anet_type cnn_net_;
-	std::vector<descriptor> samples_;
-	std::vector<int> cats_;
-	int jittering;
-	unsigned long size;
-	double padding;
-};
-
+    
 // Plain C interface for Go.
 
-facerec* facerec_init(const char* model_dir) {
+facerec* facerec_init(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path) {
 	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
 	try {
-		FaceRec* cls = new FaceRec(model_dir);
+		FaceRec* cls = new FaceRec(resnet_path,cnn_resnet_path,shape_predictor_path);
 		rec->cls = (void*)cls;
 	} catch(serialization_error& e) {
 		rec->err_str = strdup(e.what());
@@ -193,7 +119,7 @@ faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int m
 
 	if (ret->num_faces == 0)
 		return ret;
-	ret->rectangles = (long*)malloc(ret->num_faces * RECT_SIZE);
+	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
 	for (int i = 0; i < ret->num_faces; i++) {
 		long* dst = ret->rectangles + i * RECT_LEN;
 		dst[0] = rects[i].left();
@@ -201,14 +127,14 @@ faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int m
 		dst[2] = rects[i].right();
 		dst[3] = rects[i].bottom();
 	}
-	ret->descriptors = (float*)malloc(ret->num_faces * DESCR_SIZE);
+	ret->descriptors = (float*)malloc(ret->num_faces * DESCR_LEN * sizeof(float));
 	for (int i = 0; i < ret->num_faces; i++) {
-		void* dst = (uint8_t*)(ret->descriptors) + i * DESCR_SIZE;
+		void* dst = (uint8_t*)(ret->descriptors) + i * DESCR_LEN * sizeof(float);
 		void* src = (void*)&descrs[i](0,0);
-		memcpy(dst, src, DESCR_SIZE);
+		memcpy(dst, src, DESCR_LEN * sizeof(float));
 	}
 	ret->num_shapes = shapes[0].num_parts();
-	ret->shapes = (long*)malloc(ret->num_faces * ret->num_shapes * SHAPE_SIZE);
+	ret->shapes = (long*)malloc(ret->num_faces * ret->num_shapes * SHAPE_LEN * sizeof(long));
 	for (int i = 0; i < ret->num_faces; i++) {
 		long* dst = ret->shapes + i * ret->num_shapes * SHAPE_LEN;
 		const auto& shape = shapes[i];
diff --git a/facerec.h b/facerec.h
index 607fa41..340dda1 100644
--- a/facerec.h
+++ b/facerec.h
@@ -1,4 +1,84 @@
 #pragma once
+#ifndef FACEREC_H
+#define FACEREC_H
+
+#ifdef __cplusplus
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+#include "classify.h"
+
+
+// don't kill me))
+using namespace dlib;
+
+
+template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
+using residual = add_prev1<block<N,BN,1,tag1<SUBNET>>>;
+
+template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
+using residual_down = add_prev2<avg_pool<2,2,2,2,skip1<tag2<block<N,BN,2,tag1<SUBNET>>>>>>;
+
+template <int N, template <typename> class BN, int stride, typename SUBNET>
+using block  = BN<con<N,3,3,1,1,relu<BN<con<N,3,3,stride,stride,SUBNET>>>>>;
+
+template <int N, typename SUBNET> using ares      = relu<residual<block,N,affine,SUBNET>>;
+template <int N, typename SUBNET> using ares_down = relu<residual_down<block,N,affine,SUBNET>>;
+
+template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
+template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
+template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
+template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
+template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
+
+template <long num_filters, typename SUBNET> using con5d = con<num_filters,5,5,2,2,SUBNET>;
+template <long num_filters, typename SUBNET> using con5  = con<num_filters,5,5,1,1,SUBNET>;
+
+template <typename SUBNET> using downsampler  = relu<affine<con5d<32, relu<affine<con5d<32, relu<affine<con5d<16,SUBNET>>>>>>>>>;
+template <typename SUBNET> using rcon5  = relu<affine<con5<45,SUBNET>>>;
+
+using cnn_anet_type = loss_mmod<con<1,9,9,1,1,rcon5<rcon5<rcon5<downsampler<input_rgb_image_pyramid<pyramid_down<6>>>>>>>>;
+
+using anet_type = loss_metric<fc_no_bias<128,avg_pool_everything<
+                            alevel0<
+                            alevel1<
+                            alevel2<
+                            alevel3<
+                            alevel4<
+                            max_pool<3,3,2,2,relu<affine<con<32,7,7,2,2,
+                            input_rgb_image_sized<150>
+                            >>>>>>>>>>>>;
+
+class FaceRec {   
+private:
+	std::mutex detector_mutex_;
+	std::mutex net_mutex_;
+	std::mutex cnn_net_mutex_;
+	std::shared_mutex samples_mutex_;
+	dlib::frontal_face_detector detector_;
+	dlib::shape_predictor sp_;
+	anet_type net_;
+	cnn_anet_type cnn_net_;
+	std::vector<descriptor> samples_;
+	std::vector<int> cats_;
+	int jittering = 0;
+	unsigned long size = 150;
+	double padding = 0.25;
+    
+public:
+	FaceRec(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path);
+	std::tuple<std::vector<rectangle>, std::vector<descriptor>, std::vector<full_object_detection>>
+	Recognize(const matrix<rgb_pixel>& img,int max_faces,int type);
+	void SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats);
+	int Classify(const descriptor& test_sample, float tolerance);
+    void Config(unsigned long new_size, double new_padding, int new_jittering);
+};
+
+static std::vector<matrix<rgb_pixel>> jitter_image(const matrix<rgb_pixel>& img,int count);
+
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -29,12 +109,20 @@ typedef struct faceret {
 	err_code err_code;
 } faceret;
 
-facerec* facerec_init(const char* model_dir);
+#define RECT_LEN   4
+#define DESCR_LEN  128
+#define SHAPE_LEN  2
+
+facerec* facerec_init(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path);
 faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int max_faces,int type);
 void facerec_set_samples(facerec* rec, const float* descriptors, const int32_t* cats, int len);
 int facerec_classify(facerec* rec, const float* descriptor, float tolerance);
 void facerec_free(facerec* rec);
 void facerec_config(facerec* rec, unsigned long size, double padding, int jittering);
+
+
+
 #ifdef __cplusplus
 }
 #endif
+#endif /* FACEREC_H */
diff --git a/jpeg_mem_loader.h b/jpeg_mem_loader.h
index dbbc6b4..7980c2b 100644
--- a/jpeg_mem_loader.h
+++ b/jpeg_mem_loader.h
@@ -1,3 +1,7 @@
 #pragma once
+#ifndef JPEG_MEM_LOADER_H
+#define JPEG_MEM_LOADER_H
 
 void load_mem_jpeg(dlib::matrix<dlib::rgb_pixel>& img, const uint8_t* img_data, int len);
+
+#endif /* JPEG_MEM_LOADER_H */

From d1a82d911f0c7eaaefc80b714d6839e577ce4279 Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Tue, 11 Feb 2020 13:02:10 +0300
Subject: [PATCH 06/36] Update

---
 Makefile   |   2 +-
 face.go    | 171 +++++++++++++++++++++-------------------
 facerec.cc | 223 ++++++++++++++++++++++++++++++++++-------------------
 facerec.h  |  96 ++++++++++-------------
 template.h |  53 +++++++++++++
 5 files changed, 326 insertions(+), 219 deletions(-)
 create mode 100644 template.h

diff --git a/Makefile b/Makefile
index f520858..7b6ed98 100644
--- a/Makefile
+++ b/Makefile
@@ -42,4 +42,4 @@ clean:
 	rm -rf testdata
 
 test: testdata
-	go test -v
\ No newline at end of file
+	go test -v
diff --git a/face.go b/face.go
index eb50044..f686e2b 100644
--- a/face.go
+++ b/face.go
@@ -11,9 +11,9 @@ package face
 // #include "facerec.h"
 import "C"
 import (
+	"errors"
 	"fmt"
 	"image"
-	"io/ioutil"
 	"math"
 	"os"
 	"unsafe"
@@ -33,6 +33,7 @@ type Recognizer struct {
 
 // Face holds coordinates and descriptor of the human face.
 type Face struct {
+	imagePtr   *C.image_pointer
 	Rectangle  image.Rectangle
 	Descriptor Descriptor
 	Shapes     []image.Point
@@ -51,11 +52,11 @@ func SquaredEuclideanDistance(d1 Descriptor, d2 Descriptor) (sum float64) {
 
 // New creates new face with the provided parameters.
 func New(r image.Rectangle, d Descriptor) Face {
-	return Face{r, d, []image.Point{}}
+	return Face{Rectangle: r, Descriptor: d, Shapes: []image.Point{}}
 }
 
 func NewWithShape(r image.Rectangle, s []image.Point, d Descriptor) Face {
-	return Face{r, d, s}
+	return Face{Rectangle: r, Descriptor: d, Shapes: s}
 }
 
 // NewRecognizer returns a new recognizer interface. modelDir points to
@@ -63,16 +64,16 @@ func NewWithShape(r image.Rectangle, s []image.Point, d Descriptor) Face {
 // dlib_face_recognition_resnet_model_v1.dat files.
 func NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath string) (rec *Recognizer, err error) {
 	if !fileExists(resnetPath) {
-		fmt.Errorf("File '%s' not found!", resnetPath)
-		os.Exit(1)
+		err = errors.New(fmt.Sprintf("File '%s' not found!", resnetPath))
+		return
 	}
 	if !fileExists(cnnResnetPath) {
-		fmt.Errorf("File '%s' not found!", cnnResnetPath)
-		os.Exit(1)
+		err = errors.New(fmt.Sprintf("File '%s' not found!", cnnResnetPath))
+		return
 	}
 	if !fileExists(shapePredictorPath) {
-		fmt.Errorf("File '%s' not found!", shapePredictorPath)
-		os.Exit(1)
+		err = errors.New(fmt.Sprintf("File '%s' not found!", shapePredictorPath))
+		return
 	}
 	cResnetPath := C.CString(resnetPath)
 	defer C.free(unsafe.Pointer(cResnetPath))
@@ -94,26 +95,26 @@ func NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath string) (rec *R
 	return
 }
 
-func NewRecognizerWithConfig(resnetPath, cnnResnetPath, shapePredictorPath string, size int, padding float32, jittering int) (rec *Recognizer, err error) {
+func NewRecognizerWithConfig(resnetPath, cnnResnetPath, shapePredictorPath string, size int, padding float32, jittering int, minImageSize int) (rec *Recognizer, err error) {
 	rec, err = NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath)
 	cSize := C.ulong(size)
 	cPadding := C.double(padding)
 	cJittering := C.int(jittering)
-	C.facerec_config(rec.ptr, cSize, cPadding, cJittering)
+	cMinImageSize := C.int(minImageSize)
+	C.facerec_config(rec.ptr, cSize, cPadding, cJittering, cMinImageSize)
 	return
 }
 
-func (rec *Recognizer) recognize(type_ int, imgData []byte, maxFaces int) (faces []Face, err error) {
+func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, err error) {
 	if len(imgData) == 0 {
 		err = ImageLoadError("Empty image")
 		return
 	}
 	cImgData := (*C.uint8_t)(&imgData[0])
 	cLen := C.int(len(imgData))
-	cMaxFaces := C.int(maxFaces)
 	cType := C.int(type_)
 
-	ret := C.facerec_recognize(rec.ptr, cImgData, cLen, cMaxFaces, cType)
+	ret := C.facerec_detect_buffer(rec.ptr, cImgData, cLen, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -126,113 +127,123 @@ func (rec *Recognizer) recognize(type_ int, imgData []byte, maxFaces int) (faces
 	if numFaces == 0 {
 		return
 	}
-	numShapes := int(ret.num_shapes)
 
 	// Copy faces data to Go structure.
-	defer C.free(unsafe.Pointer(ret.shapes))
 	defer C.free(unsafe.Pointer(ret.rectangles))
-	defer C.free(unsafe.Pointer(ret.descriptors))
 
 	rDataLen := numFaces * rectLen
 	rDataPtr := unsafe.Pointer(ret.rectangles)
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
-	dDataLen := numFaces * descrLen
-	dDataPtr := unsafe.Pointer(ret.descriptors)
-	dData := (*[1 << 30]float32)(dDataPtr)[:dDataLen:dDataLen]
-
-	sDataLen := numFaces * numShapes * shapeLen
-	sDataPtr := unsafe.Pointer(ret.shapes)
-	sData := (*[1 << 30]C.long)(sDataPtr)[:sDataLen:sDataLen]
-
 	for i := 0; i < numFaces; i++ {
-		face := Face{}
+		face := Face{imagePtr: ret.img}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
 		y1 := int(rData[i*rectLen+3])
 		face.Rectangle = image.Rect(x0, y0, x1, y1)
-		copy(face.Descriptor[:], dData[i*descrLen:(i+1)*descrLen])
-		for j := 0; j < numShapes; j++ {
-			shapeX := int(sData[(i*numShapes+j)*shapeLen])
-			shapeY := int(sData[(i*numShapes+j)*shapeLen+1])
-			face.Shapes = append(face.Shapes, image.Point{shapeX, shapeY})
-		}
 		faces = append(faces, face)
 	}
 	return
 }
 
-func (rec *Recognizer) recognizeFile(type_ int, imgPath string, maxFaces int) (face []Face, err error) {
-	fd, err := os.Open(imgPath)
-	if err != nil {
+func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err error) {
+	if !fileExists(file) {
+		err = ImageLoadError(fmt.Sprintf("File '%s' not found!", file))
 		return
 	}
-	imgData, err := ioutil.ReadAll(fd)
-	if err != nil {
+
+	cType := C.int(type_)
+	cFile := C.CString(file)
+	defer C.free(unsafe.Pointer(cFile))
+
+	ret := C.facerec_detect_file(rec.ptr, cFile, cType)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
 		return
 	}
-	return rec.recognize(type_, imgData, maxFaces)
+
+	numFaces := int(ret.num_faces)
+	if numFaces == 0 {
+		return
+	}
+
+	// Copy faces data to Go structure.
+	defer C.free(unsafe.Pointer(ret.rectangles))
+
+	rDataLen := numFaces * rectLen
+	rDataPtr := unsafe.Pointer(ret.rectangles)
+	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
+
+	for i := 0; i < numFaces; i++ {
+		face := Face{imagePtr: ret.img}
+		x0 := int(rData[i*rectLen])
+		y0 := int(rData[i*rectLen+1])
+		x1 := int(rData[i*rectLen+2])
+		y1 := int(rData[i*rectLen+3])
+		face.Rectangle = image.Rect(x0, y0, x1, y1)
+		faces = append(faces, face)
+	}
+	return
 }
 
-// Recognize returns all faces found on the provided image, sorted from
+// Detect returns all faces found on the provided image, sorted from
 // left to right. Empty list is returned if there are no faces, error is
 // returned if there was some error while decoding/processing image.
 // Only JPEG format is currently supported. Thread-safe.
-func (rec *Recognizer) Recognize(imgData []byte) (faces []Face, err error) {
-	return rec.recognize(0, imgData, 0)
+func (rec *Recognizer) Detect(imgData []byte) (faces []Face, err error) {
+	return rec.detectBuffer(0, imgData)
 }
 
-func (rec *Recognizer) RecognizeCNN(imgData []byte) (faces []Face, err error) {
-	return rec.recognize(1, imgData, 0)
+func (rec *Recognizer) DetectCNN(imgData []byte) (faces []Face, err error) {
+	return rec.detectBuffer(1, imgData)
 }
 
-// RecognizeSingle returns face if it's the only face on the image or
-// nil otherwise. Only JPEG format is currently supported. Thread-safe.
-func (rec *Recognizer) RecognizeSingle(imgData []byte) (face *Face, err error) {
-	faces, err := rec.recognize(0, imgData, 1)
-	if err != nil || len(faces) != 1 {
-		return
-	}
-	face = &faces[0]
-	return
+// Same as Recognize but accepts image path instead.
+func (rec *Recognizer) DetectFromFile(imgPath string) (faces []Face, err error) {
+	return rec.detectFile(0, imgPath)
 }
 
-func (rec *Recognizer) RecognizeSingleCNN(imgData []byte) (face *Face, err error) {
-	faces, err := rec.recognize(1, imgData, 1)
-	if err != nil || len(faces) != 1 {
-		return
-	}
-	face = &faces[0]
-	return
+func (rec *Recognizer) DetectFromFileCNN(imgPath string) (faces []Face, err error) {
+	return rec.detectFile(1, imgPath)
 }
 
-// Same as Recognize but accepts image path instead.
-func (rec *Recognizer) RecognizeFile(imgPath string) (faces []Face, err error) {
-	return rec.recognizeFile(0, imgPath, 0)
-}
+func (rec *Recognizer) Recognize(face *Face) error {
+	x := C.int(face.Rectangle.Min.X)
+	y := C.int(face.Rectangle.Min.Y)
+	x1 := C.int(face.Rectangle.Max.X)
+	y1 := C.int(face.Rectangle.Max.Y)
 
-func (rec *Recognizer) RecognizeFileCNN(imgPath string) (faces []Face, err error) {
-	return rec.recognizeFile(1, imgPath, 0)
-}
+	ret := C.facerec_recognize(rec.ptr, face.imagePtr, x, y, x1, y1)
+	defer C.free(unsafe.Pointer(ret))
 
-// Same as RecognizeSingle but accepts image path instead.
-func (rec *Recognizer) RecognizeSingleFile(imgPath string) (face *Face, err error) {
-	faces, err := rec.recognizeFile(0, imgPath, 1)
-	if err != nil || len(faces) != 1 {
-		return
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err := makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return err
 	}
-	face = &faces[0]
-	return
-}
+	numShapes := int(ret.num_shape)
+	defer C.free(unsafe.Pointer(ret.shape))
+	defer C.free(unsafe.Pointer(ret.descriptor))
 
-func (rec *Recognizer) RecognizeSingleFileCNN(imgPath string) (face *Face, err error) {
-	faces, err := rec.recognizeFile(1, imgPath, 1)
-	if err != nil || len(faces) != 1 {
-		return
+	dDataPtr := unsafe.Pointer(ret.descriptor)
+	dData := (*[1 << 30]float32)(dDataPtr)[:descrLen:descrLen]
+
+	sDataLen := numShapes * shapeLen
+	sDataPtr := unsafe.Pointer(ret.shape)
+	sData := (*[1 << 30]C.long)(sDataPtr)[:sDataLen:sDataLen]
+
+	copy(face.Descriptor[:], dData[:descrLen])
+	for j := 0; j < numShapes; j++ {
+		shapeX := int(sData[(j)*shapeLen])
+		shapeY := int(sData[(j)*shapeLen+1])
+		face.Shapes = append(face.Shapes, image.Point{shapeX, shapeY})
 	}
-	face = &faces[0]
-	return
+
+	return nil
 }
 
 // SetSamples sets known descriptors so you can classify the new ones.
diff --git a/facerec.cc b/facerec.cc
index 7f6ce45..9c1fcea 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -3,6 +3,7 @@
 #include <dlib/image_loader/image_loader.h>
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
+#include <dlib/image_io.h>
 #include "facerec.h"
 #include "jpeg_mem_loader.h"
 #include "classify.h"
@@ -15,67 +16,76 @@ FaceRec::FaceRec(const char* resnet_path,const char* cnn_resnet_path,const char*
 		deserialize(std::string(shape_predictor_path)) >> sp_;
 		deserialize(std::string(resnet_path)) >> net_;
 		deserialize(std::string(cnn_resnet_path)) >> cnn_net_;
-	}
+}
 
-std::tuple<std::vector<rectangle>, std::vector<descriptor>, std::vector<full_object_detection>>
-	FaceRec::Recognize(const matrix<rgb_pixel>& img,int max_faces,int type) {
-		std::vector<rectangle> rects;
-		std::vector<descriptor> descrs;
-		std::vector<full_object_detection> shapes;
-
-		if(type == 0) {
-			std::lock_guard<std::mutex> lock(detector_mutex_);
-			rects = detector_(img);
-		} else{
-			std::lock_guard<std::mutex> lock(cnn_net_mutex_);
-			auto dets = cnn_net_(img);
-            for (auto&& d : dets) {
-                rects.push_back(d.rect);
-            }
-		}
+std::vector<rectangle> FaceRec::Detect(image_t& img) {
+    	std::vector<rectangle> rects;
+    	std::lock_guard<std::mutex> lock(detector_mutex_);
+        
+    while(img.size() < min_image_size) {
+        pyramid_up(img);
+    }
+        
+    rects = detector_(img);
+    return rects;
+}
 
-		// Short circuit.
-		if (rects.size() == 0 || (max_faces > 0 && rects.size() > (size_t)max_faces))
-			return {std::move(rects), std::move(descrs), std::move(shapes)};
-
-		std::sort(rects.begin(), rects.end());
-
-		for (const auto& rect : rects) {
-			auto shape = sp_(img, rect);
-			shapes.push_back(shape);
-			matrix<rgb_pixel> face_chip;
-			extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
-			std::lock_guard<std::mutex> lock(net_mutex_);
-			if (jittering > 0) {
-				descrs.push_back(mean(mat(net_(jitter_image(std::move(face_chip), jittering)))));
-			} else {
-				descrs.push_back(net_(face_chip));
-			}
-		}
+std::vector<rectangle> FaceRec::DetectCNN(image_t& img) {
+    std::vector<rectangle> rects;
+    	std::lock_guard<std::mutex> lock(cnn_net_mutex_);
+        
+    while(img.size() < min_image_size) {
+        pyramid_up(img);
+    }
+        
+	auto dets = cnn_net_(img);
+    for (auto&& d : dets) {
+        rects.push_back(d.rect);
+    }
+    return rects; 
+}
 
-		return {std::move(rects), std::move(descrs), std::move(shapes)};
-	}
+std::tuple<descriptor, full_object_detection> FaceRec::Recognize(const image_t& img,rectangle rect) {
+    full_object_detection shape;
+    descriptor descr;
+    image_t face_chip;
+        
+    std::lock_guard<std::mutex> lock(net_mutex_);
+        
+    shape = sp_(img, rect);
+        
+    extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
+        
+    if (jittering > 0) {
+        descr = mean(mat(net_(jitter_image(std::move(face_chip), jittering))));
+    } else {
+        descr = net_(face_chip);
+    }
+        
+    return std::make_tuple(descr, shape);
+}
 
-	void FaceRec::SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
-		std::unique_lock<std::shared_mutex> lock(samples_mutex_);
-		samples_ = std::move(samples);
-		cats_ = std::move(cats);
-	}
+void FaceRec::SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
+    std::unique_lock<std::shared_mutex> lock(samples_mutex_);
+    samples_ = std::move(samples);
+    cats_ = std::move(cats);
+}
 
-	int FaceRec::Classify(const descriptor& test_sample, float tolerance) {
-		std::shared_lock<std::shared_mutex> lock(samples_mutex_);
-		return classify(samples_, cats_, test_sample, tolerance);
-	}
+int FaceRec::Classify(const descriptor& test_sample, float tolerance) {
+    std::shared_lock<std::shared_mutex> lock(samples_mutex_);
+    return classify(samples_, cats_, test_sample, tolerance);
+}
 
-    void FaceRec::Config(unsigned long new_size, double new_padding, int new_jittering) {
-        size = new_size;
-        padding = new_padding;
-        jittering = new_jittering;
-    }
+void FaceRec::Config(unsigned long new_size, double new_padding, int new_jittering, int new_min_image_size) {
+    size = new_size;
+    padding = new_padding;
+    jittering = new_jittering;
+    min_image_size = new_min_image_size;
+}
     
 // Plain C interface for Go.
 
-facerec* facerec_init(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path) {
+facerec* facerec_init(const char* resnet_path, const char* cnn_resnet_path, const char* shape_predictor_path) {
 	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
 	try {
 		FaceRec* cls = new FaceRec(resnet_path,cnn_resnet_path,shape_predictor_path);
@@ -89,23 +99,41 @@ facerec* facerec_init(const char* resnet_path,const char* cnn_resnet_path,const
 	}
 	return rec;
 }
-void facerec_config(facerec* rec, unsigned long size, double padding, int jittering) {
+void facerec_config(facerec* rec, unsigned long size, double padding, int jittering, int min_image_size) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
-	cls->Config(size,padding,jittering);
+	cls->Config(size,padding, jittering, min_image_size);
 }
 
-faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int max_faces,int type) {
-	faceret* ret = (faceret*)calloc(1, sizeof(faceret));
-	FaceRec* cls = (FaceRec*)(rec->cls);
-	matrix<rgb_pixel> img;
+facesret* facerec_detect_file(facerec* rec, const char* file,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+
+	try {
+		// TODO(Kagami): Support more file types?
+        // Danil_e71: support png, gif, bmp, jpg from file
+        load_image(img,file);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, rec, img, type);
+}
+
+facesret* facerec_detect_buffer(facerec* rec, const uint8_t* img_data, int len,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
 	std::vector<rectangle> rects;
-	std::vector<descriptor> descrs;
-	std::vector<full_object_detection> shapes;
 
 	try {
 		// TODO(Kagami): Support more file types?
 		load_mem_jpeg(img, img_data, len);
-		std::tie(rects, descrs, shapes) = cls->Recognize(img, max_faces,type);
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
@@ -115,10 +143,26 @@ faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int m
 		ret->err_code = UNKNOWN_ERROR;
 		return ret;
 	}
-	ret->num_faces = descrs.size();
+    
+    return facerec_detect(ret, rec, img, type);
+}
 
-	if (ret->num_faces == 0)
+facesret* facerec_detect(facesret* ret, facerec* rec, image_t img, int type) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	std::vector<rectangle> rects;
+    
+    if (type == 0 ) {
+        rects = cls->Detect(img);
+    } else {
+        rects = cls->DetectCNN(img);
+    }
+    
+    ret->num_faces = rects.size();
+    ret->img = new image_pointer{&img};
+	
+    if (ret->num_faces == 0)
 		return ret;
+        
 	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
 	for (int i = 0; i < ret->num_faces; i++) {
 		long* dst = ret->rectangles + i * RECT_LEN;
@@ -127,22 +171,39 @@ faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int m
 		dst[2] = rects[i].right();
 		dst[3] = rects[i].bottom();
 	}
-	ret->descriptors = (float*)malloc(ret->num_faces * DESCR_LEN * sizeof(float));
-	for (int i = 0; i < ret->num_faces; i++) {
-		void* dst = (uint8_t*)(ret->descriptors) + i * DESCR_LEN * sizeof(float);
-		void* src = (void*)&descrs[i](0,0);
-		memcpy(dst, src, DESCR_LEN * sizeof(float));
-	}
-	ret->num_shapes = shapes[0].num_parts();
-	ret->shapes = (long*)malloc(ret->num_faces * ret->num_shapes * SHAPE_LEN * sizeof(long));
-	for (int i = 0; i < ret->num_faces; i++) {
-		long* dst = ret->shapes + i * ret->num_shapes * SHAPE_LEN;
-		const auto& shape = shapes[i];
-		for (int j = 0; j < ret->num_shapes; j++) {
-			dst[j*SHAPE_LEN] = shape.part(j).x();
-			dst[j*SHAPE_LEN+1] = shape.part(j).y();
-		}
+	return ret;
+}
+
+faceret* facerec_recognize(facerec* rec, image_pointer *pointer, int x, int y, int x1, int y1) {
+    	faceret* ret = (faceret*)calloc(1, sizeof(faceret));
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	descriptor descr;
+	full_object_detection shape;
+    
+	try {
+		std::tie(descr, shape) = cls->Recognize(*(pointer->img), rectangle(x,y,x1,y1));
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
 	}
+
+	ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
+	memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
+	
+	ret->num_shape = shape.num_parts();
+	ret->shape = (long*)malloc(ret->num_shape * SHAPE_LEN * sizeof(long));
+
+	long* dst = ret->shape;
+	for (int j = 0; j < ret->num_shape; j++) {
+		dst[j*SHAPE_LEN] = shape.part(j).x();
+		dst[j*SHAPE_LEN+1] = shape.part(j).y();
+    }
+	
 	return ret;
 }
 
@@ -180,8 +241,8 @@ void facerec_free(facerec* rec) {
 	}
 }
 
-static std::vector<matrix<rgb_pixel>> jitter_image(
-    const matrix<rgb_pixel>& img,
+static std::vector<image_t> jitter_image(
+    const image_t& img,
     int count
 )
 {
@@ -190,7 +251,7 @@ static std::vector<matrix<rgb_pixel>> jitter_image(
     // mirrored left to right.
     thread_local dlib::rand rnd;
 
-    std::vector<matrix<rgb_pixel>> crops;
+    std::vector<image_t> crops;
     for (int i = 0; i < count; ++i)
         crops.push_back(jitter_image(img,rnd));
 
diff --git a/facerec.h b/facerec.h
index 340dda1..c39f0f5 100644
--- a/facerec.h
+++ b/facerec.h
@@ -9,47 +9,9 @@
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
 #include "classify.h"
+#include "template.h"
 
-
-// don't kill me))
-using namespace dlib;
-
-
-template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
-using residual = add_prev1<block<N,BN,1,tag1<SUBNET>>>;
-
-template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
-using residual_down = add_prev2<avg_pool<2,2,2,2,skip1<tag2<block<N,BN,2,tag1<SUBNET>>>>>>;
-
-template <int N, template <typename> class BN, int stride, typename SUBNET>
-using block  = BN<con<N,3,3,1,1,relu<BN<con<N,3,3,stride,stride,SUBNET>>>>>;
-
-template <int N, typename SUBNET> using ares      = relu<residual<block,N,affine,SUBNET>>;
-template <int N, typename SUBNET> using ares_down = relu<residual_down<block,N,affine,SUBNET>>;
-
-template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
-template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
-template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
-template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
-template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
-
-template <long num_filters, typename SUBNET> using con5d = con<num_filters,5,5,2,2,SUBNET>;
-template <long num_filters, typename SUBNET> using con5  = con<num_filters,5,5,1,1,SUBNET>;
-
-template <typename SUBNET> using downsampler  = relu<affine<con5d<32, relu<affine<con5d<32, relu<affine<con5d<16,SUBNET>>>>>>>>>;
-template <typename SUBNET> using rcon5  = relu<affine<con5<45,SUBNET>>>;
-
-using cnn_anet_type = loss_mmod<con<1,9,9,1,1,rcon5<rcon5<rcon5<downsampler<input_rgb_image_pyramid<pyramid_down<6>>>>>>>>;
-
-using anet_type = loss_metric<fc_no_bias<128,avg_pool_everything<
-                            alevel0<
-                            alevel1<
-                            alevel2<
-                            alevel3<
-                            alevel4<
-                            max_pool<3,3,2,2,relu<affine<con<32,7,7,2,2,
-                            input_rgb_image_sized<150>
-                            >>>>>>>>>>>>;
+typedef matrix<rgb_pixel> image_t;
 
 class FaceRec {   
 private:
@@ -66,20 +28,26 @@ class FaceRec {
 	int jittering = 0;
 	unsigned long size = 150;
 	double padding = 0.25;
+    int min_image_size;
     
 public:
-	FaceRec(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path);
-	std::tuple<std::vector<rectangle>, std::vector<descriptor>, std::vector<full_object_detection>>
-	Recognize(const matrix<rgb_pixel>& img,int max_faces,int type);
-	void SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats);
-	int Classify(const descriptor& test_sample, float tolerance);
-    void Config(unsigned long new_size, double new_padding, int new_jittering);
+	FaceRec(const char*, const char*, const char*);
+    std::vector<rectangle> Detect(image_t&);
+    std::vector<rectangle> DetectCNN(image_t&);
+    std::tuple<descriptor, full_object_detection> Recognize(const image_t&,rectangle);
+    
+	void SetSamples(std::vector<descriptor>&&, std::vector<int>&&);
+	int Classify(const descriptor&, float);
+    void Config(unsigned long, double, int, int);
 };
 
-static std::vector<matrix<rgb_pixel>> jitter_image(const matrix<rgb_pixel>& img,int count);
+static std::vector<image_t> jitter_image(const image_t& img,int count);
 
+#else
+typedef void *image_t;
 #endif
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -99,12 +67,22 @@ typedef struct facerec {
 	double padding;
 } facerec;
 
-typedef struct faceret {
+typedef struct image_pointer {
+    image_t *img;
+} image_pointer;
+
+typedef struct facesret {
+    image_pointer *img;
 	int num_faces;
 	long* rectangles;
-	float* descriptors;
-	int num_shapes;
-	long* shapes;
+	const char* err_str;
+	err_code err_code;
+} facesret;
+
+typedef struct faceret {
+	float *descriptor;
+	int num_shape;
+	long* shape;
 	const char* err_str;
 	err_code err_code;
 } faceret;
@@ -113,12 +91,16 @@ typedef struct faceret {
 #define DESCR_LEN  128
 #define SHAPE_LEN  2
 
-facerec* facerec_init(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path);
-faceret* facerec_recognize(facerec* rec, const uint8_t* img_data, int len, int max_faces,int type);
-void facerec_set_samples(facerec* rec, const float* descriptors, const int32_t* cats, int len);
-int facerec_classify(facerec* rec, const float* descriptor, float tolerance);
-void facerec_free(facerec* rec);
-void facerec_config(facerec* rec, unsigned long size, double padding, int jittering);
+facerec* facerec_init(const char*,const char*,const char*);
+facesret* facerec_detect_file(facerec*, const char*,int);
+facesret* facerec_detect_buffer(facerec*, const uint8_t*, int, int);
+facesret* facerec_detect(facesret*, facerec*, image_t, int);
+
+faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
+void facerec_set_samples(facerec*, const float*, const int32_t*, int);
+int facerec_classify(facerec*, const float*, float);
+void facerec_free(facerec*);
+void facerec_config(facerec*, unsigned long, double, int, int);
 
 
 
diff --git a/template.h b/template.h
new file mode 100644
index 0000000..a46c6f6
--- /dev/null
+++ b/template.h
@@ -0,0 +1,53 @@
+#pragma once
+#ifndef TEMPLATE_H
+#define TEMPLATE_H
+
+#ifdef __cplusplus
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+
+
+// don't kill me))
+using namespace dlib;
+
+template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
+using residual = add_prev1<block<N,BN,1,tag1<SUBNET>>>;
+
+template <template <int,template<typename>class,int,typename> class block, int N, template<typename>class BN, typename SUBNET>
+using residual_down = add_prev2<avg_pool<2,2,2,2,skip1<tag2<block<N,BN,2,tag1<SUBNET>>>>>>;
+
+template <int N, template <typename> class BN, int stride, typename SUBNET>
+using block  = BN<con<N,3,3,1,1,relu<BN<con<N,3,3,stride,stride,SUBNET>>>>>;
+
+template <int N, typename SUBNET> using ares      = relu<residual<block,N,affine,SUBNET>>;
+template <int N, typename SUBNET> using ares_down = relu<residual_down<block,N,affine,SUBNET>>;
+
+template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
+template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
+template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
+template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
+template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
+
+template <long num_filters, typename SUBNET> using con5d = con<num_filters,5,5,2,2,SUBNET>;
+template <long num_filters, typename SUBNET> using con5  = con<num_filters,5,5,1,1,SUBNET>;
+
+template <typename SUBNET> using downsampler  = relu<affine<con5d<32, relu<affine<con5d<32, relu<affine<con5d<16,SUBNET>>>>>>>>>;
+template <typename SUBNET> using rcon5  = relu<affine<con5<45,SUBNET>>>;
+
+using cnn_anet_type = loss_mmod<con<1,9,9,1,1,rcon5<rcon5<rcon5<downsampler<input_rgb_image_pyramid<pyramid_down<6>>>>>>>>;
+
+using anet_type = loss_metric<fc_no_bias<128,avg_pool_everything<
+                            alevel0<
+                            alevel1<
+                            alevel2<
+                            alevel3<
+                            alevel4<
+                            max_pool<3,3,2,2,relu<affine<con<32,7,7,2,2,
+                            input_rgb_image_sized<150>
+                            >>>>>>>>>>>>;
+
+#endif
+#endif /* TEMPLATE_H */

From b964c2cdb685693f42e6d37411f33938dc9b4ab8 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Wed, 12 Feb 2020 14:27:38 +0300
Subject: [PATCH 07/36] Big update Support cv::Mat

---
 face.go            |  79 +++++++++++++++++++++++++++-----
 facerec.cc         |  68 +++++++++++++++++++--------
 facerec.h          | 111 +++++++++++++++++++++++----------------------
 jpeg_mem_loader.cc |  63 -------------------------
 jpeg_mem_loader.h  |   7 ---
 5 files changed, 174 insertions(+), 154 deletions(-)
 delete mode 100644 jpeg_mem_loader.cc
 delete mode 100644 jpeg_mem_loader.h

diff --git a/face.go b/face.go
index f686e2b..98166e9 100644
--- a/face.go
+++ b/face.go
@@ -1,5 +1,9 @@
 package face
 
+// #cgo !windows pkg-config: opencv4
+// #cgo CXXFLAGS:   --std=c++11
+// #cgo windows  CPPFLAGS:   -IC:/opencv/build/install/include
+// #cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core420 -lopencv_face420 -lopencv_videoio420 -lopencv_imgproc420 -lopencv_highgui420 -lopencv_imgcodecs420 -lopencv_objdetect420 -lopencv_features2d420 -lopencv_video420 -lopencv_dnn420 -lopencv_xfeatures2d420 -lopencv_plot420 -lopencv_tracking420 -lopencv_img_hash420 -lopencv_calib3d420
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
@@ -17,6 +21,8 @@ import (
 	"math"
 	"os"
 	"unsafe"
+
+	"gocv.io/x/gocv"
 )
 
 const (
@@ -33,10 +39,10 @@ type Recognizer struct {
 
 // Face holds coordinates and descriptor of the human face.
 type Face struct {
-	imagePtr   *C.image_pointer
-	Rectangle  image.Rectangle
-	Descriptor Descriptor
-	Shapes     []image.Point
+	imagePointer *C.image_pointer
+	Rectangle    image.Rectangle
+	Descriptor   Descriptor
+	Shapes       []image.Point
 }
 
 // Descriptor holds 128-dimensional feature vector.
@@ -110,11 +116,12 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 		err = ImageLoadError("Empty image")
 		return
 	}
-	cImgData := (*C.uint8_t)(&imgData[0])
+	cImgData := (*C.uchar)(&imgData[0])
 	cLen := C.int(len(imgData))
 	cType := C.int(type_)
+	var ptr C.image_pointer
 
-	ret := C.facerec_detect_buffer(rec.ptr, cImgData, cLen, cType)
+	ret := C.facerec_detect_buffer(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cImgData, cLen, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -136,7 +143,45 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePtr: ret.img}
+		fmt.Println("pointer", &ptr)
+		face := Face{imagePointer: &ptr}
+		x0 := int(rData[i*rectLen])
+		y0 := int(rData[i*rectLen+1])
+		x1 := int(rData[i*rectLen+2])
+		y1 := int(rData[i*rectLen+3])
+		face.Rectangle = image.Rect(x0, y0, x1, y1)
+		faces = append(faces, face)
+	}
+	return
+}
+
+func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
+	cType := C.int(type_)
+	var ptr C.image_pointer
+
+	ret := C.facerec_detect_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+
+	numFaces := int(ret.num_faces)
+	if numFaces == 0 {
+		return
+	}
+
+	// Copy faces data to Go structure.
+	defer C.free(unsafe.Pointer(ret.rectangles))
+
+	rDataLen := numFaces * rectLen
+	rDataPtr := unsafe.Pointer(ret.rectangles)
+	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
+
+	for i := 0; i < numFaces; i++ {
+		face := Face{imagePointer: &ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -156,8 +201,8 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	cType := C.int(type_)
 	cFile := C.CString(file)
 	defer C.free(unsafe.Pointer(cFile))
-
-	ret := C.facerec_detect_file(rec.ptr, cFile, cType)
+	var ptr *C.image_pointer
+	ret := C.facerec_detect_file(rec.ptr, ptr, cFile, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -179,7 +224,7 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePtr: ret.img}
+		face := Face{imagePointer: ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -190,6 +235,14 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	return
 }
 
+func (rec *Recognizer) DetectMat(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectMat(0, mat)
+}
+
+func (rec *Recognizer) DetectMatCNN(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectMat(1, mat)
+}
+
 // Detect returns all faces found on the provided image, sorted from
 // left to right. Empty list is returned if there are no faces, error is
 // returned if there was some error while decoding/processing image.
@@ -217,7 +270,7 @@ func (rec *Recognizer) Recognize(face *Face) error {
 	x1 := C.int(face.Rectangle.Max.X)
 	y1 := C.int(face.Rectangle.Max.Y)
 
-	ret := C.facerec_recognize(rec.ptr, face.imagePtr, x, y, x1, y1)
+	ret := C.facerec_recognize(rec.ptr, (*C.image_pointer)(unsafe.Pointer(face.imagePointer)), x, y, x1, y1)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -287,3 +340,7 @@ func fileExists(filename string) bool {
 	}
 	return !info.IsDir()
 }
+
+func (f *Face) Close() {
+	f.imagePointer = nil
+}
diff --git a/facerec.cc b/facerec.cc
index 9c1fcea..7d0529f 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -1,11 +1,14 @@
 #include <shared_mutex>
 #include <dlib/dnn.h>
 #include <dlib/image_loader/image_loader.h>
+#include <dlib/image_loader/jpeg_loader.h>
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
 #include <dlib/image_io.h>
+#include <dlib/opencv.h> 
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/types_c.h>
 #include "facerec.h"
-#include "jpeg_mem_loader.h"
 #include "classify.h"
 
 using namespace dlib;
@@ -45,7 +48,7 @@ std::vector<rectangle> FaceRec::DetectCNN(image_t& img) {
     return rects; 
 }
 
-std::tuple<descriptor, full_object_detection> FaceRec::Recognize(const image_t& img,rectangle rect) {
+std::tuple<descriptor, full_object_detection> FaceRec::Recognize(image_t& img,rectangle rect) {
     full_object_detection shape;
     descriptor descr;
     image_t face_chip;
@@ -104,7 +107,7 @@ void facerec_config(facerec* rec, unsigned long size, double padding, int jitter
 	cls->Config(size,padding, jittering, min_image_size);
 }
 
-facesret* facerec_detect_file(facerec* rec, const char* file,int type) {
+facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 	std::vector<rectangle> rects;
@@ -123,17 +126,40 @@ facesret* facerec_detect_file(facerec* rec, const char* file,int type) {
 		return ret;
 	}
     
-    return facerec_detect(ret, rec, img, type);
+    return facerec_detect(ret, p, rec, img, type);
 }
 
-facesret* facerec_detect_buffer(facerec* rec, const uint8_t* img_data, int len,int type) {
+facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
+    IplImage ipl_img = cvIplImage(*mat_img);
+    
+	try {
+		cv_image<bgr_pixel> dlib_img(&ipl_img);
+        assign_image(img, dlib_img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, p, rec, img, type);
+}
+
+facesret* facerec_detect_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 	std::vector<rectangle> rects;
 
 	try {
 		// TODO(Kagami): Support more file types?
-		load_mem_jpeg(img, img_data, len);
+		load_jpeg(img, img_data, size_t(len));
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
@@ -144,25 +170,25 @@ facesret* facerec_detect_buffer(facerec* rec, const uint8_t* img_data, int len,i
 		return ret;
 	}
     
-    return facerec_detect(ret, rec, img, type);
+    return facerec_detect(ret, p, rec, img, type);
 }
 
-facesret* facerec_detect(facesret* ret, facerec* rec, image_t img, int type) {
+facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t &img, int type) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	std::vector<rectangle> rects;
-    
+
     if (type == 0 ) {
         rects = cls->Detect(img);
     } else {
         rects = cls->DetectCNN(img);
     }
-    
+
     ret->num_faces = rects.size();
-    ret->img = new image_pointer{&img};
-	
+    p->p = new image_t(img);
+
     if (ret->num_faces == 0)
 		return ret;
-        
+
 	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
 	for (int i = 0; i < ret->num_faces; i++) {
 		long* dst = ret->rectangles + i * RECT_LEN;
@@ -174,14 +200,17 @@ facesret* facerec_detect(facesret* ret, facerec* rec, image_t img, int type) {
 	return ret;
 }
 
-faceret* facerec_recognize(facerec* rec, image_pointer *pointer, int x, int y, int x1, int y1) {
-    	faceret* ret = (faceret*)calloc(1, sizeof(faceret));
+faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+    faceret* ret = (faceret*)calloc(1, sizeof(faceret));
 	FaceRec* cls = (FaceRec*)(rec->cls);
+    image_t img = *((image_t*)p->p);
+
 	descriptor descr;
 	full_object_detection shape;
-    
-	try {
-		std::tie(descr, shape) = cls->Recognize(*(pointer->img), rectangle(x,y,x1,y1));
+	rectangle r = rectangle(x,y,x1,y1);
+
+   try {
+		std::tie(descr, shape) = cls->Recognize(img, r);
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
@@ -191,7 +220,6 @@ faceret* facerec_recognize(facerec* rec, image_pointer *pointer, int x, int y, i
 		ret->err_code = UNKNOWN_ERROR;
 		return ret;
 	}
-
 	ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
 	memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
 	
@@ -203,7 +231,7 @@ faceret* facerec_recognize(facerec* rec, image_pointer *pointer, int x, int y, i
 		dst[j*SHAPE_LEN] = shape.part(j).x();
 		dst[j*SHAPE_LEN+1] = shape.part(j).y();
     }
-	
+    
 	return ret;
 }
 
diff --git a/facerec.h b/facerec.h
index c39f0f5..3918cd3 100644
--- a/facerec.h
+++ b/facerec.h
@@ -2,52 +2,6 @@
 #ifndef FACEREC_H
 #define FACEREC_H
 
-#ifdef __cplusplus
-#include <shared_mutex>
-#include <dlib/dnn.h>
-#include <dlib/image_loader/image_loader.h>
-#include <dlib/image_processing/frontal_face_detector.h>
-#include <dlib/graph_utils.h>
-#include "classify.h"
-#include "template.h"
-
-typedef matrix<rgb_pixel> image_t;
-
-class FaceRec {   
-private:
-	std::mutex detector_mutex_;
-	std::mutex net_mutex_;
-	std::mutex cnn_net_mutex_;
-	std::shared_mutex samples_mutex_;
-	dlib::frontal_face_detector detector_;
-	dlib::shape_predictor sp_;
-	anet_type net_;
-	cnn_anet_type cnn_net_;
-	std::vector<descriptor> samples_;
-	std::vector<int> cats_;
-	int jittering = 0;
-	unsigned long size = 150;
-	double padding = 0.25;
-    int min_image_size;
-    
-public:
-	FaceRec(const char*, const char*, const char*);
-    std::vector<rectangle> Detect(image_t&);
-    std::vector<rectangle> DetectCNN(image_t&);
-    std::tuple<descriptor, full_object_detection> Recognize(const image_t&,rectangle);
-    
-	void SetSamples(std::vector<descriptor>&&, std::vector<int>&&);
-	int Classify(const descriptor&, float);
-    void Config(unsigned long, double, int, int);
-};
-
-static std::vector<image_t> jitter_image(const image_t& img,int count);
-
-#else
-typedef void *image_t;
-#endif
-
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -68,11 +22,10 @@ typedef struct facerec {
 } facerec;
 
 typedef struct image_pointer {
-    image_t *img;
+    void *p;
 } image_pointer;
 
 typedef struct facesret {
-    image_pointer *img;
 	int num_faces;
 	long* rectangles;
 	const char* err_str;
@@ -92,19 +45,71 @@ typedef struct faceret {
 #define SHAPE_LEN  2
 
 facerec* facerec_init(const char*,const char*,const char*);
-facesret* facerec_detect_file(facerec*, const char*,int);
-facesret* facerec_detect_buffer(facerec*, const uint8_t*, int, int);
-facesret* facerec_detect(facesret*, facerec*, image_t, int);
-
+facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
+facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
+facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
 faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
 void facerec_set_samples(facerec*, const float*, const int32_t*, int);
 int facerec_classify(facerec*, const float*, float);
 void facerec_free(facerec*);
 void facerec_config(facerec*, unsigned long, double, int, int);
 
-
+enum type
+    {
+        BMP,
+        JPG,
+        PNG,
+        DNG,
+        GIF,
+        UNKNOWN
+    };
 
 #ifdef __cplusplus
 }
 #endif
+
+#ifdef __cplusplus
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+#include "classify.h"
+#include "template.h"
+
+typedef matrix<rgb_pixel> image_t;
+
+class FaceRec {   
+private:
+	std::mutex detector_mutex_;
+	std::mutex net_mutex_;
+	std::mutex cnn_net_mutex_;
+	std::shared_mutex samples_mutex_;
+	dlib::frontal_face_detector detector_;
+	dlib::shape_predictor sp_;
+	anet_type net_;
+	cnn_anet_type cnn_net_;
+	std::vector<descriptor> samples_;
+	std::vector<int> cats_;
+	int jittering = 0;
+	unsigned long size = 150;
+	double padding = 0.25;
+    int min_image_size;
+    
+public:
+	FaceRec(const char*, const char*, const char*);
+    std::vector<rectangle> Detect(image_t&);
+    std::vector<rectangle> DetectCNN(image_t&);
+    std::tuple<descriptor, full_object_detection> Recognize(image_t&,rectangle);
+    
+	void SetSamples(std::vector<descriptor>&&, std::vector<int>&&);
+	int Classify(const descriptor&, float);
+    void Config(unsigned long, double, int, int);
+};
+
+static std::vector<image_t> jitter_image(const image_t& img,int count);
+facesret* facerec_detect(facesret*,  image_pointer *, facerec*,  image_t&, int);
+#else
+typedef void *image_t;
+#endif
 #endif /* FACEREC_H */
diff --git a/jpeg_mem_loader.cc b/jpeg_mem_loader.cc
deleted file mode 100644
index 0f1119c..0000000
--- a/jpeg_mem_loader.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-#include <stdio.h>
-#include <setjmp.h>
-#include <jpeglib.h>
-#include <dlib/image_loader/image_loader.h>
-#include "jpeg_mem_loader.h"
-
-// Based on dlib's JPEG loader and libjpeg example.
-struct jpeg_loader_error_mgr {
-	jpeg_error_mgr pub;  // "public" fields
-	jmp_buf setjmp_buffer;  // For return to caller
-};
-
-static void jpeg_loader_error_exit(j_common_ptr cinfo) {
-	// cinfo->err really points to a jpeg_loader_error_mgr struct, so coerce pointer.
-	jpeg_loader_error_mgr* myerr = (jpeg_loader_error_mgr*)cinfo->err;
-	// Return control to the setjmp point.
-	longjmp(myerr->setjmp_buffer, 1);
-}
-
-static void jpeg_loader_emit_message(j_common_ptr cinfo, int msg_level) {
-	// Just exit on any warning because file is probably corrupted.
-	if (msg_level < 0)
-		jpeg_loader_error_exit(cinfo);
-}
-
-// From memory JPEG loader because dlib lacks one.
-void load_mem_jpeg(dlib::matrix<dlib::rgb_pixel>& img, const uint8_t* img_data, int len) {
-	jpeg_decompress_struct cinfo;
-
-	jpeg_loader_error_mgr jerr;
-	cinfo.err = jpeg_std_error(&jerr.pub);
-	jerr.pub.error_exit = jpeg_loader_error_exit;
-	jerr.pub.emit_message = jpeg_loader_emit_message;
-	if (setjmp(jerr.setjmp_buffer)) {
-		char buffer[JMSG_LENGTH_MAX];
-		(jerr.pub.format_message)((j_common_ptr)&cinfo, buffer);
-		jpeg_destroy_decompress(&cinfo);
-		throw dlib::image_load_error(std::string("jpeg_mem_loader: decode error: ") + buffer);
-	}
-
-	jpeg_create_decompress(&cinfo);
-#if defined(LIBJPEG_TURBO_VERSION_NUMBER) && LIBJPEG_TURBO_VERSION_NUMBER >= 1004090
-	jpeg_mem_src(&cinfo, img_data, len);
-#else
-	jpeg_mem_src(&cinfo, (uint8_t*)img_data, len);
-#endif
-	jpeg_read_header(&cinfo, TRUE);
-	jpeg_start_decompress(&cinfo);
-
-	if (cinfo.output_components != 3) {
-		jpeg_destroy_decompress(&cinfo);
-		throw dlib::image_load_error("jpeg_mem_loader: unsupported pixel size");
-	}
-
-	img.set_size(cinfo.output_height, cinfo.output_width);
-	while (cinfo.output_scanline < cinfo.output_height) {
-		uint8_t* buffer_array[1] = { (uint8_t*)&img(cinfo.output_scanline, 0) };
-		jpeg_read_scanlines(&cinfo, buffer_array, 1);
-	}
-
-	jpeg_finish_decompress(&cinfo);
-	jpeg_destroy_decompress(&cinfo);
-}
diff --git a/jpeg_mem_loader.h b/jpeg_mem_loader.h
deleted file mode 100644
index 7980c2b..0000000
--- a/jpeg_mem_loader.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-#ifndef JPEG_MEM_LOADER_H
-#define JPEG_MEM_LOADER_H
-
-void load_mem_jpeg(dlib::matrix<dlib::rgb_pixel>& img, const uint8_t* img_data, int len);
-
-#endif /* JPEG_MEM_LOADER_H */

From 1c64a8d74ff1bd8dbab58d8cab4d5b2a49dfef59 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Wed, 12 Feb 2020 14:32:22 +0300
Subject: [PATCH 08/36] Fix memory leak

---
 face.go    |  1 +
 facerec.cc | 10 ++++++++++
 facerec.h  |  1 +
 3 files changed, 12 insertions(+)

diff --git a/face.go b/face.go
index 98166e9..885890e 100644
--- a/face.go
+++ b/face.go
@@ -342,5 +342,6 @@ func fileExists(filename string) bool {
 }
 
 func (f *Face) Close() {
+	C.image_pointer_free(f.imagePointer)
 	f.imagePointer = nil
 }
diff --git a/facerec.cc b/facerec.cc
index 7d0529f..498c196 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -269,6 +269,16 @@ void facerec_free(facerec* rec) {
 	}
 }
 
+void image_pointer_free(image_pointer* p) {
+	if (p) {
+		if (p->p) {
+			image_t *img = ((image_t*)p->p);
+			delete img;
+			p->p = NULL;
+		}
+	}
+}
+
 static std::vector<image_t> jitter_image(
     const image_t& img,
     int count
diff --git a/facerec.h b/facerec.h
index 3918cd3..e43b89f 100644
--- a/facerec.h
+++ b/facerec.h
@@ -53,6 +53,7 @@ void facerec_set_samples(facerec*, const float*, const int32_t*, int);
 int facerec_classify(facerec*, const float*, float);
 void facerec_free(facerec*);
 void facerec_config(facerec*, unsigned long, double, int, int);
+void image_pointer_free(image_pointer* p);
 
 enum type
     {

From a5d24353d4816d983c5adb5d7dfe51883270d4b1 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Wed, 12 Feb 2020 16:08:01 +0300
Subject: [PATCH 09/36] Add gender

---
 classify.cc |   2 +-
 classify.h  |   2 +-
 error.go    |   2 +-
 face.go     | 100 +++++++++++++++++------
 facerec.cc  | 221 ++++++++++----------------------------------------
 facerec.h   |  99 ++++++-----------------
 template.h  |  13 +++
 wrapper.cc  | 226 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 wrapper.h   |  73 +++++++++++++++++
 9 files changed, 457 insertions(+), 281 deletions(-)
 create mode 100644 wrapper.cc
 create mode 100644 wrapper.h

diff --git a/classify.cc b/classify.cc
index 539ca57..3cb2886 100644
--- a/classify.cc
+++ b/classify.cc
@@ -2,7 +2,7 @@
 #include <dlib/graph_utils.h>
 #include "classify.h"
 
-int classify(
+int classify_(
 	const std::vector<descriptor>& samples,
 	const std::vector<int>& cats,
 	const descriptor& test_sample,
diff --git a/classify.h b/classify.h
index c0a81ac..1a0c57b 100644
--- a/classify.h
+++ b/classify.h
@@ -4,7 +4,7 @@
 
 typedef dlib::matrix<float,0,1> descriptor;
 
-int classify(
+int classify_(
 	const std::vector<descriptor>& samples,
 	const std::vector<int>& cats,
 	const descriptor& test_sample,
diff --git a/error.go b/error.go
index 5f11f26..0a344e7 100644
--- a/error.go
+++ b/error.go
@@ -1,7 +1,7 @@
 package face
 
 // #include <stdint.h>
-// #include "facerec.h"
+// #include "wrapper.h"
 import "C"
 
 // An ImageLoadError is returned when provided image file is corrupted.
diff --git a/face.go b/face.go
index 885890e..053ae03 100644
--- a/face.go
+++ b/face.go
@@ -12,7 +12,7 @@ package face
 // #cgo LDFLAGS: -lgfortran
 // #include <stdlib.h>
 // #include <stdint.h>
-// #include "facerec.h"
+// #include "wrapper.h"
 import "C"
 import (
 	"errors"
@@ -31,6 +31,13 @@ const (
 	shapeLen = 2
 )
 
+type Gender int
+
+const (
+	Female Gender = iota
+	Male
+)
+
 // A Recognizer creates face descriptors for provided images and
 // classifies them into categories.
 type Recognizer struct {
@@ -43,6 +50,7 @@ type Face struct {
 	Rectangle    image.Rectangle
 	Descriptor   Descriptor
 	Shapes       []image.Point
+	Gender       Gender
 }
 
 // Descriptor holds 128-dimensional feature vector.
@@ -68,49 +76,80 @@ func NewWithShape(r image.Rectangle, s []image.Point, d Descriptor) Face {
 // NewRecognizer returns a new recognizer interface. modelDir points to
 // directory with shape_predictor_5_face_landmarks.dat and
 // dlib_face_recognition_resnet_model_v1.dat files.
-func NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath string) (rec *Recognizer, err error) {
-	if !fileExists(resnetPath) {
-		err = errors.New(fmt.Sprintf("File '%s' not found!", resnetPath))
-		return
-	}
-	if !fileExists(cnnResnetPath) {
-		err = errors.New(fmt.Sprintf("File '%s' not found!", cnnResnetPath))
+func NewRecognizer() (rec *Recognizer, err error) {
+	ptr := C.facerec_init()
+
+	if ptr.err_str != nil {
+		defer C.facerec_free(ptr)
+		defer C.free(unsafe.Pointer(ptr.err_str))
+		err = makeError(C.GoString(ptr.err_str), int(ptr.err_code))
 		return
 	}
+
+	rec = &Recognizer{ptr}
+	return
+}
+
+func (rec *Recognizer) SetShape(shapePredictorPath string) (err error) {
 	if !fileExists(shapePredictorPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", shapePredictorPath))
 		return
 	}
-	cResnetPath := C.CString(resnetPath)
-	defer C.free(unsafe.Pointer(cResnetPath))
-	cCnnResnetPath := C.CString(cnnResnetPath)
-	defer C.free(unsafe.Pointer(cCnnResnetPath))
 	cShapePredictorPath := C.CString(shapePredictorPath)
 	defer C.free(unsafe.Pointer(cShapePredictorPath))
+	C.facerec_set_shape(rec.ptr, cShapePredictorPath)
+	return
+}
 
-	ptr := C.facerec_init(cResnetPath, cCnnResnetPath, cShapePredictorPath)
-
-	if ptr.err_str != nil {
-		defer C.facerec_free(ptr)
-		defer C.free(unsafe.Pointer(ptr.err_str))
-		err = makeError(C.GoString(ptr.err_str), int(ptr.err_code))
+func (rec *Recognizer) SetDescriptor(resnetPath string) (err error) {
+	if !fileExists(resnetPath) {
+		err = errors.New(fmt.Sprintf("File '%s' not found!", resnetPath))
 		return
 	}
+	cResnetPath := C.CString(resnetPath)
+	defer C.free(unsafe.Pointer(cResnetPath))
+	C.facerec_set_descriptor(rec.ptr, cResnetPath)
+	return
+}
 
-	rec = &Recognizer{ptr}
+func (rec *Recognizer) SetCNN(cnnResnetPath string) (err error) {
+	if !fileExists(cnnResnetPath) {
+		err = errors.New(fmt.Sprintf("File '%s' not found!", cnnResnetPath))
+		return
+	}
+	cCnnResnetPath := C.CString(cnnResnetPath)
+	defer C.free(unsafe.Pointer(cCnnResnetPath))
+	C.facerec_set_cnn(rec.ptr, cCnnResnetPath)
 	return
 }
 
-func NewRecognizerWithConfig(resnetPath, cnnResnetPath, shapePredictorPath string, size int, padding float32, jittering int, minImageSize int) (rec *Recognizer, err error) {
-	rec, err = NewRecognizer(resnetPath, cnnResnetPath, shapePredictorPath)
-	cSize := C.ulong(size)
-	cPadding := C.double(padding)
-	cJittering := C.int(jittering)
-	cMinImageSize := C.int(minImageSize)
-	C.facerec_config(rec.ptr, cSize, cPadding, cJittering, cMinImageSize)
+func (rec *Recognizer) SetGender(genderPath string) (err error) {
+	if !fileExists(genderPath) {
+		err = errors.New(fmt.Sprintf("File '%s' not found!", genderPath))
+		return
+	}
+	cGenderPath := C.CString(genderPath)
+	defer C.free(unsafe.Pointer(cGenderPath))
+	C.facerec_set_gender(rec.ptr, cGenderPath)
 	return
 }
 
+func (rec *Recognizer) SetSize(size int) {
+	C.facerec_config_size(rec.ptr, C.ulong(size))
+}
+
+func (rec *Recognizer) SetPadding(padding float32) {
+	C.facerec_config_padding(rec.ptr, C.double(padding))
+}
+
+func (rec *Recognizer) SetJittering(jittering int) {
+	C.facerec_config_jittering(rec.ptr, C.int(jittering))
+}
+
+func (rec *Recognizer) SetMinImageSize(minImageSize int) {
+	C.facerec_config_min_image_size(rec.ptr, C.int(minImageSize))
+}
+
 func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, err error) {
 	if len(imgData) == 0 {
 		err = ImageLoadError("Empty image")
@@ -264,6 +303,15 @@ func (rec *Recognizer) DetectFromFileCNN(imgPath string) (faces []Face, err erro
 	return rec.detectFile(1, imgPath)
 }
 
+func (rec *Recognizer) GetGender(face *Face) {
+	x := C.int(face.Rectangle.Min.X)
+	y := C.int(face.Rectangle.Min.Y)
+	x1 := C.int(face.Rectangle.Max.X)
+	y1 := C.int(face.Rectangle.Max.Y)
+
+	face.Gender = Gender(int(C.facerec_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(face.imagePointer)), x, y, x1, y1)))
+}
+
 func (rec *Recognizer) Recognize(face *Face) error {
 	x := C.int(face.Rectangle.Min.X)
 	y := C.int(face.Rectangle.Min.Y)
diff --git a/facerec.cc b/facerec.cc
index 498c196..4f4d22b 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -13,15 +13,27 @@
 
 using namespace dlib;
 
-FaceRec::FaceRec(const char* resnet_path,const char* cnn_resnet_path,const char* shape_predictor_path) {
+FaceRec::FaceRec() {
 		detector_ = get_frontal_face_detector();
+}
+
+void FaceRec::setCNN(const char* cnn_resnet_path) {
+    deserialize(std::string(cnn_resnet_path)) >> cnn_net_;
+}
+
+void FaceRec::setShape(const char* shape_predictor_path) {
+    deserialize(std::string(shape_predictor_path)) >> sp_;
+}
+
+void FaceRec::setDescriptor(const char* resnet_path) {
+    deserialize(std::string(resnet_path)) >> net_;
+}
 
-		deserialize(std::string(shape_predictor_path)) >> sp_;
-		deserialize(std::string(resnet_path)) >> net_;
-		deserialize(std::string(cnn_resnet_path)) >> cnn_net_;
+void FaceRec::setGender(const char* gender_path) {
+    deserialize(std::string(gender_path)) >> gender_net_;
 }
 
-std::vector<rectangle> FaceRec::Detect(image_t& img) {
+std::vector<rectangle> FaceRec::detect(image_t& img) {
     	std::vector<rectangle> rects;
     	std::lock_guard<std::mutex> lock(detector_mutex_);
         
@@ -33,7 +45,7 @@ std::vector<rectangle> FaceRec::Detect(image_t& img) {
     return rects;
 }
 
-std::vector<rectangle> FaceRec::DetectCNN(image_t& img) {
+std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     std::vector<rectangle> rects;
     	std::lock_guard<std::mutex> lock(cnn_net_mutex_);
         
@@ -48,7 +60,19 @@ std::vector<rectangle> FaceRec::DetectCNN(image_t& img) {
     return rects; 
 }
 
-std::tuple<descriptor, full_object_detection> FaceRec::Recognize(image_t& img,rectangle rect) {
+int FaceRec::gender(image_t& img,rectangle rect) {
+    image_t face_chip;
+
+    std::lock_guard<std::mutex> lock(gender_net_mutex_);
+
+    auto shape = sp_(img, rect);
+        
+    extract_image_chip(img, get_face_chip_details(shape, 32), face_chip);
+        
+    return int(gender_net_(face_chip));
+}
+
+std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_t& img,rectangle rect) {
     full_object_detection shape;
     descriptor descr;
     image_t face_chip;
@@ -68,109 +92,31 @@ std::tuple<descriptor, full_object_detection> FaceRec::Recognize(image_t& img,re
     return std::make_tuple(descr, shape);
 }
 
-void FaceRec::SetSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
+void FaceRec::setSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
     std::unique_lock<std::shared_mutex> lock(samples_mutex_);
     samples_ = std::move(samples);
     cats_ = std::move(cats);
 }
 
-int FaceRec::Classify(const descriptor& test_sample, float tolerance) {
+int FaceRec::classify(const descriptor& test_sample, float tolerance) {
     std::shared_lock<std::shared_mutex> lock(samples_mutex_);
-    return classify(samples_, cats_, test_sample, tolerance);
+    return classify_(samples_, cats_, test_sample, tolerance);
 }
 
-void FaceRec::Config(unsigned long new_size, double new_padding, int new_jittering, int new_min_image_size) {
+void FaceRec::setSize(unsigned long new_size) {
     size = new_size;
-    padding = new_padding;
-    jittering = new_jittering;
-    min_image_size = new_min_image_size;
-}
-    
-// Plain C interface for Go.
-
-facerec* facerec_init(const char* resnet_path, const char* cnn_resnet_path, const char* shape_predictor_path) {
-	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
-	try {
-		FaceRec* cls = new FaceRec(resnet_path,cnn_resnet_path,shape_predictor_path);
-		rec->cls = (void*)cls;
-	} catch(serialization_error& e) {
-		rec->err_str = strdup(e.what());
-		rec->err_code = SERIALIZATION_ERROR;
-	} catch (std::exception& e) {
-		rec->err_str = strdup(e.what());
-		rec->err_code = UNKNOWN_ERROR;
-	}
-	return rec;
 }
-void facerec_config(facerec* rec, unsigned long size, double padding, int jittering, int min_image_size) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-	cls->Config(size,padding, jittering, min_image_size);
-}
-
-facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,int type) {
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
-	image_t img;
-	std::vector<rectangle> rects;
 
-	try {
-		// TODO(Kagami): Support more file types?
-        // Danil_e71: support png, gif, bmp, jpg from file
-        load_image(img,file);
-	} catch(image_load_error& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
-	} catch (std::exception& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = UNKNOWN_ERROR;
-		return ret;
-	}
-    
-    return facerec_detect(ret, p, rec, img, type);
+void FaceRec::setPadding(double new_padding) {
+    padding = new_padding;
 }
 
-facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
-	image_t img;
-	std::vector<rectangle> rects;
-    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
-    IplImage ipl_img = cvIplImage(*mat_img);
-    
-	try {
-		cv_image<bgr_pixel> dlib_img(&ipl_img);
-        assign_image(img, dlib_img);
-	} catch(image_load_error& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
-	} catch (std::exception& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = UNKNOWN_ERROR;
-		return ret;
-	}
-    
-    return facerec_detect(ret, p, rec, img, type);
+void FaceRec::setJittering(int new_jittering) {
+    jittering = new_jittering;
 }
 
-facesret* facerec_detect_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
-	image_t img;
-	std::vector<rectangle> rects;
-
-	try {
-		// TODO(Kagami): Support more file types?
-		load_jpeg(img, img_data, size_t(len));
-	} catch(image_load_error& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
-	} catch (std::exception& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = UNKNOWN_ERROR;
-		return ret;
-	}
-    
-    return facerec_detect(ret, p, rec, img, type);
+void FaceRec::setMinImageSize(int new_min_image_size) {
+    min_image_size = new_min_image_size;
 }
 
 facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t &img, int type) {
@@ -178,9 +124,9 @@ facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t
 	std::vector<rectangle> rects;
 
     if (type == 0 ) {
-        rects = cls->Detect(img);
+        rects = cls->detect(img);
     } else {
-        rects = cls->DetectCNN(img);
+        rects = cls->detectCNN(img);
     }
 
     ret->num_faces = rects.size();
@@ -200,86 +146,7 @@ facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t
 	return ret;
 }
 
-faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
-    faceret* ret = (faceret*)calloc(1, sizeof(faceret));
-	FaceRec* cls = (FaceRec*)(rec->cls);
-    image_t img = *((image_t*)p->p);
-
-	descriptor descr;
-	full_object_detection shape;
-	rectangle r = rectangle(x,y,x1,y1);
-
-   try {
-		std::tie(descr, shape) = cls->Recognize(img, r);
-	} catch(image_load_error& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
-	} catch (std::exception& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = UNKNOWN_ERROR;
-		return ret;
-	}
-	ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
-	memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
-	
-	ret->num_shape = shape.num_parts();
-	ret->shape = (long*)malloc(ret->num_shape * SHAPE_LEN * sizeof(long));
-
-	long* dst = ret->shape;
-	for (int j = 0; j < ret->num_shape; j++) {
-		dst[j*SHAPE_LEN] = shape.part(j).x();
-		dst[j*SHAPE_LEN+1] = shape.part(j).y();
-    }
-    
-	return ret;
-}
-
-void facerec_set_samples(
-	facerec* rec,
-	const float* c_samples,
-	const int32_t* c_cats,
-	int len
-) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-	std::vector<descriptor> samples;
-	samples.reserve(len);
-	for (int i = 0; i < len; i++) {
-		descriptor sample = mat(c_samples + i*DESCR_LEN, DESCR_LEN, 1);
-		samples.push_back(std::move(sample));
-	}
-	std::vector<int> cats(c_cats, c_cats + len);
-	cls->SetSamples(std::move(samples), std::move(cats));
-}
-
-int facerec_classify(facerec* rec, const float* c_test_sample, float tolerance) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-	descriptor test_sample = mat(c_test_sample, DESCR_LEN, 1);
-	return cls->Classify(test_sample, tolerance);
-}
-
-void facerec_free(facerec* rec) {
-	if (rec) {
-		if (rec->cls) {
-			FaceRec* cls = (FaceRec*)(rec->cls);
-			delete cls;
-			rec->cls = NULL;
-		}
-		free(rec);
-	}
-}
-
-void image_pointer_free(image_pointer* p) {
-	if (p) {
-		if (p->p) {
-			image_t *img = ((image_t*)p->p);
-			delete img;
-			p->p = NULL;
-		}
-	}
-}
-
-static std::vector<image_t> jitter_image(
+std::vector<image_t> jitter_image(
     const image_t& img,
     int count
 )
diff --git a/facerec.h b/facerec.h
index e43b89f..8c35cb0 100644
--- a/facerec.h
+++ b/facerec.h
@@ -2,79 +2,13 @@
 #ifndef FACEREC_H
 #define FACEREC_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-	IMAGE_LOAD_ERROR,
-	SERIALIZATION_ERROR,
-	UNKNOWN_ERROR,
-} err_code;
-
-typedef struct facerec {
-	void* cls;
-	const char* err_str;
-	err_code err_code;
-	int jittering;
-	unsigned long size;
-	double padding;
-} facerec;
-
-typedef struct image_pointer {
-    void *p;
-} image_pointer;
-
-typedef struct facesret {
-	int num_faces;
-	long* rectangles;
-	const char* err_str;
-	err_code err_code;
-} facesret;
-
-typedef struct faceret {
-	float *descriptor;
-	int num_shape;
-	long* shape;
-	const char* err_str;
-	err_code err_code;
-} faceret;
-
-#define RECT_LEN   4
-#define DESCR_LEN  128
-#define SHAPE_LEN  2
-
-facerec* facerec_init(const char*,const char*,const char*);
-facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
-facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
-facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
-faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
-void facerec_set_samples(facerec*, const float*, const int32_t*, int);
-int facerec_classify(facerec*, const float*, float);
-void facerec_free(facerec*);
-void facerec_config(facerec*, unsigned long, double, int, int);
-void image_pointer_free(image_pointer* p);
-
-enum type
-    {
-        BMP,
-        JPG,
-        PNG,
-        DNG,
-        GIF,
-        UNKNOWN
-    };
-
-#ifdef __cplusplus
-}
-#endif
-
 #ifdef __cplusplus
 #include <shared_mutex>
 #include <dlib/dnn.h>
 #include <dlib/image_loader/image_loader.h>
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
+#include "wrapper.h"
 #include "classify.h"
 #include "template.h"
 
@@ -85,11 +19,15 @@ class FaceRec {
 	std::mutex detector_mutex_;
 	std::mutex net_mutex_;
 	std::mutex cnn_net_mutex_;
+    std::mutex gender_net_mutex_;
+    
 	std::shared_mutex samples_mutex_;
 	dlib::frontal_face_detector detector_;
 	dlib::shape_predictor sp_;
 	anet_type net_;
 	cnn_anet_type cnn_net_;
+    agender_type gender_net_;
+    
 	std::vector<descriptor> samples_;
 	std::vector<int> cats_;
 	int jittering = 0;
@@ -98,17 +36,28 @@ class FaceRec {
     int min_image_size;
     
 public:
-	FaceRec(const char*, const char*, const char*);
-    std::vector<rectangle> Detect(image_t&);
-    std::vector<rectangle> DetectCNN(image_t&);
-    std::tuple<descriptor, full_object_detection> Recognize(image_t&,rectangle);
+	FaceRec();
+    
+    void setCNN(const char*);
+    void setShape(const char*);
+    void setDescriptor(const char*);
+    void setGender(const char*);
+    
+    void setSize(unsigned long);
+    void setPadding(double);
+    void setJittering(int);
+    void setMinImageSize(int);
+
+    int gender(image_t& img,rectangle);
+    std::vector<rectangle> detect(image_t&);
+    std::vector<rectangle> detectCNN(image_t&);
+    std::tuple<descriptor, full_object_detection> recognize(image_t&,rectangle);
     
-	void SetSamples(std::vector<descriptor>&&, std::vector<int>&&);
-	int Classify(const descriptor&, float);
-    void Config(unsigned long, double, int, int);
+	void setSamples(std::vector<descriptor>&&, std::vector<int>&&);
+	int classify(const descriptor&, float);
 };
 
-static std::vector<image_t> jitter_image(const image_t& img,int count);
+std::vector<image_t> jitter_image(const image_t& img,int count);
 facesret* facerec_detect(facesret*,  image_pointer *, facerec*,  image_t&, int);
 #else
 typedef void *image_t;
diff --git a/template.h b/template.h
index a46c6f6..ac88778 100644
--- a/template.h
+++ b/template.h
@@ -49,5 +49,18 @@ using anet_type = loss_metric<fc_no_bias<128,avg_pool_everything<
                             input_rgb_image_sized<150>
                             >>>>>>>>>>>>;
 
+
+template <int N, template <typename> class BN, int stride, typename SUBNET>
+using block_gender = BN<con<N, 3, 3, stride, stride, relu<BN<con<N, 3, 3, stride, stride, SUBNET>>>>>;
+
+template <int N, typename SUBNET> using res_ = relu<block_gender<N, bn_con, 1, SUBNET>>;
+template <int N, typename SUBNET> using ares_ = relu<block_gender<N, affine, 1, SUBNET>>;
+
+template <typename SUBNET> using alevel1_ = avg_pool<2, 2, 2, 2, ares_<64, SUBNET>>;
+template <typename SUBNET> using alevel2_ = avg_pool<2, 2, 2, 2, ares_<32, SUBNET>>;
+
+using agender_type = loss_multiclass_log<fc<2, multiply<relu<fc<16, multiply<alevel1_<alevel2_< input_rgb_image_sized<32>>>>>>>>>;
+
+
 #endif
 #endif /* TEMPLATE_H */
diff --git a/wrapper.cc b/wrapper.cc
new file mode 100644
index 0000000..ce6c407
--- /dev/null
+++ b/wrapper.cc
@@ -0,0 +1,226 @@
+// Plain C interface for Go.
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_loader/jpeg_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+#include <dlib/image_io.h>
+#include <dlib/opencv.h> 
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/types_c.h>
+#include "facerec.h"
+#include "classify.h"
+
+using namespace dlib;
+
+facerec* facerec_init() {
+	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
+	try {
+		FaceRec* cls = new FaceRec();
+		rec->cls = (void*)cls;
+	} catch(serialization_error& e) {
+		rec->err_str = strdup(e.what());
+		rec->err_code = SERIALIZATION_ERROR;
+	} catch (std::exception& e) {
+		rec->err_str = strdup(e.what());
+		rec->err_code = UNKNOWN_ERROR;
+	}
+	return rec;
+}
+
+void facerec_config_size(facerec* rec, unsigned long size) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setSize(size);
+}
+
+void facerec_config_padding(facerec* rec, double padding) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setPadding(padding);
+}
+
+void facerec_config_jittering(facerec* rec, int jittering) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setJittering(jittering);
+}
+
+void facerec_config_min_image_size(facerec* rec, int min_image_size) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setMinImageSize(min_image_size);
+}
+
+void facerec_set_cnn(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setCNN(file);
+}
+
+void facerec_set_shape(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setShape(file);
+}
+
+void facerec_set_descriptor(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setDescriptor(file);
+}
+
+void facerec_set_gender(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setGender(file);
+}
+
+facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+
+	try {
+		// TODO(Kagami): Support more file types?
+        // Danil_e71: support png, gif, bmp, jpg from file
+        load_image(img,file);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, p, rec, img, type);
+}
+
+facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
+    IplImage ipl_img = cvIplImage(*mat_img);
+    
+	try {
+		cv_image<bgr_pixel> dlib_img(&ipl_img);
+        assign_image(img, dlib_img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, p, rec, img, type);
+}
+
+facesret* facerec_detect_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+
+	try {
+		// TODO(Kagami): Support more file types?
+		load_jpeg(img, img_data, size_t(len));
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, p, rec, img, type);
+}
+
+faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+    faceret* ret = (faceret*)calloc(1, sizeof(faceret));
+	FaceRec* cls = (FaceRec*)(rec->cls);
+    image_t img = *((image_t*)p->p);
+
+	descriptor descr;
+	full_object_detection shape;
+	rectangle r = rectangle(x,y,x1,y1);
+
+   try {
+		std::tie(descr, shape) = cls->recognize(img, r);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+	ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
+	memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
+	
+	ret->num_shape = shape.num_parts();
+	ret->shape = (long*)malloc(ret->num_shape * SHAPE_LEN * sizeof(long));
+
+	long* dst = ret->shape;
+	for (int j = 0; j < ret->num_shape; j++) {
+		dst[j*SHAPE_LEN] = shape.part(j).x();
+		dst[j*SHAPE_LEN+1] = shape.part(j).y();
+    }
+    
+	return ret;
+}
+
+int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+    image_t img = *((image_t*)p->p);
+    int gender = 0;
+	rectangle r = rectangle(x,y,x1,y1);
+
+	gender = cls->gender(img, r);
+    
+	return gender;
+}
+
+void facerec_set_samples(
+	facerec* rec,
+	const float* c_samples,
+	const int32_t* c_cats,
+	int len
+) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	std::vector<descriptor> samples;
+	samples.reserve(len);
+	for (int i = 0; i < len; i++) {
+		descriptor sample = mat(c_samples + i*DESCR_LEN, DESCR_LEN, 1);
+		samples.push_back(std::move(sample));
+	}
+	std::vector<int> cats(c_cats, c_cats + len);
+	cls->setSamples(std::move(samples), std::move(cats));
+}
+
+int facerec_classify(facerec* rec, const float* c_test_sample, float tolerance) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	descriptor test_sample = mat(c_test_sample, DESCR_LEN, 1);
+	return cls->classify(test_sample, tolerance);
+}
+
+void facerec_free(facerec* rec) {
+	if (rec) {
+		if (rec->cls) {
+			FaceRec* cls = (FaceRec*)(rec->cls);
+			delete cls;
+			rec->cls = NULL;
+		}
+		free(rec);
+	}
+}
+
+void image_pointer_free(image_pointer* p) {
+	if (p) {
+		if (p->p) {
+			image_t *img = ((image_t*)p->p);
+			delete img;
+			p->p = NULL;
+		}
+	}
+}
\ No newline at end of file
diff --git a/wrapper.h b/wrapper.h
new file mode 100644
index 0000000..f08f49d
--- /dev/null
+++ b/wrapper.h
@@ -0,0 +1,73 @@
+#pragma once
+#ifndef WRAPPER_H
+#define WRAPPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	IMAGE_LOAD_ERROR,
+	SERIALIZATION_ERROR,
+	UNKNOWN_ERROR,
+} err_code;
+
+typedef struct facerec {
+	void* cls;
+	const char* err_str;
+	err_code err_code;
+	int jittering;
+	unsigned long size;
+	double padding;
+} facerec;
+
+typedef struct image_pointer {
+    void *p;
+} image_pointer;
+
+typedef struct facesret {
+	int num_faces;
+	long* rectangles;
+	const char* err_str;
+	err_code err_code;
+} facesret;
+
+typedef struct faceret {
+	float *descriptor;
+	int num_shape;
+	long* shape;
+	const char* err_str;
+	err_code err_code;
+} faceret;
+
+#define RECT_LEN   4
+#define DESCR_LEN  128
+#define SHAPE_LEN  2
+
+facerec* facerec_init();
+facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
+facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
+facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
+faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
+int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1);
+void facerec_set_cnn(facerec* , const char *);
+void facerec_set_shape(facerec* , const char *);
+void facerec_set_descriptor(facerec* , const char *);
+void facerec_set_gender(facerec* , const char *);
+
+
+
+void facerec_set_samples(facerec*, const float*, const int32_t*, int);
+int facerec_classify(facerec*, const float*, float);
+void facerec_free(facerec*);
+void facerec_config_size(facerec* rec, unsigned long size);
+void facerec_config_padding(facerec* rec, double padding);
+void facerec_config_jittering(facerec* rec, int jittering);
+void facerec_config_min_image_size(facerec* rec, int min_image_size);
+void image_pointer_free(image_pointer* p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WRAPPER_H */

From 2169ac8f1ef75620344206d31e1973bc01ce1e10 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Wed, 12 Feb 2020 16:10:26 +0300
Subject: [PATCH 10/36] Remove libs

---
 face.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/face.go b/face.go
index 053ae03..9052c11 100644
--- a/face.go
+++ b/face.go
@@ -7,9 +7,6 @@ package face
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
-// #cgo LDFLAGS: -lopenblas
-// #cgo LDFLAGS: -lquadmath
-// #cgo LDFLAGS: -lgfortran
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 04ab32b8c9a97c90fceac2defba65ba711457850 Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 20:28:24 +0300
Subject: [PATCH 11/36] Fix ldconfig

---
 Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Makefile b/Makefile
index 7b6ed98..88dc621 100644
--- a/Makefile
+++ b/Makefile
@@ -36,6 +36,7 @@ build:
 sudo_install:
 	cd $(TMP_DIR)dlib-${BRANCH}/build
 	sudo make install
+	sudo ldconfig
 
 clean:
 	rm -rf $(TMP_DIR)dlib-${BRANCH}

From 5d94d4ce9e064340681d5fa668213faf19b0ab5f Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 20:52:23 +0300
Subject: [PATCH 12/36] Add tags * if you want use 'gocv' - build -tags gocv

---
 face.go    | 55 ++++------------------------------------------
 facerec.cc |  3 ---
 gocv.cc    | 32 +++++++++++++++++++++++++++
 gocv.go    | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 gocv.h     | 19 ++++++++++++++++
 wrapper.cc | 26 ----------------------
 wrapper.h  |  1 -
 7 files changed, 119 insertions(+), 81 deletions(-)
 create mode 100644 gocv.cc
 create mode 100644 gocv.go
 create mode 100644 gocv.h

diff --git a/face.go b/face.go
index 9052c11..b4c6c08 100644
--- a/face.go
+++ b/face.go
@@ -1,9 +1,5 @@
 package face
 
-// #cgo !windows pkg-config: opencv4
-// #cgo CXXFLAGS:   --std=c++11
-// #cgo windows  CPPFLAGS:   -IC:/opencv/build/install/include
-// #cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core420 -lopencv_face420 -lopencv_videoio420 -lopencv_imgproc420 -lopencv_highgui420 -lopencv_imgcodecs420 -lopencv_objdetect420 -lopencv_features2d420 -lopencv_video420 -lopencv_dnn420 -lopencv_xfeatures2d420 -lopencv_plot420 -lopencv_tracking420 -lopencv_img_hash420 -lopencv_calib3d420
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
@@ -18,8 +14,6 @@ import (
 	"math"
 	"os"
 	"unsafe"
-
-	"gocv.io/x/gocv"
 )
 
 const (
@@ -35,6 +29,10 @@ const (
 	Male
 )
 
+func (g Gender) String() string {
+	return [...]string{"Female", "Male"}[g]
+}
+
 // A Recognizer creates face descriptors for provided images and
 // classifies them into categories.
 type Recognizer struct {
@@ -191,43 +189,6 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 	return
 }
 
-func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
-	cType := C.int(type_)
-	var ptr C.image_pointer
-
-	ret := C.facerec_detect_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
-	defer C.free(unsafe.Pointer(ret))
-
-	if ret.err_str != nil {
-		defer C.free(unsafe.Pointer(ret.err_str))
-		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
-		return
-	}
-
-	numFaces := int(ret.num_faces)
-	if numFaces == 0 {
-		return
-	}
-
-	// Copy faces data to Go structure.
-	defer C.free(unsafe.Pointer(ret.rectangles))
-
-	rDataLen := numFaces * rectLen
-	rDataPtr := unsafe.Pointer(ret.rectangles)
-	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
-
-	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: &ptr}
-		x0 := int(rData[i*rectLen])
-		y0 := int(rData[i*rectLen+1])
-		x1 := int(rData[i*rectLen+2])
-		y1 := int(rData[i*rectLen+3])
-		face.Rectangle = image.Rect(x0, y0, x1, y1)
-		faces = append(faces, face)
-	}
-	return
-}
-
 func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err error) {
 	if !fileExists(file) {
 		err = ImageLoadError(fmt.Sprintf("File '%s' not found!", file))
@@ -271,14 +232,6 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	return
 }
 
-func (rec *Recognizer) DetectMat(mat gocv.Mat) (faces []Face, err error) {
-	return rec.detectMat(0, mat)
-}
-
-func (rec *Recognizer) DetectMatCNN(mat gocv.Mat) (faces []Face, err error) {
-	return rec.detectMat(1, mat)
-}
-
 // Detect returns all faces found on the provided image, sorted from
 // left to right. Empty list is returned if there are no faces, error is
 // returned if there was some error while decoding/processing image.
diff --git a/facerec.cc b/facerec.cc
index 4f4d22b..ddc4eb6 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -5,9 +5,6 @@
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
 #include <dlib/image_io.h>
-#include <dlib/opencv.h> 
-#include <opencv2/core/core.hpp>
-#include <opencv2/core/types_c.h>
 #include "facerec.h"
 #include "classify.h"
 
diff --git a/gocv.cc b/gocv.cc
new file mode 100644
index 0000000..2c426d1
--- /dev/null
+++ b/gocv.cc
@@ -0,0 +1,32 @@
+// +build gocv
+
+#include <dlib/opencv.h> 
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/types_c.h>
+#include "facerec.h"
+#include "gocv.h"
+
+using namespace dlib;
+
+facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+	std::vector<rectangle> rects;
+    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
+    IplImage ipl_img = cvIplImage(*mat_img);
+    
+	try {
+		cv_image<bgr_pixel> dlib_img(&ipl_img);
+        assign_image(img, dlib_img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return facerec_detect(ret, p, rec, img, type);
+}
diff --git a/gocv.go b/gocv.go
new file mode 100644
index 0000000..fdee37c
--- /dev/null
+++ b/gocv.go
@@ -0,0 +1,64 @@
+// +build gocv
+
+package face
+
+// #cgo !windows pkg-config: opencv4
+// #cgo CXXFLAGS:   --std=c++1z
+// #cgo windows  CPPFLAGS:   -IC:/opencv/build/install/include
+// #cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core420 -lopencv_face420 -lopencv_videoio420 -lopencv_imgproc420 -lopencv_highgui420 -lopencv_imgcodecs420 -lopencv_objdetect420 -lopencv_features2d420 -lopencv_video420 -lopencv_dnn420 -lopencv_xfeatures2d420 -lopencv_plot420 -lopencv_tracking420 -lopencv_img_hash420 -lopencv_calib3d420
+// #include <stdlib.h>
+// #include <stdint.h>
+// #include "wrapper.h"
+// #include "gocv.h"
+import "C"
+import (
+	"image"
+	"unsafe"
+
+	"gocv.io/x/gocv"
+)
+
+func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
+	cType := C.int(type_)
+	var ptr C.image_pointer
+
+	ret := C.facerec_detect_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+
+	numFaces := int(ret.num_faces)
+	if numFaces == 0 {
+		return
+	}
+
+	// Copy faces data to Go structure.
+	defer C.free(unsafe.Pointer(ret.rectangles))
+
+	rDataLen := numFaces * rectLen
+	rDataPtr := unsafe.Pointer(ret.rectangles)
+	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
+
+	for i := 0; i < numFaces; i++ {
+		face := Face{imagePointer: &ptr}
+		x0 := int(rData[i*rectLen])
+		y0 := int(rData[i*rectLen+1])
+		x1 := int(rData[i*rectLen+2])
+		y1 := int(rData[i*rectLen+3])
+		face.Rectangle = image.Rect(x0, y0, x1, y1)
+		faces = append(faces, face)
+	}
+	return
+}
+
+func (rec *Recognizer) DetectMat(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectMat(0, mat)
+}
+
+func (rec *Recognizer) DetectMatCNN(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectMat(1, mat)
+}
diff --git a/gocv.h b/gocv.h
new file mode 100644
index 0000000..5370859
--- /dev/null
+++ b/gocv.h
@@ -0,0 +1,19 @@
+// +build gocv
+
+#pragma once
+#ifndef GOCV_H
+#define GOCV_H
+
+#include "wrapper.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GOCV_H */
diff --git a/wrapper.cc b/wrapper.cc
index ce6c407..6b22a06 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -6,9 +6,6 @@
 #include <dlib/image_processing/frontal_face_detector.h>
 #include <dlib/graph_utils.h>
 #include <dlib/image_io.h>
-#include <dlib/opencv.h> 
-#include <opencv2/core/core.hpp>
-#include <opencv2/core/types_c.h>
 #include "facerec.h"
 #include "classify.h"
 
@@ -91,29 +88,6 @@ facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,i
     return facerec_detect(ret, p, rec, img, type);
 }
 
-facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
-	image_t img;
-	std::vector<rectangle> rects;
-    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
-    IplImage ipl_img = cvIplImage(*mat_img);
-    
-	try {
-		cv_image<bgr_pixel> dlib_img(&ipl_img);
-        assign_image(img, dlib_img);
-	} catch(image_load_error& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
-	} catch (std::exception& e) {
-		ret->err_str = strdup(e.what());
-		ret->err_code = UNKNOWN_ERROR;
-		return ret;
-	}
-    
-    return facerec_detect(ret, p, rec, img, type);
-}
-
 facesret* facerec_detect_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
diff --git a/wrapper.h b/wrapper.h
index f08f49d..03bcadd 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -47,7 +47,6 @@ typedef struct faceret {
 facerec* facerec_init();
 facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
 facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
-facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
 faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
 int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1);
 void facerec_set_cnn(facerec* , const char *);

From 1a45a7fb0e6a8ed6c653e50b00e79945920e8d52 Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:46:46 +0300
Subject: [PATCH 13/36] Add age

---
 face.go    | 35 +++++++++++++++++++++-------
 facerec.cc | 58 ++++++++++++++++++++++++++++++++++++++--------
 facerec.h  |  9 ++++++++
 gocv.go    |  2 +-
 template.h | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 wrapper.cc | 16 ++++++++++---
 wrapper.h  |  6 ++---
 7 files changed, 169 insertions(+), 24 deletions(-)

diff --git a/face.go b/face.go
index b4c6c08..cc0cf29 100644
--- a/face.go
+++ b/face.go
@@ -41,11 +41,12 @@ type Recognizer struct {
 
 // Face holds coordinates and descriptor of the human face.
 type Face struct {
-	imagePointer *C.image_pointer
+	imagePointer C.image_pointer
 	Rectangle    image.Rectangle
 	Descriptor   Descriptor
 	Shapes       []image.Point
 	Gender       Gender
+	Age          int
 }
 
 // Descriptor holds 128-dimensional feature vector.
@@ -129,6 +130,17 @@ func (rec *Recognizer) SetGender(genderPath string) (err error) {
 	return
 }
 
+func (rec *Recognizer) SetAge(agePath string) (err error) {
+	if !fileExists(agePath) {
+		err = errors.New(fmt.Sprintf("File '%s' not found!", agePath))
+		return
+	}
+	cAgePath := C.CString(agePath)
+	defer C.free(unsafe.Pointer(cAgePath))
+	C.facerec_set_age(rec.ptr, cAgePath)
+	return
+}
+
 func (rec *Recognizer) SetSize(size int) {
 	C.facerec_config_size(rec.ptr, C.ulong(size))
 }
@@ -177,8 +189,7 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		fmt.Println("pointer", &ptr)
-		face := Face{imagePointer: &ptr}
+		face := Face{imagePointer: ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -221,7 +232,7 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: ptr}
+		face := Face{imagePointer: *ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -259,7 +270,16 @@ func (rec *Recognizer) GetGender(face *Face) {
 	x1 := C.int(face.Rectangle.Max.X)
 	y1 := C.int(face.Rectangle.Max.Y)
 
-	face.Gender = Gender(int(C.facerec_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(face.imagePointer)), x, y, x1, y1)))
+	face.Gender = Gender(int(C.facerec_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)))
+}
+
+func (rec *Recognizer) GetAge(face *Face) {
+	x := C.int(face.Rectangle.Min.X)
+	y := C.int(face.Rectangle.Min.Y)
+	x1 := C.int(face.Rectangle.Max.X)
+	y1 := C.int(face.Rectangle.Max.Y)
+
+	face.Age = int(C.facerec_age(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1))
 }
 
 func (rec *Recognizer) Recognize(face *Face) error {
@@ -268,7 +288,7 @@ func (rec *Recognizer) Recognize(face *Face) error {
 	x1 := C.int(face.Rectangle.Max.X)
 	y1 := C.int(face.Rectangle.Max.Y)
 
-	ret := C.facerec_recognize(rec.ptr, (*C.image_pointer)(unsafe.Pointer(face.imagePointer)), x, y, x1, y1)
+	ret := C.facerec_recognize(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -340,6 +360,5 @@ func fileExists(filename string) bool {
 }
 
 func (f *Face) Close() {
-	C.image_pointer_free(f.imagePointer)
-	f.imagePointer = nil
+	C.image_pointer_free(&f.imagePointer)
 }
diff --git a/facerec.cc b/facerec.cc
index ddc4eb6..48d6a98 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -30,6 +30,10 @@ void FaceRec::setGender(const char* gender_path) {
     deserialize(std::string(gender_path)) >> gender_net_;
 }
 
+void FaceRec::setAge(const char* age_path) {
+    deserialize(std::string(age_path)) >> age_net_;
+}
+
 std::vector<rectangle> FaceRec::detect(image_t& img) {
     	std::vector<rectangle> rects;
     	std::lock_guard<std::mutex> lock(detector_mutex_);
@@ -63,29 +67,51 @@ int FaceRec::gender(image_t& img,rectangle rect) {
     std::lock_guard<std::mutex> lock(gender_net_mutex_);
 
     auto shape = sp_(img, rect);
-        
-    extract_image_chip(img, get_face_chip_details(shape, 32), face_chip);
-        
-    return int(gender_net_(face_chip));
+    
+    if (shape.num_parts()) {
+        extract_image_chip(img, get_face_chip_details(shape, 32), face_chip);
+        return int(gender_net_(face_chip));
+    }
+    
+    return 0;
+}
+
+int FaceRec::age(image_t& img,rectangle rect) {
+    image_t face_chip;
+
+    std::lock_guard<std::mutex> lock(age_net_mutex_);
+
+    snet.subnet() = age_net_.subnet();
+
+    auto shape = sp_(img, rect);
+
+    if (shape.num_parts()) {
+        float confidence;
+        extract_image_chip(img, get_face_chip_details(shape, 64), face_chip);
+        matrix<float, 1, number_of_age_classes> p = mat(snet(face_chip));
+        return int(get_estimated_age(p, confidence));
+    }
+
+    return 0;
 }
 
 std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_t& img,rectangle rect) {
     full_object_detection shape;
     descriptor descr;
     image_t face_chip;
-        
+
     std::lock_guard<std::mutex> lock(net_mutex_);
-        
+
     shape = sp_(img, rect);
-        
+
     extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
-        
+
     if (jittering > 0) {
         descr = mean(mat(net_(jitter_image(std::move(face_chip), jittering))));
     } else {
         descr = net_(face_chip);
     }
-        
+
     return std::make_tuple(descr, shape);
 }
 
@@ -159,3 +185,17 @@ std::vector<image_t> jitter_image(
 
     return crops;
 }
+
+// Helper function to estimage the age
+uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>& p, float& confidence)
+{
+	float estimated_age = (0.25f * p(0));
+	confidence = p(0);
+
+	for (uint16_t i = 1; i < number_of_age_classes; i++) {
+		estimated_age += (static_cast<float>(i) * p(i));
+		if (p(i) > confidence) confidence = p(i);
+	}
+
+	return std::lround(estimated_age);
+}
diff --git a/facerec.h b/facerec.h
index 8c35cb0..194901e 100644
--- a/facerec.h
+++ b/facerec.h
@@ -20,13 +20,19 @@ class FaceRec {
 	std::mutex net_mutex_;
 	std::mutex cnn_net_mutex_;
     std::mutex gender_net_mutex_;
+    std::mutex age_net_mutex_;
     
 	std::shared_mutex samples_mutex_;
+    
 	dlib::frontal_face_detector detector_;
 	dlib::shape_predictor sp_;
+    
 	anet_type net_;
 	cnn_anet_type cnn_net_;
     agender_type gender_net_;
+    apredictor_t age_net_;
+    
+    softmax<apredictor_t::subnet_type> snet;
     
 	std::vector<descriptor> samples_;
 	std::vector<int> cats_;
@@ -42,6 +48,7 @@ class FaceRec {
     void setShape(const char*);
     void setDescriptor(const char*);
     void setGender(const char*);
+    void setAge(const char* age_path);
     
     void setSize(unsigned long);
     void setPadding(double);
@@ -49,6 +56,7 @@ class FaceRec {
     void setMinImageSize(int);
 
     int gender(image_t& img,rectangle);
+    int age(image_t& img,rectangle);
     std::vector<rectangle> detect(image_t&);
     std::vector<rectangle> detectCNN(image_t&);
     std::tuple<descriptor, full_object_detection> recognize(image_t&,rectangle);
@@ -59,6 +67,7 @@ class FaceRec {
 
 std::vector<image_t> jitter_image(const image_t& img,int count);
 facesret* facerec_detect(facesret*,  image_pointer *, facerec*,  image_t&, int);
+uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>&, float&);
 #else
 typedef void *image_t;
 #endif
diff --git a/gocv.go b/gocv.go
index fdee37c..fe64e4a 100644
--- a/gocv.go
+++ b/gocv.go
@@ -44,7 +44,7 @@ func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err err
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: &ptr}
+		face := Face{imagePointer: ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
diff --git a/template.h b/template.h
index ac88778..edfa658 100644
--- a/template.h
+++ b/template.h
@@ -61,6 +61,73 @@ template <typename SUBNET> using alevel2_ = avg_pool<2, 2, 2, 2, ares_<32, SUBNE
 
 using agender_type = loss_multiclass_log<fc<2, multiply<relu<fc<16, multiply<alevel1_<alevel2_< input_rgb_image_sized<32>>>>>>>>>;
 
+const unsigned long number_of_age_classes = 81;
+
+// The resnet basic block.
+template<
+	int num_filters,
+	template<typename> class BN,  // some kind of batch normalization or affine layer
+	int stride,
+	typename SUBNET
+>
+using basicblock = BN<con<num_filters, 3, 3, 1, 1, relu<BN<con<num_filters, 3, 3, stride, stride, SUBNET>>>>>;
+
+// A residual making use of the skip layer mechanism.
+template<
+	template<int, template<typename> class, int, typename> class BLOCK,  // a basic block defined before
+	int num_filters,
+	template<typename> class BN,  // some kind of batch normalization or affine layer
+	typename SUBNET
+> // adds the block to the result of tag1 (the subnet)
+using residual = add_prev1<BLOCK<num_filters, BN, 1, tag1<SUBNET>>>;
+
+// A residual that does subsampling (we need to subsample the output of the subnet, too).
+template<
+	template<int, template<typename> class, int, typename> class BLOCK,  // a basic block defined before
+	int num_filters,
+	template<typename> class BN,
+	typename SUBNET
+>
+using residual_down = add_prev2<avg_pool<2, 2, 2, 2, skip1<tag2<BLOCK<num_filters, BN, 2, tag1<SUBNET>>>>>>;
+
+// Residual block with optional downsampling and batch normalization.
+template<
+	template<template<int, template<typename> class, int, typename> class, int, template<typename>class, typename> class RESIDUAL,
+	template<int, template<typename> class, int, typename> class BLOCK,
+	int num_filters,
+	template<typename> class BN,
+	typename SUBNET
+>
+using residual_block = relu<RESIDUAL<BLOCK, num_filters, BN, SUBNET>>;
+
+template<int num_filters, typename SUBNET>
+using aresbasicblock_down = residual_block<residual_down, basicblock, num_filters, affine, SUBNET>;
+
+// Some useful definitions to design the affine versions for inference.
+template<typename SUBNET> using aresbasicblock256 = residual_block<residual, basicblock, 256, affine, SUBNET>;
+template<typename SUBNET> using aresbasicblock128 = residual_block<residual, basicblock, 128, affine, SUBNET>;
+template<typename SUBNET> using aresbasicblock64  = residual_block<residual, basicblock, 64, affine, SUBNET>;
+
+// Common input for standard resnets.
+template<typename INPUT>
+using aresnet_input = max_pool<3, 3, 2, 2, relu<affine<con<64, 7, 7, 2, 2, INPUT>>>>;
+
+// Resnet-10 architecture for estimating.
+template<typename SUBNET>
+using aresnet10_level1 = aresbasicblock256<aresbasicblock_down<256, SUBNET>>;
+template<typename SUBNET>
+using aresnet10_level2 = aresbasicblock128<aresbasicblock_down<128, SUBNET>>;
+template<typename SUBNET>
+using aresnet10_level3 = aresbasicblock64<SUBNET>;
+// The resnet 10 backbone.
+template<typename INPUT>
+using aresnet10_backbone = avg_pool_everything<
+	aresnet10_level1<
+	aresnet10_level2<
+	aresnet10_level3<
+	aresnet_input<INPUT>>>>>;
+
+using apredictor_t = loss_multiclass_log<fc<number_of_age_classes, aresnet10_backbone<input_rgb_image>>>;
 
 #endif
 #endif /* TEMPLATE_H */
diff --git a/wrapper.cc b/wrapper.cc
index 6b22a06..919fa15 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -66,6 +66,11 @@ void facerec_set_gender(facerec* rec, const char *file) {
 	cls->setGender(file);
 }
 
+void facerec_set_age(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setAge(file);
+}
+
 facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
@@ -147,12 +152,17 @@ faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1,
 int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
     image_t img = *((image_t*)p->p);
-    int gender = 0;
 	rectangle r = rectangle(x,y,x1,y1);
+    
+	return cls->gender(img, r);
+}
 
-	gender = cls->gender(img, r);
+int facerec_age(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+    image_t img = *((image_t*)p->p);
+	rectangle r = rectangle(x,y,x1,y1);
     
-	return gender;
+	return cls->age(img, r);
 }
 
 void facerec_set_samples(
diff --git a/wrapper.h b/wrapper.h
index 03bcadd..da07e37 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -48,13 +48,13 @@ facerec* facerec_init();
 facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
 facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
 faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
-int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1);
+int facerec_gender(facerec* rec, image_pointer *, int, int, int, int);
+int facerec_age(facerec* rec, image_pointer *, int, int, int, int);
 void facerec_set_cnn(facerec* , const char *);
 void facerec_set_shape(facerec* , const char *);
 void facerec_set_descriptor(facerec* , const char *);
 void facerec_set_gender(facerec* , const char *);
-
-
+void facerec_set_age(facerec* , const char *);
 
 void facerec_set_samples(facerec*, const float*, const int32_t*, int);
 int facerec_classify(facerec*, const float*, float);

From f09af14fcc4c077b2187f258bb9a3f2721c44c81 Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:55:49 +0300
Subject: [PATCH 14/36] Revert "Remove libs"

This reverts commit 2169ac8f1ef75620344206d31e1973bc01ce1e10.
---
 face.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/face.go b/face.go
index cc0cf29..91ef247 100644
--- a/face.go
+++ b/face.go
@@ -3,6 +3,9 @@ package face
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
+// #cgo LDFLAGS: -lopenblas
+// #cgo LDFLAGS: -lquadmath
+// #cgo LDFLAGS: -lgfortran
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 6d607e32d15831b969d39762a3f73f75a02f5b30 Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:56:28 +0300
Subject: [PATCH 15/36] Revert "lgfortran"

This reverts commit 0ecff40ce133ec492413df57df6552c2395063c3.
---
 face.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/face.go b/face.go
index 91ef247..1f2761b 100644
--- a/face.go
+++ b/face.go
@@ -5,7 +5,6 @@ package face
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
 // #cgo LDFLAGS: -lquadmath
-// #cgo LDFLAGS: -lgfortran
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From df3e603f02e04ff1995a7679d2b5acf494b949f5 Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:56:49 +0300
Subject: [PATCH 16/36] Revert "Math lib"

This reverts commit afd80302f12f3c1ec426d8aa10f30f870931db31.
---
 face.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/face.go b/face.go
index 1f2761b..b4ac6e2 100644
--- a/face.go
+++ b/face.go
@@ -4,7 +4,7 @@ package face
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
-// #cgo LDFLAGS: -lquadmath
+// #cgo LDFLAGS: -llapack
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 544b53687c56d79108f53aa3c5dd8ce82b34434e Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:57:06 +0300
Subject: [PATCH 17/36] Revert "Add libs"

This reverts commit e394049d511d06d75109f810bd5dae351538107c.
---
 face.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/face.go b/face.go
index b4ac6e2..3760476 100644
--- a/face.go
+++ b/face.go
@@ -4,7 +4,6 @@ package face
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #cgo LDFLAGS: -lopenblas
-// #cgo LDFLAGS: -llapack
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 53e19db8871bea294755ff1ebba7031a72ac04ae Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 21:57:22 +0300
Subject: [PATCH 18/36] Revert "Add libopenblas"

This reverts commit dc77bcd30a90869fd8fd54beafb6057e48251bfc.
---
 face.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/face.go b/face.go
index 3760476..cc0cf29 100644
--- a/face.go
+++ b/face.go
@@ -3,7 +3,6 @@ package face
 // #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
-// #cgo LDFLAGS: -lopenblas
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 3caf75f1e8cdd10525a2fa380684634d3c89824f Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 22:04:42 +0300
Subject: [PATCH 19/36] Rename funcs names

---
 face.go    | 42 +++++++++++++++++++++---------------------
 gocv.cc    |  2 +-
 gocv.go    | 12 ++++++------
 gocv.h     |  2 +-
 wrapper.cc | 16 ++++++++--------
 wrapper.h  | 20 ++++++++++++--------
 6 files changed, 49 insertions(+), 45 deletions(-)

diff --git a/face.go b/face.go
index cc0cf29..1ce9115 100644
--- a/face.go
+++ b/face.go
@@ -86,7 +86,7 @@ func NewRecognizer() (rec *Recognizer, err error) {
 	return
 }
 
-func (rec *Recognizer) SetShape(shapePredictorPath string) (err error) {
+func (rec *Recognizer) SetShapeModel(shapePredictorPath string) (err error) {
 	if !fileExists(shapePredictorPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", shapePredictorPath))
 		return
@@ -97,7 +97,7 @@ func (rec *Recognizer) SetShape(shapePredictorPath string) (err error) {
 	return
 }
 
-func (rec *Recognizer) SetDescriptor(resnetPath string) (err error) {
+func (rec *Recognizer) SetDescriptorModel(resnetPath string) (err error) {
 	if !fileExists(resnetPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", resnetPath))
 		return
@@ -108,7 +108,7 @@ func (rec *Recognizer) SetDescriptor(resnetPath string) (err error) {
 	return
 }
 
-func (rec *Recognizer) SetCNN(cnnResnetPath string) (err error) {
+func (rec *Recognizer) SetCNNModel(cnnResnetPath string) (err error) {
 	if !fileExists(cnnResnetPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", cnnResnetPath))
 		return
@@ -119,7 +119,7 @@ func (rec *Recognizer) SetCNN(cnnResnetPath string) (err error) {
 	return
 }
 
-func (rec *Recognizer) SetGender(genderPath string) (err error) {
+func (rec *Recognizer) SetGenderModel(genderPath string) (err error) {
 	if !fileExists(genderPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", genderPath))
 		return
@@ -130,7 +130,7 @@ func (rec *Recognizer) SetGender(genderPath string) (err error) {
 	return
 }
 
-func (rec *Recognizer) SetAge(agePath string) (err error) {
+func (rec *Recognizer) SetAgeModel(agePath string) (err error) {
 	if !fileExists(agePath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", agePath))
 		return
@@ -142,22 +142,22 @@ func (rec *Recognizer) SetAge(agePath string) (err error) {
 }
 
 func (rec *Recognizer) SetSize(size int) {
-	C.facerec_config_size(rec.ptr, C.ulong(size))
+	C.facerec_config_set_size(rec.ptr, C.ulong(size))
 }
 
 func (rec *Recognizer) SetPadding(padding float32) {
-	C.facerec_config_padding(rec.ptr, C.double(padding))
+	C.facerec_config_set_padding(rec.ptr, C.double(padding))
 }
 
 func (rec *Recognizer) SetJittering(jittering int) {
-	C.facerec_config_jittering(rec.ptr, C.int(jittering))
+	C.facerec_config_set_jittering(rec.ptr, C.int(jittering))
 }
 
 func (rec *Recognizer) SetMinImageSize(minImageSize int) {
-	C.facerec_config_min_image_size(rec.ptr, C.int(minImageSize))
+	C.facerec_config_set_min_image_size(rec.ptr, C.int(minImageSize))
 }
 
-func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, err error) {
+func (rec *Recognizer) detectFromBuffer(type_ int, imgData []byte) (faces []Face, err error) {
 	if len(imgData) == 0 {
 		err = ImageLoadError("Empty image")
 		return
@@ -167,7 +167,7 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 	cType := C.int(type_)
 	var ptr C.image_pointer
 
-	ret := C.facerec_detect_buffer(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cImgData, cLen, cType)
+	ret := C.facerec_detect_from_buffer(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cImgData, cLen, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -200,7 +200,7 @@ func (rec *Recognizer) detectBuffer(type_ int, imgData []byte) (faces []Face, er
 	return
 }
 
-func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err error) {
+func (rec *Recognizer) detectFromFile(type_ int, file string) (faces []Face, err error) {
 	if !fileExists(file) {
 		err = ImageLoadError(fmt.Sprintf("File '%s' not found!", file))
 		return
@@ -210,7 +210,7 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 	cFile := C.CString(file)
 	defer C.free(unsafe.Pointer(cFile))
 	var ptr *C.image_pointer
-	ret := C.facerec_detect_file(rec.ptr, ptr, cFile, cType)
+	ret := C.facerec_detect_from_file(rec.ptr, ptr, cFile, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -247,21 +247,21 @@ func (rec *Recognizer) detectFile(type_ int, file string) (faces []Face, err err
 // left to right. Empty list is returned if there are no faces, error is
 // returned if there was some error while decoding/processing image.
 // Only JPEG format is currently supported. Thread-safe.
-func (rec *Recognizer) Detect(imgData []byte) (faces []Face, err error) {
-	return rec.detectBuffer(0, imgData)
+func (rec *Recognizer) DetectFromBuffer(imgData []byte) (faces []Face, err error) {
+	return rec.detectFromBuffer(0, imgData)
 }
 
-func (rec *Recognizer) DetectCNN(imgData []byte) (faces []Face, err error) {
-	return rec.detectBuffer(1, imgData)
+func (rec *Recognizer) DetectFromBufferCNN(imgData []byte) (faces []Face, err error) {
+	return rec.detectFromBuffer(1, imgData)
 }
 
 // Same as Recognize but accepts image path instead.
 func (rec *Recognizer) DetectFromFile(imgPath string) (faces []Face, err error) {
-	return rec.detectFile(0, imgPath)
+	return rec.detectFromFile(0, imgPath)
 }
 
 func (rec *Recognizer) DetectFromFileCNN(imgPath string) (faces []Face, err error) {
-	return rec.detectFile(1, imgPath)
+	return rec.detectFromFile(1, imgPath)
 }
 
 func (rec *Recognizer) GetGender(face *Face) {
@@ -270,7 +270,7 @@ func (rec *Recognizer) GetGender(face *Face) {
 	x1 := C.int(face.Rectangle.Max.X)
 	y1 := C.int(face.Rectangle.Max.Y)
 
-	face.Gender = Gender(int(C.facerec_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)))
+	face.Gender = Gender(int(C.facerec_get_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)))
 }
 
 func (rec *Recognizer) GetAge(face *Face) {
@@ -279,7 +279,7 @@ func (rec *Recognizer) GetAge(face *Face) {
 	x1 := C.int(face.Rectangle.Max.X)
 	y1 := C.int(face.Rectangle.Max.Y)
 
-	face.Age = int(C.facerec_age(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1))
+	face.Age = int(C.facerec_get_age(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1))
 }
 
 func (rec *Recognizer) Recognize(face *Face) error {
diff --git a/gocv.cc b/gocv.cc
index 2c426d1..8b5fdc9 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -8,7 +8,7 @@
 
 using namespace dlib;
 
-facesret* facerec_detect_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
+facesret* facerec_detect_from_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 	std::vector<rectangle> rects;
diff --git a/gocv.go b/gocv.go
index fe64e4a..766c4e5 100644
--- a/gocv.go
+++ b/gocv.go
@@ -18,11 +18,11 @@ import (
 	"gocv.io/x/gocv"
 )
 
-func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
+func (rec *Recognizer) detectFromMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
 	cType := C.int(type_)
 	var ptr C.image_pointer
 
-	ret := C.facerec_detect_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
+	ret := C.facerec_detect_from_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -55,10 +55,10 @@ func (rec *Recognizer) detectMat(type_ int, mat gocv.Mat) (faces []Face, err err
 	return
 }
 
-func (rec *Recognizer) DetectMat(mat gocv.Mat) (faces []Face, err error) {
-	return rec.detectMat(0, mat)
+func (rec *Recognizer) DetectFromMat(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectFromMat(0, mat)
 }
 
-func (rec *Recognizer) DetectMatCNN(mat gocv.Mat) (faces []Face, err error) {
-	return rec.detectMat(1, mat)
+func (rec *Recognizer) DetectFromMatCNN(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectFromMat(1, mat)
 }
diff --git a/gocv.h b/gocv.h
index 5370859..a084ff9 100644
--- a/gocv.h
+++ b/gocv.h
@@ -10,7 +10,7 @@
 extern "C" {
 #endif
 
-facesret* facerec_detect_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
+facesret* facerec_detect_from_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
 
 #ifdef __cplusplus
 }
diff --git a/wrapper.cc b/wrapper.cc
index 919fa15..22f6e85 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -26,22 +26,22 @@ facerec* facerec_init() {
 	return rec;
 }
 
-void facerec_config_size(facerec* rec, unsigned long size) {
+void facerec_config_set_size(facerec* rec, unsigned long size) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	cls->setSize(size);
 }
 
-void facerec_config_padding(facerec* rec, double padding) {
+void facerec_config_set_padding(facerec* rec, double padding) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	cls->setPadding(padding);
 }
 
-void facerec_config_jittering(facerec* rec, int jittering) {
+void facerec_config_set_jittering(facerec* rec, int jittering) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	cls->setJittering(jittering);
 }
 
-void facerec_config_min_image_size(facerec* rec, int min_image_size) {
+void facerec_config_set_min_image_size(facerec* rec, int min_image_size) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	cls->setMinImageSize(min_image_size);
 }
@@ -71,7 +71,7 @@ void facerec_set_age(facerec* rec, const char *file) {
 	cls->setAge(file);
 }
 
-facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,int type) {
+facesret* facerec_detect_from_file(facerec* rec, image_pointer *p, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 	std::vector<rectangle> rects;
@@ -93,7 +93,7 @@ facesret* facerec_detect_file(facerec* rec, image_pointer *p, const char* file,i
     return facerec_detect(ret, p, rec, img, type);
 }
 
-facesret* facerec_detect_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
+facesret* facerec_detect_from_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 	std::vector<rectangle> rects;
@@ -149,7 +149,7 @@ faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1,
 	return ret;
 }
 
-int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+int facerec_get_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
     image_t img = *((image_t*)p->p);
 	rectangle r = rectangle(x,y,x1,y1);
@@ -157,7 +157,7 @@ int facerec_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1)
 	return cls->gender(img, r);
 }
 
-int facerec_age(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+int facerec_get_age(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
     image_t img = *((image_t*)p->p);
 	rectangle r = rectangle(x,y,x1,y1);
diff --git a/wrapper.h b/wrapper.h
index da07e37..4a79716 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -45,11 +45,13 @@ typedef struct faceret {
 #define SHAPE_LEN  2
 
 facerec* facerec_init();
-facesret* facerec_detect_file(facerec*,  image_pointer *, const char*,int);
-facesret* facerec_detect_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
+facesret* facerec_detect_from_file(facerec*,  image_pointer *, const char*,int);
+facesret* facerec_detect_from_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
 faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
-int facerec_gender(facerec* rec, image_pointer *, int, int, int, int);
-int facerec_age(facerec* rec, image_pointer *, int, int, int, int);
+
+int facerec_get_gender(facerec* rec, image_pointer *, int, int, int, int);
+int facerec_get_age(facerec* rec, image_pointer *, int, int, int, int);
+
 void facerec_set_cnn(facerec* , const char *);
 void facerec_set_shape(facerec* , const char *);
 void facerec_set_descriptor(facerec* , const char *);
@@ -59,10 +61,12 @@ void facerec_set_age(facerec* , const char *);
 void facerec_set_samples(facerec*, const float*, const int32_t*, int);
 int facerec_classify(facerec*, const float*, float);
 void facerec_free(facerec*);
-void facerec_config_size(facerec* rec, unsigned long size);
-void facerec_config_padding(facerec* rec, double padding);
-void facerec_config_jittering(facerec* rec, int jittering);
-void facerec_config_min_image_size(facerec* rec, int min_image_size);
+
+void facerec_config_set_size(facerec* rec, unsigned long size);
+void facerec_config_set_padding(facerec* rec, double padding);
+void facerec_config_set_jittering(facerec* rec, int jittering);
+void facerec_config_set_min_image_size(facerec* rec, int min_image_size);
+
 void image_pointer_free(image_pointer* p);
 
 #ifdef __cplusplus

From d65b255146060ec0b5b7da757e3300f025f0f3fd Mon Sep 17 00:00:00 2001
From: danile71 <danile71@gmail.com>
Date: Wed, 12 Feb 2020 22:35:22 +0300
Subject: [PATCH 20/36] Some fixes

---
 example_test.go | 32 +++++++++++++++++++++++++-------
 face.go         |  4 ++--
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/example_test.go b/example_test.go
index d66e015..87294a9 100644
--- a/example_test.go
+++ b/example_test.go
@@ -10,23 +10,38 @@ import (
 
 // Path to directory with models and test images. Here it's assumed it
 // points to the <https://github.com/Kagami/go-face-testdata> clone.
-const dataDir = "testdata"
+const cnn = "testdata/mmod_human_face_detector.dat"
+const shape = "testdata/shape_predictor_68_face_landmarks.dat"
+const descr = "testdata/dlib_face_recognition_resnet_model_v1.dat"
+const gender = "testdata/dnn_gender_classifier_v1.dat"
+const age = "testdata/dnn_age_predictor_v1.dat"
 
 // This example shows the basic usage of the package: create an
 // recognizer, recognize faces, classify them using few known ones.
 func Example_basic() {
 	// Init the recognizer.
-	rec, err := face.NewRecognizer(dataDir)
+	rec, err := face.NewRecognizer()
 	if err != nil {
 		log.Fatalf("Can't init face recognizer: %v", err)
 	}
 	// Free the resources when you're finished.
 	defer rec.Close()
 
+	rec.SetCNNModel(cnn)
+	rec.SetDescriptorModel(descr)
+	rec.SetShapeModel(shape)
+	rec.SetGenderModel(gender)
+	rec.SetAgeModel(age)
+
+	rec.SetSize(150)
+	rec.SetPadding(0.25)
+	rec.SetMinImageSize(100)
+	rec.SetJittering(0)
+
 	// Test image with 10 faces.
 	testImagePristin := filepath.Join(dataDir, "pristin.jpg")
 	// Recognize faces on that image.
-	faces, err := rec.RecognizeFile(testImagePristin)
+	faces, err := rec.DetectFromFile(testImagePristin)
 	if err != nil {
 		log.Fatalf("Can't recognize: %v", err)
 	}
@@ -40,6 +55,7 @@ func Example_basic() {
 	var samples []face.Descriptor
 	var cats []int32
 	for i, f := range faces {
+		rec.Recognize(&f)
 		samples = append(samples, f.Descriptor)
 		// Each face is unique on that image so goes to its own category.
 		cats = append(cats, int32(i))
@@ -54,14 +70,16 @@ func Example_basic() {
 
 	// Now let's try to classify some not yet known image.
 	testImageNayoung := filepath.Join(dataDir, "nayoung.jpg")
-	nayoungFace, err := rec.RecognizeSingleFile(testImageNayoung)
+	nayoungFace, err := rec.DetectFromFile(testImageNayoung)
 	if err != nil {
 		log.Fatalf("Can't recognize: %v", err)
 	}
-	if nayoungFace == nil {
-		log.Fatalf("Not a single face on the image")
+	if len(faces) != 1 {
+		log.Fatalf("Wrong number of faces")
 	}
-	catID := rec.Classify(nayoungFace.Descriptor)
+	rec.Recognize(&nayoungFace[0])
+
+	catID := rec.Classify(nayoungFace[0].Descriptor)
 	if catID < 0 {
 		log.Fatalf("Can't classify")
 	}
diff --git a/face.go b/face.go
index 1ce9115..c064cac 100644
--- a/face.go
+++ b/face.go
@@ -209,8 +209,8 @@ func (rec *Recognizer) detectFromFile(type_ int, file string) (faces []Face, err
 	cType := C.int(type_)
 	cFile := C.CString(file)
 	defer C.free(unsafe.Pointer(cFile))
-	var ptr *C.image_pointer
-	ret := C.facerec_detect_from_file(rec.ptr, ptr, cFile, cType)
+	var ptr C.image_pointer
+	ret := C.facerec_detect_from_file(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cFile, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {

From c1e5673111f9aa8ac654722e90cf98a3f8c28e57 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 08:19:55 +0300
Subject: [PATCH 21/36] Add method RenderFaceDetections

---
 face.go |  2 +-
 gocv.go | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/face.go b/face.go
index c064cac..f29de57 100644
--- a/face.go
+++ b/face.go
@@ -232,7 +232,7 @@ func (rec *Recognizer) detectFromFile(type_ int, file string) (faces []Face, err
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: *ptr}
+		face := Face{imagePointer: ptr}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
diff --git a/gocv.go b/gocv.go
index 766c4e5..914acf9 100644
--- a/gocv.go
+++ b/gocv.go
@@ -13,6 +13,7 @@ package face
 import "C"
 import (
 	"image"
+	"image/color"
 	"unsafe"
 
 	"gocv.io/x/gocv"
@@ -62,3 +63,61 @@ func (rec *Recognizer) DetectFromMat(mat gocv.Mat) (faces []Face, err error) {
 func (rec *Recognizer) DetectFromMatCNN(mat gocv.Mat) (faces []Face, err error) {
 	return rec.detectFromMat(1, mat)
 }
+
+func RenderFaceDetections(img *gocv.Mat, Shapes []image.Point, col color.RGBA, thickness int) {
+	if len(Shapes) == 5 {
+		gocv.Line(img, Shapes[0], Shapes[1], col, thickness)
+		gocv.Line(img, Shapes[1], Shapes[4], col, thickness)
+		gocv.Line(img, Shapes[4], Shapes[3], col, thickness)
+		gocv.Line(img, Shapes[3], Shapes[2], col, thickness)
+	} else {
+		// Around Chin. Ear to Ear
+		for i := 1; i <= 16; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+
+		// Line on top of nose
+		for i := 28; i <= 30; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+
+		// left eyebrow
+		for i := 18; i <= 21; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		// Right eyebrow
+		for i := 23; i <= 26; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		// Bottom part of the nose
+		for i := 31; i <= 35; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		// Line from the nose to the bottom part above
+		gocv.Line(img, Shapes[30], Shapes[35], col, thickness)
+
+		// Left eye
+		for i := 37; i <= 41; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		gocv.Line(img, Shapes[36], Shapes[41], col, thickness)
+
+		// Right eye
+		for i := 43; i <= 47; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		gocv.Line(img, Shapes[42], Shapes[47], col, thickness)
+
+		// Lips outer part
+		for i := 49; i <= 59; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		gocv.Line(img, Shapes[48], Shapes[59], col, thickness)
+
+		// Lips inside part
+		for i := 61; i <= 67; i++ {
+			gocv.Line(img, Shapes[i], Shapes[i-1], col, thickness)
+		}
+		gocv.Line(img, Shapes[60], Shapes[67], col, thickness)
+	}
+}

From f628381b584742a6ae5b30879300dba8c3ddb7c9 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 08:51:03 +0300
Subject: [PATCH 22/36] Fix some bugs

---
 facerec.cc | 20 +++++++++-----------
 facerec.h  |  2 --
 2 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/facerec.cc b/facerec.cc
index 48d6a98..e6a5ceb 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -35,20 +35,18 @@ void FaceRec::setAge(const char* age_path) {
 }
 
 std::vector<rectangle> FaceRec::detect(image_t& img) {
-    	std::vector<rectangle> rects;
-    	std::lock_guard<std::mutex> lock(detector_mutex_);
+    std::lock_guard<std::mutex> lock(detector_mutex_);
         
     while(img.size() < min_image_size) {
         pyramid_up(img);
     }
-        
-    rects = detector_(img);
-    return rects;
+
+    return detector_(img);
 }
 
 std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     std::vector<rectangle> rects;
-    	std::lock_guard<std::mutex> lock(cnn_net_mutex_);
+    std::lock_guard<std::mutex> lock(cnn_net_mutex_);
         
     while(img.size() < min_image_size) {
         pyramid_up(img);
@@ -58,13 +56,14 @@ std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     for (auto&& d : dets) {
         rects.push_back(d.rect);
     }
-    return rects; 
+
+    return rects;
 }
 
 int FaceRec::gender(image_t& img,rectangle rect) {
     image_t face_chip;
 
-    std::lock_guard<std::mutex> lock(gender_net_mutex_);
+    std::lock_guard<std::mutex> lock(net_mutex_);
 
     auto shape = sp_(img, rect);
     
@@ -79,7 +78,7 @@ int FaceRec::gender(image_t& img,rectangle rect) {
 int FaceRec::age(image_t& img,rectangle rect) {
     image_t face_chip;
 
-    std::lock_guard<std::mutex> lock(age_net_mutex_);
+    std::lock_guard<std::mutex> lock(net_mutex_);
 
     snet.subnet() = age_net_.subnet();
 
@@ -96,13 +95,12 @@ int FaceRec::age(image_t& img,rectangle rect) {
 }
 
 std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_t& img,rectangle rect) {
-    full_object_detection shape;
     descriptor descr;
     image_t face_chip;
 
     std::lock_guard<std::mutex> lock(net_mutex_);
 
-    shape = sp_(img, rect);
+    auto shape = sp_(img, rect);
 
     extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
 
diff --git a/facerec.h b/facerec.h
index 194901e..ec4a627 100644
--- a/facerec.h
+++ b/facerec.h
@@ -19,8 +19,6 @@ class FaceRec {
 	std::mutex detector_mutex_;
 	std::mutex net_mutex_;
 	std::mutex cnn_net_mutex_;
-    std::mutex gender_net_mutex_;
-    std::mutex age_net_mutex_;
     
 	std::shared_mutex samples_mutex_;
     

From 11c19703ee8c94c7c156067cc45f977d55bac3eb Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 12:29:16 +0300
Subject: [PATCH 23/36] Upd

---
 face.go    |  39 ++++++----------
 facerec.cc | 134 ++++++++++++++++++++++++++---------------------------
 facerec.h  |  15 +++---
 gocv.cc    |  11 ++---
 gocv.go    |   8 ++--
 gocv.h     |   2 +-
 utils.cc   |  37 +++++++++++++++
 utils.h    |  12 +++++
 wrapper.cc |  77 +++++++++++++-----------------
 wrapper.h  |  15 +++---
 10 files changed, 190 insertions(+), 160 deletions(-)
 create mode 100644 utils.cc
 create mode 100644 utils.h

diff --git a/face.go b/face.go
index f29de57..71f8a4e 100644
--- a/face.go
+++ b/face.go
@@ -165,9 +165,8 @@ func (rec *Recognizer) detectFromBuffer(type_ int, imgData []byte) (faces []Face
 	cImgData := (*C.uchar)(&imgData[0])
 	cLen := C.int(len(imgData))
 	cType := C.int(type_)
-	var ptr C.image_pointer
 
-	ret := C.facerec_detect_from_buffer(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cImgData, cLen, cType)
+	ret := C.facerec_detect_from_buffer(rec.ptr, cImgData, cLen, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -183,13 +182,17 @@ func (rec *Recognizer) detectFromBuffer(type_ int, imgData []byte) (faces []Face
 
 	// Copy faces data to Go structure.
 	defer C.free(unsafe.Pointer(ret.rectangles))
+	defer C.free(unsafe.Pointer(ret.p))
+
+	rPtr := unsafe.Pointer(ret.p)
+	rP := (*[1 << 30]C.image_pointer)(rPtr)[:numFaces:numFaces]
 
 	rDataLen := numFaces * rectLen
 	rDataPtr := unsafe.Pointer(ret.rectangles)
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: ptr}
+		face := Face{imagePointer: rP[i]}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -209,8 +212,7 @@ func (rec *Recognizer) detectFromFile(type_ int, file string) (faces []Face, err
 	cType := C.int(type_)
 	cFile := C.CString(file)
 	defer C.free(unsafe.Pointer(cFile))
-	var ptr C.image_pointer
-	ret := C.facerec_detect_from_file(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), cFile, cType)
+	ret := C.facerec_detect_from_file(rec.ptr, cFile, cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -226,13 +228,17 @@ func (rec *Recognizer) detectFromFile(type_ int, file string) (faces []Face, err
 
 	// Copy faces data to Go structure.
 	defer C.free(unsafe.Pointer(ret.rectangles))
+	defer C.free(unsafe.Pointer(ret.p))
+
+	rPtr := unsafe.Pointer(ret.p)
+	rP := (*[1 << 30]C.image_pointer)(rPtr)[:numFaces:numFaces]
 
 	rDataLen := numFaces * rectLen
 	rDataPtr := unsafe.Pointer(ret.rectangles)
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: ptr}
+		face := Face{imagePointer: rP[i]}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
@@ -265,30 +271,15 @@ func (rec *Recognizer) DetectFromFileCNN(imgPath string) (faces []Face, err erro
 }
 
 func (rec *Recognizer) GetGender(face *Face) {
-	x := C.int(face.Rectangle.Min.X)
-	y := C.int(face.Rectangle.Min.Y)
-	x1 := C.int(face.Rectangle.Max.X)
-	y1 := C.int(face.Rectangle.Max.Y)
-
-	face.Gender = Gender(int(C.facerec_get_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)))
+	face.Gender = Gender(int(C.facerec_get_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)))))
 }
 
 func (rec *Recognizer) GetAge(face *Face) {
-	x := C.int(face.Rectangle.Min.X)
-	y := C.int(face.Rectangle.Min.Y)
-	x1 := C.int(face.Rectangle.Max.X)
-	y1 := C.int(face.Rectangle.Max.Y)
-
-	face.Age = int(C.facerec_get_age(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1))
+	face.Age = int(C.facerec_get_age(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer))))
 }
 
 func (rec *Recognizer) Recognize(face *Face) error {
-	x := C.int(face.Rectangle.Min.X)
-	y := C.int(face.Rectangle.Min.Y)
-	x1 := C.int(face.Rectangle.Max.X)
-	y1 := C.int(face.Rectangle.Max.Y)
-
-	ret := C.facerec_recognize(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)), x, y, x1, y1)
+	ret := C.facerec_recognize(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)))
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
diff --git a/facerec.cc b/facerec.cc
index e6a5ceb..5694b6c 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -7,6 +7,7 @@
 #include <dlib/image_io.h>
 #include "facerec.h"
 #include "classify.h"
+#include "utils.h"
 
 using namespace dlib;
 
@@ -47,11 +48,11 @@ std::vector<rectangle> FaceRec::detect(image_t& img) {
 std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     std::vector<rectangle> rects;
     std::lock_guard<std::mutex> lock(cnn_net_mutex_);
-        
+
     while(img.size() < min_image_size) {
         pyramid_up(img);
     }
-        
+
 	auto dets = cnn_net_(img);
     for (auto&& d : dets) {
         rects.push_back(d.rect);
@@ -60,14 +61,21 @@ std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     return rects;
 }
 
-int FaceRec::gender(image_t& img,rectangle rect) {
-    image_t face_chip;
-
+int FaceRec::gender(image_pointer *p) {
+    full_object_detection shape;
     std::lock_guard<std::mutex> lock(net_mutex_);
+    image_t img = *((image_t*)p->img);
 
-    auto shape = sp_(img, rect);
+    if (p->shape) {
+        shape = *((full_object_detection*)p->shape);
+    } else {
+        rectangle rect = *((rectangle*)p->rect);
+        shape = sp_(img, rect);
+        p->shape = new full_object_detection(shape);
+    }
     
     if (shape.num_parts()) {
+        image_t face_chip;
         extract_image_chip(img, get_face_chip_details(shape, 32), face_chip);
         return int(gender_net_(face_chip));
     }
@@ -75,17 +83,24 @@ int FaceRec::gender(image_t& img,rectangle rect) {
     return 0;
 }
 
-int FaceRec::age(image_t& img,rectangle rect) {
-    image_t face_chip;
-
+int FaceRec::age(image_pointer *p) {
+    full_object_detection shape;
     std::lock_guard<std::mutex> lock(net_mutex_);
+    image_t img = *((image_t*)p->img);
 
+    if (p->shape) {
+        shape = *((full_object_detection*)p->shape);
+    } else {
+        rectangle rect = *((rectangle*)p->rect);
+        shape = sp_(img, rect);
+        p->shape = new full_object_detection(shape);
+    }
+    
     snet.subnet() = age_net_.subnet();
 
-    auto shape = sp_(img, rect);
-
     if (shape.num_parts()) {
         float confidence;
+        image_t face_chip;
         extract_image_chip(img, get_face_chip_details(shape, 64), face_chip);
         matrix<float, 1, number_of_age_classes> p = mat(snet(face_chip));
         return int(get_estimated_age(p, confidence));
@@ -94,34 +109,32 @@ int FaceRec::age(image_t& img,rectangle rect) {
     return 0;
 }
 
-std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_t& img,rectangle rect) {
+std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_pointer *p) {
     descriptor descr;
-    image_t face_chip;
-
+    full_object_detection shape;
     std::lock_guard<std::mutex> lock(net_mutex_);
+    image_t img = *((image_t*)p->img);
 
-    auto shape = sp_(img, rect);
-
-    extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
-
-    if (jittering > 0) {
-        descr = mean(mat(net_(jitter_image(std::move(face_chip), jittering))));
+    if (p->shape) {
+        shape = *((full_object_detection*)p->shape);
     } else {
-        descr = net_(face_chip);
+        rectangle rect = *((rectangle*)p->rect);
+        shape = sp_(img, rect);
+        p->shape = new full_object_detection(shape);
     }
 
-    return std::make_tuple(descr, shape);
-}
-
-void FaceRec::setSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
-    std::unique_lock<std::shared_mutex> lock(samples_mutex_);
-    samples_ = std::move(samples);
-    cats_ = std::move(cats);
-}
+    if (shape.num_parts()) {
+        image_t face_chip;
+        extract_image_chip(img, get_face_chip_details(shape, size, padding), face_chip);
+
+        if (jittering > 0) {
+            descr = mean(mat(net_(jitter_image(std::move(face_chip), jittering))));
+        } else {
+            descr = net_(face_chip);
+        }
+    }
 
-int FaceRec::classify(const descriptor& test_sample, float tolerance) {
-    std::shared_lock<std::shared_mutex> lock(samples_mutex_);
-    return classify_(samples_, cats_, test_sample, tolerance);
+    return std::make_tuple(descr, shape);
 }
 
 void FaceRec::setSize(unsigned long new_size) {
@@ -140,7 +153,7 @@ void FaceRec::setMinImageSize(int new_min_image_size) {
     min_image_size = new_min_image_size;
 }
 
-facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t &img, int type) {
+facesret* facerec_detect(facesret *ret, facerec* rec, image_t &img, int type) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	std::vector<rectangle> rects;
 
@@ -150,50 +163,35 @@ facesret* facerec_detect(facesret* ret, image_pointer *p, facerec* rec, image_t
         rects = cls->detectCNN(img);
     }
 
-    ret->num_faces = rects.size();
-    p->p = new image_t(img);
+    ret->num_faces = rects.size();    
 
     if (ret->num_faces == 0)
 		return ret;
 
 	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
+    ret->p = new image_pointer[ret->num_faces];
+
 	for (int i = 0; i < ret->num_faces; i++) {
-		long* dst = ret->rectangles + i * RECT_LEN;
-		dst[0] = rects[i].left();
-		dst[1] = rects[i].top();
-		dst[2] = rects[i].right();
-		dst[3] = rects[i].bottom();
-	}
+        ret->p[i].img = new image_t(img);
+        ret->p[i].rect = new rectangle(rects[i]);
+        ret->p[i].shape = 0;     
+        long* dst = ret->rectangles + i * RECT_LEN;
+        dst[0] = rects[i].left();
+        dst[1] = rects[i].top();
+        dst[2] = rects[i].right();
+        dst[3] = rects[i].bottom();
+    }
 	return ret;
 }
 
-std::vector<image_t> jitter_image(
-    const image_t& img,
-    int count
-)
-{
-    // All this function does is make count copies of img, all slightly jittered by being
-    // zoomed, rotated, and translated a little bit differently. They are also randomly
-    // mirrored left to right.
-    thread_local dlib::rand rnd;
-
-    std::vector<image_t> crops;
-    for (int i = 0; i < count; ++i)
-        crops.push_back(jitter_image(img,rnd));
-
-    return crops;
+// Classify
+void FaceRec::setSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
+    std::unique_lock<std::shared_mutex> lock(samples_mutex_);
+    samples_ = std::move(samples);
+    cats_ = std::move(cats);
 }
 
-// Helper function to estimage the age
-uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>& p, float& confidence)
-{
-	float estimated_age = (0.25f * p(0));
-	confidence = p(0);
-
-	for (uint16_t i = 1; i < number_of_age_classes; i++) {
-		estimated_age += (static_cast<float>(i) * p(i));
-		if (p(i) > confidence) confidence = p(i);
-	}
-
-	return std::lround(estimated_age);
+int FaceRec::classify(const descriptor& test_sample, float tolerance) {
+    std::shared_lock<std::shared_mutex> lock(samples_mutex_);
+    return classify_(samples_, cats_, test_sample, tolerance);
 }
diff --git a/facerec.h b/facerec.h
index ec4a627..742b89f 100644
--- a/facerec.h
+++ b/facerec.h
@@ -37,7 +37,7 @@ class FaceRec {
 	int jittering = 0;
 	unsigned long size = 150;
 	double padding = 0.25;
-    int min_image_size;
+    int min_image_size = 0;
     
 public:
 	FaceRec();
@@ -53,19 +53,20 @@ class FaceRec {
     void setJittering(int);
     void setMinImageSize(int);
 
-    int gender(image_t& img,rectangle);
-    int age(image_t& img,rectangle);
     std::vector<rectangle> detect(image_t&);
     std::vector<rectangle> detectCNN(image_t&);
-    std::tuple<descriptor, full_object_detection> recognize(image_t&,rectangle);
+    
+    std::tuple<descriptor, full_object_detection> recognize(image_pointer *);
+    
+    int gender(image_pointer *);
+    int age(image_pointer *);
     
 	void setSamples(std::vector<descriptor>&&, std::vector<int>&&);
 	int classify(const descriptor&, float);
 };
 
-std::vector<image_t> jitter_image(const image_t& img,int count);
-facesret* facerec_detect(facesret*,  image_pointer *, facerec*,  image_t&, int);
-uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>&, float&);
+facesret* facerec_detect(facesret*, facerec*,  image_t&, int);
+
 #else
 typedef void *image_t;
 #endif
diff --git a/gocv.cc b/gocv.cc
index 8b5fdc9..7300cac 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -8,14 +8,13 @@
 
 using namespace dlib;
 
-facesret* facerec_detect_from_mat(facerec* rec, image_pointer *p, const void *mat,int type) {
+facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
-	std::vector<rectangle> rects;
-    cv::Mat *mat_img = new cv::Mat(*((cv::Mat*)mat));
-    IplImage ipl_img = cvIplImage(*mat_img);
-    
+
 	try {
+        cv::Mat *mat_img = (cv::Mat*)mat;
+        IplImage ipl_img = cvIplImage(*mat_img);
 		cv_image<bgr_pixel> dlib_img(&ipl_img);
         assign_image(img, dlib_img);
 	} catch(image_load_error& e) {
@@ -28,5 +27,5 @@ facesret* facerec_detect_from_mat(facerec* rec, image_pointer *p, const void *ma
 		return ret;
 	}
     
-    return facerec_detect(ret, p, rec, img, type);
+    return facerec_detect(ret, rec, img, type);
 }
diff --git a/gocv.go b/gocv.go
index 914acf9..9eb9e12 100644
--- a/gocv.go
+++ b/gocv.go
@@ -21,9 +21,8 @@ import (
 
 func (rec *Recognizer) detectFromMat(type_ int, mat gocv.Mat) (faces []Face, err error) {
 	cType := C.int(type_)
-	var ptr C.image_pointer
 
-	ret := C.facerec_detect_from_mat(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&ptr)), unsafe.Pointer(mat.Ptr()), cType)
+	ret := C.facerec_detect_from_mat(rec.ptr, unsafe.Pointer(mat.Ptr()), cType)
 	defer C.free(unsafe.Pointer(ret))
 
 	if ret.err_str != nil {
@@ -39,13 +38,16 @@ func (rec *Recognizer) detectFromMat(type_ int, mat gocv.Mat) (faces []Face, err
 
 	// Copy faces data to Go structure.
 	defer C.free(unsafe.Pointer(ret.rectangles))
+	defer C.free(unsafe.Pointer(ret.p))
 
+	rPtr := unsafe.Pointer(ret.p)
+	rP := (*[1 << 30]C.image_pointer)(rPtr)[:numFaces:numFaces]
 	rDataLen := numFaces * rectLen
 	rDataPtr := unsafe.Pointer(ret.rectangles)
 	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
 
 	for i := 0; i < numFaces; i++ {
-		face := Face{imagePointer: ptr}
+		face := Face{imagePointer: rP[i]}
 		x0 := int(rData[i*rectLen])
 		y0 := int(rData[i*rectLen+1])
 		x1 := int(rData[i*rectLen+2])
diff --git a/gocv.h b/gocv.h
index a084ff9..f482425 100644
--- a/gocv.h
+++ b/gocv.h
@@ -10,7 +10,7 @@
 extern "C" {
 #endif
 
-facesret* facerec_detect_from_mat(facerec* rec,  image_pointer *p, const void *mat,int type);
+facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type);
 
 #ifdef __cplusplus
 }
diff --git a/utils.cc b/utils.cc
new file mode 100644
index 0000000..fb64ae4
--- /dev/null
+++ b/utils.cc
@@ -0,0 +1,37 @@
+#include <dlib/graph_utils.h>
+#include <dlib/image_io.h>
+#include "facerec.h"
+#include "utils.h"
+
+using namespace dlib;
+
+std::vector<image_t> jitter_image(
+    const image_t& img,
+    int count
+)
+{
+    // All this function does is make count copies of img, all slightly jittered by being
+    // zoomed, rotated, and translated a little bit differently. They are also randomly
+    // mirrored left to right.
+    thread_local dlib::rand rnd;
+
+    std::vector<image_t> crops;
+    for (int i = 0; i < count; ++i)
+        crops.push_back(jitter_image(img,rnd));
+
+    return crops;
+}
+
+// Helper function to estimage the age
+uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>& p, float& confidence)
+{
+	float estimated_age = (0.25f * p(0));
+	confidence = p(0);
+
+	for (uint16_t i = 1; i < number_of_age_classes; i++) {
+		estimated_age += (static_cast<float>(i) * p(i));
+		if (p(i) > confidence) confidence = p(i);
+	}
+
+	return std::lround(estimated_age);
+}
diff --git a/utils.h b/utils.h
new file mode 100644
index 0000000..79612f8
--- /dev/null
+++ b/utils.h
@@ -0,0 +1,12 @@
+#pragma once
+#ifndef UTILS_H
+#define UTILS_H
+
+#ifdef __cplusplus
+#include <dlib/graph_utils.h>
+
+std::vector<image_t> jitter_image(const image_t& img,int count);
+uint8_t get_estimated_age(matrix<float, 1, number_of_age_classes>&, float&);
+
+#endif
+#endif /* UTILS_H */
diff --git a/wrapper.cc b/wrapper.cc
index 22f6e85..664636f 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -71,10 +71,9 @@ void facerec_set_age(facerec* rec, const char *file) {
 	cls->setAge(file);
 }
 
-facesret* facerec_detect_from_file(facerec* rec, image_pointer *p, const char* file,int type) {
+facesret* facerec_detect_from_file(facerec* rec, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
-	std::vector<rectangle> rects;
 
 	try {
 		// TODO(Kagami): Support more file types?
@@ -90,13 +89,12 @@ facesret* facerec_detect_from_file(facerec* rec, image_pointer *p, const char* f
 		return ret;
 	}
     
-    return facerec_detect(ret, p, rec, img, type);
+    return facerec_detect(ret, rec, img, type);
 }
 
-facesret* facerec_detect_from_buffer(facerec* rec, image_pointer *p, unsigned char* img_data, int len,int type) {
+facesret* facerec_detect_from_buffer(facerec* rec, unsigned char* img_data, int len,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
-	std::vector<rectangle> rects;
 
 	try {
 		// TODO(Kagami): Support more file types?
@@ -111,58 +109,47 @@ facesret* facerec_detect_from_buffer(facerec* rec, image_pointer *p, unsigned ch
 		return ret;
 	}
     
-    return facerec_detect(ret, p, rec, img, type);
+    return facerec_detect(ret, rec, img, type);
 }
 
-faceret* facerec_recognize(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
+faceret* facerec_recognize(facerec* rec, image_pointer *p) {
     faceret* ret = (faceret*)calloc(1, sizeof(faceret));
-	FaceRec* cls = (FaceRec*)(rec->cls);
-    image_t img = *((image_t*)p->p);
-
-	descriptor descr;
-	full_object_detection shape;
-	rectangle r = rectangle(x,y,x1,y1);
-
-   try {
-		std::tie(descr, shape) = cls->recognize(img, r);
+    FaceRec* cls = (FaceRec*)(rec->cls);
+
+    try {
+        descriptor descr;
+	    full_object_detection shape;
+        std::tie(descr, shape) = cls->recognize(p);
+        ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
+        memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
+
+        ret->num_shape = shape.num_parts();
+        ret->shape = (long*)malloc(ret->num_shape * SHAPE_LEN * sizeof(long));
+
+        long* dst = ret->shape;
+	    for (int j = 0; j < ret->num_shape; j++) {
+		    dst[j*SHAPE_LEN] = shape.part(j).x();
+		    dst[j*SHAPE_LEN+1] = shape.part(j).y();
+        }
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
-		return ret;
 	} catch (std::exception& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = UNKNOWN_ERROR;
-		return ret;
 	}
-	ret->descriptor = (float*)malloc(DESCR_LEN * sizeof(float));
-	memcpy((uint8_t*)(ret->descriptor), (void*)&descr(0,0), DESCR_LEN * sizeof(float));
-	
-	ret->num_shape = shape.num_parts();
-	ret->shape = (long*)malloc(ret->num_shape * SHAPE_LEN * sizeof(long));
-
-	long* dst = ret->shape;
-	for (int j = 0; j < ret->num_shape; j++) {
-		dst[j*SHAPE_LEN] = shape.part(j).x();
-		dst[j*SHAPE_LEN+1] = shape.part(j).y();
-    }
-    
+
 	return ret;
 }
 
-int facerec_get_gender(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-    image_t img = *((image_t*)p->p);
-	rectangle r = rectangle(x,y,x1,y1);
-    
-	return cls->gender(img, r);
+int facerec_get_gender(facerec* rec, image_pointer *p) {
+	FaceRec* cls = (FaceRec*)(rec->cls);    
+	return cls->gender(p);
 }
 
-int facerec_get_age(facerec* rec, image_pointer *p, int x, int y, int x1, int y1) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-    image_t img = *((image_t*)p->p);
-	rectangle r = rectangle(x,y,x1,y1);
-    
-	return cls->age(img, r);
+int facerec_get_age(facerec* rec, image_pointer *p) {
+	FaceRec* cls = (FaceRec*)(rec->cls);    
+	return cls->age(p);
 }
 
 void facerec_set_samples(
@@ -201,10 +188,10 @@ void facerec_free(facerec* rec) {
 
 void image_pointer_free(image_pointer* p) {
 	if (p) {
-		if (p->p) {
-			image_t *img = ((image_t*)p->p);
+		if (p->img) {
+			image_t *img = ((image_t*)p->img);
 			delete img;
-			p->p = NULL;
+			p->img = NULL;
 		}
 	}
 }
\ No newline at end of file
diff --git a/wrapper.h b/wrapper.h
index 4a79716..733388d 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -22,10 +22,13 @@ typedef struct facerec {
 } facerec;
 
 typedef struct image_pointer {
-    void *p;
+    void *img;
+    void *shape;
+    void *rect;
 } image_pointer;
 
 typedef struct facesret {
+    image_pointer *p;
 	int num_faces;
 	long* rectangles;
 	const char* err_str;
@@ -45,12 +48,12 @@ typedef struct faceret {
 #define SHAPE_LEN  2
 
 facerec* facerec_init();
-facesret* facerec_detect_from_file(facerec*,  image_pointer *, const char*,int);
-facesret* facerec_detect_from_buffer(facerec*,  image_pointer *, unsigned char*, int, int);
-faceret* facerec_recognize(facerec*, image_pointer*, int, int, int, int);
+facesret* facerec_detect_from_file(facerec*, const char*,int);
+facesret* facerec_detect_from_buffer(facerec*, unsigned char*, int, int);
+faceret* facerec_recognize(facerec*, image_pointer*);
 
-int facerec_get_gender(facerec* rec, image_pointer *, int, int, int, int);
-int facerec_get_age(facerec* rec, image_pointer *, int, int, int, int);
+int facerec_get_gender(facerec* rec, image_pointer *);
+int facerec_get_age(facerec* rec, image_pointer *);
 
 void facerec_set_cnn(facerec* , const char *);
 void facerec_set_shape(facerec* , const char *);

From 560fa0f4066def051eae5dee8bb794a4b74e6bba Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 13:25:28 +0300
Subject: [PATCH 24/36] Fix zoom

---
 facerec.cc | 108 ++++++++++++++++++++++++++---------------------------
 facerec.h  |   3 +-
 gocv.cc    |   3 +-
 wrapper.cc |  10 +++--
 wrapper.h  |   1 +
 5 files changed, 65 insertions(+), 60 deletions(-)

diff --git a/facerec.cc b/facerec.cc
index 5694b6c..f7fe3ec 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -35,13 +35,64 @@ void FaceRec::setAge(const char* age_path) {
     deserialize(std::string(age_path)) >> age_net_;
 }
 
-std::vector<rectangle> FaceRec::detect(image_t& img) {
-    std::lock_guard<std::mutex> lock(detector_mutex_);
-        
+void FaceRec::setSize(unsigned long new_size) {
+    size = new_size;
+}
+
+void FaceRec::setPadding(double new_padding) {
+    padding = new_padding;
+}
+
+void FaceRec::setJittering(int new_jittering) {
+    jittering = new_jittering;
+}
+
+void FaceRec::setMinImageSize(int new_min_image_size) {
+    min_image_size = new_min_image_size;
+}
+
+facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
+	std::vector<rectangle> rects;
+    int upped = 0;
+
     while(img.size() < min_image_size) {
         pyramid_up(img);
+        upped += 2;
+    }
+
+    if (type == 0 ) {
+        rects = detectFront(img);
+    } else {
+        rects = detectCNN(img);
     }
 
+    ret->num_faces = rects.size();    
+
+    if (ret->num_faces == 0)
+		return ret;
+
+	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
+    ret->p = new image_pointer[ret->num_faces];
+
+	for (int i = 0; i < ret->num_faces; i++) {
+        ret->p[i].img = new image_t(img);
+        ret->p[i].rect = new rectangle(rects[i]);
+        ret->p[i].shape = 0;
+        if (upped == 0) upped = 1; 
+        ret->p[i].upped = upped;     
+
+        long* dst = ret->rectangles + i * RECT_LEN;
+        dst[0] = rects[i].left() / upped;
+        dst[1] = rects[i].top() / upped;
+        dst[2] = rects[i].right() / upped;
+        dst[3] = rects[i].bottom() / upped;
+    }
+	return ret;
+}
+
+std::vector<rectangle> FaceRec::detectFront(image_t& img) {
+    std::lock_guard<std::mutex> lock(detector_mutex_);
+
     return detector_(img);
 }
 
@@ -49,10 +100,6 @@ std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
     std::vector<rectangle> rects;
     std::lock_guard<std::mutex> lock(cnn_net_mutex_);
 
-    while(img.size() < min_image_size) {
-        pyramid_up(img);
-    }
-
 	auto dets = cnn_net_(img);
     for (auto&& d : dets) {
         rects.push_back(d.rect);
@@ -137,53 +184,6 @@ std::tuple<descriptor, full_object_detection> FaceRec::recognize(image_pointer *
     return std::make_tuple(descr, shape);
 }
 
-void FaceRec::setSize(unsigned long new_size) {
-    size = new_size;
-}
-
-void FaceRec::setPadding(double new_padding) {
-    padding = new_padding;
-}
-
-void FaceRec::setJittering(int new_jittering) {
-    jittering = new_jittering;
-}
-
-void FaceRec::setMinImageSize(int new_min_image_size) {
-    min_image_size = new_min_image_size;
-}
-
-facesret* facerec_detect(facesret *ret, facerec* rec, image_t &img, int type) {
-	FaceRec* cls = (FaceRec*)(rec->cls);
-	std::vector<rectangle> rects;
-
-    if (type == 0 ) {
-        rects = cls->detect(img);
-    } else {
-        rects = cls->detectCNN(img);
-    }
-
-    ret->num_faces = rects.size();    
-
-    if (ret->num_faces == 0)
-		return ret;
-
-	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
-    ret->p = new image_pointer[ret->num_faces];
-
-	for (int i = 0; i < ret->num_faces; i++) {
-        ret->p[i].img = new image_t(img);
-        ret->p[i].rect = new rectangle(rects[i]);
-        ret->p[i].shape = 0;     
-        long* dst = ret->rectangles + i * RECT_LEN;
-        dst[0] = rects[i].left();
-        dst[1] = rects[i].top();
-        dst[2] = rects[i].right();
-        dst[3] = rects[i].bottom();
-    }
-	return ret;
-}
-
 // Classify
 void FaceRec::setSamples(std::vector<descriptor>&& samples, std::vector<int>&& cats) {
     std::unique_lock<std::shared_mutex> lock(samples_mutex_);
diff --git a/facerec.h b/facerec.h
index 742b89f..47bc2b2 100644
--- a/facerec.h
+++ b/facerec.h
@@ -53,7 +53,8 @@ class FaceRec {
     void setJittering(int);
     void setMinImageSize(int);
 
-    std::vector<rectangle> detect(image_t&);
+    facesret* detect(facesret *, image_t &, int);
+    std::vector<rectangle> detectFront(image_t&);
     std::vector<rectangle> detectCNN(image_t&);
     
     std::tuple<descriptor, full_object_detection> recognize(image_pointer *);
diff --git a/gocv.cc b/gocv.cc
index 7300cac..a3940d7 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -9,6 +9,7 @@
 using namespace dlib;
 
 facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type) {
+    FaceRec* cls = (FaceRec*)(rec->cls);
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 
@@ -27,5 +28,5 @@ facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type) {
 		return ret;
 	}
     
-    return facerec_detect(ret, rec, img, type);
+    return cls->detect(ret, img, type);
 }
diff --git a/wrapper.cc b/wrapper.cc
index 664636f..becd620 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -73,6 +73,7 @@ void facerec_set_age(facerec* rec, const char *file) {
 
 facesret* facerec_detect_from_file(facerec* rec, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+    FaceRec* cls = (FaceRec*)(rec->cls);
 	image_t img;
 
 	try {
@@ -89,10 +90,11 @@ facesret* facerec_detect_from_file(facerec* rec, const char* file,int type) {
 		return ret;
 	}
     
-    return facerec_detect(ret, rec, img, type);
+    return cls->detect(ret, img, type);
 }
 
 facesret* facerec_detect_from_buffer(facerec* rec, unsigned char* img_data, int len,int type) {
+    FaceRec* cls = (FaceRec*)(rec->cls);
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
 	image_t img;
 
@@ -109,7 +111,7 @@ facesret* facerec_detect_from_buffer(facerec* rec, unsigned char* img_data, int
 		return ret;
 	}
     
-    return facerec_detect(ret, rec, img, type);
+    return cls->detect(ret, img, type);
 }
 
 faceret* facerec_recognize(facerec* rec, image_pointer *p) {
@@ -128,8 +130,8 @@ faceret* facerec_recognize(facerec* rec, image_pointer *p) {
 
         long* dst = ret->shape;
 	    for (int j = 0; j < ret->num_shape; j++) {
-		    dst[j*SHAPE_LEN] = shape.part(j).x();
-		    dst[j*SHAPE_LEN+1] = shape.part(j).y();
+		    dst[j*SHAPE_LEN] = shape.part(j).x() / p->upped;
+		    dst[j*SHAPE_LEN+1] = shape.part(j).y() / p->upped;
         }
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
diff --git a/wrapper.h b/wrapper.h
index 733388d..2b0afee 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -25,6 +25,7 @@ typedef struct image_pointer {
     void *img;
     void *shape;
     void *rect;
+    int upped;
 } image_pointer;
 
 typedef struct facesret {

From 8ff93abc93ac86242f03398671100fdc48af6f7b Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 14:12:33 +0300
Subject: [PATCH 25/36] Add support cv::Mat grayscale

---
 facerec.cc | 39 ++++++++++++---------------------------
 facerec.h  |  3 ---
 gocv.cc    | 13 +++++++++++--
 3 files changed, 23 insertions(+), 32 deletions(-)

diff --git a/facerec.cc b/facerec.cc
index f7fe3ec..90124ee 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -12,7 +12,7 @@
 using namespace dlib;
 
 FaceRec::FaceRec() {
-		detector_ = get_frontal_face_detector();
+	detector_ = get_frontal_face_detector();
 }
 
 void FaceRec::setCNN(const char* cnn_resnet_path) {
@@ -52,6 +52,7 @@ void FaceRec::setMinImageSize(int new_min_image_size) {
 }
 
 facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
+    std::lock_guard<std::mutex> lock(detector_mutex_);
 	std::vector<rectangle> rects;
     int upped = 0;
 
@@ -61,9 +62,12 @@ facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
     }
 
     if (type == 0 ) {
-        rects = detectFront(img);
+        rects = detector_(img);
     } else {
-        rects = detectCNN(img);
+        auto dets = cnn_net_(img);
+        for (auto&& d : dets) {
+            rects.push_back(d.rect);
+        }
     }
 
     ret->num_faces = rects.size();    
@@ -78,36 +82,17 @@ facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
         ret->p[i].img = new image_t(img);
         ret->p[i].rect = new rectangle(rects[i]);
         ret->p[i].shape = 0;
-        if (upped == 0) upped = 1; 
-        ret->p[i].upped = upped;     
+        ret->p[i].upped = upped == 0?1:upped;     
 
         long* dst = ret->rectangles + i * RECT_LEN;
-        dst[0] = rects[i].left() / upped;
-        dst[1] = rects[i].top() / upped;
-        dst[2] = rects[i].right() / upped;
-        dst[3] = rects[i].bottom() / upped;
+        dst[0] = rects[i].left() / ret->p[i].upped;
+        dst[1] = rects[i].top() / ret->p[i].upped;
+        dst[2] = rects[i].right() / ret->p[i].upped;
+        dst[3] = rects[i].bottom() / ret->p[i].upped;
     }
 	return ret;
 }
 
-std::vector<rectangle> FaceRec::detectFront(image_t& img) {
-    std::lock_guard<std::mutex> lock(detector_mutex_);
-
-    return detector_(img);
-}
-
-std::vector<rectangle> FaceRec::detectCNN(image_t& img) {
-    std::vector<rectangle> rects;
-    std::lock_guard<std::mutex> lock(cnn_net_mutex_);
-
-	auto dets = cnn_net_(img);
-    for (auto&& d : dets) {
-        rects.push_back(d.rect);
-    }
-
-    return rects;
-}
-
 int FaceRec::gender(image_pointer *p) {
     full_object_detection shape;
     std::lock_guard<std::mutex> lock(net_mutex_);
diff --git a/facerec.h b/facerec.h
index 47bc2b2..482b8c5 100644
--- a/facerec.h
+++ b/facerec.h
@@ -18,7 +18,6 @@ class FaceRec {
 private:
 	std::mutex detector_mutex_;
 	std::mutex net_mutex_;
-	std::mutex cnn_net_mutex_;
     
 	std::shared_mutex samples_mutex_;
     
@@ -54,8 +53,6 @@ class FaceRec {
     void setMinImageSize(int);
 
     facesret* detect(facesret *, image_t &, int);
-    std::vector<rectangle> detectFront(image_t&);
-    std::vector<rectangle> detectCNN(image_t&);
     
     std::tuple<descriptor, full_object_detection> recognize(image_pointer *);
     
diff --git a/gocv.cc b/gocv.cc
index a3940d7..74b1b46 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -15,9 +15,18 @@ facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type) {
 
 	try {
         cv::Mat *mat_img = (cv::Mat*)mat;
+        if (!mat_img) {
+            ret->err_code = UNKNOWN_ERROR;
+            return ret;
+        }
         IplImage ipl_img = cvIplImage(*mat_img);
-		cv_image<bgr_pixel> dlib_img(&ipl_img);
-        assign_image(img, dlib_img);
+        if (mat_img->channels() > 1) {
+		    cv_image<bgr_pixel> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        } else {
+            cv_image<uchar> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        }
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;

From 5616a78e2db657a5ebe19146cb762644c2796a39 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 14:37:26 +0300
Subject: [PATCH 26/36] Return sort

---
 facerec.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/facerec.cc b/facerec.cc
index 90124ee..f9aeee1 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -75,6 +75,8 @@ facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
     if (ret->num_faces == 0)
 		return ret;
 
+	std::sort(rects.begin(), rects.end());
+
 	ret->rectangles = (long*)malloc(ret->num_faces * RECT_LEN * sizeof(long));
     ret->p = new image_pointer[ret->num_faces];
 

From 8e5e4d5351d528514a2e5d28dd79cbf5a3ff262a Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 14:40:20 +0300
Subject: [PATCH 27/36] Update test

---
 example_test.go | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/example_test.go b/example_test.go
index 87294a9..35bfc20 100644
--- a/example_test.go
+++ b/example_test.go
@@ -10,8 +10,9 @@ import (
 
 // Path to directory with models and test images. Here it's assumed it
 // points to the <https://github.com/Kagami/go-face-testdata> clone.
+const dataDir = "testdata"
 const cnn = "testdata/mmod_human_face_detector.dat"
-const shape = "testdata/shape_predictor_68_face_landmarks.dat"
+const shape = "testdata/shape_predictor_5_face_landmarks.dat"
 const descr = "testdata/dlib_face_recognition_resnet_model_v1.dat"
 const gender = "testdata/dnn_gender_classifier_v1.dat"
 const age = "testdata/dnn_age_predictor_v1.dat"
@@ -36,7 +37,7 @@ func Example_basic() {
 	rec.SetSize(150)
 	rec.SetPadding(0.25)
 	rec.SetMinImageSize(100)
-	rec.SetJittering(0)
+	rec.SetJittering(20)
 
 	// Test image with 10 faces.
 	testImagePristin := filepath.Join(dataDir, "pristin.jpg")
@@ -46,7 +47,7 @@ func Example_basic() {
 		log.Fatalf("Can't recognize: %v", err)
 	}
 	if len(faces) != 10 {
-		log.Fatalf("Wrong number of faces")
+		log.Fatalf("Wrong number of faces, %d", len(faces))
 	}
 
 	// Fill known samples. In the real world you would use a lot of images
@@ -74,8 +75,8 @@ func Example_basic() {
 	if err != nil {
 		log.Fatalf("Can't recognize: %v", err)
 	}
-	if len(faces) != 1 {
-		log.Fatalf("Wrong number of faces")
+	if len(nayoungFace) != 1 {
+		log.Fatalf("Wrong number of faces %d", len(nayoungFace))
 	}
 	rec.Recognize(&nayoungFace[0])
 

From 99c0cb80eb8f8c6303ed100d822cdc415aa8d299 Mon Sep 17 00:00:00 2001
From: danil_e71 <korekovtsevda@lad24.ru>
Date: Thu, 13 Feb 2020 16:31:33 +0300
Subject: [PATCH 28/36] Fix test?

---
 face_test.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/face_test.go b/face_test.go
index 2b073f3..29477fb 100644
--- a/face_test.go
+++ b/face_test.go
@@ -117,10 +117,12 @@ func getTrainData(idata *IdolData) (tdata *TrainData) {
 
 func recognizeAndClassify(fpath string, tolerance float32) (id int, err error) {
 	id = -1
-	f, err := rec.RecognizeSingleFile(fpath)
-	if err != nil || f == nil {
+	faces, err := rec.DetectFromFile(fpath)
+	if err != nil || len(faces) <= 0 {
 		return
 	}
+	f := faces[0]
+	rec.Recognize(&f)
 	if tolerance < 0 {
 		id = rec.Classify(f.Descriptor)
 	} else {
@@ -129,26 +131,29 @@ func recognizeAndClassify(fpath string, tolerance float32) (id int, err error) {
 	return
 }
 
-func TestSerializationError(t *testing.T) {
-	_, err := face.NewRecognizer("/notexist")
+/*func TestSerializationError(t *testing.T) {
+	_, err := face.NewRecognizer()
 	switch err.(type) {
 	case face.SerializationError:
 		// skip
 	default:
 		t.Fatalf("Wrong error: %v", err)
 	}
-}
+}*/
 
 func TestInit(t *testing.T) {
 	var err error
-	rec, err = face.NewRecognizer("testdata")
+	rec, err = face.NewRecognizer()
 	if err != nil {
 		t.Fatalf("Can't init face recognizer: %v", err)
 	}
+	rec.SetCNNModel(cnn)
+	rec.SetDescriptorModel(descr)
+	rec.SetShapeModel(shape)
 }
 
 func TestImageLoadError(t *testing.T) {
-	_, err := rec.Recognize([]byte{1, 2, 3})
+	_, err := rec.DetectFromBuffer([]byte{1, 2, 3})
 	switch err.(type) {
 	case face.ImageLoadError:
 		// skip
@@ -158,7 +163,7 @@ func TestImageLoadError(t *testing.T) {
 }
 
 func TestNumFaces(t *testing.T) {
-	faces, err := rec.RecognizeFile(getTPath("pristin.jpg"))
+	faces, err := rec.DetectFromFile(getTPath("pristin.jpg"))
 	if err != nil {
 		t.Fatalf("Can't get faces: %v", err)
 	}

From 70cd49063c0f61945e8c9d0528873549ec96d97b Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Thu, 14 May 2020 13:17:37 +0300
Subject: [PATCH 29/36] Add support custom models

---
 face.go    | 19 +++++++++++++++++++
 facerec.cc | 11 ++++++++++-
 facerec.h  |  2 ++
 template.h |  6 ++++++
 wrapper.cc |  5 +++++
 wrapper.h  |  1 +
 6 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/face.go b/face.go
index 71f8a4e..bbe1b74 100644
--- a/face.go
+++ b/face.go
@@ -119,6 +119,17 @@ func (rec *Recognizer) SetCNNModel(cnnResnetPath string) (err error) {
 	return
 }
 
+func (rec *Recognizer) SetCustomModel(cnnResnetPath string) (err error) {
+	if !fileExists(cnnResnetPath) {
+		err = errors.New(fmt.Sprintf("File '%s' not found!", cnnResnetPath))
+		return
+	}
+	cCnnResnetPath := C.CString(cnnResnetPath)
+	defer C.free(unsafe.Pointer(cCnnResnetPath))
+	C.facerec_set_custom(rec.ptr, cCnnResnetPath)
+	return
+}
+
 func (rec *Recognizer) SetGenderModel(genderPath string) (err error) {
 	if !fileExists(genderPath) {
 		err = errors.New(fmt.Sprintf("File '%s' not found!", genderPath))
@@ -261,6 +272,10 @@ func (rec *Recognizer) DetectFromBufferCNN(imgData []byte) (faces []Face, err er
 	return rec.detectFromBuffer(1, imgData)
 }
 
+func (rec *Recognizer) DetectFromBufferCustom(imgData []byte) (faces []Face, err error) {
+	return rec.detectFromBuffer(2, imgData)
+}
+
 // Same as Recognize but accepts image path instead.
 func (rec *Recognizer) DetectFromFile(imgPath string) (faces []Face, err error) {
 	return rec.detectFromFile(0, imgPath)
@@ -270,6 +285,10 @@ func (rec *Recognizer) DetectFromFileCNN(imgPath string) (faces []Face, err erro
 	return rec.detectFromFile(1, imgPath)
 }
 
+func (rec *Recognizer) DetectFromFileCustom(imgPath string) (faces []Face, err error) {
+	return rec.detectFromFile(2, imgPath)
+}
+
 func (rec *Recognizer) GetGender(face *Face) {
 	face.Gender = Gender(int(C.facerec_get_gender(rec.ptr, (*C.image_pointer)(unsafe.Pointer(&face.imagePointer)))))
 }
diff --git a/facerec.cc b/facerec.cc
index f9aeee1..e9160b5 100644
--- a/facerec.cc
+++ b/facerec.cc
@@ -19,6 +19,10 @@ void FaceRec::setCNN(const char* cnn_resnet_path) {
     deserialize(std::string(cnn_resnet_path)) >> cnn_net_;
 }
 
+void FaceRec::setCustom(const char* cnn_resnet_path) {
+    deserialize(std::string(cnn_resnet_path)) >> custom_cnn_net_;
+}
+
 void FaceRec::setShape(const char* shape_predictor_path) {
     deserialize(std::string(shape_predictor_path)) >> sp_;
 }
@@ -63,11 +67,16 @@ facesret* FaceRec::detect(facesret *ret, image_t &img, int type) {
 
     if (type == 0 ) {
         rects = detector_(img);
-    } else {
+    } else if (type == 1) {
         auto dets = cnn_net_(img);
         for (auto&& d : dets) {
             rects.push_back(d.rect);
         }
+    } else if (type == 2) {
+        auto dets = custom_cnn_net_(img);
+        for (auto&& d : dets) {
+            rects.push_back(d.rect);
+        }
     }
 
     ret->num_faces = rects.size();    
diff --git a/facerec.h b/facerec.h
index 482b8c5..f2649d4 100644
--- a/facerec.h
+++ b/facerec.h
@@ -26,6 +26,7 @@ class FaceRec {
     
 	anet_type net_;
 	cnn_anet_type cnn_net_;
+    custom_anet_type custom_cnn_net_;
     agender_type gender_net_;
     apredictor_t age_net_;
     
@@ -42,6 +43,7 @@ class FaceRec {
 	FaceRec();
     
     void setCNN(const char*);
+    void setCustom(const char*);
     void setShape(const char*);
     void setDescriptor(const char*);
     void setGender(const char*);
diff --git a/template.h b/template.h
index edfa658..ee7ac1f 100644
--- a/template.h
+++ b/template.h
@@ -33,6 +33,12 @@ template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
 
 template <long num_filters, typename SUBNET> using con5d = con<num_filters,5,5,2,2,SUBNET>;
 template <long num_filters, typename SUBNET> using con5  = con<num_filters,5,5,1,1,SUBNET>;
+template <long num_filters, typename SUBNET> using con3  = con<num_filters,3,3,1,1,SUBNET>;
+
+
+template <typename SUBNET> using downsampler_  = relu<bn_con<con5d<32, relu<bn_con<con5d<32, relu<bn_con<con5d<32,SUBNET>>>>>>>>>;
+template <typename SUBNET> using rcon3  = relu<bn_con<con3<32,SUBNET>>>;
+using custom_anet_type  = loss_mmod<con<1,6,6,1,1,rcon3<rcon3<rcon3<downsampler_<input_rgb_image_pyramid<pyramid_down<6>>>>>>>>;
 
 template <typename SUBNET> using downsampler  = relu<affine<con5d<32, relu<affine<con5d<32, relu<affine<con5d<16,SUBNET>>>>>>>>>;
 template <typename SUBNET> using rcon5  = relu<affine<con5<45,SUBNET>>>;
diff --git a/wrapper.cc b/wrapper.cc
index becd620..bfc66e1 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -51,6 +51,11 @@ void facerec_set_cnn(facerec* rec, const char *file) {
 	cls->setCNN(file);
 }
 
+void facerec_set_custom(facerec* rec, const char *file) {
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	cls->setCustom(file);
+}
+
 void facerec_set_shape(facerec* rec, const char *file) {
 	FaceRec* cls = (FaceRec*)(rec->cls);
 	cls->setShape(file);
diff --git a/wrapper.h b/wrapper.h
index 2b0afee..58ea002 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -57,6 +57,7 @@ int facerec_get_gender(facerec* rec, image_pointer *);
 int facerec_get_age(facerec* rec, image_pointer *);
 
 void facerec_set_cnn(facerec* , const char *);
+void facerec_set_custom(facerec* , const char *);
 void facerec_set_shape(facerec* , const char *);
 void facerec_set_descriptor(facerec* , const char *);
 void facerec_set_gender(facerec* , const char *);

From f007b84145556da021c8a6635a1986a50ea44a5a Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Fri, 15 May 2020 10:14:45 +0300
Subject: [PATCH 30/36] upd

---
 gocv.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gocv.go b/gocv.go
index 9eb9e12..d72e1c8 100644
--- a/gocv.go
+++ b/gocv.go
@@ -66,6 +66,10 @@ func (rec *Recognizer) DetectFromMatCNN(mat gocv.Mat) (faces []Face, err error)
 	return rec.detectFromMat(1, mat)
 }
 
+func (rec *Recognizer) DetectFromMatCustom(mat gocv.Mat) (faces []Face, err error) {
+	return rec.detectFromMat(2, mat)
+}
+
 func RenderFaceDetections(img *gocv.Mat, Shapes []image.Point, col color.RGBA, thickness int) {
 	if len(Shapes) == 5 {
 		gocv.Line(img, Shapes[0], Shapes[1], col, thickness)

From f82722746fa63846039442a70af8379d6e9f946c Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Tue, 9 Jun 2020 15:38:03 +0300
Subject: [PATCH 31/36] add tracking

---
 go-face.tar.xz | Bin 0 -> 17264 bytes
 gocv.cc        |  69 ++++++++++++++++++++++++++++
 gocv.go        |  24 ++++++++++
 gocv.h         |   2 +
 tracker.cc     |  39 ++++++++++++++++
 tracker.go     |  57 +++++++++++++++++++++++
 tracker.h      |  27 +++++++++++
 wrapper.cc     | 122 +++++++++++++++++++++++++++++++++++++++++++++++++
 wrapper.h      |  21 +++++++++
 9 files changed, 361 insertions(+)
 create mode 100644 go-face.tar.xz
 create mode 100644 tracker.cc
 create mode 100644 tracker.go
 create mode 100644 tracker.h

diff --git a/go-face.tar.xz b/go-face.tar.xz
new file mode 100644
index 0000000000000000000000000000000000000000..d1f070b103ff773ad0af9e4b447e8f4b327d3aa6
GIT binary patch
literal 17264
zcmV(rK<>Z&H+ooF000E$*0e?f03iVu0001VFXf}*Xa7SmT>v|rh(^b=)x@GDN)r3O
z?NkS<qV2D-Q9irK1bYkM1Fm2{Nay)b;yNWhA$z!yHrnvUszMojdr98aPf<rNI!@?O
za?@Xi<vmA=8%0ZJb>u!(Yaj>z5(@N1TF`j#H<gB&O<7n;s=<v3ueHX=x-1$?&fT>t
z$;bSwE3Q8cqL$4fTSiH&tRdgm72%{Sis)|aY(-ga_md)=<ux-0Rw#-cA7B1UfZFRg
zlP2-vnO2|ufQv(}bxLvF!LajSbSqGY6hZFn*)TWI9X%LYFb+17Kh+j0ZuNwrsr~>U
zVFM4PQj#4wVRakg%3Qg;G4@h53@1_3*0dI8%9$)3V?GnW^Jz8V&JCu0X+ha$%!%=Z
zF#r#QC}2O~TE2f~@ju7drjy1=@d@uecwJ9)2w*&F^y6fn&Oz{$vcN`yecR!a{8r<!
za;0VagHkF&Pue_ZD(?*Sc!W8vHLw-%5l%bm@c+1kO(l@hL&|u+)rSKPYjC^kEvUOA
zO!y#OY9y3xUwO?Zyt^zFilW`}Ig4%NrBcptQEX#=$dc8_48yR;Ybd_M!RhQE+W2^R
zkTwa|I~TL*61{+uron8**thN8ff-mU?h|m~vP~qfP^3&d1$^Jje^6?qwlY+NM*UVJ
zS+dJ=)<pnfhyw&-QLiGEj~G3gV8MhTnv6ZbpCt29w_Puz9S%4a+A}qK9k^<96_ae+
z*}qS*O{4#2$hQe%QI~Kl3F^NV$~_puc$`92@Pydjr-Ndx@COu^76%z&8(tX9kL^6}
z%8m_KDdh!Q)V&-#bA74RL>~2|p!+g}wmU2k7*o+WVP2+9nIDUCxtqKZeqIdot@Gns
z5x?*4uPee{(Na650b4WaHq5GF{g$@gU+2CX2`XC5g?%f0R%n40%SMd4p^^@)5X)ZU
z&FuDP@q*cr^3;)*#0r`EGEvCVREf4>S;B^8zj9%#(I4gCr3DXK?pz?Q-$#3-R#-fX
zfH`h&S5Ex*MKH;(O88SU&#?Exeaai<GaqkG&|G|K5o|wsrPkgXbG~*lln{6;w9h4o
zhlpR+Z1%H#pYqZYTW2xCUF@V#)-H#ffeAlz8>Jm@Il`xrtwzOkf(=Jy4J^8J>TjGW
zogf#D8!rR~CACL;9%w3T0s7(>c_Zb@?6rwPS&H0IkHFbB_B($hV<R+?obYHOWoC9S
z54VHJo5Xfa6%#!4Lp-5DB6qsC-eY{kuo<a?E)eZpR!o;nOE(He9_*j6L6@|P3@@^Y
zO_bE4`va*;frsIHhkK$y!BODwso#|s^hz02Q=+`&L1r&Lp~L)y+|;3yH`|2_#^|ZE
z)QU@X;d@7?lU`)O)f^&y$SBPPVfH*htjLm=x32u*4?!j2UhaT+Alr12Qw(V<+At-H
z0zFhSurD~hxwpLLBc=(Hyjy$C=V!+kZAZmBGx4!2jlOjgD|<*JbXO;^dNBb#$5X?t
zkDcm!kF6-dXubZt`&2Sr9E{3JaHrKU4p=O0U_Cv35r2xCnI|S^UV)B6y4`h9FMjj5
zpYS2V54UXP$Ss(LWt#R_lnr)uti0>9Xyqisf_hMEMdluM63LLk>`;d*=%Y}Vx4l%+
z*eHvJfRqXyMBcF9O{|w!@**wxU}tmq`}GeX*sQCod?_}j!YmgN20wP&su>H_D}j5V
zQIDA<fWGD1*-r@MM$D}|$?^rgx)*WZm;m&OPPE=5-_73u65&NCr@$ZSLO864V5>+=
zZ_E+ET!K0f?#cyWy#g4+4K=Jo)&pm-9K4oeRw>5&=Vr=#n<<v0naZA2)sRV}RsPIw
zVZ;(R$VO-X4N4s<oZytgq()oLAz51!8+h#^$cM*6b24xx_S)hg(y}gDz+KCxf#@2}
zN-JPQ1<|?CNc@<6ai&<q)Tp#zg|VWfh`)yNir$hOD0tMbjsShlv31`lQ^Gvw8C%_r
zzSH;D6sM2TYFQ`wq)98^I>|C=f}oAQU?6hQnP_^Uc4+eZdu6ZL4@aucEW9zoh0;Mf
znklYc4#(ilN-r`!ktJ@14o%MO1GxDO_Yhd{ar^;%Lbc!TM`fEkLws21?3tLxhb-&E
z!W>r(B4+-6E@ki*g9G;z{KHnjJ*X8@BiZ|xYb~PtlluU<u$Y{yiWAMqfHgJZnDsU0
zZeK@y5~nPDLAiMAz<ZKI_1sSDXHv7Q9}i(}2@p?-tm%(KIMwroOv6rMvM}uOz(MpN
z8N}-!SfS2^jC=-fEI8X$h@tsYypGb~LUy}c0^EWgZ(%%9(Wj#T_Mr`f$u^qHHBRyu
z22;h7zO+;^$Kr$<;SC;L^IIp(a%K4-{F$_`1dBy?DM%2RnNjRW)$0Cpp}EK-LRbB^
zjK`NoJ~Pe>aM3iS)FSE)?1;?!&_3BP)7ui{<XK2<Cw@RxNSg1OmmU|&%VNC*!dBsx
z)s=Ezq6LWJSwhUgIy+BIT)4+h2MoU^hzf-q5d#tHG0i=08L@<d6Vjd_5M!(=3tR*k
z)S`oj`sjkl(@i2s+@xB(?h!^fQMC-(285Aa(2vE3dm&e&4fMVwV}VH2m(yi?LVHXX
zVjIduL77fqVj4`S=mNQtIYN2a@3}9;utU^}3q%*({%0nQ(HrnG$`I2U21O$IaG}oh
zRwl03o>t3!*{8ex2!aMyF1FNn@~V=lyA8#F)RUs~?_u`&+>1|J8D=-l?Eot9MWFE*
zdk~I9FBi9i0COnVCMXYnp63zsmHYOx$-ZpdL0n1P4^0ZYTTQN~xveQO3F&$ij_NN+
ze8>A0jfpUqnRyK4T1Ag8Q(ZD-<@6RU&U`eF^I;zxrjaD$z6EQ3f}$aDuw^#bWpizb
z3Q7hw1(Q5QEr2?qWiAvLWeG<!V^Y-Zy5V5#*kMtqu&ljS7ho%mf^!2<CL>p9GNL=v
ze$OZ6D`WtnXo#!?<8fv_P9y%BS2RZ871;U)7U@hHY;6hL#EJ^u4(h4&BpSzqJmUWI
zEmAvQ?}%7$d{H&U@E_(X4n{{Pz(!v!vqd!`r^sl#FTN+aVv4b}mVhqXc?hu>#H6Cv
z$SG@U9}FhwZbwiEw(|z}d^H~k$|I{TjDbp_E#-?5>co?d((5U$ze06oSWIN~hous=
ze|d%5kdo>kJxD10hBFi|UKvd%$j@-NRj@60iLcB9WmZAM8(?XX4Q0uC#Qa-?lCdFI
zUMHYTO8ws<^c$0WBkpxPAY&euNKa?g;7reka$Uv~c2xk!{Kb=(i8Yfgeg}VBh6?Sk
zm*!oh$j*P;N8L?liopep8=Zx=M!`R?54`GmTaMnbCF3r3;NnuSgX%xt$rT0_9pPgc
zx3`rsDN5+|C{HKi?iA5o3z6LL2<;Xb$E@DuNQI!B5Zy_6Dpj@+@9A<_2h@Xk<d&mH
zq98{P#O~sM<~p#Vce1&N&0Me@D~BTxv@fM!g}yI1&=>zTj`>vuBjtJ6W=evF%!C$j
zYK1<nZE-iFE=>GXt&w;6XB@!aEi8t0(_yRqzG1uIoo$TSmWfyi3FzgKxL-3NyNIYV
zYgF>(A7;(Wyse3`(6)u^Jy>?=g}waLFHSzT*63Q@{P3SQgMBWG#!)<+xHxP5yn2xd
z_}XEzwPMSGb^*L;kwLYGV3EJ&sR1u~I#@fU>d+<ZFs}m#E0K7$rels%djI%&#^xS%
zFsBe&K_IlB2z>C1EIA;fVDR&cS=@DBr*(n>(`rnNsUX0f)X2-_6&tOHzUb7+fhp*r
z$y<ezyk5j*7Nxmcl0rP-jZqur(@1HEt#uftZWZ;u0(MT{u!!HA9UI~cUtQ-;@JzBJ
zD)~wWh#=WrF6cLe%sTG<iG(+$lw?}JJyd<5;rX)azW?0%ZdA;k-U%o(gL^Bf&N(D_
zreD+yINdGtt~~e2LYjTZ_^<XxgdO|(nIY?GCDIP&_v>{nG-j48UdDHS7{gV6s?V{L
zr(RGz_Y4s>&vhtsQfdS_D$od0sfvQFj}27D#>A-KN6+qd4GHbSbnfXM*(vt>sV4iX
z^4F^8hBP~gno&zzjf_QT(!k9k)Q)_!go@RxY$?o?kqysc>qJXS_E)t$L7%wXmZMLm
zCeGQt_fwy$lHT!LF^#L1OxR*zDuXXm^Fz>}2;7up?Ga?GAyKbElX5@4&aMn@^_QxO
zK634X(|K5eYx1C;j60%dFJ<B9m)K?n-p(_&kIlql*<8(9)o5KMp9q1&@M)?4l9N6*
zzQ+YR6MCoaA7kx-#cH9V<PjKF^UtEXC)c{`XqcaMOQVmfObWnmAMFTL6DaK8U-FL0
zSeg0%PqP41h`tm3f+?^{dyD@Aj51v(tlTd`40P>|9#!Gu)8IsQn|`G|!C)~GP?8e$
zOJxc3NJjWqIsw#|)F?)Wp@L0w_;^rf<ejDT9ngcbm}`ZZbEhgCfKYwZo3{4UcBIfF
zi><?E0s4hf?5I-#5#+gx=r$Z5%MK$MT36F!VKV?gzT!sy6Nh)7vKaAe{e;qy*sc~5
zmKoS@(z&D=2=7GAT$6@iwAoVbO0zHPFjP*%6AHzZL#%DV5p#GrEGXfDm0`IK^j{nF
z?3F%<+#4o$xex(n=fo~t>c4Q^RdJzucL4*!G=f9vtl6-7$i(SNhgO=@d}YQvd|DDb
z+v?)79|O9uk{igX{hsNTPEop6ET*@zL=fuUBabNnh+)U?ULj5xzRYxsP_7M*sc@@W
zpe?|PBPKR4?xqd%rc^lm<>2S*f*cB1P(>FC%ZOgT(WmH6CcXwBtB>fBhH{TWA2k%B
z%ABi8^kUMi`UEgQVjZTAe5ad_1$+@+z*=m6vI4%xB9uf(|I~u9`LslC<_Vz#`S_`;
z%i^h}0Gy1a_$Y~r=0A1zAt632O0>;ib)oR3v~~}8bDLRG06%`S#+A#vjWXr>Yeh_?
za7T?8pM^|Z#if7ZtR;RJDK5hHn#fQwmL&}luQK@6u2J=IOUO#-4e^ru8H**&*q^{Z
zo7>cmK5=brJ24FZnYDubKEf;2`*jSRgbE?8NPQbF)>(d65^_ccC)lRPouq56^Z8;v
z8d%9se<mrvMx8|ZdjJMzAR3z}amJ6$8!pV*-K%tU8_T0Rw)F9OJn-#nd`I?GC@50#
z7g~W4@BUwy$g3?20=@sAVIA@NOa^cPZ#&wlu&=suFciJKl!zCN8v)SS??DH=F2cYI
zWHFB*OSH1=w<>;JHy9M2GAn!9o#SvJ6-m14Ei^TMMDuiM$4?(+s9eTm<ULUfD+*Vy
z?xO8V+-eM#v_;lb0kj*UfV#Z-Oj}?|!t@BaPnmh<h`?K3%;_u83K*7xcpjCilf>9q
zx(iR>WDXr<2^q0U$!NlPbo!5dBSMLA094JbH&ZE!$cvOo7AR5}Jmb`s8}A9)!Uc5B
zQs}QC!A|>eR)QTz5i(C#L?6!TKywbj60b^xhlc^nnt_E<1iH_0NP3DItQ4ZMtH7-X
zNys8;4YY{n3oBF!$snN1EN_b6o&_5lW3i0KApdsWCfk*`3eY!(^p0{1A!>dIt79J^
z-&Mn(p;++&KghDS$G(j!0Rbj-eWbN$N$T_aGhb!x7BxuvlYX8Hx{>6$n@jPcj{Cc+
zvN%-p^JOc7L-7a0mSOd|q;bjGu{4_S=?2Rl<_+?H!6r!jE_h`f(hXc}@`S@S-^u7!
zSLEKAl>EP^$ljJU51rHb|Nc?+=GUQW#ji|`rwch>pGf<_XIWSFDM!i;br=OP@wX#6
zxD$PpatFD|g1H@eYhGh^>AVor;_+58Yg!C^97$fJb`dS(C71ECo0$t~Cr+TO`|TIZ
zz6~|<TWCKTN{efR!Z@zeRNx4+rSKo0r4%4rf~-@q!((CM1gpGivJ)99QZ2F5BShgQ
z@rO;9*=-rp<y_mWeR*S;anB~jc!|ax6OdUnRAlUwMTONwVB*Z&ykerfrm1iB@_X-|
zmk<y-y5B%9Hqx)IS((Vf*O0U$qoQfv(Bf}Yn+K3}&rfe=TUo1RoEhs%&Qfwd2haB{
zC4AkVE86z;GON=ceJW$?5+)4Ek(9?EY|fM{=UyGEkij@hQX@LYeXL0iS%?CQzcfs$
zFrO$&+pkNKOhSxk)ww0+P(ae2UU$cr$Smbz{SJ=?RB?3XM^^PG7w&8EFlwkF?t|wK
zsjsFq4{Kuth4heHCD-0D(URaIngQR0s^ZO&Xv4y@ZuHw+R%7!~s*OfUvTSj6i4|jy
z6gFRnN?nT#1(NJ$_ygYuiPp~nY>SfoKs$FNxMip@d)~_@4LD@eoeaz#6aTo)t#sA*
znYZ}*gb)u*{1C*sE=S)w6IIo9w$+NHXooN!QKG|5p=a8#wa=$ulK&i4My<Zg-geHs
zu<Bx$q)fIQzjni(AD{r|I&Z8P05N9tHdUR8R(0Teu4xn|hVkeeTayg`SlJr!+sg?x
z5XM9cPNAsrb2)jUXv!&|+kLS7hIPXSHD-sxPil@vk|D6H08y3a_EuC#0#Wl6fI91y
z_v?g61;3$;(SR!{uJd(@f|i{UGy7`wv4II)vkhqg@6Qu$GABP3R{r@yb;nE?lyLCi
z$+H#?!2Sfa{~^l*h}r*Q#4y0e)Gf(<nxns{GLMz2aqeX1le`CuK<45Uks3H_7hmv1
zvq})8W=Jxv^yS>i6Sk`Dm4}9c&;sU<^q|ha9*I!ZGsK5a9!DmlfvO?^=N!@%koJ27
z_k(m6z-0*J(!K$~QIyBkMaV&1SBOOFPBtAs7jrhq347Z;8UCIVowYncP?BUCwy<!w
z()%Mr35WUqj3>Y%b#$RKy7F~VV6~2-H~3E64#1B7*$?D_Gh_eZ{+9QN{~})+98QrF
zU-Fm{#Vm3)H5NBbZr-4=in92+o$k{aX>vgDXt{soi5LWLl-?URRJ8QQpU99HlufjN
zg<hJvHKw0H<l%G=*K(VZ7v#BtF;a!aM}<I=Jd6lc7jMh_y5HR?=2>b+x=Njs&XsDp
z3&&_JC9z?0yoLb61MCYB9|M;9iV76WW+^-p@b|yuOp$XzO0{0r9sZjyO@$04bl+s$
zqZ&koS<!?Ho*21ME0hyKjNc5v25({_pUJ{=23C#}ipuxy{Ti9#&U##sFDXL^nQ9u(
zPs<`MXfV$?2vzs(GWzk~tPk{@{Zlt<@HW{)DW2PUfy6#-c!bq8hdehueqedl?N4Vz
zL~^$mP1;z3t4c|(Tt5adPn=$;e&Jr8y`4OTIc}z&VOUU%iYn@4f#n_9hYWBQys|tb
zw4mmTcNW)z5asGGc87vMTEnn6dEd+#OQD`}g%qL+gUyZ;h-w{b|6jwPRgu==Q8G_V
z4Rra!55*M4knnqFxSl2@ylnP6mLf=b;CT%>clSl$ScA9s8s(YFoNnb9Z@9*^ex#gB
z5WswTuJy%szUT424{d~b5z?Q-EJ!KSP{-$3T;$+JacvD6(=Tis>gZOHlpDNB>ju4r
zH5?&8)eh;nzh+7)bM6UqFx6sDnWiS@fb1-_z8+XZY%cqfVz*j1!$zi==BKAWCg~RL
z@Y5PL3B%_G<ftJEZp5>#2af9Tx5o#?^!;ZIw_AYE8oGaN+57trzfPI%l7jpie|Y+2
z`yFwArNefm;7>PqFq-l^JZ6z3hL!Zi90BTlRm1yEN;A`mNpXNP3r)D`F35kIspT-~
z%R*6C85Mmeu}oOj=HLELDI*;zDz(qtpmDmP_*d3JhKX!A@G~XFa(6eryDNjp=#Z`P
z3S!k4NX*MYRhP->FJl6NBr@E^sw1iL-LN^!>Yy1WdqGuV`E~V0PiniLI9&^_IX^sg
z>qGqPS<n8H;iSDU4h=}+rHMTdp*pKEVf76T-Py|&mivwGBk=|^`<@|X^X|};=Zb8P
z?;TFp2SKp9^jPKQh&#vp)}&Xp<GDf~K~fo_{;Nw`!4cA2(+;yDXhvcd2urN@!bwco
z03af61P0aiD15dD5(jceR2*U(ErE)m@Y{8oFha+fTY-y`y|D?N8ibEPJ#3%zD#{tC
zd%X6C56`_IL;0g-`f}snmD;B2>(gG45@A4=$rPZ*jEWDvzh3Yni_{K(-D`3Wx>`*n
z=yQ_r8^U;&UxFA|-`L(j49OuVcPL9;Z?dKB>=_#vWazlngYa8?5@o7mORoH_T+hwl
z=A9E~;ZMFU*-lwfK>6Ra3mmB3Q#3Xc49Y61S>?J5sXbJcBT|()nIEJIE3_bAEYDNE
zqyUm7@IO8^G{6%h`~z2KvEzYm&O+_~x{XLqn(~D2fD|fy4LkEXkD-A!rlVWC7*Hzt
zh9MN4$W}0P5d;^HS@3HKy61^IJoM6b%r-F_aP3VfA1CtkGjaBfOsI*aI?&rIB^7aG
z1#@xMk#vxK0!Kv2J}+J^mhV3{o_c=nFEyr>e*7i-rj7X(uUVyhy=euujRdwCu|*Q3
zs(xdy`1WAM!-0}*c9;s6;}-8A%MUo5$jf=+dThfF*=_zqy8QfRl2g*v402h;99*Vv
z1N#=}Y!dI^rY-<U+|=6>@uZ(y@@y@~webx0owSx`JZb8X;tmNyY{&RXFH?=eQ_TXS
zh<KlvFh|Ukax-O|D5>35gFOE|mrHGQbHXop9z_-4{=lDSSTaAgypOUaSDB0!sx&{S
zX(1-!F|}x-jrN@@Ku{wWZDGJ6;2-oNxZn`gO5Z>@DyB|IQrM@YSv?w%r4GKoG0d0<
z6OU4=?Th45!Fo``nN?}3ldCcgzS8Gpc$1=@^Okl%BSjp7w*L-w0hLEI0kN{m#Tp%c
z`KS$xgNI1$7&P9E_?%tlf=ECRa$`%;T<Ct6=Mbgv$-TtbQT(R9qufE3xmw;F8c^@O
z*ZDV>20RK*G1GsOugsIvYVob<)LJE#zQX##?B)$3-}zAir^&f9q0snDl9dgczf`H=
zL7x2S7~qd19^KtJk>C-}OW}05tfK4keW)Nt8n2HwNt=l^wJ}m7hB7r2Y?f`VS3mr{
zZQWqO+U9X|kmM?0>bqKT&oQPGd9SE>%9Gs4ImzxJl^ae!X!&c;U5Vjdnv-AH=L=H%
zm#2m;9X0l^xdu>kU1mQu?uqeQNMA9JD3Rb3&42N~)ksO>mx-9$zXF=e;x^8j{~P8(
z*`+`dxTEYVml4g~&fuF3tLih8t3S*34zwUbI%OtI<yf}Epw829f(PU?-)TFx*=N_f
z`)!VKQ_^<DmhJ1&9uDI|8dvz)tH!^vn%tIOP}BE>syCJb6gXsEUcO@*%6lGCvO6j*
zGFVhNis<5`ID^I)DPb*B%Tr_orT}#A{0p;BnB(=F4SY_gAI}bvrMQ5%ic6)CG>?oG
zUTS}m62ul-Vj_@N@X@d2px1jcq<25`XC8od7&0O`O#~mSF7ia5y7cgee(5nksP<p{
ze~?W2r%l1;y0i4kv3#Fx2LnQbi1jSf#X5{5TZmVD;c!t+VX%UIHnE&Fl<H5g(`>%T
zdwaNB#3xuZvIYC3buknw)X)mQB1QRr?TS=N31O)h?OJrqE&w#v^m0~iUztSq75@jj
z%XR-SW|{F#z*#TI8V^Gmd=8tXVbm+}*I9G9r}8{~i6Sh%Wnw|$@J>+icxcY92ar>A
z*99Br4Yg4qJe0Jk2m%pm{l5KZ<?N8W$#(`5;t-M-u0Vf{^d#rs0CUrn051VpF!JGp
zyD%>2Ss$rp7C5t^_o^gs!X;U`-xZ)nR8uP3V3tmez3u8d_~iTs)wW_4WBH8B^H{ol
zvzi$|*<XxuNrT-QkGD|2A(1w9P615`Eu1_}U=JaH@_)b2H;;g0@Xfo@oyW(qxhKH_
zgohnX%~EX{0W&%krlV(#z&@|f5JAO(vb|{0BWs_43j<489>mE8j1r!UM16rtKZs){
z7`gTWkEYd!w=6c{LE{DeMUk5_d*)8MkS`)ire9RzY8b^OgMjS?1HjgR+QGe>m4?Jr
zYUr=^5qN=qqgO8oC*JI+P#^Iq2))|@cBiGf6adpkT|G~u?I)UBQidyvnQI|=clbo#
zdE8Z(s3X;}`6bB0!=>f76vgifz`(S6P!-0Yld=6sGECL41!H<@c&6U^0#_o|y>nB+
z4pXc{7Qb&FMY2#F)fgtI@s(I!(u|W=YjE;hy(>&Ld#R&HzJb}pt@Xf5&4Q2Gf=)aJ
z)4X6J8BWRPXNTCDO|yRwAE|NA(ocVoQ(9Z4sOip-6%g^lsM3<m|EDPNDh(0c)T{ke
z^)E#u{Ygvbe*1MlCAfqDs0_Qp*9JM~F)#&1$7lQsL<fm(J6f`W%c4Rf&erGI_h^+3
z8jM@%2YaSSd|ze+Po#s%AsjZ!Nu9r3<{&s-^O<)Q=rUQX#%&gv<oWd=99$y5H``}v
z!JCqa?fDn<FJ5(*oSM2*xb=CWr)WtEbxl)_Cu<KMUgY;O;zg>jRId5^W6pO0Q-q{C
zE`y(&x?{?R1n%WSi7W2FPdFDsPw>l5u7a*<FbHl>`U%rBVDz7H+iU@moOUA5k97X&
zTP>5PVUcK_-A@w^cZf4+6L$3we`yYWQz&J*a-E7(ceXpQ<rI{_RTm%61uV^XRTwT?
zfrUHjG`*(i-7M_^l0>yYBHYH9FH2^*qnZkE`C*<o=b1ObFuZcs>qZO?OSzU*c|5%|
zq{UKb;GKE%4r7Q!2Y$hLl(&TO+K8+rqiypW(vN9S!oc06`nX5&5iNKMG9wlFBC9Ko
zNy>N5!H2G3Qi3`)mG$oTbvtS%`@HC9RC{r2iopNrPc5h+uRi>P0SO;n)T>Cw<~BAT
z2t0S4Ihb^amAdHcqN>z$A_xOhdi&}fb^AUX+lT5%K;c3OJf^`3`5*JPm%jhTHN(F#
zE|G2x{-~KzO?2y@;Cyh~#OiR#&+f|}>40D++nYg)!1E6Sp|x&HkGR^pZgZG2(27zL
zxbGi{fT#i18&=m1KJ^w|T}f{BA#iwmCb)Mp^!mNOn^U!=66gPP<eEY7)dY39=3$6b
zgLC08XDC09aANFzy_lUBnu++a1$_zJNA?rOCEyE3&Q-Gb&&|l@zWQ)aQ~PfsEg+~4
zGmEfZplPdK#HTEQIu&+9$BQBFTlq@{0>4dnQ^m^13a4~gL3YW<@-;&+<`N_kn_R=3
zdzPFq#Q31a_i6)jS=|W(8~-J{c{}=qL;!*23l{0q<r92h<J&vHF9&pt+Td3=D7rV3
zgy9LR7bHepLPux*3h`!p-GFWdPq!HT;|QgCb2&C!p83GaS3Y8oBRB;?0MgxWtThv<
zU7O(x1Wj@(l=E-+WFqX3hb0#NE6G}uIzoK8Xry^TW}WsiNN6Zgxqq{?$U0dzx9y~j
zUW1DS_lI|^K9ve8v&8vYV?%-3SUnORuVGhhpJp|LAP+<oZhDjY0Cm~$CUypvA*0@n
z@BgEDFknDVaFNQ4`zk5N%xMj&EXozognoYwf1+5B+}Tc$qT?;t(Qi15YDTyHUFiR4
zp+S@>%R6NI_Sz2p;l-}ww@IzP4F`xyW|DMPZeQe~Z+xT*?;Al*HxODAG@cMX>}(R6
zwe!4@WB)cxCXEpnh5_N?H(0}pz%W6V@uMs+;Hj<qIi5*gsfIvEd+&XKe;Hsf$l!eM
z(5|txyV3`gq{&;qe2YUK;cIt0eG_*H8E)6l=dz!rPr$%wdkZ3?8-1dNCT`&invNV?
zwR<^dp3UXH+L4`1fr^_7?%s($TF|sHQKkwPEwj4=<5D*9om>Qe>olGq{)ll8^h^)X
z9%&~r)9+|N)jCFtr-*JtGYOIMwiH}kNGD7W@5Z3m;}OPe^UtIKc*)aCNL4)(Ty6HU
zOuC55L1-0UsBx={siBQtc=Yw9_D77Q*%Q=mT$HCdf1d82uTN(kLMcEzW?>;vdYG{o
zTW*w2k0h5hUy*LGTEI*Ks9F2s08G_!LlxFY#_5~d#vusmiqccVChl7BXyx-92C)%4
z`Ze!Wvn2YJa<s?jnllm{CH)};c8YCW<ku)GSEln3#WF@{bqH-U=PV8TJ8aPBu2iJY
z?#$;GC)-Xm6GI~G=pife1y^{_7pvp@zX(F=RJ*j2+}k<6%9_V?2_a4n7bjENCS+@g
zQ%!_=&H@Ti@&yLNIC_U>+vYLm`jLx*5cdGSsXU<p$S=!cfsvLtAi=XV3&R@G6N~jn
z8#=Vr;m#R4>EK>;3<UL+KHQq~y4<6yK(J8eww-h$*B4ZPXON@CahD=?z&+{ig6ZCZ
z8j@)_d1M9^y)5wz47<z8*Q&*u4co4HLPm5NP{R0Zd?1}RF<A}}P-V`suGwAT!v;)E
zEjY(&vZiL0D(of9?BSTW30im!VFJGTL5l{|Bnbv2KyuZ;_;s5(l-qM~fl9J{vyAlx
zN+1_yDf-RcElOC9R}&wXnCKzQZ`8-mqH@=qEfs^-At|kNvIoGmk@YvDFRoQctwW&q
zZAPgP9FbZ#I}qPreFZ5}^a6+W9mx>L)sNc7av@-xVPUjrO$}>D&@P=9VrU5X`uivu
zz_*0$v*g<c^XHc<!~(rV@1C4hO7c*uK^PVaPYyDy3xlwHx)A$ER!f9hi|FvcAaB9H
zFj7NLN7IR98(`YuO#@s9!3gUZSs5(ow!kR=ItwE=eirGZrq-Q?dfP5;PKKa6|1qeN
zZgHG#?(06oQ85MLW1Tv}i1;YN9f$keR<xS}KOjUH+*45LbZ&r(&vO%Cou*_UJdu)(
z^yJ?t`{vBUG~~X?<OZ$S^mT|h4PZd#VA^HF`59EyMnjhN9QmvK_J(U=QlM}d&2iON
zc<gZU^pfX?{@G9z=T~KIm=u1T_wZDvyWcoI?Rw+18)0iVwbm&`^(Cr{Um}Mu>rfrD
z(T_P3tzH`N`vZ0LYlj11#}G2qb}N@S(5gJ>|0#)2);n@U%gp|0v)YprHgZ##ejbrB
z+;CXqqV`H+McvYP3{PB4!aSVxLD#seB>Jez>TjE%G9$@pT1y*2;V+OGbcCbcdZaQr
z=L8{GJqH6%C8NqhDE<jM>VjqDapf_qstJ0`i@iqR(44<HbWGt&*09=L%c)K~b2DiV
z*V#g#myn5r9RaEkpB85KB#0t(#P=swxv2YOJwvglnNy9xNO$j(jb_5N?Y-ys{P%->
zbD@n}9GY^z3o0xx(G31)tp;XgyZ-|%_ZU<DET;6BW|g4ZOQ2h4#UVu}F&J{wkJ>qP
z$#I!Z@%cBRAG+Nx`+v@92Gi6H1489i1;GJm7XBfy0s4f^2@X$^S!p>`{hZ>$Z!?Zj
zQ)$-OzLpW`<S0Q&bTMtTfEG+G0e7Dx$6&iIG1rB%$qS$I`v@1S&~5ed>JIW}kfV^|
zBtm_4=7Y`mUFNYE&;M(#o7N6%$6!@cXESx9LV@qb63F!xSfb@^@Pfw>VT{69y(gIz
z9G;ry&Xgd=^a5cU#HJ{YT@QXTr@9Q)qA+DGBWgqu-}LcU`>je;{eTNm_a0?>JmPJ0
zJ;4fG$AYz7s^hMZlFTeNKQ2;8JO*-{rdR{UtXX0&w}au_aX%Ae8zTEH9bk~bnfGhY
zt5RT6FgG%}U-ZF9&SFWcz9i{2(DsBh42)~2_+3r6%zbOT$0C4T+yU-~lAN)9<8!r7
zJo+jQ?m`*Ph&mSWqt|mC>lYGm>1}|ILzGKhcR@U<c}-;xNlPMAkW<pV`JN(wmNmnb
z5}($t4<VXYAILO@u6c-`EAbE{kt;J;R*1^GcDc8!8TIen2dx=JN81h4G<jgR2c0JL
z<u$^JNNHMKYs?blWbL?=t=vr0&ZQ0QinbYgbMaQQy?Wu-kV~tXsaogE1V@qt3w1ez
z`WxJmk=XBrHN>?vE5+03X^;Uq#J_<Ik`Ti4cw%EOrd;y)^i+;fK{X$EBtl@Ql<HH8
zOi2excEt6+wjvy}z35t|S6qLrsfK;^-S<S=qGAmPTO@;v^%Mi%k=D}^tMOi1_;Za4
z;R<DPA_}HwZ~HQ#e~QZJhJRCC?Rz<~5VsoBVYnikO-sc_b<||6WSY8NpVsLqrFK-n
zp8MaxBCTrVHX^510I$B4{bm7HfhK(AUD&po@-kUC1yOMLS-PW)D7)@D2@1U{*8F?3
z2KT8Q;TlR&F^&Ok!}D>RK^}^-d#+t86733Hb`?WI6`omiCt-1A0N}$A<L9GGKlxEq
zYcNS^AZbv7&NEOGPteWcb?!AOZA`(uyXX>|{K%W!-+a<)h=E+L0O_zZ&$y8L{HxJJ
zTKo#@IB3W%?PvBiI>eYIpVOZ^KWqnt!SV|Y*)x*`5@RTTwy-^lMMVPV#yf1Eli!<O
zJ3s+_DnF8LrA0aVf7A6DGBX8nKIj5){Yi_n^fTXu)H};goG3yM1YhT(G<Xns=*4;&
z@}9?}TzQi9OgQ!fcNvHLX>LPwbM2Z;1}3G3YEMs#EQ9M9OzH>F8*T@Yf@lulf~@YX
z+q*h7GI;Ac`fnnDKqq)ET8uJ0K2`IgGlZm&iQE=0wIsJlWX!ZX{%=Gn!f}=HZIklF
z1n4_HlegQ=WOXJHJJ9}_+l|-bp%M3&0jx2J6Qftt(m%`*`%uMtt88GYEoRwkkY(XT
zE1ob<*W^iOc4&}tna~c+4HmQ-vY#LUfrN|w?ZVSd>#55^;<lbSR7BWQNZyv;j7s}k
z6!?3{(@GLB-1p``;dLS*Ly|u#mbr5c43B8p$P?!BUBC*pB&$m}B8uYC9yMr^;^QHB
zqnhR>HWf!SVhQ(v^&D!X^sa@>A~UcC3`s@*bE-VIybu3x)z}F9<)0`e&=~KLqZap;
zz;|X6+R$GqX23)yi&jOYj?7ST6<iNXCh6cjM$)5+h30rid8gL3Ly#!yx@rw+1gtbN
z@P+kn-HIn}hY~t|GP%uU2#BfrClC2rjz62g)3sKX*Y_Mi;e-R4DQzn<kA$#eyw+m5
zqPKq*DytMc-Scb$i;020k#O;$qOmVMg6*B8lC{N_B*sQ*-2B9|T$~G+pQ2QvAwSZs
z0k-Sjv;_2|%{4MTth32GMw$c&!h!8j<;|syEaX_v19Pja9PpaQ4ecy%kDq!j1;hoo
zbM}C)KEp|;D<Q(l4m<yAWlJIN00+*w*htefGV7I8ZP?H4b!0)Sgox`(p3O&L5T?#N
zD?@I_v_v=4s`79Ya7F`LJ_Pvfj3nT3Z}6N@@SHKHMmj0|n~R-BI_FB)c`U9kVQ!RL
z6hoO&aT`>D4J+{CR0*nsWfaVSZOyKO^*MkPoX^b#mcSed*QjF`*I<vz%Eml|ql?<4
zHPDSajM(sY&)+8vX8kOZF0NVD`!c(WPNl{Q7-wg-{o%|7=rprmfyPhIxw}0{Mo<x;
zLWU1rq~UmE$XG^#z0Y|@gh=gwqjF^2?d>*Oij`@f?Vw~#fkd(E-D1q%T$%J;z=9<%
zbF+BIrI4$wLyF)N6aVAhCGT5of}D)gXlqwooT8L6L3JwRhgZmNqB`xD|Fm13aF^ZU
zz0sT*2ivWnSk`r;nhIt(s0>Iwl+$ECeoCdv>HqNBeQu!i+GBuEJ`D>?KFWMSpR&(S
z`!x{~w8WInI2g5W%3ie7TioIKUi4~am#E&nvmb3<6xOOTd2lJ==@+*AccM?QPAHfE
zP0;`i^6tj1cS`lu2a7b&chWYLtL&f~?t7m3-&7E=sCt}GPgl$o?_a9W!|stI=>f+h
z2YN+$MGL)RPk)Gw#MmJQm8?BBqM6CMUafM&mWUss67_>z%<PSA*~kpR1522B|Lt6D
z?uZR8`i&^%g!%EosIP<f*4gwW(Gs*|cY#;UUcxRKEu0QhobB-~4E+I9V{Xv%k0~iU
z0`)R>$e+qs7M85h$WXaUMAb5?38TDo#R-N)ms43tC_~&|lG*t8y<-~Ree|#Q$|2Gy
zmAK4NTwLkYXSAf$n_V67ZVLs752CzSP!=b}=@uoe!n={!n^OR?iudae7%nvW7mgq_
z+lPJ~A{)S%P{flO^7pEGk8@abQU%sr5S4i36$N1)fj#sD<;?dZpo8%4?PL$tWV}Ki
zk{sT^jki?^J*_5Mr<W0LTntiwtr~sh=B>go7^}v^3FFk7L9c=U7@Hne=%iNzr#!1p
z0XbP?6$|{%a!E$A96*P?oJ6&$t0v!lkK_;31YcbIq^!_RK`rg}i&C{g!gfTw(!5w|
zQ@K<__i(di29FbFL~VEpr@GKVo&cNNYId8chhed^eZpfS6@>4B<U<gn|B-6>P|I)%
zj$yky39e$I*#7hhuJ`rUl#uKIZ=8w1x9|CRcr2{l9@+h$Na<v{jM`+lIeoDTC%_QF
z@)gZtamXs|@*`NYae&CPX?xZck6{L)|0|vJnlf?DE`u?<@{hea7QG$5NvBty6QgpO
zj|{%nfFc=&{8chXdcy>}baIIh6Kqjb`5+B*N_@?1d(|OWYYx!)txVKrkp8|#y_rQ7
zsWSC%Ym?~048x5b!^c=qYU`2kv&*yln^$Bj1SPt9HkD-jCHzZAl`Jm5L%Dj|YtsV4
z8QDjnEXUkwdGJ1(awT;jYLljzoQ3*L+v)|=i)uR>QoIInvO=8gM-(C2+mwGS{D>_>
z&);`3tDilCwaI}n)I%Gf?+Mv)Q&I+e1hf-1nk{()lE@;+&W(6e7Dwq&lwKKaWt>dm
zLD1suMl!2bs!Rr6$M;9ylNj0P_(~$!TyWVl6klSK_XOR4%)>`JzRDm6^&&26x`(uY
zg2U?_c<pP{3LPY~Y#9@W>;V;%avuJvfXcPI8B7H`XGd1z!X|Iix~wyDNuhjH+OiDW
zB8OkcXP%_q9Q($WT+7BM0G|`1#SWCPUpWKDNw4^KsyLd%OlA4a2ws-OvHgFCpKYFA
z^7R8`_^NHZgRBMET1yvwX~@7$B)&`8CMs5rC7qcOzkbQ`6)RMXBGnP>fb^CL*+In0
zsz?0mouE1hGq`}Pfkj_WwnrWULU3`fYpyj0_HbPz2k+3NaG@s3(ro)GF9gn$iU~qI
z6YxzX(913&B+e$tb(6hj8-}2e67R{Rq?W+1VR8!i6%fNqu$?$VA{r#(EzMPJ$AH$O
zDN<ttjELq<gYOP+G=tmB%j2c;a*D-rvcV7TT8ohOFEEwPlNLktxZD~6NDAxJin~sZ
zTo0j?p`_ROZOB1Yk>RQIndP^)nXfaoV?^7~CdOzmv|O+HI?>kX+PQ9ZeX|5OzlK<%
zZoa3nqEeVkVQXKvkysj_`ODQamq?Wp@8M`BXR=9=|18=(JZZNuINYa{=wX(?moxof
zoTFZHhy9;xhP-T-J{qG}BFqZyG|E&bysw|Ab;qYSVtVQ)hCbJrQ(jlKaeeM&W$#5v
zapL%~&C(r8E?_ivPORMOP>dSLeK{-P?&}oA+)U_D-l;p`QpgBh*z!_NW5Gs30V4KH
z>d2p^aBZJ0T2yMqj8`GWx2-JzlpF|dDUEWQM3Ei7-?GrXke85sdDS=PT0z_WqzQP)
z>?;NDq}}7fS!s?N=UPl@!rSIs%Vey5)U?Pb-HijU3z(jT^>4y$xLqDe&Cr;C_wfDT
zamA~aE}%;>TfHMDN({G+$e|8n$2n7`#H671Szx0A&VtS(5oG3B5q30WeU~rjbwT+0
z%Y*&466ZgMkhw&G^s-nJ;h@mOccrO!);Q%PB@vHp<6zgqnk#*#bSPruAJV@bR;Cv{
zkhqY4<_I3zHkp`-bK=A*SN4W7eg&SXQ5&<8SCI8*KO0VBj_Z`Qw!OqJzZA9LRi#~#
zLqTz$D3gpqsNQm{K?mbJlwaq1kpU$(kBuDfLEKuP=rA0|ON7EhL#)@ARya%do0E59
z>n$rrzd{IDzyRe6ML_!Ew*)L-xPN3YA>Xmb0EXW6X+)Hloj_GDixzm^^mVl@?g5A1
zq?Qa^f;GQ3;9Oh1=BVA3&cMr>|F22+4w)UFR}y@CM5G;k+D<3;ONK7wmYxx0yNW!M
zQ~0f(vH9=To6s^s{W0MiJo=U{<}Rct2sSZ(2%<aGI{t?&H*=0&U+DV{g24E0iu{uR
zjY3DCp&<IwJ7ep9>yh<Inq66L8!3eI@nRDczS;y->RqIr@rJ7lzpYnAvUByhZ`%Mu
zF(zL~is+rPlA(=%j9ls2tMULnds*F@m$?oh{7IFFxISmJ!3Qy*(`D?_PMG<d*&mKC
za0@ZjIX*XhR0@4ssknzAiJX8+C%(ZiJrbxUE@_;W2oJ?~NCRccV)g?2GY7rDn4Ay|
zfpTqQ+_f-a9KN3@_2k~GJyB|$EDdEZ!dYdOcdm=EV6nnm=7ONBdz4!v8I{s)C_^<S
zt0Oh2JHmN4Gud@$naoGG&L^qNe%9lsmc38DMVx0k1;Y6i9Ga;Q-;@|{CQBwNAJ{s|
z8S#11@yB!%2m$nlEUz9@)<5W3CfIaw=+-M0{AZos4gvbMy<o_A`kt{LGQQCo(nq-)
z#Y++QV>PD{JF<eb)h?MPsFHAGRa|7_s%5)mmxITp&|w!(&@pB?ho>d6{;!?~LNzK0
z+ai*i5fm$aM>11A*Xw+YP|#XmikkHg2i|MOY0_O4U0#EERV<#1`nYJQoqs9H>{A<~
z0excdv0+ua$j@4nK*oEhk*1c#kTFl7R^0**C@>lwLSvcdlkH?Fa+o40_!RfDt@1&A
zUR#`Z`ymtDyD13*99SDo#bZ50CYaewXhQUscNY-kKWQlqj~BfYcN|HoE!%rm47`|L
zUnsdcLy7=|?#%-Ye1xObJmbL%OMX#<ilw{DZ2ItzEog9CJy)OrF6$<Vc<o7eOf`{<
zfi$=mNld+QXp2)!_N>fWzL*n=X9(`fayUclhBM-t7OdhTD9^Tf1a$Z>0ee0sOpJMk
z`s6&Ys)~K<<cQda%ET=dki+TS8@tc})%yqbkRI34(9n}@OrTvoz0aP%4x`m|VBi0_
z)zbZm^m{Ny!E7+*3T9bMJbOw4U(Ks_?V^e^_+=N%DEnu&d+VyJ1-`7f{7un+VEFWd
z)(xT%LF6JvKnC0p=Doq?j5gb=fO0C|HOPJyXJq?=R^g!y2(b}_q_`^@cBLfcOp58I
zrhnQBAOq>6>tiOG3z2N<V+-4qSyI)>sv<M6%@f;5>4;8R+yNRE|82xu2+<BUwX8A1
zlWr+bX=vi!VE0s2g3aMQvaghtqS@dYzFbe<`nD_B{mF4HkQ)9~tq!-LERKUxN&;)(
zjS9i|-fBj>8a}$~_cr74#s(|S2&Apbve-TTtXAfn^g2}<G#^>}l1Q;^^fG5<(%T^7
z`e75+7516~`LlnNl3s{h;IN?u1w_Os`c*AB!u<}pfhoFJhTkHy3cnYgnaKPY4bqza
zb6Z8AJn-EPQ4<(Oj{)SUM`ry@0Cbaq^WCK33cNiFxqKOh_1J9vJYP0B$%E17eZWCQ
z*#q@kerabNTk~skkLRa*YpD&w%(gtvh?9ezwY*c^>n6L~fOf@^i;LOkTBY@A0WB`G
z$grBr;m+}Bqx_bbPgRKW+;|9^-jl1YdWvHUcd;zrgaR?rk<RX;K1JAW;{5YR;T8WS
z6Uz19n;CU+ARRtR$nYEAuN$iYqOtp$#0p}EPyGSVA&8pv#~+Wm*r<=jhxp6+M=}X%
zwuWSZby1U_&5#2<SLhH{aSMg{p3i>BgI!2iV*L-5-tB+?qA?*5UtR@Gx?DF*-R8Qt
zQ5Ij%CM;9q2J@+D#WrQ5_WU!n>jEwC+1MvbT9|}%SgErD1{Mq$M2Z#R6tVL&+c^KI
zgIgAZ@IRclNFV=V`+fmlx+7=YC`DvTc80(hO_Ib8hXGGlypgoMY6)urK(!2Mqd8}3
z9=B0IedU;ec~2WFV|9qg)&1KGM;4~#Jv=Mb!YtAwIrj4fC2B)}92Vvk{tPhU%CL==
z$zTj#R>JIFC>?;zBfx)j^}fw-tH5c>h0ksIS>7O`<gy-*1v;oY-Y^(Wyq#EgYCy~<
z*GmJ@a{y0h0N7|J=gM}DbEa~!uPH}gs!6J!rjU02cRg4AY(|=vjKSEUE6l3_$en9c
z>cc{%&t^dEtT2^DpA0XM(iqAc*u(nvK`(N=Gr5wVwZc%_PUkj`=@?r-)H1m_zQuk*
zzh5IlVMj~@b^nWRJl?!g-4E6w+x=L(eFD0H>kIzaqD!wFy?q(8Fn&`6zDLMY=o|^~
zp1Mq9i#WVV=*#HYfbj!^nLmn`*oA94v-c<Q;OYu+Argw%I4QNxJj+Xy*IGOMNH^KK
zeQ~}ul6=8Hia2yB<GXLM+|eU?vxMJ_YdwJaRv-GRL}hjXXw}D<7)(=jIXI#Vwdzl-
z&TumYEY118jc+H&Z_<u{ef=X79HwNl7BwIIpu?B_Ja%F?6UwoS=f?y1JlgGRoXYBx
z6C6(|%6N+*^Xo>+8()i6v8x`N!T-wZi*_w8avS)hGkDaUuIK)QeShv=IM-o*#12}<
zLbJ%nQsiy|HSu1V_sYH1PH7*jIte%76TK;%j8Ude2!x+%BNG@CQW`95w?K50To42V
zUYTvmDp(_V)>_d0Q@t!EKL78Wh9%tLdPp;I9(p4!@9fBcw^(}|KQn39*(@r!ay|Rr
zf(1(VK7|Wrl7_(-dg%yQ0#Af*znp=l_ujW<s0+3{KOxccxw$ftkccK-1Ijs?6#t1M
zcsej3hW9@oJA#_36@M#Yw07#(re!mfs3o#BqrVx-f!GgE-Hu8E5fmWnHG=b5PyRV+
zL+Lt83G9q=MU(w$JXB8zY61koBq;~k(F}-rE!=EI*;#aP>`<~$MD}$tt}ru~ey!QO
z(r&z_;&K)CwFb2+t`*AIHh?i9SmnCJ$3;V9v$zamhe#(>+N=kye{vPhe%)xgD?QNG
zG>6$0A5Tmt!aO-%S^XBX`vtgT-mZM0-5>-*8@vA<mzue-0e1<UD48mWoBf}2Gt2XC
z<+@Q?f=#D`ICbW?+M8s*^ILpwL9g=Q<g2{2*Xh0q7^NQVAxjWGZ*2>!q+c;y03?6`
zYHYJz{BcKtEL)Fv8upeR-%PtotPBJbnS!|`(-e<xXP9#aKAU`h&QQa|>*ma+aniI<
zvf<_Yd;K***C%(WAwB(k3jO06fmN!u^Ku3`dRm1X?51RYD1|{y?b(BsL6xQRsELh~
z3bpR=nvpR8kV$A0G@K2-E`Bc{WIF{hS9d|_xU|UK{Mz!=y3=y-{!GsJsV;b$%BPA(
z9l?#G)tDi~k@I`twzX|2sEiopFj3YQVOVQfV}WO=`aGq>w_Kur`~}ONn*IVWh;-nV
zbJcvaV5D17WiLp@YB-_<Rhi}ve9jkTlx_BshZsDO8<~y(loR+vHfa0<V%|@2Pw9hy
zRg;4$#HOI@L2<1)!-9WldyvKP*=g8W`aZ`7cuLJ{9n_=TzuwvzLHIyXfVqUS85s0@
z>;AZ*ERCxNK^Md%7YP(vs{GLYHOkQjd&|*`D_?@f4*M`+t=)(2Ql`sQKni)yX%#r?
zzRYOLGxK%W85iaGKm$LwzDb*&9Zx;CM?PSSu$GRYP4{UI`qaGy$em}Wrmp=(C)eAW
z(+xN3SazIps8*bn2vdVo1fqWYA0!t|d7;zJsrWCU#iFMBmiTM<>8thUGw`TPO%_d}
zI+veOkyXZftB;-=Z=^Uueo^2mbTYZ1sD*D4nLC0cYwLcX6ps~8gn&S5yxK2~gJy(1
zi0`hmlUVc`TnR4D?uo4`@D{MZJWm5WCx20#0bc{4{CEs;h<3GxH&R<6diICUzoCU-
zeYElo%0yBGL~b+@1a^jfb~G^L>a^2c*o^fonwY&8-ngIS)}<ZyAw9J)o?M_oR5}WS
z!y6_P$2bW+&7OSwBz*Xvd8NfoM&2K2+-*o~${rQS+B&ViaYX^wzhT1u?Z@%YJPf%)
z;DQlg3L^tjnFZ|{76-4sHkske{b-81qMt=DO1{y54*t_U*#S#@PXvHMbor`8Prl6Q
zQAMv@4(?R#IGuN14vmItPRe#<LJ67CCj9|T8J=cA*i+!`VIo|VQZuy?i{9QD+_&_E
zDXOooLyE2h^bPB~fvGeG(39Ov2L-9M2^4|R+A-0z0iG%O{^HBz)i^G&0GDMOB~L{D
zg0yQJ=O$?@>ZfS<c%Am=*+pmw8r(u$^0vl+SKO5BTCL;G{gLp12Dz84Np#WWygA!N
z(o9p1D$U$7EyP+T_-n+dL($0S=(jh9B<5g)$}MavdEglPC5E|Q!shYqn;$-UBmf|~
zfHkGHZ?$452%h_{%iuZZS{u8@q&c92Tl3{C0h`h?)@rxJ7m8UAjAN+^&jB*mDja;h
zx=DB4Xzsr4PIi1H?R{k<Nc!>_ym_5A2y<k}VZyZCaY(IzK*40FB8#okyJI|$$3%A%
zH|zSX|5X@xrEQVw9t-CpL(o;llsCH2JQ`p_EZMaxYQ^W6+3K@+S~}>?t>&X(>xIr<
z#=4~Ftmp1r1`Q>x;g(8+w(oDNVl(0l13*{=`fv_usH;3QR`(e+LT%E-Zhlks|LAVD
zm@kT8l=b(8TGF}90B%SvjWO6ZD5KGFV}a6rvL}uHNcMak*l|g^KIZSi$@^hxj;l)8
z7ba-QH_bNDS`NdD>lg=3s$^!8S>H$y(lmD`ZN1JV-R#V%s~tbbrIOXxGgG!OyJ-MX
z-=PcDr)`DORQB+bMv%qG2oOqDljg2<!4@O1$;f8Lvy;YU-&&-jXs%9I&2%y8WUp~E
z7C~Sj(j`K?{vck0h?}B-_g`(wqa2J$Y?uV<#u^p;9|#b-`hmq*^d;MrYCPjk^1u36
zx^0e!d@+V&ahqWw!6>R7-3vq?s5i8+TxPB<BEZrBf3by2@;DuO00GQ~0f5j2RRRJt
PvBYQl0ssI200dcD0_Uhi

literal 0
HcmV?d00001

diff --git a/gocv.cc b/gocv.cc
index 74b1b46..4f83b86 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -4,6 +4,7 @@
 #include <opencv2/core/core.hpp>
 #include <opencv2/core/types_c.h>
 #include "facerec.h"
+#include "tracker.h"
 #include "gocv.h"
 
 using namespace dlib;
@@ -39,3 +40,71 @@ facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type) {
     
     return cls->detect(ret, img, type);
 }
+
+facesret* start_track_from_mat(tracker* tr, const void *mat,int x1, int y1, int x2, int y2) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+
+	try {
+        cv::Mat *mat_img = (cv::Mat*)mat;
+        if (!mat_img) {
+            ret->err_code = UNKNOWN_ERROR;
+            return ret;
+        }
+        IplImage ipl_img = cvIplImage(*mat_img);
+        if (mat_img->channels() > 1) {
+		    cv_image<bgr_pixel> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        } else {
+            cv_image<uchar> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        }
+        
+        cls->StartTrack(img,rectangle(x1,y1,x2,y2));
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return ret;
+}
+
+facesret* update_track_from_mat(tracker* tr, const void *mat) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+
+	try {
+        cv::Mat *mat_img = (cv::Mat*)mat;
+        if (!mat_img) {
+            ret->err_code = UNKNOWN_ERROR;
+            return ret;
+        }
+        IplImage ipl_img = cvIplImage(*mat_img);
+        if (mat_img->channels() > 1) {
+		    cv_image<bgr_pixel> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        } else {
+            cv_image<uchar> dlib_img(&ipl_img);
+            assign_image(img, dlib_img);
+        }
+        
+        cls->Update(img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+    
+    return ret;
+}
\ No newline at end of file
diff --git a/gocv.go b/gocv.go
index d72e1c8..39841b1 100644
--- a/gocv.go
+++ b/gocv.go
@@ -127,3 +127,27 @@ func RenderFaceDetections(img *gocv.Mat, Shapes []image.Point, col color.RGBA, t
 		gocv.Line(img, Shapes[60], Shapes[67], col, thickness)
 	}
 }
+
+func (tracker *Tracker) StartMat(mat gocv.Mat, rect image.Rectangle) (err error) {
+	ret := C.start_track_from_mat(tracker.ptr, unsafe.Pointer(mat.Ptr()), C.int(rect.Min.X), C.int(rect.Min.Y), C.int(rect.Max.X), C.int(rect.Max.Y))
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+	return
+}
+
+func (tracker *Tracker) UpdateMat(mat gocv.Mat) (err error) {
+	ret := C.update_track_from_mat(tracker.ptr, unsafe.Pointer(mat.Ptr()))
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+	return
+}
diff --git a/gocv.h b/gocv.h
index f482425..c4b3820 100644
--- a/gocv.h
+++ b/gocv.h
@@ -11,6 +11,8 @@ extern "C" {
 #endif
 
 facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type);
+facesret* start_track_from_mat(tracker* tr, const void *mat,int x1, int y1, int x2, int y2);
+facesret* update_track_from_mat(tracker* tr, const void *mat);
 
 #ifdef __cplusplus
 }
diff --git a/tracker.cc b/tracker.cc
new file mode 100644
index 0000000..506daba
--- /dev/null
+++ b/tracker.cc
@@ -0,0 +1,39 @@
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_loader/jpeg_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+#include <dlib/image_io.h>
+#include "tracker.h"
+#include "facerec.h"
+
+using namespace dlib;
+
+Tracker::Tracker() {
+}
+
+void Tracker::StartTrack(image_t &img, rectangle rect) {
+    tracker.start_track(img, rect);
+}
+
+
+void Tracker::Update(image_t &img) {
+    tracker.update(img);
+}
+
+tracker_ret *Tracker::Position() {
+    	tracker_ret* ret = (tracker_ret*)calloc(1, sizeof(tracker_ret));
+
+    auto rect = tracker.get_position();
+    
+    	ret->rectangles = (long*)malloc(RECT_LEN * sizeof(long));
+        
+    long* dst = ret->rectangles;
+    dst[0] = rect.left();
+    dst[1] = rect.top();
+    dst[2] = rect.right();
+    dst[3] = rect.bottom();
+        
+    return ret;
+}
diff --git a/tracker.go b/tracker.go
new file mode 100644
index 0000000..d17c2a5
--- /dev/null
+++ b/tracker.go
@@ -0,0 +1,57 @@
+package face
+
+// #cgo pkg-config: dlib-1
+// #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
+// #cgo LDFLAGS: -ljpeg
+// #include <stdlib.h>
+// #include <stdint.h>
+// #include "wrapper.h"
+// #include "tracker.h"
+import "C"
+import (
+	"image"
+	"unsafe"
+)
+
+type Tracker struct {
+	ptr *C.tracker
+}
+
+func NewTracker() (tracker *Tracker, err error) {
+	ptr := C.tracker_init()
+
+	if ptr.err_str != nil {
+		defer C.tracker_free(ptr)
+		defer C.free(unsafe.Pointer(ptr.err_str))
+		err = makeError(C.GoString(ptr.err_str), int(ptr.err_code))
+		return
+	}
+
+	tracker = &Tracker{ptr}
+	return
+}
+
+func (tracker *Tracker) Position() (rect image.Rectangle, err error) {
+	ret := C.get_track_position(tracker.ptr)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+
+	// Copy faces data to Go structure.
+	defer C.free(unsafe.Pointer(ret.rectangles))
+
+	rDataLen := rectLen
+	rDataPtr := unsafe.Pointer(ret.rectangles)
+	rData := (*[1 << 30]C.long)(rDataPtr)[:rDataLen:rDataLen]
+
+	x0 := int(rData[0])
+	y0 := int(rData[1])
+	x1 := int(rData[2])
+	y1 := int(rData[3])
+	rect = image.Rect(x0, y0, x1, y1)
+	return
+}
diff --git a/tracker.h b/tracker.h
new file mode 100644
index 0000000..82360a3
--- /dev/null
+++ b/tracker.h
@@ -0,0 +1,27 @@
+#pragma once
+#ifndef TRACKER_H
+#define TRACKER_H
+
+#ifdef __cplusplus
+#include <shared_mutex>
+#include <dlib/dnn.h>
+#include <dlib/image_loader/image_loader.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/graph_utils.h>
+#include "facerec.h"
+
+typedef dlib::correlation_tracker correlation_tracker;
+
+class Tracker {   
+private:  
+	correlation_tracker tracker;   
+public:
+	Tracker();
+    void StartTrack(image_t &,rectangle);
+    void Update(image_t &img);
+    tracker_ret *Position();
+};
+
+#endif
+
+#endif /* TRACKER_H */
diff --git a/wrapper.cc b/wrapper.cc
index bfc66e1..59c12bb 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -7,10 +7,26 @@
 #include <dlib/graph_utils.h>
 #include <dlib/image_io.h>
 #include "facerec.h"
+#include "tracker.h"
 #include "classify.h"
 
 using namespace dlib;
 
+tracker* tracker_init() {
+	tracker* tr = (tracker*)calloc(1, sizeof(tracker));
+	try {
+		Tracker* cls = new Tracker();
+		tr->cls = (void*)cls;
+	} catch(serialization_error& e) {
+		tr->err_str = strdup(e.what());
+		tr->err_code = SERIALIZATION_ERROR;
+	} catch (std::exception& e) {
+		tr->err_str = strdup(e.what());
+		tr->err_code = UNKNOWN_ERROR;
+	}
+	return tr;
+}
+
 facerec* facerec_init() {
 	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
 	try {
@@ -76,6 +92,101 @@ void facerec_set_age(facerec* rec, const char *file) {
 	cls->setAge(file);
 }
 
+facesret* start_track_from_file(tracker* tr, const char* file,int x1, int y1, int x2, int y2) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+    
+    	try {
+		// TODO(Kagami): Support more file types?
+        // Danil_e71: support png, gif, bmp, jpg from file
+        load_image(img,file);
+        cls->StartTrack(img,rectangle(x1,y1,x2,y2));
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+
+    return ret;
+}
+
+facesret* start_track_from_buffer(tracker* tr, unsigned char* img_data, int len,int x1, int y1, int x2, int y2) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+
+    	try {
+		// TODO(Kagami): Support more file types?
+		load_jpeg(img, img_data, size_t(len));
+        cls->StartTrack(img,rectangle(x1,y1,x2,y2));
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+
+    return ret;
+}
+
+facesret* update_track_from_file(tracker* tr, const char* file) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+    
+    	try {
+		// TODO(Kagami): Support more file types?
+        // Danil_e71: support png, gif, bmp, jpg from file
+        load_image(img,file);
+        cls->Update(img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+
+    return ret;
+}
+
+facesret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len) {
+    Tracker* cls = (Tracker*)(tr->cls);
+	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	image_t img;
+
+    	try {
+		// TODO(Kagami): Support more file types?
+		load_jpeg(img, img_data, size_t(len));
+        cls->Update(img);
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+		return ret;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+		return ret;
+	}
+
+    return ret;
+}
+
+tracker_ret* get_track_position(tracker* tr) {
+    Tracker* cls = (Tracker*)(tr->cls);   
+    return cls->Position();
+}
+
 facesret* facerec_detect_from_file(facerec* rec, const char* file,int type) {
 	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
     FaceRec* cls = (FaceRec*)(rec->cls);
@@ -193,6 +304,17 @@ void facerec_free(facerec* rec) {
 	}
 }
 
+void tracker_free(tracker* tr) {
+	if (tr) {
+		if (tr->cls) {
+			Tracker* cls = (Tracker*)(tr->cls);
+			delete cls;
+			tr->cls = NULL;
+		}
+		free(tr);
+	}
+}
+
 void image_pointer_free(image_pointer* p) {
 	if (p) {
 		if (p->img) {
diff --git a/wrapper.h b/wrapper.h
index 58ea002..0ce3753 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -21,6 +21,19 @@ typedef struct facerec {
 	double padding;
 } facerec;
 
+
+typedef struct tracker {
+	void* cls;
+	const char* err_str;
+	err_code err_code;
+} tracker;
+
+typedef struct tracker_ret {
+	long* rectangles;
+	const char* err_str;
+	err_code err_code;
+} tracker_ret;
+
 typedef struct image_pointer {
     void *img;
     void *shape;
@@ -48,6 +61,13 @@ typedef struct faceret {
 #define DESCR_LEN  128
 #define SHAPE_LEN  2
 
+tracker* tracker_init();
+facesret* start_track_from_file(tracker* tr, const char* file,int x1, int y1, int x2, int y2);
+facesret* start_track_from_buffer(tracker* tr, unsigned char* img_data, int len,int x1, int y1, int x2, int y2);
+facesret* update_track_from_file(tracker* tr, const char* file);
+facesret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len);
+tracker_ret* get_track_position(tracker* tr);
+
 facerec* facerec_init();
 facesret* facerec_detect_from_file(facerec*, const char*,int);
 facesret* facerec_detect_from_buffer(facerec*, unsigned char*, int, int);
@@ -66,6 +86,7 @@ void facerec_set_age(facerec* , const char *);
 void facerec_set_samples(facerec*, const float*, const int32_t*, int);
 int facerec_classify(facerec*, const float*, float);
 void facerec_free(facerec*);
+void tracker_free(tracker*);
 
 void facerec_config_set_size(facerec* rec, unsigned long size);
 void facerec_config_set_padding(facerec* rec, double padding);

From 94728f9f6fa78aa90ce53f552c08c1cb75315d97 Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Wed, 10 Jun 2020 11:07:50 +0300
Subject: [PATCH 32/36] update api

---
 gocv.cc    |  6 ++--
 gocv.go    |  5 +++-
 gocv.h     |  3 +-
 tracker.cc |  4 +--
 tracker.go | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 tracker.h  |  2 +-
 wrapper.cc | 12 ++++----
 wrapper.h  | 10 +++++--
 8 files changed, 114 insertions(+), 16 deletions(-)

diff --git a/gocv.cc b/gocv.cc
index 4f83b86..e567c59 100644
--- a/gocv.cc
+++ b/gocv.cc
@@ -75,9 +75,9 @@ facesret* start_track_from_mat(tracker* tr, const void *mat,int x1, int y1, int
     return ret;
 }
 
-facesret* update_track_from_mat(tracker* tr, const void *mat) {
+update_ret* update_track_from_mat(tracker* tr, const void *mat) {
     Tracker* cls = (Tracker*)(tr->cls);
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	update_ret* ret = (update_ret*)calloc(1, sizeof(update_ret));
 	image_t img;
 
 	try {
@@ -95,7 +95,7 @@ facesret* update_track_from_mat(tracker* tr, const void *mat) {
             assign_image(img, dlib_img);
         }
         
-        cls->Update(img);
+        ret->confidence = cls->Update(img);
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
diff --git a/gocv.go b/gocv.go
index 39841b1..8b628cf 100644
--- a/gocv.go
+++ b/gocv.go
@@ -140,7 +140,7 @@ func (tracker *Tracker) StartMat(mat gocv.Mat, rect image.Rectangle) (err error)
 	return
 }
 
-func (tracker *Tracker) UpdateMat(mat gocv.Mat) (err error) {
+func (tracker *Tracker) UpdateMat(mat gocv.Mat) (confidence float32, err error) {
 	ret := C.update_track_from_mat(tracker.ptr, unsafe.Pointer(mat.Ptr()))
 	defer C.free(unsafe.Pointer(ret))
 
@@ -149,5 +149,8 @@ func (tracker *Tracker) UpdateMat(mat gocv.Mat) (err error) {
 		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
 		return
 	}
+
+	confidence = float32(ret.confidence)
+
 	return
 }
diff --git a/gocv.h b/gocv.h
index c4b3820..7431073 100644
--- a/gocv.h
+++ b/gocv.h
@@ -11,8 +11,9 @@ extern "C" {
 #endif
 
 facesret* facerec_detect_from_mat(facerec* rec, const void *mat,int type);
+
 facesret* start_track_from_mat(tracker* tr, const void *mat,int x1, int y1, int x2, int y2);
-facesret* update_track_from_mat(tracker* tr, const void *mat);
+update_ret* update_track_from_mat(tracker* tr, const void *mat);
 
 #ifdef __cplusplus
 }
diff --git a/tracker.cc b/tracker.cc
index 506daba..fb82f92 100644
--- a/tracker.cc
+++ b/tracker.cc
@@ -18,8 +18,8 @@ void Tracker::StartTrack(image_t &img, rectangle rect) {
 }
 
 
-void Tracker::Update(image_t &img) {
-    tracker.update(img);
+double Tracker::Update(image_t &img) {
+    return tracker.update(img);
 }
 
 tracker_ret *Tracker::Position() {
diff --git a/tracker.go b/tracker.go
index d17c2a5..5eace8f 100644
--- a/tracker.go
+++ b/tracker.go
@@ -55,3 +55,91 @@ func (tracker *Tracker) Position() (rect image.Rectangle, err error) {
 	rect = image.Rect(x0, y0, x1, y1)
 	return
 }
+
+func (tracker *Tracker) StartFile(file string, rect image.Rectangle) (err error) {
+	if !fileExists(file) {
+		err = ImageLoadError(fmt.Sprintf("File '%s' not found!", file))
+		return
+	}
+
+	cFile := C.CString(file)
+	defer C.free(unsafe.Pointer(cFile))
+
+	ret := C.start_track_from_file(tracker.ptr, cFile, C.int(rect.Min.X), C.int(rect.Min.Y), C.int(rect.Max.X), C.int(rect.Max.Y))
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+	return
+}
+
+func (tracker *Tracker) UpdateFile(file string) (confidence float32, err error) {
+	if !fileExists(file) {
+		err = ImageLoadError(fmt.Sprintf("File '%s' not found!", file))
+		return
+	}
+
+	cFile := C.CString(file)
+	defer C.free(unsafe.Pointer(cFile))
+	ret := C.update_track_from_file(tracker.ptr, cFile)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+
+	confidence = float32(ret.confidence)
+
+	return
+}
+
+func (tracker *Tracker) StartBuffer(imgData []byte, rect image.Rectangle) (err error) {
+	if len(imgData) == 0 {
+		err = ImageLoadError("Empty image")
+		return
+	}
+	cImgData := (*C.uchar)(&imgData[0])
+	cLen := C.int(len(imgData))
+
+	ret := C.start_track_from_buffer(tracker.ptr, cImgData, cLen, C.int(rect.Min.X), C.int(rect.Min.Y), C.int(rect.Max.X), C.int(rect.Max.Y))
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+	return
+}
+
+func (tracker *Tracker) UpdateBuffer(imgData []byte) (confidence float32, err error) {
+	if len(imgData) == 0 {
+		err = ImageLoadError("Empty image")
+		return
+	}
+	cImgData := (*C.uchar)(&imgData[0])
+	cLen := C.int(len(imgData))
+
+	ret := C.update_track_from_buffer(tracker.ptr, cImgData, cLen)
+	defer C.free(unsafe.Pointer(ret))
+
+	if ret.err_str != nil {
+		defer C.free(unsafe.Pointer(ret.err_str))
+		err = makeError(C.GoString(ret.err_str), int(ret.err_code))
+		return
+	}
+
+	confidence = float32(ret.confidence)
+
+	return
+}
+
+func (tracker *Tracker) Close() {
+	C.tracker_free(tracker.ptr)
+	tracker.ptr = nil
+}
diff --git a/tracker.h b/tracker.h
index 82360a3..8280713 100644
--- a/tracker.h
+++ b/tracker.h
@@ -18,7 +18,7 @@ class Tracker {
 public:
 	Tracker();
     void StartTrack(image_t &,rectangle);
-    void Update(image_t &img);
+    double Update(image_t &img);
     tracker_ret *Position();
 };
 
diff --git a/wrapper.cc b/wrapper.cc
index 59c12bb..27c4fa4 100644
--- a/wrapper.cc
+++ b/wrapper.cc
@@ -137,16 +137,16 @@ facesret* start_track_from_buffer(tracker* tr, unsigned char* img_data, int len,
     return ret;
 }
 
-facesret* update_track_from_file(tracker* tr, const char* file) {
+update_ret* update_track_from_file(tracker* tr, const char* file) {
     Tracker* cls = (Tracker*)(tr->cls);
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	update_ret* ret = (update_ret*)calloc(1, sizeof(update_ret));
 	image_t img;
     
     	try {
 		// TODO(Kagami): Support more file types?
         // Danil_e71: support png, gif, bmp, jpg from file
         load_image(img,file);
-        cls->Update(img);
+        ret->confidence = cls->Update(img);
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
@@ -160,15 +160,15 @@ facesret* update_track_from_file(tracker* tr, const char* file) {
     return ret;
 }
 
-facesret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len) {
+update_ret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len) {
     Tracker* cls = (Tracker*)(tr->cls);
-	facesret* ret = (facesret*)calloc(1, sizeof(facesret));
+	update_ret* ret = (update_ret*)calloc(1, sizeof(update_ret));
 	image_t img;
 
     	try {
 		// TODO(Kagami): Support more file types?
 		load_jpeg(img, img_data, size_t(len));
-        cls->Update(img);
+        ret->confidence = cls->Update(img);
 	} catch(image_load_error& e) {
 		ret->err_str = strdup(e.what());
 		ret->err_code = IMAGE_LOAD_ERROR;
diff --git a/wrapper.h b/wrapper.h
index 0ce3753..419a9d2 100644
--- a/wrapper.h
+++ b/wrapper.h
@@ -34,6 +34,12 @@ typedef struct tracker_ret {
 	err_code err_code;
 } tracker_ret;
 
+typedef struct update_ret {
+    double confidence;
+	const char* err_str;
+	err_code err_code;
+} update_ret;
+
 typedef struct image_pointer {
     void *img;
     void *shape;
@@ -64,8 +70,8 @@ typedef struct faceret {
 tracker* tracker_init();
 facesret* start_track_from_file(tracker* tr, const char* file,int x1, int y1, int x2, int y2);
 facesret* start_track_from_buffer(tracker* tr, unsigned char* img_data, int len,int x1, int y1, int x2, int y2);
-facesret* update_track_from_file(tracker* tr, const char* file);
-facesret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len);
+update_ret* update_track_from_file(tracker* tr, const char* file);
+update_ret* update_track_from_buffer(tracker* tr, unsigned char* img_data, int len);
 tracker_ret* get_track_position(tracker* tr);
 
 facerec* facerec_init();

From 609358f4e1697436ff5f66b036ef41166ba0e550 Mon Sep 17 00:00:00 2001
From: Daniel <danile71@gmail.com>
Date: Wed, 10 Jun 2020 13:27:50 +0300
Subject: [PATCH 33/36] update api

---
 tracker.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tracker.go b/tracker.go
index 5eace8f..21ab9d6 100644
--- a/tracker.go
+++ b/tracker.go
@@ -9,6 +9,7 @@ package face
 // #include "tracker.h"
 import "C"
 import (
+	"fmt"
 	"image"
 	"unsafe"
 )

From 4820b5ba8b5cba91a8ca84d1c0c381d69bac482b Mon Sep 17 00:00:00 2001
From: danil_e71 <danile71@gmail.com>
Date: Wed, 7 Apr 2021 14:46:13 +0300
Subject: [PATCH 34/36] add go mod

---
 face.go        |   1 -
 go-face.tar.xz | Bin 17264 -> 0 bytes
 go.mod         |   3 +++
 tracker.go     |   1 -
 4 files changed, 3 insertions(+), 2 deletions(-)
 delete mode 100644 go-face.tar.xz
 create mode 100644 go.mod

diff --git a/face.go b/face.go
index bbe1b74..d1ad16c 100644
--- a/face.go
+++ b/face.go
@@ -1,6 +1,5 @@
 package face
 
-// #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #include <stdlib.h>
diff --git a/go-face.tar.xz b/go-face.tar.xz
deleted file mode 100644
index d1f070b103ff773ad0af9e4b447e8f4b327d3aa6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17264
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
PvBYQl0ssI200dcD0_Uhi

diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..febfad7
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,3 @@
+module github.com/Danile71/go-face
+
+go 1.15
diff --git a/tracker.go b/tracker.go
index 21ab9d6..d73f3a5 100644
--- a/tracker.go
+++ b/tracker.go
@@ -1,6 +1,5 @@
 package face
 
-// #cgo pkg-config: dlib-1
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ljpeg
 // #include <stdlib.h>

From 9fe7b40e7b966b49ab7621c0ef32628106656be4 Mon Sep 17 00:00:00 2001
From: danil_e71 <danile71@gmail.com>
Date: Tue, 29 Jun 2021 23:10:31 +0300
Subject: [PATCH 35/36] fix build for mac os

---
 face.go    | 2 +-
 tracker.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/face.go b/face.go
index d1ad16c..8b277aa 100644
--- a/face.go
+++ b/face.go
@@ -1,7 +1,7 @@
 package face
 
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
-// #cgo LDFLAGS: -ljpeg
+// #cgo LDFLAGS: -ldlib -lblas -llapack -ljpeg
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"
diff --git a/tracker.go b/tracker.go
index d73f3a5..28c6666 100644
--- a/tracker.go
+++ b/tracker.go
@@ -1,7 +1,7 @@
 package face
 
 // #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
-// #cgo LDFLAGS: -ljpeg
+// #cgo LDFLAGS: -ldlib -lblas -llapack -ljpeg
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"

From 0fa887565aaa3b6b43263c822c74735256153047 Mon Sep 17 00:00:00 2001
From: danil_e71 <danile71@gmail.com>
Date: Tue, 12 Oct 2021 08:54:10 +0300
Subject: [PATCH 36/36] add m1 support

---
 cgo.go              |  6 +++
 cgo_darwin_arm64.go |  6 +++
 example_test.go     | 89 ---------------------------------------------
 face.go             |  1 -
 gocv.go             |  4 +-
 tracker.go          |  2 -
 6 files changed, 14 insertions(+), 94 deletions(-)
 create mode 100644 cgo.go
 create mode 100644 cgo_darwin_arm64.go
 delete mode 100644 example_test.go

diff --git a/cgo.go b/cgo.go
new file mode 100644
index 0000000..c4a451b
--- /dev/null
+++ b/cgo.go
@@ -0,0 +1,6 @@
+// +build !arm64,!darwin
+
+package face
+
+// #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
+import "C"
diff --git a/cgo_darwin_arm64.go b/cgo_darwin_arm64.go
new file mode 100644
index 0000000..c309245
--- /dev/null
+++ b/cgo_darwin_arm64.go
@@ -0,0 +1,6 @@
+// +build arm64,darwin
+
+package face
+
+// #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG
+import "C"
diff --git a/example_test.go b/example_test.go
deleted file mode 100644
index 35bfc20..0000000
--- a/example_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package face_test
-
-import (
-	"fmt"
-	"log"
-	"path/filepath"
-
-	"github.com/Kagami/go-face"
-)
-
-// Path to directory with models and test images. Here it's assumed it
-// points to the <https://github.com/Kagami/go-face-testdata> clone.
-const dataDir = "testdata"
-const cnn = "testdata/mmod_human_face_detector.dat"
-const shape = "testdata/shape_predictor_5_face_landmarks.dat"
-const descr = "testdata/dlib_face_recognition_resnet_model_v1.dat"
-const gender = "testdata/dnn_gender_classifier_v1.dat"
-const age = "testdata/dnn_age_predictor_v1.dat"
-
-// This example shows the basic usage of the package: create an
-// recognizer, recognize faces, classify them using few known ones.
-func Example_basic() {
-	// Init the recognizer.
-	rec, err := face.NewRecognizer()
-	if err != nil {
-		log.Fatalf("Can't init face recognizer: %v", err)
-	}
-	// Free the resources when you're finished.
-	defer rec.Close()
-
-	rec.SetCNNModel(cnn)
-	rec.SetDescriptorModel(descr)
-	rec.SetShapeModel(shape)
-	rec.SetGenderModel(gender)
-	rec.SetAgeModel(age)
-
-	rec.SetSize(150)
-	rec.SetPadding(0.25)
-	rec.SetMinImageSize(100)
-	rec.SetJittering(20)
-
-	// Test image with 10 faces.
-	testImagePristin := filepath.Join(dataDir, "pristin.jpg")
-	// Recognize faces on that image.
-	faces, err := rec.DetectFromFile(testImagePristin)
-	if err != nil {
-		log.Fatalf("Can't recognize: %v", err)
-	}
-	if len(faces) != 10 {
-		log.Fatalf("Wrong number of faces, %d", len(faces))
-	}
-
-	// Fill known samples. In the real world you would use a lot of images
-	// for each person to get better classification results but in our
-	// example we just get them from one big image.
-	var samples []face.Descriptor
-	var cats []int32
-	for i, f := range faces {
-		rec.Recognize(&f)
-		samples = append(samples, f.Descriptor)
-		// Each face is unique on that image so goes to its own category.
-		cats = append(cats, int32(i))
-	}
-	// Name the categories, i.e. people on the image.
-	labels := []string{
-		"Sungyeon", "Yehana", "Roa", "Eunwoo", "Xiyeon",
-		"Kyulkyung", "Nayoung", "Rena", "Kyla", "Yuha",
-	}
-	// Pass samples to the recognizer.
-	rec.SetSamples(samples, cats)
-
-	// Now let's try to classify some not yet known image.
-	testImageNayoung := filepath.Join(dataDir, "nayoung.jpg")
-	nayoungFace, err := rec.DetectFromFile(testImageNayoung)
-	if err != nil {
-		log.Fatalf("Can't recognize: %v", err)
-	}
-	if len(nayoungFace) != 1 {
-		log.Fatalf("Wrong number of faces %d", len(nayoungFace))
-	}
-	rec.Recognize(&nayoungFace[0])
-
-	catID := rec.Classify(nayoungFace[0].Descriptor)
-	if catID < 0 {
-		log.Fatalf("Can't classify")
-	}
-	// Finally print the classified label. It should be "Nayoung".
-	fmt.Println(labels[catID])
-}
diff --git a/face.go b/face.go
index 8b277aa..1dcb532 100644
--- a/face.go
+++ b/face.go
@@ -1,6 +1,5 @@
 package face
 
-// #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
 // #cgo LDFLAGS: -ldlib -lblas -llapack -ljpeg
 // #include <stdlib.h>
 // #include <stdint.h>
diff --git a/gocv.go b/gocv.go
index 8b628cf..56a9049 100644
--- a/gocv.go
+++ b/gocv.go
@@ -3,9 +3,9 @@
 package face
 
 // #cgo !windows pkg-config: opencv4
-// #cgo CXXFLAGS:   --std=c++1z
+// #cgo CXXFLAGS:   --std=c++11
 // #cgo windows  CPPFLAGS:   -IC:/opencv/build/install/include
-// #cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core420 -lopencv_face420 -lopencv_videoio420 -lopencv_imgproc420 -lopencv_highgui420 -lopencv_imgcodecs420 -lopencv_objdetect420 -lopencv_features2d420 -lopencv_video420 -lopencv_dnn420 -lopencv_xfeatures2d420 -lopencv_plot420 -lopencv_tracking420 -lopencv_img_hash420 -lopencv_calib3d420
+// #cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core453 -lopencv_face453 -lopencv_videoio453 -lopencv_imgproc453 -lopencv_highgui453 -lopencv_imgcodecs453 -lopencv_objdetect453 -lopencv_features2d453 -lopencv_video453 -lopencv_dnn453 -lopencv_xfeatures2d453 -lopencv_plot453 -lopencv_tracking453 -lopencv_img_hash453 -lopencv_calib3d453 -lopencv_bgsegm453 -lopencv_photo453
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"
diff --git a/tracker.go b/tracker.go
index 28c6666..a6812e6 100644
--- a/tracker.go
+++ b/tracker.go
@@ -1,7 +1,5 @@
 package face
 
-// #cgo CXXFLAGS: -std=c++1z -Wall -O3 -DNDEBUG -march=native
-// #cgo LDFLAGS: -ldlib -lblas -llapack -ljpeg
 // #include <stdlib.h>
 // #include <stdint.h>
 // #include "wrapper.h"