Added dexined quantized model for edge detection (#272)

* Added dexined.onnx file

* Added sample, license, example outputs

* Added a seperate wrapper class for supporting functions

* Shifted to Tickmeter, and renamed files to demo.cpp and demo.py

CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.22.2)
+project(opencv_zoo_edge_detection_dexined)
+
+set(OPENCV_VERSION "5.0.0")
+set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
+
+# Find OpenCV
+find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
+
+add_executable(edge_detection edge_detection.cpp)
+target_link_libraries(edge_detection ${OpenCV_LIBS})

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Xavier Soria Poma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,55 @@
+# DexiNed
+
+DexiNed is a Convolutional Neural Network (CNN) architecture for edge detection.
+
+Notes:
+
+- Model source: [ONNX](https://drive.google.com/file/d/1u_qXqXqaIP_SqdGaq4CbZyjzkZb02XTs/view).
+- Model source: [.pth](https://drive.google.com/file/d/1V56vGTsu7GYiQouCIKvTWl5UKCZ6yCNu/view).
+- This ONNX model has fixed input shape, but OpenCV DNN infers on the exact shape of input image. See https://github.com/opencv/opencv_zoo/issues/44 for more information.
+
+## Requirements 
+Install latest OpenCV >=5.0.0 and CMake >= 3.22.2 to get started with.
+
+## Demo
+
+### Python
+
+Run the following command to try the demo:
+
+```shell
+# detect on camera input
+python demo.py
+# detect on an image
+python demo.py --input /path/to/image
+
+# get help regarding various parameters
+python demo.py --help
+```
+
+### C++
+
+```shell
+# A typical and default installation path of OpenCV is /usr/local
+cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
+cmake --build build
+
+# detect on camera input
+./build/demo
+# detect on an image
+./build/demo --input=/path/to/image
+# get help messages
+./build/demo -h
+```
+
+### Example outputs
+
+![chicky](./example_outputs/chicky_output.jpg)
+
+## License
+
+All files in this directory are licensed under [MIT License](./LICENSE).
+
+## Reference
+
+- https://github.com/xavysp/DexiNed

demo.cpp

@@ -0,0 +1,138 @@
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+#include <string>
+#include <cmath>
+#include <vector>
+
+using namespace cv;
+using namespace cv::dnn;
+using namespace std;
+
+class Dexined {
+public:
+    Dexined(const string& modelPath) {
+        loadModel(modelPath);
+    }
+
+    // Function to set up the input image and process it
+    void processFrame(const Mat& image, Mat& result) {
+        Mat blob = blobFromImage(image, 1.0, Size(512, 512), Scalar(103.5, 116.2, 123.6), false, false, CV_32F);
+        net.setInput(blob);
+        applyDexined(image, result);
+    }
+
+private:
+    Net net;
+
+    // Load Model
+    void loadModel(const string modelPath) {
+        net = readNetFromONNX(modelPath);
+        net.setPreferableBackend(DNN_BACKEND_DEFAULT);
+        net.setPreferableTarget(DNN_TARGET_CPU);
+    }
+
+    // Function to apply sigmoid activation
+    static void sigmoid(Mat& input) {
+        exp(-input, input);          // e^-input
+        input = 1.0 / (1.0 + input); // 1 / (1 + e^-input)
+    }
+
+    // Function to process the neural network output to generate edge maps
+    static pair<Mat, Mat> postProcess(const vector<Mat>& output, int height, int width) {
+        vector<Mat> preds;
+        preds.reserve(output.size());
+        for (const Mat &p : output) {
+            Mat img;
+            Mat processed;
+            if (p.dims == 4 && p.size[0] == 1 && p.size[1] == 1) {
+                processed = p.reshape(0, {p.size[2], p.size[3]});
+            } else {
+                processed = p.clone();
+            }
+            sigmoid(processed);
+            normalize(processed, img, 0, 255, NORM_MINMAX, CV_8U);
+            resize(img, img, Size(width, height));
+            preds.push_back(img);
+        }
+        Mat fuse = preds.back();
+        Mat ave = Mat::zeros(height, width, CV_32F);
+        for (Mat &pred : preds) {
+            Mat temp;
+            pred.convertTo(temp, CV_32F);
+            ave += temp;
+        }
+        ave /= static_cast<float>(preds.size());
+        ave.convertTo(ave, CV_8U);
+        return {fuse, ave};
+    }
+
+    // Function to apply the Dexined model
+    void applyDexined(const Mat& image, Mat& result) {
+        int originalWidth = image.cols;
+        int originalHeight = image.rows;
+        vector<Mat> outputs;
+        net.forward(outputs);
+        pair<Mat, Mat> res = postProcess(outputs, originalHeight, originalWidth);
+        result = res.first; // or res.second for average edge map
+    }
+};
+
+int main(int argc, char** argv) {
+    const string about =
+        "This sample demonstrates edge detection with dexined edge detection techniques.\n\n";
+    const string keys =
+        "{ help h          |                                     | Print help message. }"
+        "{ input i         |                                     | Path to input image or video file. Skip this argument to capture frames from a camera.}"
+        "{ model           | edge_detection_dexined_2024sep.onnx | Path to the dexined.onnx model file }";
+
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        cout << about << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    parser = CommandLineParser(argc, argv, keys);
+    string model = parser.get<String>("model");
+    parser.about(about);
+
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(samples::findFile(parser.get<String>("input")));
+    else
+        cap.open(0);
+
+    namedWindow("Input", WINDOW_AUTOSIZE);
+    namedWindow("Output", WINDOW_AUTOSIZE);
+    moveWindow("Output", 200, 0);
+
+    // Create an instance of Dexined
+    Dexined dexined(model);
+    Mat image;
+
+    for (;;){
+        cap >> image;
+        if (image.empty())
+        {
+            cout << "Press any key to exit" << endl;
+            waitKey();
+            break;
+        }
+
+        Mat result;
+        dexined.processFrame(image, result);
+
+        imshow("Input", image);
+        imshow("Output", result);
+        int key = waitKey(1);
+        if (key == 27 || key == 'q')
+        {
+            break;
+        }
+    }
+    destroyAllWindows();
+    return 0;
+}

demo.py

@@ -0,0 +1,51 @@
+import cv2 as cv
+import argparse
+from dexined import Dexined
+
+def get_args_parser(func_args):
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.', default=0, required=False)
+    parser.add_argument('--model', help='Path to dexined.onnx', default='edge_detection_dexined_2024sep.onnx', required=False)
+
+    args, _ = parser.parse_known_args()
+    parser = argparse.ArgumentParser(parents=[parser],
+                                     description='', formatter_class=argparse.RawTextHelpFormatter)
+    return parser.parse_args(func_args)
+
+def main(func_args=None):
+    args = get_args_parser(func_args)
+
+    dexined = Dexined(modelPath=args.model)
+
+    # Open video or capture from camera
+    cap = cv.VideoCapture(cv.samples.findFile(args.input) if args.input else 0)
+    if not cap.isOpened():
+        print("Failed to open the input video")
+        exit(-1)
+        
+    cv.namedWindow('Input', cv.WINDOW_AUTOSIZE)
+    cv.namedWindow('Output', cv.WINDOW_AUTOSIZE)
+    cv.moveWindow('Output', 200, 50)
+
+    # Process frames
+    tm = cv.TickMeter()
+    while cv.waitKey(1) < 0:
+        hasFrame, image = cap.read()
+        if not hasFrame:
+            print("Press any key to exit")
+            cv.waitKey(0)
+            break
+        
+        tm.start()
+        result = dexined.infer(image)
+        tm.stop()
+        label = 'Inference time: {:.2f} ms, FPS: {:.2f}'.format(tm.getTimeMilli(), tm.getFPS())
+
+        cv.imshow("Input", image)
+        cv.putText(result, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255))
+        cv.imshow("Output", result)
+
+    cv.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()

dexined.py

@@ -0,0 +1,50 @@
+import cv2 as cv
+import numpy as np
+
+class Dexined:
+    def __init__(self, modelPath='edge_detection_dexined_2024sep.onnx', backendId=0, targetId=0):
+        self._modelPath = modelPath
+        self._backendId = backendId
+        self._targetId = targetId
+        
+        # Load the model
+        self._model = cv.dnn.readNetFromONNX(self._modelPath)
+        self.setBackendAndTarget(self._backendId, self._targetId)
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self._backendId = backendId
+        self._targetId = targetId
+        self._model.setPreferableBackend(self._backendId)
+        self._model.setPreferableTarget(self._targetId)
+
+    @staticmethod
+    def sigmoid(x):
+        return 1.0 / (1.0 + np.exp(-x))
+
+    def postProcessing(self, output, shape):
+        h, w = shape
+        preds = []
+        for p in output:
+            img = self.sigmoid(p)
+            img = np.squeeze(img)
+            img = cv.normalize(img, None, 0, 255, cv.NORM_MINMAX, cv.CV_8U)
+            img = cv.resize(img, (w, h))
+            preds.append(img)
+        fuse = preds[-1]
+        ave = np.array(preds, dtype=np.float32)
+        ave = np.uint8(np.mean(ave, axis=0))
+        return fuse, ave
+
+    def infer(self, image):
+        inp = cv.dnn.blobFromImage(image, 1.0, (512, 512), (103.5, 116.2, 123.6), swapRB=False, crop=False)
+        self._model.setInput(inp)
+        
+        # Forward pass through the model
+        out = self._model.forward()
+        result, _ = self.postProcessing(out, image.shape[:2])
+
+        return result