circe 0.1.0

data/ext/circe.cpp

@@ -0,0 +1,404 @@
+#include <ruby.h>
+
+#if 0
+void estimateHeadPose(cv::Mat& image, CameraModel& camera, const FaceDetection::Landmark& landmark)
+{
+    /* reference: https://qiita.com/TaroYamada/items/e3f3d0ea4ecc0a832fac */
+    /* reference: https://github.com/spmallick/learnopencv/blob/master/HeadPose/headPose.cpp */
+    static const std::vector<cv::Point3f> face_object_point_list = {
+        {    0.0f,    0.0f,    0.0f }, // Nose
+        { -225.0f,  170.0f, -135.0f }, // Left eye
+        {  225.0f,  170.0f, -135.0f }, // Right eye
+        { -150.0f, -150.0f, -125.0f }, // Left lip
+        {  150.0f, -150.0f, -125.0f }, // Right lip
+    };
+    
+    static const std::vector<cv::Point3f> face_object_point_for_pnp_list = {
+        face_object_point_list[0], face_object_point_list[0], // Nose
+        face_object_point_list[1], face_object_point_list[1], // Left eye
+        face_object_point_list[2], face_object_point_list[2], // Right eye
+        face_object_point_list[3], face_object_point_list[3], // Left lip
+        face_object_point_list[4], face_object_point_list[4], // Righ lip
+    };
+
+    std::vector<cv::Point2f> face_image_point_list;
+    face_image_point_list.push_back(landmark[2]);  // Nose
+    face_image_point_list.push_back(landmark[2]);  // Nose
+    face_image_point_list.push_back(landmark[0]);  // Left eye
+    face_image_point_list.push_back(landmark[0]);  // Left eye
+    face_image_point_list.push_back(landmark[1]);  // Right eye
+    face_image_point_list.push_back(landmark[1]);  // Right eye
+    face_image_point_list.push_back(landmark[3]);  // Left lip
+    face_image_point_list.push_back(landmark[3]);  // Left lip
+    face_image_point_list.push_back(landmark[4]);  // Right lip
+    face_image_point_list.push_back(landmark[4]);  // Right lip
+
+    cv::Mat rvec = cv::Mat_<float>(3, 1);
+    cv::Mat tvec = cv::Mat_<float>(3, 1);
+    cv::solvePnP(face_object_point_for_pnp_list, face_image_point_list, camera.K, camera.dist_coeff, rvec, tvec, false, cv::SOLVEPNP_ITERATIVE);
+
+    char text[128];
+    snprintf(text, sizeof(text), "Pitch = %-+4.0f, Yaw = %-+4.0f, Roll = %-+4.0f", Rad2Deg(rvec.at<float>(0, 0)), Rad2Deg(rvec.at<float>(1, 0)), Rad2Deg(rvec.at<float>(2, 0)));
+    CommonHelper::drawText(image, text, cv::Point(10, 10), 0.7, 3, cv::Scalar(0, 0, 0), cv::Scalar(255, 255, 255), false);
+    
+    std::vector<cv::Point3f> nose_end_point3D = { { 0.0f, 0.0f, 500.0f } };
+    std::vector<cv::Point2f> nose_end_point2D;
+    cv::projectPoints(nose_end_point3D, rvec, tvec,
+		      camera.K, camera.dist_coeff, nose_end_point2D);
+    cv::arrowedLine(image, face_image_point_list[0], nose_end_point2D[0],
+		    cv::Scalar(0, 255, 0), 5);
+
+    
+    /* Calculate Euler Angle */
+    cv::Mat R;
+    cv::Rodrigues(rvec, R);
+    cv::Mat projMat = (cv::Mat_<double>(3, 4) <<
+        R.at<float>(0, 0), R.at<float>(0, 1), R.at<float>(0, 2), 0,
+        R.at<float>(1, 0), R.at<float>(1, 1), R.at<float>(1, 2), 0,
+        R.at<float>(2, 0), R.at<float>(2, 1), R.at<float>(2, 2), 0);
+
+    cv::Mat K, R2, tvec2, R_x, R_y, R_z, eulerAngles;
+    cv::decomposeProjectionMatrix(projMat, K, R, tvec2,
+				  R_x, R_y, R_z, eulerAngles);
+    double pitch = eulerAngles.at<double>(0, 0);
+    double yaw   = eulerAngles.at<double>(1, 0);
+    double roll  = eulerAngles.at<double>(2, 0);
+    snprintf(text, sizeof(text), "X = %-+4.0f, Y = %-+4.0f, Z = %-+4.0f", pitch, yaw, roll);
+    CommonHelper::drawText(image, text, cv::Point(10, 40), 0.7, 3, cv::Scalar(0, 0, 0), cv::Scalar(255, 255, 255), false);
+}
+#endif
+
+#if 0
+    CameraModel camera;
+    camera.SetIntrinsic(image_input.cols, image_input.rows, FocalLength(image_input.cols, kFovDeg));
+    camera.SetDist({ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f });
+    camera.SetExtrinsic({ 0.0f, 0.0f, 0.0f },    /* rvec [deg] */
+			{ 0.0f, 0.0f, 0.0f }, true);   /* tvec (in world coordinate) */
+
+    estimateHeadPose(image_input, camera, face_list[i].second);
+
+#endif
+
+#define IF_UNDEF(a, b)                          \
+    ((a) == Qundef) ? (b) : (a)
+
+
+static VALUE cCirce       = Qundef;
+static VALUE eCirceError  = Qundef;
+
+#include <tuple>
+#include <string>
+#include <chrono>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include "yolo.h"
+#include "yunet.h"
+
+using namespace std;
+using namespace cv;
+
+
+
+// Text parameters.
+const float FONT_SCALE = 0.7;
+const int   FONT_FACE  = FONT_HERSHEY_SIMPLEX;
+const int   THICKNESS  = 1;
+
+// Colors.
+cv::Scalar BLACK  = cv::Scalar(0,0,0);
+cv::Scalar BLUE   = cv::Scalar(255, 178, 50);
+cv::Scalar YELLOW = cv::Scalar(0, 255, 255);
+cv::Scalar RED    = cv::Scalar(0,0,255);
+
+
+static ID id_debug;
+static ID id_face;
+static ID id_classify;
+static ID id_class;
+static ID id_png;
+static ID id_jpg;
+
+
+static Yolo  *yolo;
+static YuNet *yunet;
+
+
+
+static void
+draw_label(cv::Mat& img, string label, Point& origin,
+	   Scalar& fgcolor, Scalar& bgcolor, int thickness = 1)
+{
+    int baseLine;
+    cv::Size label_size =
+	cv::getTextSize(label, FONT_FACE, FONT_SCALE, thickness, &baseLine);
+    
+    Point a = { origin.x, max(origin.y, label_size.height) };
+    Point b = { a.x + label_size.width,
+		a.y + label_size.height + baseLine };
+    Point t = { a.x, a.y + label_size.height };
+    
+    cv::rectangle(img, a, b, bgcolor, cv::FILLED);
+    cv::putText(img, label, t, FONT_FACE, FONT_SCALE, fgcolor, THICKNESS);
+}
+
+static void
+draw_labelbox(cv::Mat& img, string label, Rect& box,
+	      Scalar& framecolor = BLUE, Scalar& textcolor = BLACK,
+	      int thickness = 1) {
+
+    Point a = { box.x,             box.y              };
+    Point b = { box.x + box.width, box.y + box.height };
+
+    cv::rectangle(img, a, b, framecolor, thickness);
+    draw_label(img, label, a, textcolor, framecolor);    
+}
+
+
+
+
+
+void
+yunet_process_features(vector<YuNet::Face>& faces,
+		       Mat& img, VALUE v_features, int *state)
+{
+    for (int i = 0; i < faces.size(); i++) {
+	Rect box              = faces[i].first;
+	YuNet::Landmark lmark = faces[i].second;
+	
+	VALUE v_type       = ID2SYM(id_face);
+	VALUE v_box        = rb_ary_new_from_args(4,
+				 INT2NUM(box.x    ), INT2NUM(box.y     ),
+				 INT2NUM(box.width), INT2NUM(box.height));
+	VALUE v_landmark   = rb_ary_new_from_args(5,
+			        rb_ary_new_from_args(2, INT2NUM(lmark[0].x),
+						        INT2NUM(lmark[0].y)),
+				rb_ary_new_from_args(2, INT2NUM(lmark[1].x),
+						        INT2NUM(lmark[1].y)),
+				rb_ary_new_from_args(2, INT2NUM(lmark[2].x),
+						        INT2NUM(lmark[2].y)),
+				rb_ary_new_from_args(2, INT2NUM(lmark[3].x),
+						        INT2NUM(lmark[3].y)),
+				rb_ary_new_from_args(2, INT2NUM(lmark[4].x),
+						        INT2NUM(lmark[4].y)));
+	VALUE v_feature    = rb_ary_new_from_args(3, v_type, v_box,
+						     v_landmark);
+	rb_ary_push(v_features, v_feature);
+	
+	if (!img.empty() && rb_block_given_p()) {
+	    VALUE v_annotation= rb_yield_splat(v_feature);
+	    VALUE v_label     = Qnil;
+	    VALUE v_color     = ULONG2NUM(0x0000ff);
+	    VALUE v_thickness = INT2NUM(1);
+
+	    switch (TYPE(v_annotation)) {
+	    case T_NIL:
+		break;
+	    case T_HASH:
+		break;
+	    case T_ARRAY:
+		switch(RARRAY_LENINT(v_annotation)) {
+		default:
+		case 3: v_thickness = RARRAY_AREF(v_annotation, 2);
+		case 2: v_color     = RARRAY_AREF(v_annotation, 1);
+		case 1: v_label     = RARRAY_AREF(v_annotation, 0);
+		case 0: break;
+		}
+		break;
+	    case T_STRING:
+		v_label = v_annotation;
+		break;
+	    }
+	    
+	    if (! NIL_P(v_label)) {
+		string label     = StringValueCStr(v_label);
+		long   rgb       = NUM2ULONG(v_color);
+		int    thickness = NUM2INT(v_thickness);
+		Scalar color     = cv::Scalar((rgb >>  0) & 0xFF,
+					      (rgb >>  8) & 0xFF,
+					      (rgb >> 16) & 0xFF);
+		draw_labelbox(img, label, box, color, BLACK, thickness);
+		
+		for (const auto& p : lmark) {
+		    cv::circle(img, p, 3, cv::Scalar(255, 0, 0), 2);
+		}
+	    }
+	}
+    }
+}
+
+
+
+void
+yolo_process_features(vector<Yolo::Item>& items,
+		      Mat& img, VALUE v_features, int *state)
+{   
+    for (int i = 0; i < items.size(); i++) {
+	string name        = std::get<0>(items[i]);
+	float  confidence  = std::get<1>(items[i]);
+	Rect   box         = std::get<2>(items[i]);
+	
+	VALUE v_type       = ID2SYM(id_class);
+	VALUE v_name       = rb_str_new(name.c_str(), name.size());
+	VALUE v_confidence = DBL2NUM(confidence);
+	VALUE v_box        = rb_ary_new_from_args(4,
+				  INT2NUM(box.x    ), INT2NUM(box.y     ),
+				  INT2NUM(box.width), INT2NUM(box.height));
+	VALUE v_feature    = rb_ary_new_from_args(4, v_type, v_box,
+						     v_name, v_confidence);
+	rb_ary_push(v_features, v_feature);
+
+	if (rb_block_given_p()) {
+	    VALUE v_annotation = rb_yield_splat(v_feature);
+	    
+	    VALUE v_label      = Qnil;
+	    VALUE v_color      = ULONG2NUM(0x0000ff);
+	    VALUE v_thickness  = INT2NUM(1);
+	    
+	    switch (TYPE(v_annotation)) {
+	    case T_NIL:
+		break;
+	    case T_HASH:
+		break;
+	    case T_ARRAY:
+		switch(RARRAY_LENINT(v_annotation)) {
+		default:
+		case 3: v_thickness = RARRAY_AREF(v_annotation, 2);
+		case 2: v_color     = RARRAY_AREF(v_annotation, 1);
+		case 1: v_label     = RARRAY_AREF(v_annotation, 0);
+		case 0: break;
+		}
+		break;
+	    case T_STRING:
+		v_label = v_annotation;
+		break;
+	    }
+	    
+	    if (! NIL_P(v_label)) {
+		string label     = StringValueCStr(v_label);
+		long   rgb       = NUM2ULONG(v_color);
+		int    thickness = NUM2INT(v_thickness);
+		Scalar color     = cv::Scalar((rgb >>  0) & 0xFF,
+					      (rgb >>  8) & 0xFF,
+					      (rgb >> 16) & 0xFF);
+		draw_labelbox(img, label, box, color, BLACK, thickness);
+	    }
+	}
+    }
+}
+
+
+
+static VALUE
+circe_m_analyze(int argc, VALUE* argv, VALUE self) {
+    // Retrieve arguments
+    VALUE v_imgstr, v_format, v_opts;
+    VALUE kwargs[3];
+    rb_scan_args(argc, argv, "11:", &v_imgstr, &v_format, &v_opts);
+    rb_get_kwargs(v_opts, (ID[]){ id_debug, id_face, id_classify },
+		  0, 3, kwargs);
+    VALUE v_debug    = IF_UNDEF(kwargs[0], Qfalse);
+    VALUE v_face     = IF_UNDEF(kwargs[1], Qfalse);
+    VALUE v_classify = IF_UNDEF(kwargs[2], Qfalse);
+
+    VALUE v_features = rb_ary_new();
+    VALUE v_image    = Qnil;
+    
+    if (! NIL_P(v_format)) {
+	Check_Type(v_format, T_SYMBOL);
+	ID i_format = rb_sym2id(v_format);
+	if ((i_format != id_png) && (i_format != id_jpg))
+	    rb_raise(rb_eArgError, "format must be :png, :jpg or nil");
+    }
+    
+    if (!RTEST(v_face) && !RTEST(v_classify)) {
+	v_face = v_classify = Qtrue;
+    }
+
+
+    // Load image.
+    Mat i_img = cv::imdecode(cv::Mat(1, RSTRING_LEN(v_imgstr), CV_8UC1,
+				     (unsigned char *)RSTRING_PTR(v_imgstr)),
+			     IMREAD_UNCHANGED);	    
+    Mat o_img = NIL_P(v_format) ? cv::Mat() : i_img.clone();
+
+    // Processing
+    std::chrono::time_point<std::chrono::system_clock> start_time, end_time;
+    std::chrono::duration<double> duration;
+    int state = 0;
+
+    start_time = std::chrono::system_clock::now();
+    
+    if (RTEST(v_classify)) {
+	vector<Yolo::Item> items;
+	yolo->process(i_img, items);
+	yolo_process_features(items, o_img, v_features, &state);
+	if (state) goto exception;
+    }
+
+    if (RTEST(v_face)) {
+	vector<YuNet::Face> faces;
+	yunet->process(i_img, faces);
+	yunet_process_features(faces, o_img, v_features, &state);
+	if (state) goto exception;
+    }
+
+    end_time = std::chrono::system_clock::now();
+    duration = end_time - start_time;
+    
+
+    if (! NIL_P(v_format)) {
+	if (RTEST(v_debug)) {
+	    double ms    = duration / 1.0ms;
+	    string label = cv::format("Inference time : %0.2f ms", ms);
+	    cv::putText(o_img, label, Point(20, 40),
+			FONT_FACE, FONT_SCALE, RED);
+	}
+
+	ID   i_format = rb_sym2id(v_format);
+	string format;
+	if      (i_format == id_png) { format = ".png"; }
+	else if (i_format == id_jpg) { format = ".jpg"; }
+
+	std::vector<uchar> buf;	
+	cv::imencode(format, o_img, buf);
+	v_image = rb_str_new(reinterpret_cast<char*>(buf.data()), buf.size());
+    }
+    return rb_ary_new_from_args(2, v_features, v_image);
+
+ exception:
+    i_img.release();
+    o_img.release();
+    rb_jump_tag(state);
+}
+
+
+
+
+extern "C"
+void Init_core(void) {
+    /* Main classes */
+    cCirce      = rb_define_class("Circe", rb_cObject);
+    eCirceError = rb_define_class_under(cCirce, "Error", rb_eStandardError);
+    // myclass = rb_const_get(mymodule, sym_myclass);
+
+    VALUE v_onnx_yolo  = rb_const_get(cCirce, rb_intern("ONNX_YOLO"));
+    VALUE v_onnx_yunet = rb_const_get(cCirce, rb_intern("ONNX_YUNET"));
+
+    static Yolo  _yolo  = { StringValueCStr(v_onnx_yolo ) };
+    static YuNet _yunet = { StringValueCStr(v_onnx_yunet) };
+
+    yolo  = &_yolo;
+    yunet = &_yunet;
+
+    
+    id_debug       = rb_intern_const("debug"   );
+    id_face        = rb_intern_const("face"    );
+    id_classify    = rb_intern_const("classify");
+    id_class       = rb_intern_const("class"   );
+    id_png         = rb_intern_const("png"     );
+    id_jpg         = rb_intern_const("jpg"     );
+    
+    
+    rb_define_method(cCirce, "analyze", circe_m_analyze, -1);
+}

