Merge pull request justadudewhohacks#464 from bookjan/master

cc: add dnn readNetFromDarknet API

Author: justadudewhohacks

cc/modules/dnn/dnn.cc

@@ -20,10 +20,13 @@ NAN_MODULE_INIT(Dnn::Init) {
   Nan::SetMethod(target, "blobFromImages", BlobFromImages);
   Nan::SetMethod(target, "blobFromImagesAsync", BlobFromImagesAsync);
 #if CV_VERSION_MINOR > 3
+  Nan::SetMethod(target, "readNetFromDarknet", readNetFromDarknet);
+  Nan::SetMethod(target, "readNetFromDarknetAsync", readNetFromDarknetAsync);
   Nan::SetMethod(target, "NMSBoxes", NMSBoxes);
 #endif
 };
 
+
 NAN_METHOD(Dnn::ReadNetFromTensorflow) {
   FF::SyncBinding(
     std::make_shared<DnnBindings::ReadNetFromTensorflowWorker>(),
@@ -89,6 +92,22 @@ NAN_METHOD(Dnn::BlobFromImagesAsync) {
 }
 
 #if CV_VERSION_MINOR > 3
+NAN_METHOD(Dnn::readNetFromDarknet)
+{
+  FF::SyncBinding(
+      std::make_shared<DnnBindings::readNetFromDarknetWorker>(),
+      "readNetFromDarknet",
+      info);
+}
+
+NAN_METHOD(Dnn::readNetFromDarknetAsync)
+{
+  FF::AsyncBinding(
+      std::make_shared<DnnBindings::readNetFromDarknetWorker>(),
+      "readNetFromDarknetAsync",
+      info);
+}
+
 NAN_METHOD(Dnn::NMSBoxes) {
   FF::SyncBinding(
     std::make_shared<DnnBindings::NMSBoxes>(),

cc/modules/dnn/dnn.h

@@ -20,6 +20,8 @@ class Dnn {
   static NAN_METHOD(BlobFromImages);
   static NAN_METHOD(BlobFromImagesAsync);
 #if CV_VERSION_MINOR > 3
+  static NAN_METHOD(readNetFromDarknet);
+  static NAN_METHOD(readNetFromDarknetAsync);
   static NAN_METHOD(NMSBoxes);
 #endif
 };

cc/modules/dnn/dnnBindings.h

@@ -5,16 +5,53 @@
 
 namespace DnnBindings {
 
+#if CV_VERSION_MINOR > 3
+  struct readNetFromDarknetWorker : public CatchCvExceptionWorker{
+  public:
+    std::string cfgFile;
+    std::string darknetModelFile = "";
+
+    cv::dnn::Net net;
+
+    std::string executeCatchCvExceptionWorker() {
+      net = cv::dnn::readNetFromDarknet(cfgFile, darknetModelFile);
+      if (net.empty()) {
+        return std::string("failed to cfgFile: " + cfgFile + ", darknetModelFile: " + darknetModelFile).data();
+      }
+      return "";
+    }
+
+    v8::Local<v8::Value> getReturnValue() {
+      return Net::Converter::wrap(net);
+    }
+
+    bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+          StringConverter::arg(0, &cfgFile, info));
+    }
+
+    bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+          StringConverter::optArg(1, &darknetModelFile, info));
+    }
+  };
+#endif
+
   struct ReadNetFromTensorflowWorker : public CatchCvExceptionWorker {
   public:
     std::string modelFile;
+    std::string configFile = "";
 
     cv::dnn::Net net;
 
     std::string executeCatchCvExceptionWorker() {
+#if CV_VERSION_MINOR > 3
+      net = cv::dnn::readNetFromTensorflow(modelFile, configFile);
+#else
       net = cv::dnn::readNetFromTensorflow(modelFile);
+#endif
       if (net.empty()) {
-        return std::string("failed to load net: " + modelFile).data();
+        return std::string("failed to load net: " + modelFile + "failed to load config: " + configFile).data();
       }
       return "";
     }
@@ -25,7 +62,13 @@ namespace DnnBindings {
 
     bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
       return (
-        StringConverter::arg(0, &modelFile, info)
+          StringConverter::arg(0, &modelFile, info)
+      );
+    }
+
+    bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+          StringConverter::optArg(1, &configFile, info)
       );
     }
   };

