opencv DNN Windows instructions

OpenCV-dnn-gpu-support-Windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+PROJECT(openPose)
+
+find_package( OpenCV REQUIRED )
+
+include_directories( ${OpenCV_INCLUDE_DIRS})
+
+MACRO(add_example name)
+  ADD_EXECUTABLE(${name} ${name}.cpp)
+  TARGET_LINK_LIBRARIES(${name} ${OpenCV_LIBS})
+ENDMACRO()
+
+add_example(OpenPoseVideo)

OpenCV-dnn-gpu-support-Windows/OpenPoseVideo.cpp

@@ -0,0 +1,163 @@
+#include <opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+using namespace cv::dnn;
+
+#define MPI
+
+#ifdef MPI
+const int POSE_PAIRS[14][2] = 
+{   
+    {0,1}, {1,2}, {2,3},
+    {3,4}, {1,5}, {5,6},
+    {6,7}, {1,14}, {14,8}, {8,9},
+    {9,10}, {14,11}, {11,12}, {12,13}
+};
+
+string protoFile = "pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt";
+string weightsFile = "pose/mpi/pose_iter_160000.caffemodel";
+
+int nPoints = 15;
+#endif
+
+#ifdef COCO
+const int POSE_PAIRS[17][2] = 
+{   
+    {1,2}, {1,5}, {2,3},
+    {3,4}, {5,6}, {6,7},
+    {1,8}, {8,9}, {9,10},
+    {1,11}, {11,12}, {12,13},
+    {1,0}, {0,14},
+    {14,16}, {0,15}, {15,17}
+};
+
+string protoFile = "pose/coco/pose_deploy_linevec.prototxt";
+string weightsFile = "pose/coco/pose_iter_440000.caffemodel";
+
+int nPoints = 18;
+#endif
+
+int main(int argc, char **argv)
+{
+
+    cout << "USAGE : ./OpenPose <videoFile> " << endl;
+    cout << "USAGE : ./OpenPose <videoFile> <device>" << endl;
+
+    string device = "cpu";
+    string videoFile = "sample_video.mp4";
+
+    // Take arguments from commmand line
+    if (argc == 2)
+    {
+        if((string)argv[1] == "gpu")
+            device = "gpu";
+        else
+            videoFile = argv[1];
+    }
+    else if (argc == 3)
+    {
+        videoFile = argv[1];
+        if((string)argv[2] == "gpu")
+            device = "gpu";
+    }
+
+    int inWidth = 368;
+    int inHeight = 368;
+    float thresh = 0.01;
+
+    cv::VideoCapture cap(videoFile);
+
+    if (!cap.isOpened())
+    {
+        cerr << "Unable to connect to camera" << endl;
+        return 1;
+    }
+
+    Mat frame, frameCopy;
+    int frameWidth = cap.get(CAP_PROP_FRAME_WIDTH);
+    int frameHeight = cap.get(CAP_PROP_FRAME_HEIGHT);
+
+    VideoWriter video("Output-Skeleton.avi",VideoWriter::fourcc('M','J','P','G'), 10, Size(frameWidth,frameHeight));
+
+    Net net = readNetFromCaffe(protoFile, weightsFile);
+
+    if (device == "cpu")
+    {
+        cout << "Using CPU device" << endl;
+        net.setPreferableBackend(DNN_TARGET_CPU);
+    }
+    else if (device == "gpu")
+    {
+        cout << "Using GPU device" << endl;
+        net.setPreferableBackend(DNN_BACKEND_CUDA);
+        net.setPreferableTarget(DNN_TARGET_CUDA);
+    }
+
+    double t=0;
+    while( waitKey(1) < 0)
+    {
+        double t = (double) cv::getTickCount();
+
+        cap >> frame;
+        frameCopy = frame.clone();
+        Mat inpBlob = blobFromImage(frame, 1.0 / 255, Size(inWidth, inHeight), Scalar(0, 0, 0), false, false);
+
+        net.setInput(inpBlob);
+
+        Mat output = net.forward();
+
+        int H = output.size[2];
+        int W = output.size[3];
+
+        // find the position of the body parts
+        vector<Point> points(nPoints);
+        for (int n=0; n < nPoints; n++)
+        {
+            // Probability map of corresponding body's part.
+            Mat probMap(H, W, CV_32F, output.ptr(0,n));
+
+            Point2f p(-1,-1);
+            Point maxLoc;
+            double prob;
+            minMaxLoc(probMap, 0, &prob, 0, &maxLoc);
+            if (prob > thresh)
+            {
+                p = maxLoc;
+                p.x *= (float)frameWidth / W ;
+                p.y *= (float)frameHeight / H ;
+
+                circle(frameCopy, cv::Point((int)p.x, (int)p.y), 8, Scalar(0,255,255), -1);
+                cv::putText(frameCopy, cv::format("%d", n), cv::Point((int)p.x, (int)p.y), cv::FONT_HERSHEY_COMPLEX, 1.1, cv::Scalar(0, 0, 255), 2);
+            }
+            points[n] = p;
+        }
+
+        int nPairs = sizeof(POSE_PAIRS)/sizeof(POSE_PAIRS[0]);
+
+        for (int n = 0; n < nPairs; n++)
+        {
+            // lookup 2 connected body/hand parts
+            Point2f partA = points[POSE_PAIRS[n][0]];
+            Point2f partB = points[POSE_PAIRS[n][1]];
+
+            if (partA.x<=0 || partA.y<=0 || partB.x<=0 || partB.y<=0)
+                continue;
+
+            line(frame, partA, partB, Scalar(0,255,255), 8);
+            circle(frame, partA, 8, Scalar(0,0,255), -1);
+            circle(frame, partB, 8, Scalar(0,0,255), -1);
+        }
+
+        t = ((double)cv::getTickCount() - t)/cv::getTickFrequency();
+        cv::putText(frame, cv::format("time taken = %.3f sec", t), cv::Point(50, 50), cv::FONT_HERSHEY_COMPLEX, .8, cv::Scalar(255, 50, 0), 2);
+        imshow("Output-Skeleton", frame);
+        video.write(frame);
+    }
+    // When everything done, release the video capture and write object
+    cap.release();
+    video.release();
+
+    return 0;
+}

