Merge branch 'master' of https://github.com/spmallick/learnopencv

Author: ChetanPatil28

Classification-with-localization-convert-any-keras-classifier-into-a-detector/README.md

@@ -0,0 +1,13 @@
+This folder contains code for Classification With Localization: Convert any keras Classifier to a Detector. You can find the Complete blogpost [here](https://www.learnopencv.com/classification-with-localization/).
+
+Although you can download the code from this section, but you can also use this Ready to run [Colab Notebook](https://colab.research.google.com/drive/1naVE8yU_ryVGvLRxHE_QPR5rjmaVb4ne#scrollTo=wNgVViF5Tz19).
+
+# 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>

Classification-with-localization-convert-any-keras-classifier-into-a-detector/[LearnOpenCV]_Classification_With_Localization_Notebook.ipynb

@@ -0,0 +1,13 @@
+tensorflow==2.3.0
+imgaug==0.2.9
+numpy==1.18.5
+pandas==1.1.3
+opencv-contrib-python==4.1.2.30
+opencv-python==4.1.2.30
+sklearn==0.0
+sklearn-pandas==1.8.0
+scikit-image==0.16.2
+scikit-learn==0.22.2.post1
+scipy==1.4.1
+matplotlib==3.2.2
+urllib3==1.24.3

Classification-with-localization-convert-any-keras-classifier-into-a-detector/requirements.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.1)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+PROJECT(stereo)
+
+find_package( OpenCV REQUIRED )
+
+
+MACRO(add_example name)
+  ADD_EXECUTABLE(${name} ${name}.cpp)
+  TARGET_LINK_LIBRARIES(${name} ${OpenCV_LIBS})
+ENDMACRO()
+
+add_example(stereo)

EpipolarGeometryAndStereoVision/CMakeLists.txt

@@ -0,0 +1,38 @@
+# Introduction to Epipolar Geometry and Stereo Vision
+This folder contains the code for the blog post on [Introduction to Epipolar Geometry and Stereo Vision](https://www.learnopencv.com/introduction-to-epipolar-geometry-and-stereo-vision/). 
+## Compilation
+To compile the `stereo.cpp` code file, use the following:
+```shell
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+```
+
+## Usage
+
+### Using the C++ code
+
+Refer to the following to use the compiled files:
+
+```shell
+./build/stereo
+```
+
+### Using the python code
+
+Refer to the following to use the `stereo.py` file:
+
+```shell
+python3 stereo.py
+```
+
+# 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>

EpipolarGeometryAndStereoVision/README.md

@@ -0,0 +1,41 @@
+#include <opencv2/opencv.hpp>
+#include "opencv2/core/core.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <stdio.h>
+#include <string.h>
+
+int main(int argc, char** argv)
+{
+
+  cv::Mat imgL,imgR;
+  
+  imgL = cv::imread("images/im0.png",0);
+  cv::resize(imgL,imgL,cv::Size(600,600));
+  imgR = cv::imread("images/im1.png",0);
+  cv::resize(imgR,imgR,cv::Size(600,600));
+  
+  int minDisparity = 0;
+  int numDisparities = 64;
+  int blockSize = 8;
+  int disp12MaxDiff = 1;
+  int uniquenessRatio = 10;
+  int speckleWindowSize = 10;
+  int speckleRange = 8;
+
+  cv::Ptr<cv::StereoSGBM> stereo = cv::StereoSGBM::create(minDisparity,numDisparities,blockSize,disp12MaxDiff,uniquenessRatio,speckleWindowSize,speckleRange);
+
+  cv::Mat disp;
+  stereo->compute(imgL,imgR,disp);
+  
+  cv::normalize(disp, disp, 0, 255, cv::NORM_MINMAX, CV_8UC1);  
+  
+  cv::imshow("Left image",imgL);
+  cv::imshow("Right image",imgR);
+  cv::imshow("disparity",disp);
+  cv::waitKey(0);
+
+  return 0;
+}
+

EpipolarGeometryAndStereoVision/images/im0.png

@@ -0,0 +1,47 @@
+from __future__ import print_function
+
+import numpy as np
+import cv2
+
+def main():
+    imgL = cv2.imread("images/im0.png",0)
+    imgL = cv2.resize(imgL,(600,600))
+
+    imgR = cv2.imread("images/im1.png",0)
+    imgR = cv2.resize(imgR,(600,600))
+
+    # Setting parameters for StereoSGBM algorithm
+    minDisparity = 0
+    numDisparities = 64
+    blockSize = 8
+    disp12MaxDiff = 1
+    uniquenessRatio = 10
+    speckleWindowSize = 10
+    speckleRange = 8
+
+    # Creating an object of StereoSGBM algorithm
+    stereo = cv2.StereoSGBM_create(minDisparity = minDisparity,
+        numDisparities = numDisparities,
+        blockSize = blockSize,
+        disp12MaxDiff = disp12MaxDiff,
+        uniquenessRatio = uniquenessRatio,
+        speckleWindowSize = speckleWindowSize,
+        speckleRange = speckleRange
+    )
+
+    # Calculating disparith using the StereoSGBM algorithm
+    disp = stereo.compute(imgL, imgR).astype(np.float32)
+
+    # Calculating disparith using the StereoSGBM algorithm
+    disp = cv2.normalize(disp,0,255,cv2.NORM_MINMAX)
+    
+    # Displaying the disparity map
+    cv2.imshow("disparity",disp)
+    cv2.imshow("left image",imgL)
+    cv2.imshow("right image",imgR)
+    cv2.waitKey(0)
+    
+
+if __name__ == '__main__':
+    main()
+    cv2.destroyAllWindows()

EpipolarGeometryAndStereoVision/images/im1.png

@@ -0,0 +1,93 @@
+# Optical Flow demo
+
+This contains the code for **Optical Flow in OpenCV (C++/Python)** post
+For more information - visit 
+[Optical Flow in OpenCV (C++/Python)](https://www.learnopencv.com/optical-flow-in-opencv)
+
+## Python
+
+### Installation
+
+Before you start the demo of Optical Flow calculation, you need to create a virtual environment in your working
+directory and install the required libraries:
+
+```Shell
+virtualenv -p python3.7 venv
+source venv/bin/activate
+pip install -r reqirements.txt
+```
+
+### Sparse Optical Flow
+
+There is a demo `lucas_kanade.py` script of **Lucas-Kanade** algorithm which can be run with this command:
+
+```
+python3 demo.py --algorithm lucaskanade --video_path videos/car.mp4
+```
+
+### Dense Optical Flow
+
+The wrapper of Dense Optical Flow algorithms `dense_optical_flow.py` can run a couple of OpenCV's algorithm
+implementations:
+
+- To start the **Dense Lucas-Kanade** algorithm:
+  ```
+  python3 demo.py --algorithm lucaskanade_dense --video_path videos/people.mp4
+  ```
+- To start the **Farneback** algorithm:
+  ```
+  python3 demo.py --algorithm farneback --video_path videos/people.mp4
+  ```
+- To start the **RLOF** algorithm:
+  ```
+  python3 demo.py --algorithm rlof --video_path videos/people.mp4
+  ```
+
+## C++
+
+### Installation
+
+Before you start the demo of Optical Flow calculation, you need to build the project:
+
+```Shell
+cd algorithms
+cmake .
+make
+```
+
+### Sparse Optical Flow
+
+There is a demo `lucas_kanade.cpp` script of **Lucas-Kanade** algorithm which can be run with this command:
+
+```
+./OpticalFlow ../videos/car.mp4 lucaskanade
+```
+
+### Dense Optical Flow
+
+The wrapper of Dense Optical Flow algorithms `dense_optical_flow.py` can run a couple of OpenCV's algorithm
+implementations:
+
+- To start the **Dense Lucas-Kanade** algorithm:
+  ```
+  ./OpticalFlow ../videos/car.mp4 lucaskanade_dense
+  ```
+- To start the **Farneback** algorithm:
+  ```
+  ./OpticalFlow ../videos/car.mp4 farneback
+  ```
+- To start the **RLOF** algorithm:
+  ```
+  ./OpticalFlow ../videos/car.mp4 rlof
+  ```
+
+
+# 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>

EpipolarGeometryAndStereoVision/stereo.cpp

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.15)
+project(OpticalFlow)
+find_package( OpenCV REQUIRED )
+set(CMAKE_CXX_STANDARD 14)
+
+add_executable(OpticalFlow main.cpp)
+target_link_libraries( OpticalFlow ${OpenCV_LIBS} )

EpipolarGeometryAndStereoVision/stereo.py

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+
+
+using namespace cv;
+using namespace std;
+
+template <typename Method, typename... Args>
+void dense_optical_flow(string filename, bool save, Method method, bool to_gray, Args&&... args)
+{
+    VideoCapture capture(samples::findFile(filename));
+    if (!capture.isOpened()) {
+        //error in opening the video input
+        cerr << "Unable to open file!" << endl;
+    }
+    Mat frame1, prvs;
+    capture >> frame1;
+    if (to_gray)
+        cvtColor(frame1, prvs, COLOR_BGR2GRAY);
+    else
+        prvs = frame1;
+    int counter = 0;
+    while (true) {
+        Mat frame2, next;
+        capture >> frame2;
+        if (frame2.empty())
+            break;
+        if (to_gray)
+            cvtColor(frame2, next, COLOR_BGR2GRAY);
+        else
+            next = frame2;
+        Mat flow(prvs.size(), CV_32FC2);
+        method(prvs, next, flow, std::forward<Args>(args)...);
+        // visualization
+        Mat flow_parts[2];
+        split(flow, flow_parts);
+        Mat magnitude, angle, magn_norm;
+        cartToPolar(flow_parts[0], flow_parts[1], magnitude, angle, true);
+        normalize(magnitude, magn_norm, 0.0f, 1.0f, NORM_MINMAX);
+        angle *= ((1.f / 360.f) * (180.f / 255.f));
+        //build hsv image
+        Mat _hsv[3], hsv, hsv8, bgr;
+        _hsv[0] = angle;
+        _hsv[1] = Mat::ones(angle.size(), CV_32F);
+        _hsv[2] = magn_norm;
+        merge(_hsv, 3, hsv);
+        hsv.convertTo(hsv8, CV_8U, 255.0);
+        cvtColor(hsv8, bgr, COLOR_HSV2BGR);
+        if (save) {
+            string save_path = "./optical_flow_frames/frame_" + to_string(counter) + ".jpg";
+            imwrite(save_path, bgr);
+        }
+        imshow("frame", frame2);
+        imshow("flow", bgr);
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+        prvs = next;
+        counter++;
+    }
+}
+

Optical-Flow-in-OpenCV/README.md

@@ -0,0 +1,43 @@
+import cv2
+import numpy as np
+
+
+def dense_optical_flow(method, video_path, params=[], to_gray=False):
+    # read the video
+    cap = cv2.VideoCapture(video_path)
+    # Read the first frame
+    ret, old_frame = cap.read()
+
+    # crate HSV & make Value a constant
+    hsv = np.zeros_like(old_frame)
+    hsv[..., 1] = 255
+
+    # Preprocessing for exact method
+    if to_gray:
+        old_frame = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
+
+    while True:
+        # Read the next frame
+        ret, new_frame = cap.read()
+        frame_copy = new_frame
+        if not ret:
+            break
+        # Preprocessing for exact method
+        if to_gray:
+            new_frame = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY)
+        # Calculate Optical Flow
+        flow = method(old_frame, new_frame, None, *params)
+
+        # Encoding: convert the algorithm's output into Polar coordinates
+        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
+        # Use Hue and Saturation to encode the Optical Flow
+        hsv[..., 0] = ang * 180 / np.pi / 2
+        hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
+        # Convert HSV image into BGR for demo
+        bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+        cv2.imshow("frame", frame_copy)
+        cv2.imshow("optical flow", bgr)
+        k = cv2.waitKey(25) & 0xFF
+        if k == 27:
+            break
+        old_frame = new_frame