Merge pull request #247 from simarpreetsingh-019/master

Detecting geometrical shapes using opencv

Author: powerexploit

Image-Processing/Canny Edge Detection/CannyEdgeDetection.py

@@ -0,0 +1,26 @@
+import cv2
+import numpy as np
+
+from matplotlib import pyplot as plt
+
+img = cv2.imread("messi5.jpg", cv2.IMREAD_GRAYSCALE )
+lap = cv2.Laplacian(img, cv2.CV_64F, ksize = 1)
+lap = np.uint8(np.absolute(lap))
+sobelX = cv2.Sobel(img, cv2.CV_64F, 1, 0)
+sobelY = cv2.Sobel(img, cv2.CV_64F, 0, 1)
+canny = cv2.Canny(img, 100, 200)
+
+sobelX = np.uint8(np.absolute(sobelX))
+sobelY = np.uint8(np.absolute(sobelY))
+
+sobelCombined = cv2.bitwise_or(sobelX, sobelY)
+
+titles = ['images','Laplacian', 'SobelX', 'SobelY', 'sobelCombined', 'Canny']
+images = [img, lap, sobelX, sobelY, sobelCombined, canny]
+
+for i in range(6):
+    plt.subplot(2, 3, i+1), plt.imshow(images[i], 'gray')
+    plt.title(titles[i])
+    plt.xticks([]), plt.yticks([])
+
+plt.show()

Image-Processing/Canny Edge Detection/Canny_EdgeDetection_using_math.py

@@ -0,0 +1,138 @@
+from scipy import ndimage
+from scipy.ndimage.filters import convolve
+
+from scipy import misc
+import numpy as np
+
+
+class cannyEdgeDetector:
+    def __init__(self, imgs, sigma=1, kernel_size=5, weak_pixel=75, strong_pixel=255, lowthreshold=0.05,
+                 highthreshold=0.15):
+        self.imgs = imgs
+        self.imgs_final = []
+        self.img_smoothed = None
+        self.gradientMat = None
+        self.thetaMat = None
+        self.nonMaxImg = None
+        self.thresholdImg = None
+        self.weak_pixel = weak_pixel
+        self.strong_pixel = strong_pixel
+        self.sigma = sigma
+        self.kernel_size = kernel_size
+        self.lowThreshold = lowthreshold
+        self.highThreshold = highthreshold
+        return
+
+    def gaussian_kernel(self, size, sigma=1):
+        size = int(size) // 2
+        x, y = np.mgrid[-size:size + 1, -size:size + 1]
+        normal = 1 / (2.0 * np.pi * sigma ** 2)
+        g = np.exp(-((x ** 2 + y ** 2) / (2.0 * sigma ** 2))) * normal
+        return g
+
+    def sobel_filters(self, img):
+        Kx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], np.float32)
+        Ky = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], np.float32)
+
+        Ix = ndimage.filters.convolve(img, Kx)
+        Iy = ndimage.filters.convolve(img, Ky)
+
+        G = np.hypot(Ix, Iy)
+        G = G / G.max() * 255
+        theta = np.arctan2(Iy, Ix)
+        return (G, theta)
+
+    def non_max_suppression(self, img, D):
+        M, N = img.shape
+        Z = np.zeros((M, N), dtype=np.int32)
+        angle = D * 180. / np.pi
+        angle[angle < 0] += 180
+
+        for i in range(1, M - 1):
+            for j in range(1, N - 1):
+                try:
+                    q = 255
+                    r = 255
+
+                    # angle 0
+                    if (0 <= angle[i, j] < 22.5) or (157.5 <= angle[i, j] <= 180):
+                        q = img[i, j + 1]
+                        r = img[i, j - 1]
+                    # angle 45
+                    elif (22.5 <= angle[i, j] < 67.5):
+                        q = img[i + 1, j - 1]
+                        r = img[i - 1, j + 1]
+                    # angle 90
+                    elif (67.5 <= angle[i, j] < 112.5):
+                        q = img[i + 1, j]
+                        r = img[i - 1, j]
+                    # angle 135
+                    elif (112.5 <= angle[i, j] < 157.5):
+                        q = img[i - 1, j - 1]
+                        r = img[i + 1, j + 1]
+
+                    if (img[i, j] >= q) and (img[i, j] >= r):
+                        Z[i, j] = img[i, j]
+                    else:
+                        Z[i, j] = 0
+
+
+                except IndexError as e:
+                    pass
+
+        return Z
+
+    def threshold(self, img):
+
+        highThreshold = img.max() * self.highThreshold;
+        lowThreshold = highThreshold * self.lowThreshold;
+
+        M, N = img.shape
+        res = np.zeros((M, N), dtype=np.int32)
+
+        weak = np.int32(self.weak_pixel)
+        strong = np.int32(self.strong_pixel)
+
+        strong_i, strong_j = np.where(img >= highThreshold)
+        zeros_i, zeros_j = np.where(img < lowThreshold)
+
+        weak_i, weak_j = np.where((img <= highThreshold) & (img >= lowThreshold))
+
+        res[strong_i, strong_j] = strong
+        res[weak_i, weak_j] = weak
+
+        return (res)
+
+    def hysteresis(self, img):
+
+        M, N = img.shape
+        weak = self.weak_pixel
+        strong = self.strong_pixel
+
+        for i in range(1, M - 1):
+            for j in range(1, N - 1):
+                if (img[i, j] == weak):
+                    try:
+                        if ((img[i + 1, j - 1] == strong) or (img[i + 1, j] == strong) or (img[i + 1, j + 1] == strong)
+                                or (img[i, j - 1] == strong) or (img[i, j + 1] == strong)
+                                or (img[i - 1, j - 1] == strong) or (img[i - 1, j] == strong) or (
+                                        img[i - 1, j + 1] == strong)):
+                            img[i, j] = strong
+                        else:
+                            img[i, j] = 0
+                    except IndexError as e:
+                        pass
+
+        return img
+
+    def detect(self):
+        imgs_final = []
+        for i, img in enumerate(self.imgs):
+            self.img_smoothed = convolve(img, self.gaussian_kernel(self.kernel_size, self.sigma))
+            self.gradientMat, self.thetaMat = self.sobel_filters(self.img_smoothed)
+            self.nonMaxImg = self.non_max_suppression(self.gradientMat, self.thetaMat)
+            self.thresholdImg = self.threshold(self.nonMaxImg)
+            img_final = self.hysteresis(self.thresholdImg)
+            self.imgs_final.append(img_final)
+
+        return self.imgs_final