data/ext/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+$PKGCONFIG =
+    case RbConfig::CONFIG['host_os']
+    when /bsd/ then '/usr/local/bin/pkgconf'
+    end
+
+
+cflags, ldflags, libs = pkg_config('opencv4')
+
+$LDFLAGS  += " #{ldflags} #{libs}"
+$INCFLAGS += " #{cflags}"
+$CXXFLAGS += "-std=c++17"
+
+create_makefile("circe/core")

data/ext/yolo.cpp

@@ -0,0 +1,94 @@
+#include <tuple>
+#include <string>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/dnn.hpp>
+
+#include "yolo.h"
+
+
+Yolo::Yolo(const std::string& model) {
+    net = cv::dnn::readNetFromONNX(model);
+}
+
+
+void Yolo::process(cv::Mat &img, std::vector<Yolo::Item> &items) {
+
+    // Pre-process
+    cv::Mat blob;
+    std::vector<cv::Mat> outputs;
+
+    cv::dnn::blobFromImage(img, blob, 1./255.,
+			   cv::Size(INPUT_WIDTH, INPUT_HEIGHT),
+			   cv::Scalar(), true, false);
+
+    // Process
+    net.setInput(blob);
+    net.forward(outputs, net.getUnconnectedOutLayersNames());
+
+    // Post-process
+    std::vector<int>   class_ids;
+    std::vector<float> confidences;
+    std::vector<cv::Rect>  boxes;
+
+    // Resizing factor.
+    float x_factor = img.cols / INPUT_WIDTH;
+    float y_factor = img.rows / INPUT_HEIGHT;
+
+    float *data = (float *)outputs[0].data;
+    const int dimensions = 85;
+    
+    // 25200 for default size 640.
+    const int rows = 25200;
+    // Iterate through 25200 detections.
+    for (int i = 0; i < rows; ++i) {
+	float confidence = data[4];
+
+	// Discard bad detections and continue.
+	if (confidence >= CONFIDENCE_THRESHOLD) {
+            float *classes_scores = data + 5;
+
+            // Create a 1x85 Mat and store class scores of 80 classes.
+	    cv::Mat scores(1, names.size(), CV_32FC1, classes_scores);
+
+            // Perform minMaxLoc and acquire the index of best class score.
+	    cv::Point class_id;
+            double max_class_score;
+            minMaxLoc(scores, 0, &max_class_score, 0, &class_id);
+
+            // Continue if the class score is above the threshold.
+            if (max_class_score > SCORE_THRESHOLD) {
+                // Store class ID and confidence in the pre-defined
+		// respective vectors.
+                float cx = data[0];  // Center
+                float cy = data[1];
+                float w  = data[2];  // Box dimension
+                float h  = data[3];
+		
+                // Bounding box coordinates.
+                int left   = int((cx - 0.5 * w) * x_factor);
+                int top    = int((cy - 0.5 * h) * y_factor);
+                int width  = int(w              * x_factor);
+                int height = int(h              * y_factor);
+
+                // Store good detections in the boxes vector.
+                confidences.push_back(confidence);
+                class_ids.push_back(class_id.x);
+                boxes.push_back(cv::Rect(left, top, width, height));
+            }
+        }
+        // Jump to the next row.
+        data += 85;
+    }
+    
+    // Perform Non-Maximum Suppression and draw predictions.
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(boxes, confidences,
+		      SCORE_THRESHOLD, NMS_THRESHOLD, indices);
+
+    items.clear();
+
+    for (int i = 0; i < indices.size(); i++) {
+        int  idx = indices[i];
+	items.push_back({ names[class_ids[idx]],confidences[idx],boxes[idx] });
+    }
+}

