Mar 10, 2021: 1st commit

Author: dassein

Ostu/ostu_example.py

@@ -1,25 +1,25 @@
-import cv2   
-import numpy as np   
-from matplotlib import pyplot as plt 
-
-img = cv2.imread('img.png',0)
-ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
-ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
-blur = cv2.GaussianBlur(img,(5,5),0)
-ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
-
-titles = ['orgianl Noisy Image','Histogram','Global Threshold(v=127)',
-          'orgianl Noisy Image','Histogram',"Otsu's THresholding",
-          'Guassian filtered Image','Histogram',"Otsu's Thresholding"]
-images = [img,0,th1,
-          img,0,th2,
-          blur,0,th3]
-
-for i in range(3):
-    plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
-    plt.title(titles[i*3]),plt.xticks([]),plt.yticks([])
-    plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)
-    plt.title(titles[i*3+1]),plt.xticks([]),plt.yticks([])
-    plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
-    plt.title(titles[i*3+2]),plt.xticks([]),plt.yticks([])
+import cv2   
+import numpy as np   
+from matplotlib import pyplot as plt 
+
+img = cv2.imread('img.png',0)
+ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
+blur = cv2.GaussianBlur(img,(5,5),0)
+ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
+
+titles = ['orgianl Noisy Image','Histogram','Global Threshold(v=127)',
+          'orgianl Noisy Image','Histogram',"Otsu's THresholding",
+          'Guassian filtered Image','Histogram',"Otsu's Thresholding"]
+images = [img,0,th1,
+          img,0,th2,
+          blur,0,th3]
+
+for i in range(3):
+    plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
+    plt.title(titles[i*3]),plt.xticks([]),plt.yticks([])
+    plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)
+    plt.title(titles[i*3+1]),plt.xticks([]),plt.yticks([])
+    plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
+    plt.title(titles[i*3+2]),plt.xticks([]),plt.yticks([])
 plt.show()

README.md

@@ -1,7 +1,7 @@
-# image_processing_algo
-
-In the project, we implemented the image processing methods
-* chap3_image_transform spatial_filter  
-auto-contrast, histogram matching, spatial filters such as Gauss, Laplace, LoG, the weighted median
-* chap4_freq_filter  
-2d DFT, 2d DCT based on FFT, filters in the frequency domain
+# image_processing_algo
+
+In the project, we implemented the image processing methods
+* chap3_image_transform spatial_filter  
+auto-contrast, histogram matching, spatial filters such as Gauss, Laplace, LoG, the weighted median
+* chap4_freq_filter  
+2d DFT, 2d DCT based on FFT, filters in the frequency domain

harris_corner/Corner_Detection.py

