Initial commit

COPYING

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

Makefile

@@ -0,0 +1,7 @@
+export GOPATH = $(PWD)
+
+gofmt-staged:
+	./gofmt-staged.sh
+
+test: gofmt-staged
+	go test -v

README.md

@@ -0,0 +1,7 @@
+# go-dlib
+
+Partial [dlib](https://github.com/davisking/dlib) bindings for Go.
+
+## License
+
+[CC0](COPYING).

dlib.go

@@ -0,0 +1,6 @@
+package dlib
+
+// #cgo pkg-config: dlib-1
+// #cgo CFLAGS: -Wall -O3 -march=native
+// #cgo LDFLAGS: -lgif
+import "C"

error.go

@@ -0,0 +1,42 @@
+package dlib
+
+// #include "facerec.h"
+import "C"
+
+type ImageLoadError string
+
+func (e ImageLoadError) Error() string {
+	return string(e)
+}
+
+type SerializationError string
+
+func (e SerializationError) Error() string {
+	return string(e)
+}
+
+type RecognizeError string
+
+func (e RecognizeError) Error() string {
+	return string(e)
+}
+
+type UnknownError string
+
+func (e UnknownError) Error() string {
+	return string(e)
+}
+
+// Construct Go error from passed error info.
+func makeError(s string, code int) error {
+	switch code {
+	case C.IMAGE_LOAD_ERROR:
+		return ImageLoadError(s)
+	case C.SERIALIZATION_ERROR:
+		return SerializationError(s)
+	case C.RECOGNIZE_ERROR:
+		return RecognizeError(s)
+	default:
+		return UnknownError(s)
+	}
+}

facerec.cc

@@ -0,0 +1,129 @@
+#include <dlib/dnn.h>
+#include <dlib/image_io.h>
+#include <dlib/image_processing/frontal_face_detector.h>
+
+#include "facerec.h"
+
+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>>>;
+
+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<float,0,1> descriptor;
+static const size_t DESCR_SIZE = 128 * sizeof(float);
+
+class FaceRec {
+public:
+	FaceRec(const char* model_dir) {
+		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";
+
+		deserialize(shape_predictor_path) >> sp_;
+		deserialize(resnet_path) >> net_;
+	}
+
+	// TODO(Kagami): Jittering?
+	std::vector<descriptor> Recognize(const char* img_path) {
+		matrix<rgb_pixel> img;
+		load_image(img, img_path);
+
+		std::vector<matrix<rgb_pixel>> faces;
+		for (auto face : detector_(img)) {
+			auto shape = sp_(img, face);
+			matrix<rgb_pixel> face_chip;
+			extract_image_chip(img, get_face_chip_details(shape, 150, 0.25), face_chip);
+			faces.push_back(std::move(face_chip));
+		}
+
+		// Short circuit.
+		if (faces.size() == 0)
+			return {};
+
+		std::vector<descriptor> descriptors = net_(faces);
+		return descriptors;
+	}
+private:
+	frontal_face_detector detector_;
+	shape_predictor sp_;
+	anet_type net_;
+};
+
+// Plain C interface for Go.
+
+facerec* facerec_init(const char* model_dir) {
+	facerec* rec = (facerec*)calloc(1, sizeof(facerec));
+	try {
+		FaceRec* cls = new FaceRec(model_dir);
+		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;
+}
+
+faceret* facerec_recognize(facerec* rec, const char* img_path) {
+	faceret* ret = (faceret*)calloc(1, sizeof(faceret));
+	FaceRec* cls = (FaceRec*)(rec->cls);
+	try {
+		std::vector<descriptor> descriptors = cls->Recognize(img_path);
+		ret->num_faces = descriptors.size();
+		if (ret->num_faces == 0)
+			return ret;
+		ret->descriptors = (float*)malloc(ret->num_faces * DESCR_SIZE);
+		for (int i = 0; i < ret->num_faces; i++) {
+			void* dst = (uint8_t*)(ret->descriptors) + i * DESCR_SIZE;
+			void* src = (void*)&descriptors[i](0,0);
+			memcpy(dst, src, DESCR_SIZE);
+		}
+	} catch(image_load_error& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = IMAGE_LOAD_ERROR;
+	} catch (std::exception& e) {
+		ret->err_str = strdup(e.what());
+		ret->err_code = UNKNOWN_ERROR;
+	}
+	return ret;
+}
+
+void facerec_free(facerec* rec) {
+	if (rec) {
+		if (rec->cls) {
+			FaceRec* cls = (FaceRec*)(rec->cls);
+			delete cls;
+			rec->cls = NULL;
+		}
+		free(rec);
+	}
+}

facerec.go

@@ -0,0 +1,77 @@
+package dlib
+
+// #include <stdlib.h>
+// #include "facerec.h"
+import "C"
+import (
+	"unsafe"
+)
+
+const (
+	DESCR_LEN = 128
+)
+
+// Preinitialized extractor.
+type FaceRec struct {
+	p *_Ctype_struct_facerec
+}
+
+// Face structure.
+type Face struct {
+	Descriptor [DESCR_LEN]float32
+}
+
+func NewFaceRec(modelDir string) (rec *FaceRec, err error) {
+	cModelDir := C.CString(modelDir)
+	defer C.free(unsafe.Pointer(cModelDir))
+	p := C.facerec_init(cModelDir)
+
+	if p.err_str != nil {
+		defer C.facerec_free(p)
+		defer C.free(unsafe.Pointer(p.err_str))
+		err = makeError(C.GoString(p.err_str), int(p.err_code))
+		return
+	}
+
+	rec = &FaceRec{p}
+	return
+}
+
+// Extract faces from the provided image file.
+// Empty list is returned if there are no faces, error is returned if
+// there was some error while decoding/processing image.
+func (rec *FaceRec) Recognize(imgPath string) (faces []*Face, err error) {
+	cImgPath := C.CString(imgPath)
+	defer C.free(unsafe.Pointer(cImgPath))
+	ret := C.facerec_recognize(rec.p, cImgPath)
+	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
+	}
+
+	// No faces.
+	numFaces := int(ret.num_faces)
+	if numFaces == 0 {
+		return
+	}
+
+	// Copy descriptor data to Go structure.
+	defer C.free(unsafe.Pointer(ret.descriptors))
+	dataLen := numFaces * DESCR_LEN
+	dataPtr := unsafe.Pointer(ret.descriptors)
+	data := (*[1 << 30]float32)(dataPtr)[:dataLen:dataLen]
+	for i := 0; i < numFaces; i++ {
+		var face Face
+		copy(face.Descriptor[:], data[i*DESCR_LEN:(i+1)*DESCR_LEN])
+		faces = append(faces, &face)
+	}
+	return
+}
+
+func (rec *FaceRec) Close() {
+	C.facerec_free(rec.p)
+	rec.p = nil
+}

facerec.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	IMAGE_LOAD_ERROR,
+	SERIALIZATION_ERROR,
+	RECOGNIZE_ERROR,
+	UNKNOWN_ERROR,
+} err_code;
+
+typedef struct facerec {
+	void* cls;
+	const char* err_str;
+	err_code err_code;
+} facerec;
+
+typedef struct faceret {
+	float* descriptors;
+	int num_faces;
+	const char* err_str;
+	err_code err_code;
+} faceret;
+
+facerec* facerec_init(const char* model_dir);
+faceret* facerec_recognize(facerec* rec, const char* img_path);
+void facerec_free(facerec* rec);
+
+#ifdef __cplusplus
+}
+#endif

facerec_test.go

@@ -0,0 +1,21 @@
+package dlib
+
+import (
+	"testing"
+)
+
+func TestNumFaces(t *testing.T) {
+	rec, err := NewFaceRec("testdata")
+	if err != nil {
+		t.Fatalf("Can't init face recognizer: %v", err)
+	}
+	defer rec.Close()
+	faces, err := rec.Recognize("testdata/pristin.jpg")
+	if err != nil {
+		t.Fatalf("Can't recognize faces: %v", err)
+	}
+	numFaces := len(faces)
+	if err != nil || numFaces != 10 {
+		t.Fatalf("Wrong number of faces: %d", numFaces)
+	}
+}

gofmt-staged.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# https://github.com/edsrzf/gofmt-git-hook
+IFS='
+'
+exitcode=0
+for file in `git diff --cached --name-only --diff-filter=ACM | grep '\.go$'`
+do
+    output=`gofmt -w "$file"`
+    if test -n "$output"
+    then
+        # any output is a syntax error
+        echo >&2 "$output"
+        exitcode=1
+    fi
+    git add "$file"
+done
+exit $exitcode