improve

Author: Hank-Tsou

.DS_Store

@@ -0,0 +1,99 @@
+# Hough Line Transform
+"Hough Transform" is a method to detect any shape with a mathematical shape equation, here describe how hough transform work with line detection.
+
+* Provide Hough Line Transform implement from scatch. [(Code)]
+
+## Outline
+- Hough Line Transform
+- Probabilistic Hough Line Transform
+
+## Step of the process
+* (1) Find edges from the source image
+* (2) Generate a matrix by 'theta' and 'rho'
+* (3) Convert (x, y) Coordinate System to (theta, rho) Coordinate System
+* (4) Use threshold to select the Line
+
+### Step 1. Find edges from the source image
+
+* Read image and convert to grayscale using cv2.cvtColor().
+* Get edge image by using Canny Edge Detection, cv2.Canny().
+
+![](README_IMG/step1.png)
+
+### Step 2. Generate a matrix by "theta" and "rho"
+
+* General line equation: y = ax+b
+* Hough Line Transform use another line representation: x * cos(theta)+y * sin(theta) = rho
+
+![](README_IMG/step2.png)
+
+### Step 3. Convert (x, y) Coordinate System to (theta, rho) Coordinate System
+Calculate (theta, rho) for each edge pixel (x, y) then add 1 to the matrix (theta, rho).
+
+![](README_IMG/step3.png)
+
+### Step 4. Use threshold to select the Line
+Get the several high value in matrix then use that 'theta' and 'rho' value to draw the line.
+
+```python
+a = np.cos(theta)   x0 = a * rho
+b = np.sin(theta)   y0 = b * rho
+
+x1 = int(x0 + 1000*(-b))
+y1 = int(y0 + 1000*(a))
+x2 = int(x0 - 1000*(-b))
+y2 = int(y0 - 1000*(a))
+
+Line: (x1, y1), (x2, y2)
+```
+
+### Useful link:
+
+- [Changing Colorspace](https://github.com/Hank-Tsou/Computer-Vision-OpenCV-Python/tree/master/tutorials/Image_Processing/1_Changing_colorspace)
+- [Canny Edge Detection](https://github.com/Hank-Tsou/Computer-Vision-OpenCV-Python/tree/master/tutorials/Image_Processing/6_Canny_Edge_Detection)
+- [Youtube: How Hough Transform works](https://www.youtube.com/watch?v=4zHbI-fFIlI)
+
+## Hough Line Transform
+```
+- File name: Hough_Line_Transform.py
+- Input image: pool.jpg
+- Command Line: python Hough_Line_Transform.py -i pool.jpg
+```
+
+* Main Function: lines = cv2.HoughLines(src_img, rho, theta, threshold)
+```python
+* rho: Distance resolution of the accumulator in pixels.
+* theta: Angle resolution of the accumulator in radians. (np.pi/180)
+* threshold: Accumulator threshold, line selection.
+```
+```
+Draw Line: cv2.line(src_img, (x1,y1), (x2,y2), Color, thickness)
+```
+## Probabilistic Hough Line Transform
+Probabilistic Hough Transform is an optimization of Hough Transform we saw. It doesn’t take all the points into consideration, instead take only a random subset of points and that is sufficient for line detection.  --(OpenCV-Python documentation)
+
+* Main Function: lines = cv2.HoughLinesP(image, rho, theta, threshold, minLineLength, maxLineGap)
+```python
+* minLineLength: Minimum line length. Line segments shorter than that are rejected.
+* maxLineGap: Maximum allowed gap between points on the same line to link them.
+```
+```
+NOTE: This method returns the two endpoints of lines. HoughLines() only return the parameters of lines.
+```
+
+![](README_IMG/line.png)
+
+## Code
+- [Hough Line Transform](https://github.com/Hank-Tsou/Computer-Vision-OpenCV-Python/tree/master/tutorials/Image_Processing/11_Hough_Line_Transform)
+
+## Improvements
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
+
+## Reference & Acknowledgments
+
+* OpenCV-Python Tutorial: https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html
+* (Hough Line) https://docs.opencv.org/2.4/modules/imgproc/doc/feature_detection.html?highlight=houghlines
+* (Draw Line) https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html

tutorials/.DS_Store

@@ -0,0 +1,74 @@
+
+#------------------------------------#
+# Author: Yueh-Lin Tsou              #
+# Update: 7/25/2019                  #
+# E-mail: [email protected]    #
+#------------------------------------#
+
+"""-----------------------------------------
+Improve hough line transform on pool table
+------------------------------------------"""
+"""
+Improvement: Use color range to select the target, function table_selection()
+"""
+
+import numpy as np # use numpy library as np for array object
+import cv2 # opencv-python
+
+# segment the pool table used color information
+def table_selection(image):
+    boundary = [ ([60, 60, 0], [190, 150, 55])] # color boundary for the pool table
+
+    # create NumPy arrays from the boundary
+    for (lower, upper) in boundary:
+    	lower = np.array(lower, dtype = "uint8")
+    	upper = np.array(upper, dtype = "uint8")
+
+    	mask = cv2.inRange(image, lower, upper) # create the mask for the selected region
+    	result = cv2.bitwise_and(image, image, mask = mask) # remain only the pool table
+
+    return result # return table selection
+
+# Canny Edge Detection
+def edge_detection(image):
+    gray = cv2.cvtColor(table_img, cv2.COLOR_BGR2GRAY) # convert image in to grayscale
+    gray = cv2.GaussianBlur(gray,(3, 3),0) # use gaussian blur
+    edged = cv2.Canny(gray,50,150,apertureSize = 3) # Canny Edge Detection
+    return edged # return edge image
+
+# Hough Lines Detection (with "cv2.HoughLines")
+def hough_line(image, edge_img):
+    # Call function "cv2.HoughLines" and adjust the parameter for the function
+    line = cv2.HoughLines(edge_img,rho=2,theta=np.pi/180, threshold=170)
+
+    # calsulate the line point use "theta" and "rho" value
+
+    # Parameters ---------------------------------------------#
+    # rho – Distance resolution of the accumulator in pixels. #
+    # theta – Angle resolution of the accumulator in radians. #
+    #---------------------------------------------------------#
+
+    for i in range(len(line)): # calculate points for each line and draw the four lines
+        for rho,theta in line[i]:
+            a, b = np.cos(theta), np.sin(theta)              # calculate slop scale
+            x, y = a*rho, b*rho                            # calculate one point (x0, y0) on the line
+            x1, y1 = int(x + 600*(-b)), int(y + 600*(a))   # calculate two end points of the line
+            x2, y2 = int(x - 1500*(-b)), int(y - 1500*(a)) # calculate two end points of the line
+
+            cv2.line(image,(x1,y1),(x2,y2),(0,255,255),1) # draw line on the image
+
+    return image # return image with four lines for the pool table
+
+
+# -------------------------- main -------------------------- #
+if __name__ == '__main__':
+    # command >> python table_color.py
+
+    image = cv2.imread('pool.jpg') # read image
+    table_img = table_selection(image) # segment the pool table used color information
+    edge_img = edge_detection(table_img) # Canny Edge Detection
+    HL_line_img = hough_line(image, edge_img) # Hough Lines Detection
+
+     # show result image
+    cv2.imshow("images", HL_line_img)
+    cv2.waitKey(0) # system pause, press esc to exit

tutorials/Image_Processing/.DS_Store

@@ -0,0 +1,92 @@
+
+#------------------------------------#
+# Author: Yueh-Lin Tsou              #
+# Update: 7/25/2019                  #
+# E-mail: [email protected]    #
+#------------------------------------#
+
+"""-----------------------------------------
+Improve hough line transform on pool tabke
+------------------------------------------"""
+"""
+Improvement: Use target mask to select the target, function table_selection(), largest_contours()
+"""
+
+import numpy as np # use numpy library as np for array object
+import cv2 # opencv-python
+
+# segment the pool table used color information
+def table_selection(ts_image):
+    boundaries = [ ([60, 60, 0], [190, 150, 35])] # color boundary for the pool table
+
+    # create NumPy arrays from the boundary
+    for (lower, upper) in boundaries:
+    	lower = np.array(lower, dtype = "uint8")
+    	upper = np.array(upper, dtype = "uint8")
+
+    	ts_mask = cv2.inRange(ts_image, lower, upper) # create the mask for the selected region
+    	result = cv2.bitwise_and(ts_image, ts_image, mask = ts_mask) # remain only the pool table
+
+    return result, ts_mask # return table selection and mask
+
+# Canny Edge Detection
+def edge_detection(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # convert image in to grayscale
+    gray = cv2.GaussianBlur(gray,(3, 3),0) # use gaussian blur
+    edged = cv2.Canny(gray,50,150,apertureSize = 3) # Canny Edge Detection
+    return edged # return edge image
+
+# Hough Lines Detection (with "cv2.HoughLines")
+def hough_line(image, edge_img):
+    # Call function "cv2.HoughLines" and adjust the parameter for the function
+    line = cv2.HoughLines(edge_img,rho=2,theta=np.pi/180, threshold=150)
+    p, q, r = line.shape
+    # calsulate the line point use "theta" and "rho" value
+
+    # Parameters ---------------------------------------------#
+    # rho – Distance resolution of the accumulator in pixels. #
+    # theta – Angle resolution of the accumulator in radians. #
+    #---------------------------------------------------------#
+
+    for i in range(p): # calculate points for each line and draw the four lines
+        for rho,theta in line[i]:
+            a, b = np.cos(theta), np.sin(theta)              # calculate slop scale
+            x, y = a*rho, b*rho                            # calculate one point (x0, y0) on the line
+            x1, y1 = int(x + 600*(-b)), int(y + 600*(a))   # calculate two end points of the line
+            x2, y2 = int(x - 1500*(-b)), int(y - 1500*(a)) # calculate two end points of the line
+
+            cv2.line(image,(x1,y1),(x2,y2),(0,255,255),1) # draw line on the image
+
+    return image # return image with four lines for the pool table
+
+# select the largest pool table
+def largest_contours(ori_image, lc_image, lc_mask):
+    ret,thresh = cv2.threshold(lc_mask, 40, 255, 0) # convert the mask image into black and white
+
+    # find contours
+    im,contours,hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+
+    if len(contours) != 0: # if has contour
+        c = max(contours, key = cv2.contourArea) # find the largest contour area
+
+    mask = np.zeros(ori_image.shape, dtype='uint8') # create a empty mask
+    mask = cv2.drawContours(mask, [c], -1, (225,225,225), -1) # create a mask for the largest pool table
+
+    gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY) # convert the mask into grayscale
+    output = cv2.bitwise_and(ori_image, ori_image, mask=gray) #create the image only the largest pool table
+
+    return output, mask # return the largest pool table image and it's mask
+
+# -------------------------- main -------------------------- #
+if __name__ == '__main__':
+    # command >> python table_mask.py
+
+    ori_image = cv2.imread('pool.jpg') # read image
+    table_img, table_img_mask = table_selection(ori_image) # segment the pool table used color information
+    seg_obj, obj_mask = largest_contours(ori_image, table_img, table_img_mask) # slect the largest pool table
+    edge_img = edge_detection(seg_obj) # Canny Edge Detection
+    line_img = hough_line(ori_image, edge_img) # Hough Lines Detection
+
+    # show result image
+    cv2.imshow("images", line_img)
+    cv2.waitKey(0) # system pause, press esc to exit