contour detection blog folder added

Contour-Detection-using-OpenCV/README.md

@@ -0,0 +1,79 @@
+# README
+
+
+
+## Directory Structure
+
+**All the code files and folders follow the following structure.**
+
+```
+├── CPP
+│   ├── channel_experiments
+│   │   ├── channel_experiments.cpp
+│   │   └── CMakeLists.txt
+│   ├── contour_approximations
+│   │   ├── CMakeLists.txt
+│   │   └── contour_approx.cpp
+│   └── contour_extraction
+│       ├── CMakeLists.txt
+│       └── contour_extraction.cpp
+├── input
+│   ├── custom_colors.jpg
+│   ├── image_1.jpg
+│   └── image_2.jpg
+├── python
+│   ├── channel_experiments
+│   │   └── channel_experiments.py
+│   ├── contour_approximations
+│   │   └── contour_approx.py
+│   └── contour_extraction
+│       └── contour_extraction.py
+└── README.md
+```
+
+
+
+## Instructions
+
+### Python
+
+To run the code in Python, please go into the `python` folder and execute the Python scripts in each of the respective sub-folders.
+
+### C++
+
+To run the code in C++, please go into the `cpp` folder, then go into each of the respective sub-folders and follow the steps below:
+
+```
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+cd ..
+./build/channel_experiments
+```
+
+```
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+cd ..
+./build/contour_approximations
+```
+
+```
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+cd ..
+./build/contour_extraction
+```
+
+
+
+# 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.
+
+[![img](https://camo.githubusercontent.com/18c5719ef10afe9607af3e87e990068c942ae4cba8bd4d72d21950d6213ea97e/68747470733a2f2f7777772e6c6561726e6f70656e63762e636f6d2f77702d636f6e74656e742f75706c6f6164732f323032302f30342f41492d436f75727365732d42792d4f70656e43562d4769746875622e706e67)](https://opencv.org/courses/)

Contour-Detection-using-OpenCV/cpp/.vscode/settings.json

@@ -0,0 +1,48 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "typeinfo": "cpp",
+        "bit": "cpp"
+    }
+}

Contour-Detection-using-OpenCV/cpp/channel_experiments/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.0.0)
+project(channel_experiments VERSION 0.1.0)
+
+include(CTest)
+enable_testing()
+
+find_package(OpenCV REQUIRED)
+find_package(Threads REQUIRED)
+
+add_executable(channel_experiments channel_experiments.cpp)
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX__STANDARD_REQUIRED ON)
+
+include_directories(${OpenCV_INCLUDE_DIRS})
+target_link_libraries(channel_experiments ${OpenCV_LIBS} ${CMAKE_THREAD_LIBS_INIT})

Contour-Detection-using-OpenCV/cpp/channel_experiments/channel_experiments.cpp

@@ -0,0 +1,50 @@
+#include<opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main() {
+    // read the image
+    Mat image = imread("../../input/image_1.jpg");
+
+    // B, G, R channel splitting
+    Mat channels[3];
+    split(image, channels);
+
+    // detect contours using blue channel and without thresholding
+    vector<vector<Point>> contours1;
+    vector<Vec4i> hierarchy1;
+    findContours(channels[0], contours1, hierarchy1, RETR_TREE, CHAIN_APPROX_NONE);
+    // draw contours on the original image
+    Mat image_contour_blue = image.clone();
+    drawContours(image_contour_blue, contours1, -1, Scalar(0, 255, 0), 2);
+    imshow("Contour detection using blue channels only", image_contour_blue);
+    waitKey(0);
+    imwrite("blue_channel.jpg", image_contour_blue);
+    destroyAllWindows();
+
+    // detect contours using green channel and without thresholding
+    vector<vector<Point>> contours2;
+    vector<Vec4i> hierarchy2;
+    findContours(channels[1], contours2, hierarchy2, RETR_TREE, CHAIN_APPROX_NONE);
+    // draw contours on the original image
+    Mat image_contour_green = image.clone();
+    drawContours(image_contour_green, contours2, -1, Scalar(0, 255, 0), 2);
+    imshow("Contour detection using green channels only", image_contour_green);
+    waitKey(0);
+    imwrite("green_channel.jpg", image_contour_green);
+    destroyAllWindows();
+
+    // detect contours using red channel and without thresholding
+    vector<vector<Point>> contours3;
+    vector<Vec4i> hierarchy3;
+    findContours(channels[2], contours3, hierarchy3, RETR_TREE, CHAIN_APPROX_NONE);
+    // draw contours on the original image
+    Mat image_contour_red = image.clone();
+    drawContours(image_contour_red, contours3, -1, Scalar(0, 255, 0), 2);
+    imshow("Contour detection using red channels only", image_contour_red);
+    waitKey(0);
+    imwrite("red_channel.jpg", image_contour_red);
+    destroyAllWindows();
+}