@@ -1,141 +1,141 @@
-# 1st version written by Shivam Chourey
-# Zhankun corrected the definition of Sobel operators, and changed the "CornerStrengthThreshold"
-# Implementation of Harris Corner detection algorithm
-# This algoruthm is very useful in corner detection and is used in a number of applications
-# It's also used in algorithms like FAST and ORB(which uses FAST and BREIF)
-
-import numpy as np
-import cv2
-
-
-
-# Kernel operation using input operator of size 3*3
-def GetSobel(image, Sobel, width, height):
-    # Initialize the matrix
-    I_d = np.zeros((width, height), np.float32)
-
-    # For every pixel in the image
-    for rows in range(width):
-        for cols in range(height):
-            # Run the Sobel kernel for each pixel
-            if rows >= 1 or rows <= width-2 and cols >= 1 or cols <= height-2:
-                for ind in range(3):
-                    for ite in range(3):
-                        I_d[rows][cols] += Sobel[ind][ite] * image[rows - ind - 1][cols - ite - 1]
-            else:
-                I_d[rows][cols] = image[rows][cols]
-
-    return I_d
-
-
-# Method implements the Harris Corner Detection algorithm
-def HarrisCornerDetection(image):
-
-    # The two Sobel operators - for x and y direction
-    SobelX = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
-    SobelY = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
-
-    w, h = image.shape
-
-    # X and Y derivative of image using Sobel operator
-    ImgX = GetSobel(image, SobelX, w, h)
-    ImgY = GetSobel(image, SobelY, w, h)
-
-    # # Eliminate the negative values
-    # There are multiple ways this can be done
-    # 1. Off setting with a positive value (commented out below)
-    # 2. Setting negative values to Zero (commented out)
-    # 3. Multiply by -1 (implemented below, found most reliable method)
-    # ImgX += 128.0
-    # ImgY += 128.0
-    for ind1 in range(w):
-        for ind2 in range(h):
-            if ImgY[ind1][ind2] < 0:
-                ImgY[ind1][ind2] *= -1
-                # ImgY[ind1][ind2] = 0
-            if ImgX[ind1][ind2] < 0:
-                ImgX[ind1][ind2] *= -1
-                # ImgX[ind1][ind2] = 0
-
-    # # Display the output results after Sobel operations
-    # cv2.imshow("SobelX", ImgX)
-    # cv2.imshow("SobelY", ImgY)
-
-    ImgX_2 = np.square(ImgX)
-    ImgY_2 = np.square(ImgY)
-
-    ImgXY = np.multiply(ImgX, ImgY)
-    ImgYX = np.multiply(ImgY, ImgX)
-
-    #Use Gaussian Blur
-    Sigma = 1.4
-    kernelsize = (3, 3)
-
-    ImgX_2 = cv2.GaussianBlur(ImgX_2, kernelsize, Sigma)
-    ImgY_2 = cv2.GaussianBlur(ImgY_2, kernelsize, Sigma)
-    ImgXY = cv2.GaussianBlur(ImgXY, kernelsize, Sigma)
-    ImgYX = cv2.GaussianBlur(ImgYX, kernelsize, Sigma)
-    # print(ImgXY.shape, ImgYX.shape)
-
-    alpha = 0.06
-    R = np.zeros((w, h), np.float32)
-    # For every pixel find the corner strength
-    for row in range(w):
-        for col in range(h):
-            M_bar = np.array([[ImgX_2[row][col], ImgXY[row][col]], [ImgYX[row][col], ImgY_2[row][col]]])
-            R[row][col] = np.linalg.det(M_bar) - (alpha * np.square(np.trace(M_bar)))
-    return R
-
-if __name__ == "__main__":
-    #### Main Program ####
-    firstimagename = "checkerboard.png"
-
-    # Get the first image
-    bgr = cv2.imread(firstimagename)
-    firstimage = cv2.cvtColor(bgr, cv2.COLOR_RGB2GRAY)
-    w, h = firstimage.shape
-
-    # Covert image to color to draw colored circles on it
-    bgr = cv2.cvtColor(firstimage, cv2.COLOR_GRAY2RGB)
-
-    # Corner detection
-    R = HarrisCornerDetection(firstimage)
-
-    # Empirical Parameter
-    # This parameter will need tuning based on the use-case
-    CornerStrengthThreshold = 20000
-
-    # Plot detected corners on image
-    radius = 1
-    color = (0, 255, 0)  # Green
-    thickness = 1
-
-    PointList = []
-    # Look for Corner strengths above the threshold
-    for row in range(w):
-        for col in range(h):
-            if R[row][col] > CornerStrengthThreshold:
-                # print(R[row][col])
-                max = R[row][col]
-
-                # Local non-maxima suppression
-                skip = False
-                for nrow in range(5):
-                    for ncol in range(5):
-                        if row + nrow - 2 < w and col + ncol - 2 < h:
-                            if R[row + nrow - 2][col + ncol - 2] > max:
-                                skip = True
-                                break
-
-                if not skip:
-                    # Point is expressed in x, y which is col, row
-                    cv2.circle(bgr, (col, row), radius, color, thickness)
-                    PointList.append((row, col))
-
-    # Display image indicating corners and save it
-    cv2.imshow("Corners", bgr)
-    outname = "Output_" + str(CornerStrengthThreshold) + ".png"
-    cv2.imwrite(outname, bgr)
-
-    cv2.waitKey(0)
-    cv2.destroyAllWindows()
+# 1st version written by Shivam Chourey
+# Zhankun corrected the definition of Sobel operators, and changed the "CornerStrengthThreshold"
+# Implementation of Harris Corner detection algorithm
+# This algoruthm is very useful in corner detection and is used in a number of applications
+# It's also used in algorithms like FAST and ORB(which uses FAST and BREIF)
+
+import numpy as np
+import cv2
+
+
+
+# Kernel operation using input operator of size 3*3
+def GetSobel(image, Sobel, width, height):
+    # Initialize the matrix
+    I_d = np.zeros((width, height), np.float32)
+
+    # For every pixel in the image
+    for rows in range(width):
+        for cols in range(height):
+            # Run the Sobel kernel for each pixel
+            if rows >= 1 or rows <= width-2 and cols >= 1 or cols <= height-2:
+                for ind in range(3):
+                    for ite in range(3):
+                        I_d[rows][cols] += Sobel[ind][ite] * image[rows - ind - 1][cols - ite - 1]
+            else:
+                I_d[rows][cols] = image[rows][cols]
+
+    return I_d
+
+
+# Method implements the Harris Corner Detection algorithm
+def HarrisCornerDetection(image):
+
+    # The two Sobel operators - for x and y direction
+    SobelX = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
+    SobelY = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
+
+    w, h = image.shape
+
+    # X and Y derivative of image using Sobel operator
+    ImgX = GetSobel(image, SobelX, w, h)
+    ImgY = GetSobel(image, SobelY, w, h)
+
+    # # Eliminate the negative values
+    # There are multiple ways this can be done
+    # 1. Off setting with a positive value (commented out below)
+    # 2. Setting negative values to Zero (commented out)
+    # 3. Multiply by -1 (implemented below, found most reliable method)
+    # ImgX += 128.0
+    # ImgY += 128.0
+    for ind1 in range(w):
+        for ind2 in range(h):
+            if ImgY[ind1][ind2] < 0:
+                ImgY[ind1][ind2] *= -1
+                # ImgY[ind1][ind2] = 0
+            if ImgX[ind1][ind2] < 0:
+                ImgX[ind1][ind2] *= -1
+                # ImgX[ind1][ind2] = 0
+
+    # # Display the output results after Sobel operations
+    # cv2.imshow("SobelX", ImgX)
+    # cv2.imshow("SobelY", ImgY)
+
+    ImgX_2 = np.square(ImgX)
+    ImgY_2 = np.square(ImgY)
+
+    ImgXY = np.multiply(ImgX, ImgY)
+    ImgYX = np.multiply(ImgY, ImgX)
+
+    #Use Gaussian Blur
+    Sigma = 1.4
+    kernelsize = (3, 3)
+
+    ImgX_2 = cv2.GaussianBlur(ImgX_2, kernelsize, Sigma)
+    ImgY_2 = cv2.GaussianBlur(ImgY_2, kernelsize, Sigma)
+    ImgXY = cv2.GaussianBlur(ImgXY, kernelsize, Sigma)
+    ImgYX = cv2.GaussianBlur(ImgYX, kernelsize, Sigma)
+    # print(ImgXY.shape, ImgYX.shape)
+
+    alpha = 0.06
+    R = np.zeros((w, h), np.float32)
+    # For every pixel find the corner strength
+    for row in range(w):
+        for col in range(h):
+            M_bar = np.array([[ImgX_2[row][col], ImgXY[row][col]], [ImgYX[row][col], ImgY_2[row][col]]])
+            R[row][col] = np.linalg.det(M_bar) - (alpha * np.square(np.trace(M_bar)))
+    return R
+
+if __name__ == "__main__":
+    #### Main Program ####
+    firstimagename = "checkerboard.png"
+
+    # Get the first image
+    bgr = cv2.imread(firstimagename)
+    firstimage = cv2.cvtColor(bgr, cv2.COLOR_RGB2GRAY)
+    w, h = firstimage.shape
+
+    # Covert image to color to draw colored circles on it
+    bgr = cv2.cvtColor(firstimage, cv2.COLOR_GRAY2RGB)
+
+    # Corner detection
+    R = HarrisCornerDetection(firstimage)
+
+    # Empirical Parameter
+    # This parameter will need tuning based on the use-case
+    CornerStrengthThreshold = 20000
+
+    # Plot detected corners on image
+    radius = 1
+    color = (0, 255, 0)  # Green
+    thickness = 1
+
+    PointList = []
+    # Look for Corner strengths above the threshold
+    for row in range(w):
+        for col in range(h):
+            if R[row][col] > CornerStrengthThreshold:
+                # print(R[row][col])
+                max = R[row][col]
+
+                # Local non-maxima suppression
+                skip = False
+                for nrow in range(5):
+                    for ncol in range(5):
+                        if row + nrow - 2 < w and col + ncol - 2 < h:
+                            if R[row + nrow - 2][col + ncol - 2] > max:
+                                skip = True
+                                break
+
+                if not skip:
+                    # Point is expressed in x, y which is col, row
+                    cv2.circle(bgr, (col, row), radius, color, thickness)
+                    PointList.append((row, col))
+
+    # Display image indicating corners and save it
+    cv2.imshow("Corners", bgr)
+    outname = "Output_" + str(CornerStrengthThreshold) + ".png"
+    cv2.imwrite(outname, bgr)
+
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()

sift/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 2.8)
+project(extract_contour)
+
+# set(CMAKE_BUILD_TYPE Release)
+# set(CMAKE_CXX_FLAGS "-std=c++14 -O3")
+# list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
+
+# OpenCV
+find_package(OpenCV REQUIRED)
+# include_directories(${OpenCV_INCLUDE_DIRS}) # we can use this statement as well
+include_directories(OpenCV_INCLUDE_DIRS)
+
+add_executable(sift sift.cpp)
+target_link_libraries(sift ${OpenCV_LIBS})
+set( CMAKE_INSTALL_BINDIR "${CMAKE_SOURCE_DIR}/bin/")
+install(TARGETS sift
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+add_executable(surf surf.cpp)
+target_link_libraries(surf ${OpenCV_LIBS})
+set( CMAKE_INSTALL_BINDIR "${CMAKE_SOURCE_DIR}/bin/")
+install(TARGETS surf
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+
+# commands for compile to "./build"" folder, and install to "./bin" folder:
+# mkdir build
+# cd ./build
+# cmake ..
+# make 
+# make install