Image-Processing/Canny Edge Detection/Images/glimpse all result.JPG

@@ -0,0 +1,75 @@
+[![forthebadge](https://forthebadge.com/images/badges/made-with-python.svg)](https://forthebadge.com)
+
+# Canny Edge detection using OpenCV and python
+
+<div align="center">
+<img src="https://miro.medium.com/max/700/0*eZT8V5qNeSiXiXBn.png" height=500 width="1000">
+</div>
+
+## What is Canny Edge Detection?
+
+> It is an edge detection operator that uses a multi-stage algorithm to detect a wide range of edges in images.
+  It was developed by John F. Canny ,an Australian computer scientist, back in 1986.
+
+
+
+### _The Canny edge detection algorithm is composed of 5 steps_:
++ Noise reduction;
++ Gradient calculation;
++ Non-maximum suppression;
++ Double threshold;
++ Edge Tracking by Hysteresis.
+
+## Lets see how it's done.
+
+   <div align="center">
+   <img src="Images/pic1.JPG" >
+   </div>
+
+1. ### Input image:  
+    Input in RGB format.  
+    <div align="center">
+    <img src="Images/input image.JPG" width="400">
+    </div>
+
+2. ### Converting the image to grayscale:
+   For easier calculations.  
+   <div align="center">
+   <img src="Images/tograyscale.JPG" width="400">
+   </div>
+
+
+3. ### Smoothing the image:  
+   Smoothing of image for noise reduction. Gradient is the first order derivatives of image for each direction.
+   It is cause of edges that seems more and the edges look thick.  
+   <div align="center">
+   <img src="Images/res1pic1.JPG" width="400">
+   </div>
+        
+4. ### Image gradient:  
+   Gradient is the function of the partial derivatives. I applied to the image convolution process with Sobel filters to obtain this partial derivative.
+   <div align="center">
+   <img src="Images/res3sudoku.JPG" width="400">
+   </div>
+
+5. ### Non-maximum suppression:  
+   In this step the pixel is compared with its two neighbors of the pixel, if the compared pixel is larger than neighbor we do not change the pixel,
+   otherwise, this pixel is not maximum value hence, we set the zero to that pixel.
+
+6. ### Tracking the edge by hysteresis:  
+   In this step we choose two type of threshold, high and low threshold value. Afterward, each pixel of image is compared with two different threshold value.
+   If the pixel is larger than the high threshold, this pixel mark with 255 in the final image.
+   If the pixel between high threshold and low threshold. If the pixel is smaller than low-threshold image, mark as black with 0 (black) value in the resulting image.  
+   
+7. ### Final Results:  
+   After passing all of the mentioned steps, we will give the final result from the method.
+   
+# Output Results:
+
+   <div align="center">
+   <img src="Images/glimpse all result.JPG" >
+   </div>  
+   
+
+## Endnote: 
+### **For more detail on learning Canny Edge Detection and maths behind, see my article** [here](https://medium.com/simply-dev/what-is-canny-edge-detection-cfefa272a8d0)

Image-Processing/Canny Edge Detection/Images/input image.JPG

@@ -0,0 +1,38 @@
+[![forthebadge](https://forthebadge.com/images/badges/made-with-python.svg)](https://forthebadge.com)
+## Detecting Geometrical shapes in an image using OpenCV  
+### What is Contours?
+
+Contours can be explained simply as a curve joining all the continuous points (along the boundary), having the same color or intensity.
+The contours are a useful tool for shape analysis and object detection and recognition.
+
+### Why we discussing about contours?
+We will be using Contours to first find the curving of object, then will be checkin and naming about shape of it depending on sides of object.
+
+## Approach : 
+The approach we would use to detect the shape of a given polygon will be based on classifying the detected shape on the basis of a number of sides it has.
+For example, if the detected polynomial has 3 sides, then it could be considered as a triangle, if the polynomial has 4 sides then it could be classified as a square or a rectangle, and so on.
+
+### Important :  
+Please add the image you want to use this on in the same folder you are saving the code, or else add the whole location.
+
+## Language used : Python
+
+
+## Libraries used: 
+1. OpenCV
+2. Numpy
+
+
+### Input
+
+<div align="center">
+<img src="https://github.com/simarpreetsingh-019/Awesome-Python-Scripts/blob/master/Image-Processing/Detecting%20Contours/shapes.png" width="250">
+</div>
+
+
+### output
+
+<div align="center">
+<img src="https://github.com/simarpreetsingh-019/Awesome-Python-Scripts/blob/master/Image-Processing/Detecting%20Contours/output2.JPG" width="250">
+</div>
+

Image-Processing/Canny Edge Detection/Images/pic1.JPG

@@ -0,0 +1,40 @@
+import numpy as np
+import cv2
+
+img = cv2.imread('shapes.PNG')
+imgGry = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+ret , thrash = cv2.threshold(imgGry, 240 , 255, cv2.CHAIN_APPROX_NONE)
+contours , hierarchy = cv2.findContours(thrash, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+for contour in contours:
+    approx = cv2.approxPolyDP(contour, 0.01* cv2.arcLength(contour, True), True)
+    cv2.drawContours(img, [approx], 0, (0, 0, 0), 5)
+    x = approx.ravel()[0]
+    y = approx.ravel()[1] - 5
+
+    if len(approx) == 3:
+        cv2.putText( img, "Triangle", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0) )
+    elif len(approx) == 4 :
+        x, y , w, h = cv2.boundingRect(approx)
+        aspectRatio = float(w)/h
+        print(aspectRatio)
+        
+        if aspectRatio >= 0.95 and aspectRatio < 1.05:
+            cv2.putText(img, "square", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0))
+            
+        else:
+            cv2.putText(img, "rectangle", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0))
+            
+    elif len(approx) == 5 :
+        cv2.putText(img, "pentagon", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0))
+        
+    elif len(approx) == 10 :
+        cv2.putText(img, "star", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0))
+     
+    else:
+        cv2.putText(img, "circle", (x, y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0))
+
+cv2.imshow('shapes', img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()