added code

Author: Pluto8195

binary.py

@@ -0,0 +1,74 @@
+import numpy as np
+import cv2
+
+def getSobel (channel):
+
+    sobelx = cv2.Sobel(channel, cv2.CV_16S, 1, 0, borderType=cv2.BORDER_REPLICATE)
+    sobely = cv2.Sobel(channel, cv2.CV_16S, 0, 1, borderType=cv2.BORDER_REPLICATE)
+    sobel = np.hypot(sobelx, sobely)
+
+    return sobel;
+
+def findSignificantContours (img, sobel_8u):
+    image, contours, heirarchy = cv2.findContours(sobel_8u, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Find level 1 contours
+    level1 = []
+    for i, tupl in enumerate(heirarchy[0]):
+        # Each array is in format (Next, Prev, First child, Parent)
+        # Filter the ones without parent
+        if tupl[3] == -1:
+            tupl = np.insert(tupl, 0, [i])
+            level1.append(tupl)
+
+    # From among them, find the contours with large surface area.
+    significant = []
+    tooSmall = sobel_8u.size * 5 / 100 # If contour isn't covering 5% of total area of image then it probably is too small
+    for tupl in level1:
+        contour = contours[tupl[0]];
+        area = cv2.contourArea(contour)
+        if area > tooSmall:
+            cv2.drawContours(img, [contour], 0, (0,255,0),2, cv2.LINE_AA, maxLevel=1)
+            significant.append([contour, area])
+
+    significant.sort(key=lambda x: x[1])
+    return [x[0] for x in significant];
+
+def segment (path):
+    img = cv2.imread(path)
+
+    blurred = cv2.GaussianBlur(img, (5, 5), 0) # Remove noise
+
+    # Edge operator
+    sobel = np.max( np.array([ getSobel(blurred[:,:, 0]), getSobel(blurred[:,:, 1]), getSobel(blurred[:,:, 2]) ]), axis=0 )
+
+    # Noise reduction trick, from http://sourceforge.net/p/octave/image/ci/default/tree/inst/edge.m#l182
+    mean = np.mean(sobel)
+
+    # Zero any values less than mean. This reduces a lot of noise.
+    sobel[sobel <= mean] = 0;
+    sobel[sobel > 255] = 255;
+
+    cv2.imwrite('output/edge.png', sobel);
+
+    sobel_8u = np.asarray(sobel, np.uint8)
+
+    # Find contours
+    significant = findSignificantContours(img, sobel_8u)
+
+    # Mask
+    mask = sobel.copy()
+    mask[mask > 0] = 0
+    cv2.fillPoly(mask, significant, 255)
+    # Invert mask
+    mask = np.logical_not(mask)
+
+    #Finally remove the background
+    img[mask] = 0;
+
+    fname = path.split('/')[-1]
+    cv2.imwrite('output/' + fname, img);
+    print (path)
+
+
+segment('original-small.jpg')

bit.jpg

@@ -0,0 +1,101 @@
+import numpy as np
+import cv2
+from matplotlib import pyplot as plt
+
+def auto_canny(image, sigma=0.33):
+	# compute the median of the single channel pixel intensities
+	v = np.median(image)
+ 
+	# apply automatic Canny edge detection using the computed median
+	lower = int(max(0, (1.0 - sigma) * v))
+	upper = int(min(255, (1.0 + sigma) * v))
+	edged = cv2.Canny(image, lower, upper)
+ 
+	# return the edged image
+	return edged
+
+
+
+
+def thresh_callback(thresh, blur, img):
+    # edges = cv2.Canny(blur,thresh,thresh*2)
+    # wide = cv2.Canny(blurred, 10, 200)
+    edges = cv2.Canny(blur, 200, 250)
+    minLineLength = 0
+    maxLineGap = 0
+    lines = cv2.HoughLines(edges,1,np.pi/180, 16)
+
+    for line in lines:
+      for r,theta in line:
+        a = np.cos(theta)
+        b = np.sin(theta)
+        x0 = a*r
+        y0 = b*r
+        x1 = int(x0 + 1000*(-b))
+        y1 = int(y0 + 1000*(a))
+        x2 = int(x0 - 1000*(-b))
+        y2 = int(y0 - 1000*(a))
+        cv2.line(img,(x1,y1), (x2,y2), (0,0,255),2)
+    # drawing = np.zeros(img.shape,np.uint8)     # Image to draw the contours
+    # image, contours, hierarchy =   cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+    # for cnt in contours:
+    #     color = np.random.randint(0,255,(3)).tolist()  # Select a random color
+    #     cv2.drawContours(drawing,[cnt],0,color,2)
+    #     # cv2.imshow('output',drawing)
+    # # cv2.imwrite('img.jpg', drawing)
+    return img,edges
+
+
+def main():
+	img = cv2.pyrDown(cv2.pyrDown(cv2.imread('bit3.jpg')))
+
+	height, width, channels = img.shape
+
+	middle = width/2
+	lm = width*.4
+	rm = width-(width*.4)
+
+	leftmid = int(lm)
+	rightmid = int(rm)
+	inc = rightmid-leftmid
+	nextinc = inc
+	var = []
+	crop_img = img[0:height, leftmid:rightmid]
+
+	height, width, channels = crop_img.shape
+	previnc = 0
+	
+
+	thresh = 100
+	for x in range(0,4):
+		newcrop = crop_img[previnc:nextinc, 0:width]
+		gray = cv2.cvtColor(newcrop,cv2.COLOR_BGR2GRAY)
+		blur = cv2.GaussianBlur(gray,(5,5),0)
+		out,edges = thresh_callback(thresh, blur, newcrop)
+		cv2.imwrite('croped'+str(x)+'.jpg',newcrop)
+
+		previnc += inc
+		nextinc += inc
+		plt.subplot(240+x+1)
+		plt.imshow(cv2.cvtColor(out, cv2.COLOR_BGR2RGB))
+		plt.subplot(240+x+5)
+		plt.imshow(edges, cmap = 'gray')
+		cv2.imwrite('edges'+str(x)+'.jpg',edges)
+		cv2.imwrite('lines'+str(x)+'.jpg',out)
+		var = np.append(var,[out])
+
+	plt.show()
+
+
+  # max_thresh = 255
+
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+
+
+

bit2.jpg

@@ -0,0 +1,98 @@
+import numpy as np
+import cv2
+from matplotlib import pyplot as plt
+
+def auto_canny(image, sigma=0.33):
+	# compute the median of the single channel pixel intensities
+	v = np.median(image)
+ 
+	# apply automatic Canny edge detection using the computed median
+	lower = int(max(0, (1.0 - sigma) * v))
+	upper = int(min(255, (1.0 + sigma) * v))
+	edged = cv2.Canny(image, lower, upper)
+ 
+	# return the edged image
+	return edged
+
+
+
+
+def thresh_callback(thresh, blur, img):
+    # edges = cv2.Canny(blur,thresh,thresh*2)
+    # wide = cv2.Canny(blurred, 10, 200)
+    edges = cv2.Canny(blur, 200, 250)
+    minLineLength = 100
+    maxLineGap = 10
+    lines = cv2.HoughLines(edges,1,np.pi/180, 25)
+ 
+
+    for line in lines:
+      for r,theta in line:
+        a = np.cos(theta)
+        b = np.sin(theta)
+        x0 = a*r
+        y0 = b*r
+        x1 = int(x0 + 1000*(-b))
+        y1 = int(y0 + 1000*(a))
+        x2 = int(x0 - 1000*(-b))
+        y2 = int(y0 - 1000*(a))
+        cv2.line(img,(x1,y1), (x2,y2), (0,0,255),2)
+    # drawing = np.zeros(img.shape,np.uint8)     # Image to draw the contours
+    # image, contours, hierarchy =   cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+    # for cnt in contours:
+    #     color = np.random.randint(0,255,(3)).tolist()  # Select a random color
+    #     cv2.drawContours(drawing,[cnt],0,color,2)
+    #     # cv2.imshow('output',drawing)
+    # # cv2.imwrite('img.jpg', drawing)
+    return img,edges
+
+
+def main():
+	img = cv2.pyrDown(cv2.pyrDown(cv2.imread('bit3.jpg')))
+
+	height, width, channels = img.shape
+
+	middle = width/2
+	lm = width*.4
+	rm = width-(width*.4)
+
+	leftmid = int(lm)
+	rightmid = int(rm)
+	inc = rightmid-leftmid
+	nextinc = inc
+	var = []
+	crop_img = img[0:height, leftmid:rightmid]
+
+	height, width, channels = crop_img.shape
+	previnc = 0
+	
+
+	thresh = 100
+	for x in range(0,4):
+		newcrop = crop_img[previnc:nextinc, 0:width]
+		gray = cv2.cvtColor(newcrop,cv2.COLOR_BGR2GRAY)
+		blur = cv2.GaussianBlur(gray,(5,5),0)
+		out,edges = thresh_callback(thresh, blur, newcrop)
+		previnc += inc
+		nextinc += inc
+		plt.subplot(240+x+1)
+		plt.imshow(cv2.cvtColor(out, cv2.COLOR_BGR2RGB))
+		plt.subplot(240+x+5)
+		plt.imshow(edges, cmap = 'gray')
+		var = np.append(var,[out])
+
+	plt.show()
+
+
+  # max_thresh = 255
+
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+
+
+