Contour-Detection-using-OpenCV/cpp/contour_approximations/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.0.0)
+project(contour_approximations VERSION 0.1.0)
+
+include(CTest)
+enable_testing()
+
+
+find_package(OpenCV REQUIRED)
+find_package(Threads REQUIRED)
+
+add_executable(contour_approximations contour_approx.cpp)
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX__STANDARD_REQUIRED ON)
+
+include_directories(${OpenCV_INCLUDE_DIRS})
+target_link_libraries(contour_approximations ${OpenCV_LIBS} ${CMAKE_THREAD_LIBS_INIT})

Contour-Detection-using-OpenCV/cpp/contour_approximations/contour_approx.cpp

@@ -0,0 +1,73 @@
+#include<opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main() {
+    // read the image
+    Mat image = imread("../../input/image_1.jpg");
+    // convert the image to grayscale format
+    Mat img_gray;
+    cvtColor(image, img_gray, COLOR_BGR2GRAY);
+    // apply binary thresholding
+    Mat thresh;
+    threshold(img_gray, thresh, 150, 255, THRESH_BINARY);
+    imshow("Binary mage", thresh);
+    waitKey(0);
+    imwrite("image_thres1.jpg", thresh);
+    destroyAllWindows();
+
+    // detect the contours on the binary image using cv2.CHAIN_APPROX_NONE
+    vector<vector<Point>> contours;
+    vector<Vec4i> hierarchy;
+    findContours(thresh, contours, hierarchy, RETR_TREE, CHAIN_APPROX_NONE);
+    // draw contours on the original image
+    Mat image_copy = image.clone();
+    drawContours(image_copy, contours, -1, Scalar(0, 255, 0), 2);
+    imshow("None approximation", image_copy);
+    waitKey(0);
+    imwrite("contours_none_image1.jpg", image_copy);
+    destroyAllWindows();
+
+
+    // Now let's try with CHAIN_APPROX_SIMPLE`
+    // detect the contours on the binary image using cv2.CHAIN_APPROX_NONE
+    vector<vector<Point>> contours1;
+    vector<Vec4i> hierarchy1;
+    findContours(thresh, contours1, hierarchy1, RETR_TREE, CHAIN_APPROX_SIMPLE);
+    // draw contours on the original image
+    Mat image_copy1 = image.clone();
+    drawContours(image_copy1, contours1, -1, Scalar(0, 255, 0), 2);
+    imshow("Simple approximation", image_copy1);
+    waitKey(0);
+    imwrite("contours_simple_image1.jpg", image_copy1);
+    destroyAllWindows();
+
+    // using a proper image for visualizing CHAIN_APPROX_SIMPLE
+    Mat image1 = imread("../../input/image_2.jpg");
+    Mat img_gray1;
+    cvtColor(image1, img_gray1, COLOR_BGR2GRAY);
+    Mat thresh1;
+    threshold(img_gray1, thresh1, 150, 255, THRESH_BINARY);
+    vector<vector<Point>> contours2;
+    vector<Vec4i> hierarchy2;
+    findContours(thresh1, contours2, hierarchy2, RETR_TREE, CHAIN_APPROX_NONE);
+    Mat image_copy2 = image1.clone();
+    drawContours(image_copy2, contours2, -1, Scalar(0, 255, 0), 2);
+    imshow("None approximation", image_copy2);
+    waitKey(0);
+    imwrite("contours_none_image1.jpg", image_copy2);
+    destroyAllWindows();
+    Mat image_copy3 = image1.clone();
+    for(int i=0; i<contours2.size(); i=i+1){
+        for (int j=0; j<contours2[i].size(); j=j+1){
+            circle(image_copy3, (contours2[i][0], contours2[i][1]), 2, 
+            Scalar(0, 255, 0), 2);
+        }
+    }
+    imshow("CHAIN_APPROX_SIMPLE Point only", image_copy3);
+    waitKey(0);
+    imwrite("contour_point_simple.jpg", image_copy3);
+    destroyAllWindows();
+}