examples/dnnDarknetYOLORealTimeObjectDetection.js

@@ -0,0 +1,120 @@
+/**
+ * Please refer to the python version of "YOLO object detection with OpenCV" by Adrian Rosebrock.
+ * For more detail: https://www.pyimagesearch.com/2018/11/12/yolo-object-detection-with-opencv/
+ */
+const fs = require("fs");
+const path = require("path");
+const { cv, drawBlueRect, runVideoDetection } = require("./utils");
+
+if (!cv.xmodules.dnn) {
+  throw new Error("exiting: opencv4nodejs compiled without dnn module");
+}
+
+// replace with path where you unzipped darknet model
+const darknetPath = "../data/dnn/yolo-object-detection";
+
+const cfgFile = path.resolve(darknetPath, "yolov3-tiny.cfg");
+const weightsFile = path.resolve(darknetPath, "yolov3-tiny.weights");
+const labelsFile = path.resolve(darknetPath, "coco.names");
+
+if (
+  !fs.existsSync(weightsFile) ||
+  !fs.existsSync(cfgFile) ||
+  !fs.existsSync(labelsFile)
+) {
+  console.log("could not find darknet model");
+  console.log("download the model from: https://pjreddie.com/darknet/yolo/");
+  throw new Error("exiting");
+}
+
+// set webcam port
+const webcamPort = 0;
+
+const minConfidence = 0.5;
+const nmsThreshold = 0.3;
+
+// read classNames and store them in an array
+const labels = fs
+  .readFileSync(labelsFile)
+  .toString()
+  .split("\n");
+
+// initialize tensorflow darknet model from modelFile
+const net = cv.readNetFromDarknet(cfgFile, weightsFile);
+
+const classifyImg = img => {
+  // object detection model works with 416 x 416 images
+  const size = new cv.Size(416, 416);
+  const vec3 = new cv.Vec(0, 0, 0);
+  const [imgHeight, imgWidth] = img.sizes;
+
+  // network accepts blobs as input
+  const inputBlob = cv.blobFromImage(img, 1 / 255.0, size, vec3, true, true);
+  net.setInput(inputBlob);
+
+  // specify two layers "yolo_16" and "yolo_23"
+  const layerNames = ["yolo_16", "yolo_23"];
+
+  console.time("net.forward");
+  // forward pass input through entire network
+  const layerOutputs = net.forward(layerNames);
+  console.timeEnd("net.forward");
+
+  let boxes = [];
+  let confidences = [];
+  let classIDs = [];
+
+  layerOutputs.forEach(mat => {
+    const output = mat.getDataAsArray();
+    output.forEach(detection => {
+      const scores = detection.slice(5);
+      const classId = scores.indexOf(Math.max(...scores));
+      const confidence = scores[classId];
+
+      if (confidence > minConfidence) {
+        const box = detection.slice(0, 4);
+
+        const centerX = parseInt(box[0] * imgWidth);
+        const centerY = parseInt(box[1] * imgHeight);
+        const width = parseInt(box[2] * imgWidth);
+        const height = parseInt(box[3] * imgHeight);
+
+        const x = parseInt(centerX - width / 2);
+        const y = parseInt(centerY - height / 2);
+
+        boxes.push(new cv.Rect(x, y, width, height));
+        confidences.push(confidence);
+        classIDs.push(classId);
+
+        const indices = cv.NMSBoxes(
+          boxes,
+          confidences,
+          minConfidence,
+          nmsThreshold
+        );
+
+        indices.forEach(i => {
+          const rect = boxes[i];
+          const imgRect = new cv.Rect(rect.x, rect.y, rect.width, rect.height);
+          drawBlueRect(img, imgRect);
+          const text = labels[classIDs[i]];
+          img.putText(
+            text,
+            new cv.Point(rect.x, rect.y + 0.1 * imgHeight),
+            cv.FONT_ITALIC,
+            2,
+            {
+              color: new cv.Vec(255, 0, 0),
+              thickness: 2
+            }
+          );
+          drawBlueRect(img, imgRect);
+        });
+      }
+    });
+  });
+
+  cv.imshow("Darknet YOLO Object Detection", img);
+};
+
+runVideoDetection(webcamPort, classifyImg);