OpenCV-dnn-gpu-support-Windows/OpenPoseVideo.py

@@ -0,0 +1,103 @@
+import cv2
+import time
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Run keypoint detection')
+parser.add_argument("--device", default="cpu", help="Device to inference on")
+parser.add_argument("--video_file", default="sample_video.mp4", help="Input Video")
+
+args = parser.parse_args()
+
+MODE = "MPI"
+
+if MODE == "COCO":
+    protoFile = "pose/coco/pose_deploy_linevec.prototxt"
+    weightsFile = "pose/coco/pose_iter_440000.caffemodel"
+    nPoints = 18
+    POSE_PAIRS = [ [1,0],[1,2],[1,5],[2,3],[3,4],[5,6],[6,7],[1,8],[8,9],[9,10],[1,11],[11,12],[12,13],[0,14],[0,15],[14,16],[15,17]]
+
+elif MODE == "MPI" :
+    protoFile = "pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt"
+    weightsFile = "pose/mpi/pose_iter_160000.caffemodel"
+    nPoints = 15
+    POSE_PAIRS = [[0,1], [1,2], [2,3], [3,4], [1,5], [5,6], [6,7], [1,14], [14,8], [8,9], [9,10], [14,11], [11,12], [12,13] ]
+
+
+inWidth = 368
+inHeight = 368
+threshold = 0.1
+
+
+input_source = args.video_file
+cap = cv2.VideoCapture(input_source)
+hasFrame, frame = cap.read()
+
+vid_writer = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 10, (frame.shape[1],frame.shape[0]))
+
+net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
+if args.device == "cpu":
+    net.setPreferableBackend(cv2.dnn.DNN_TARGET_CPU)
+    print("Using CPU device")
+elif args.device == "gpu":
+    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
+    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
+    print("Using GPU device")
+
+while cv2.waitKey(1) < 0:
+    t = time.time()
+    hasFrame, frame = cap.read()
+    frameCopy = np.copy(frame)
+    if not hasFrame:
+        cv2.waitKey()
+        break
+
+    frameWidth = frame.shape[1]
+    frameHeight = frame.shape[0]
+
+    inpBlob = cv2.dnn.blobFromImage(frame, 1.0 / 255, (inWidth, inHeight),
+                              (0, 0, 0), swapRB=False, crop=False)
+    net.setInput(inpBlob)
+    output = net.forward()
+
+    H = output.shape[2]
+    W = output.shape[3]
+    # Empty list to store the detected keypoints
+    points = []
+
+    for i in range(nPoints):
+        # confidence map of corresponding body's part.
+        probMap = output[0, i, :, :]
+
+        # Find global maxima of the probMap.
+        minVal, prob, minLoc, point = cv2.minMaxLoc(probMap)
+
+        # Scale the point to fit on the original image
+        x = (frameWidth * point[0]) / W
+        y = (frameHeight * point[1]) / H
+
+        if prob > threshold : 
+            cv2.circle(frameCopy, (int(x), int(y)), 8, (0, 255, 255), thickness=-1, lineType=cv2.FILLED)
+            cv2.putText(frameCopy, "{}".format(i), (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, lineType=cv2.LINE_AA)
+
+            # Add the point to the list if the probability is greater than the threshold
+            points.append((int(x), int(y)))
+        else :
+            points.append(None)
+
+    # Draw Skeleton
+    for pair in POSE_PAIRS:
+        partA = pair[0]
+        partB = pair[1]
+
+        if points[partA] and points[partB]:
+            cv2.line(frame, points[partA], points[partB], (0, 255, 255), 3, lineType=cv2.LINE_AA)
+            cv2.circle(frame, points[partA], 8, (0, 0, 255), thickness=-1, lineType=cv2.FILLED)
+            cv2.circle(frame, points[partB], 8, (0, 0, 255), thickness=-1, lineType=cv2.FILLED)
+
+    cv2.putText(frame, "time taken = {:.3f} sec".format(time.time() - t), (50, 50), cv2.FONT_HERSHEY_COMPLEX, .8, (255, 50, 0), 2, lineType=cv2.LINE_AA)
+    cv2.imshow('Output-Skeleton', frame)
+
+    vid_writer.write(frame)
+
+vid_writer.release()

OpenCV-dnn-gpu-support-Windows/README.md

@@ -0,0 +1,37 @@
+# Code for How to use OpenCV DNN Module with Nvidia GPU on Windows
+
+This repository contains the code for [How to use OpenCV DNN Module with Nvidia GPU on Windows](https://www.learnopencv.com/how-to-use-opencv-dnn-module-with-nvidia-gpu-on-windows)
+
+## Models
+Download models from
+
+COCO : https://www.dropbox.com/s/2h2bv29a130sgrk/pose_iter_440000.caffemodel?dl=0
+
+MPI : https://www.dropbox.com/s/drumc6dzllfed16/pose_iter_160000.caffemodel?dl=0"
+
+## Run Code:
+
+### C++
+```
+mkdir build
+cd build
+cmake -G "Visual Studio 16 2019" ..
+cmake --build . --config Release
+cd ..
+./build/Release/OpenPoseVideo <input_file> <gpu/cpu>
+```
+
+### Python
+```
+python OpenPoseVideo.py --device=<cpu/gpu> 
+```
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start. 
+
+<a href="https://opencv.org/courses/">
+<p align="center"> 
+<img src="https://www.learnopencv.com/wp-content/uploads/2020/04/AI-Courses-By-OpenCV-Github.png">
+</p>
+</a>

OpenCV-dnn-gpu-support-Windows/getModels.sh

@@ -0,0 +1,13 @@
+# ------------------------- POSE MODELS -------------------------
+
+
+# Downloading the pose-model trained on COCO
+COCO_POSE_URL="https://www.dropbox.com/s/2h2bv29a130sgrk/pose_iter_440000.caffemodel"
+COCO_FOLDER="pose/coco/"
+wget -c ${COCO_POSE_URL} -P ${COCO_FOLDER}
+
+# Downloading the pose-model trained on MPI
+MPI_POSE_URL="https://www.dropbox.com/s/drumc6dzllfed16/pose_iter_160000.caffemodel"
+MPI_FOLDER="pose/mpi/"
+wget -c ${MPI_POSE_URL} -P ${MPI_FOLDER}
+