Contour-Detection-using-OpenCV/cpp/contour_extraction/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.0.0)
+project(contour_extraction VERSION 0.1.0)
+
+include(CTest)
+enable_testing()
+
+find_package(OpenCV REQUIRED)
+find_package(Threads REQUIRED)
+
+add_executable(contour_extraction contour_extraction.cpp)
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX__STANDARD_REQUIRED ON)
+
+include_directories(${OpenCV_INCLUDE_DIRS})
+target_link_libraries(contour_extraction ${OpenCV_LIBS} ${CMAKE_THREAD_LIBS_INIT})

Contour-Detection-using-OpenCV/cpp/contour_extraction/contour_extraction.cpp

@@ -0,0 +1,57 @@
+#include<opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main() {
+    /*
+    Contour detection and drawing using different extraction modes to complement 
+    the understanding of hierarchies
+    */
+    Mat image2 = imread("../../input/custom_colors.jpg");
+    Mat img_gray2;
+    cvtColor(image2, img_gray2, COLOR_BGR2GRAY);
+    Mat thresh2;
+    threshold(img_gray2, thresh2, 150, 255, THRESH_BINARY);
+
+    vector<vector<Point>> contours3;
+    vector<Vec4i> hierarchy3;
+    findContours(thresh2, contours3, hierarchy3, RETR_LIST, CHAIN_APPROX_NONE);
+    Mat image_copy4 = image2.clone();
+    drawContours(image_copy4, contours3, -1, Scalar(0, 255, 0), 2);
+    imshow("LIST", image_copy4);
+    waitKey(0);
+    imwrite("contours_retr_list.jpg", image_copy4);
+    destroyAllWindows();
+
+    vector<vector<Point>> contours4;
+    vector<Vec4i> hierarchy4;
+    findContours(thresh2, contours4, hierarchy4, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+    Mat image_copy5 = image2.clone();
+    drawContours(image_copy5, contours4, -1, Scalar(0, 255, 0), 2);
+    imshow("EXTERNAL", image_copy5);
+    waitKey(0);
+    imwrite("contours_retr_external.jpg", image_copy4);
+    destroyAllWindows();
+
+    vector<vector<Point>> contours5;
+    vector<Vec4i> hierarchy5;
+    findContours(thresh2, contours5, hierarchy5, RETR_CCOMP, CHAIN_APPROX_NONE);
+    Mat image_copy6 = image2.clone();
+    drawContours(image_copy6, contours5, -1, Scalar(0, 255, 0), 2);
+    imshow("EXTERNAL", image_copy6);
+    waitKey(0);
+    imwrite("contours_retr_ccomp.jpg", image_copy6);
+    destroyAllWindows();
+
+    vector<vector<Point>> contours6;
+    vector<Vec4i> hierarchy6;
+    findContours(thresh2, contours6, hierarchy6, RETR_TREE, CHAIN_APPROX_NONE);
+    Mat image_copy7 = image2.clone();
+    drawContours(image_copy7, contours6, -1, Scalar(0, 255, 0), 2);
+    imshow("EXTERNAL", image_copy7);
+    waitKey(0);
+    imwrite("contours_retr_tree.jpg", image_copy7);
+    destroyAllWindows();
+}