data/ext/yolo.h

@@ -0,0 +1,48 @@
+#ifndef __YOLO__
+#define __YOLO__
+
+#include <string>
+#include <vector>
+#include <tuple>
+
+#include <opencv2/dnn.hpp>
+
+
+class Yolo
+{
+public:
+    typedef std::tuple<std::string, float, cv::Rect> Item;
+    
+private:
+    static constexpr float INPUT_WIDTH          = 640.0;
+    static constexpr float INPUT_HEIGHT         = 640.0;
+    static constexpr float SCORE_THRESHOLD      =   0.5;
+    static constexpr float NMS_THRESHOLD        =   0.45;
+    static constexpr float CONFIDENCE_THRESHOLD =   0.45;
+
+ public:
+    const std::vector<std::string> names = {
+	"person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train",
+	"truck", "boat", "traffic light", "fire hydrant", "stop sign",
+	"parking meter", "bench", "bird", "cat", "dog", "horse", "sheep",
+	"cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella",
+	"handbag", "tie", "suitcase", "frisbee", "skis", "snowboard",
+	"sports ball", "kite", "baseball bat", "baseball glove", "skateboard",
+	"surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork",
+	"knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange",
+	"broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair",
+	"sofa", "potted plant", "bed", "dining table", "toilet", "tvmonitor",
+	"laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
+	"oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+	"scissors", "teddy bear", "hair drier", "toothbrush"
+    };
+
+public:
+    Yolo(const std::string& model);
+    void process(cv::Mat &img, std::vector<Item> &items);
+    
+private:
+    cv::dnn::Net net;
+};
+
+#endif