examples/dnnTensorflowObjectDetection.js

@@ -0,0 +1,87 @@
+/**
+ * Please refer to the python version of "ExploreOpencvDnn" by Saumya Shovan Roy.
+ * For more detail: https://github.com/rdeepc/ExploreOpencvDnn
+ */
+const fs = require("fs");
+const path = require("path");
+const classNames = require("./dnnTensorflowObjectDetectionClassNames");
+const { cv, drawBlueRect, runVideoDetection } = require("./utils");
+
+if (!cv.xmodules.dnn) {
+  throw new Error("exiting: opencv4nodejs compiled without dnn module");
+}
+
+// replace with path where you unzipped detection model
+const detectionModelPath = "../data/dnn/tf-detection";
+
+const pbFile = path.resolve(detectionModelPath, "frozen_inference_graph.pb");
+const pbtxtFile = path.resolve(
+  detectionModelPath,
+  "ssd_mobilenet_v2_coco_2018_03_29.pbtxt"
+);
+
+if (!fs.existsSync(pbFile) || !fs.existsSync(pbtxtFile)) {
+  console.log("could not find detection model");
+  console.log(
+    "download the model from: https://github.com/opencv/opencv/wiki/TensorFlow-Object-Detection-API#use-existing-config-file-for-your-model"
+  );
+  throw new Error("exiting");
+}
+
+// set webcam port
+const webcamPort = 0;
+
+// initialize tensorflow darknet model from modelFile
+const net = cv.readNetFromTensorflow(pbFile, pbtxtFile);
+
+const classifyImg = img => {
+  // object detection model works with 300 x 300 images
+  const size = new cv.Size(300, 300);
+  const vec3 = new cv.Vec(0, 0, 0);
+
+  // network accepts blobs as input
+  const inputBlob = cv.blobFromImage(img, 1, size, vec3, true, true);
+  net.setInput(inputBlob);
+
+  console.time("net.forward");
+  // forward pass input through entire network, will return
+  // classification result as 1x1xNxM Mat
+  const outputBlob = net.forward();
+  console.timeEnd("net.forward");
+
+  // get height and width from the image
+  const [imgHeight, imgWidth] = img.sizes;
+  const numRows = outputBlob.sizes.slice(2,3);
+
+  for (let y = 0; y < numRows; y += 1) {
+    const confidence = outputBlob.at([0, 0, y, 2]);
+    if (confidence > 0.5) {
+      const classId = outputBlob.at([0, 0, y, 1]);
+      const className = classNames[classId];
+      const boxX = imgWidth * outputBlob.at([0, 0, y, 3]);
+      const boxY = imgHeight * outputBlob.at([0, 0, y, 4]);
+      const boxWidht = imgWidth * outputBlob.at([0, 0, y, 5]);
+      const boxHeight = imgHeight * outputBlob.at([0, 0, y, 6]);
+      const imgRect = new cv.Rect(boxX, boxY, boxWidht, boxHeight);
+
+      // draw the blue rect for the object
+      drawBlueRect(img, imgRect);
+
+      // put text on the object
+      img.putText(
+        className,
+        new cv.Point(boxX, boxY + 0.1 * imgHeight),
+        cv.FONT_ITALIC,
+        2,
+        {
+          color: new cv.Vec(255, 0, 0),
+          thickness: 2
+        }
+      );
+    }
+  }
+
+  cv.imshow("Temsorflow Object Detection", img);
+};
+
+runVideoDetection(webcamPort, classifyImg);