data/ext/yunet.cpp

@@ -0,0 +1,132 @@
+#include <cmath>
+#include <string>
+#include <vector>
+#include <numeric>
+#include <algorithm>
+
+#include <opencv2/dnn.hpp>
+
+#include "yunet.h"
+
+
+YuNet::YuNet(const std::string& model_filename)
+{
+    net = cv::dnn::readNetFromONNX(model_filename);
+    net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
+    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
+}
+
+
+void YuNet::process(const cv::Mat& img, std::vector<YuNet::Face>& faces)
+{
+    /* -- Preparing for image size -- */
+    cv::Size model_size;
+    model_size.width  = MODEL_WIDTH;
+    model_size.height = MODEL_WIDTH * img.rows / img.cols;
+    model_size.height = (model_size.height / 32) * 32;
+
+    std::pair<int32_t, int32_t> feature_map_2th = {
+	(model_size.height + 1) / 2 / 2,
+	(model_size.width  + 1) / 2 / 2
+    };
+
+    std::vector<std::pair<int32_t, int32_t>> feature_map_list;
+    feature_map_list.push_back({ (feature_map_2th.first  + 1) / 2 ,
+	                         (feature_map_2th.second + 1) / 2 });
+
+    for (int32_t i = 0; i < 3; i++) {
+        const auto& previous = feature_map_list.back();
+        feature_map_list.push_back({ (previous.first  + 1) / 2 ,
+		                     (previous.second + 1) / 2 });
+    }
+
+    std::vector<std::vector<float>> prior_list;
+    for (int i = 0; i < static_cast<int32_t>(feature_map_list.size()); i++) {
+        const auto& min_sizes   = MIN_SIZES[i];
+        const auto& feature_map = feature_map_list[i];
+        for (int y = 0; y < feature_map.first; y++) {
+            for (int x = 0; x < feature_map.second; x++) {
+                for (const auto& min_size : min_sizes) {
+                    float s_kx = static_cast<float>(min_size) / model_size.width;
+                    float s_ky = static_cast<float>(min_size) / model_size.height;
+                    float cx = (x + 0.5f) * STEPS[i] / model_size.width;
+                    float cy = (y + 0.5f) * STEPS[i] / model_size.height;
+                    prior_list.push_back({ cx, cy, s_kx, s_ky });
+                }
+            }
+        }
+    }
+
+    
+    /* -- Pre-process -- */
+    cv::Mat blob;
+    cv::dnn::blobFromImage(img, blob, 1.0, model_size);
+        
+    /* -- Inference -- */
+    std::vector<cv::Mat> outputs;
+    net.setInput(blob);
+    net.forward(outputs, { "conf", "iou",  "loc" });
+
+    /* -- Post Process -- */
+    const cv::Mat& mat_conf   = outputs[0];
+    const cv::Mat& mat_iou    = outputs[1];
+    const cv::Mat& mat_loc    = outputs[2];
+    const cv::Size image_size = img.size();    
+
+    // Get score list
+    std::vector<float> cls_score;
+    for (int32_t row = 0; row < mat_conf.rows; row++) {
+        float val = mat_conf.at<float>(cv::Point(1, row));
+        cls_score.push_back(std::clamp(val, 0.0f, 1.0f));
+    }
+
+    std::vector<float> iou_score;
+    for (int32_t row = 0; row < mat_iou.rows; row++) {
+        float val = mat_conf.at<float>(cv::Point(0, row));
+        iou_score.push_back(std::clamp(val, 0.0f, 1.0f));
+    }
+
+    std::vector<float> score;
+    for (int32_t row = 0; row < mat_conf.rows; row++) {
+        score.push_back(std::sqrt(cls_score[row] * iou_score[row]));
+    }
+
+    // All bbox
+    std::vector<cv::Rect> bbox_all;
+    for (int row = 0; row < mat_loc.rows; row++) {
+        float cx = mat_loc.at<float>(cv::Point(0, row));
+        float cy = mat_loc.at<float>(cv::Point(1, row));
+        float w  = mat_loc.at<float>(cv::Point(2, row));
+        float h  = mat_loc.at<float>(cv::Point(3, row));
+
+        cx = prior_list[row][0] + cx * VARIANCES[0] * prior_list[row][2];
+        cy = prior_list[row][1] + cy * VARIANCES[0] * prior_list[row][3];
+        w  = prior_list[row][2] * std::exp(w * VARIANCES[0]);
+        h  = prior_list[row][3] * std::exp(h * VARIANCES[1]);
+
+        bbox_all.push_back({
+		static_cast<int32_t>((cx - w / 2) * image_size.width),
+		static_cast<int32_t>((cy - h / 2) * image_size.height),
+		static_cast<int32_t>(w * image_size.width),
+		static_cast<int32_t>(h * image_size.height) });
+    }
+
+    // Non-Maximum Suppression
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(bbox_all, score, CONF_THRESHOLD, NMS_THRESHOLD, indices);
+
+    // Get valid bbox and landmark
+    faces.clear();
+    for (int idx : indices) {
+        Landmark landmark; // (landmark is 5 points)
+        for (int i = 0; i < static_cast<int>(landmark.size()); i++) {
+	    cv::Point& p = landmark[i];
+            float x      = mat_loc.at<float>(cv::Point(4 + i * 2,     idx));
+            float y      = mat_loc.at<float>(cv::Point(4 + i * 2 + 1, idx));
+            p.x = static_cast<int32_t>((prior_list[idx][0] + x * VARIANCES[0] * prior_list[idx][2]) * image_size.width);
+            p.y = static_cast<int32_t>((prior_list[idx][1] + y * VARIANCES[0] * prior_list[idx][3]) * image_size.height);
+        }
+
+	faces.push_back({ bbox_all[idx], landmark });
+    }
+}