Add files via upload

Author: mmtaksuu

AddNoise.py

@@ -0,0 +1,42 @@
+# We will add salt & pepper noise on an image. 
+# Noises are unwanted signals.
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+
+def main():
+
+	img_path = "D:\\Dataset\\4.1.03.tiff"
+	img = cv2.imread(img_path, 1) # takes img as bgr
+	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+	rows, columns, channels = img.shape # returns 3 values which is about the given image.
+	p = 0.02 # If we reduce this value, noises will become less than before on the image.
+	output = np.zeros(img.shape, dtype = np.uint8)  
+	
+	print(rows)     # output will be : 256
+	print(columns)  # output will be : 256
+	print(channels) # output will be : 3
+
+	for i in range(rows):
+		for j in range(columns):
+			r = random.random() # creates a random value is named r 
+			if r < p/2:
+				output[i][j] = [0, 0, 0] #pepper noise sprinkles as 0
+			elif r < p:
+				output[i][j] = [255, 255, 255] #salt noise sprinkles as 1
+			else:
+				output[i][j] = img[i][j]
+
+	plt.imshow(output)
+	plt.title('Image with "Salt & Pepper" Noise')
+	plt.show()
+
+	#cv2.imshow('Result', img)
+	#cv2.waitKey(0)
+	#cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+		main()	

HoughLine.py

@@ -0,0 +1,50 @@
+#HIGH PASS FILTERS can perform these actions:
+# edge detection --> using Hough Line Transform
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def main():
+
+	windowName = 'Hough Line Transform Method'
+
+	cap = cv2.VideoCapture(0)
+
+	if cap.isOpened():
+		ret, frame = cap.read()
+	else:
+		ret = False	
+
+	while ret:
+		
+		ret, frame = cap.read()
+		
+		gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+		edges = cv2.Canny(gray, 50, 250, apertureSize=3, L2gradient=True)
+
+		lines = cv2.HoughLines(edges, 1, np.pi/180, 150)
+		
+		if lines is not None:
+			for rho, theta in lines[0]:
+				a = np.cos(theta)
+				b = np.sin(theta)
+				x0 = a*rho
+				y0 = b*rho
+				pts1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a)))
+				pts2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))
+				cv2.line(frame, pts1, pts2, (0, 255, 0), 3)
+
+		cv2.imshow(windowName, frame)
+
+		if cv2.waitKey(1)==27:  # Exit on ESC
+			break
+
+	cap.release()	
+	cv2.destroyAllWindows()
+		
+
+if __name__ == '__main__':
+	main()
+

ImgSegment06.py

@@ -0,0 +1,96 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+def main():
+	
+	path = "C:\\Users\\enesa\\Documents\\MATLAB\\blobs_objects.jpg"
+
+	img = cv2.imread(path, 1)
+	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+	
+	filter1 = np.array(([0, -1, 0], [-1, 5, -1], [0, -1, 0]), np.float32) #Sharpening Filter
+	output = cv2.filter2D(img, -1, filter1) #convolution filter
+
+	blur = cv2.GaussianBlur(img,(5,5),0)
+
+	gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
+	
+	_, thresh = cv2.threshold(gray,170,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
+
+###########################################################################################################################
+
+	# Create a simple filter. The kernel slides through the image (as in 2D convolution).
+	kernel = np.ones((3, 3), np.uint8) 
+
+	# Create a Rectangular Structuring Element
+	se1 = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
+
+	# Create a Elliptical Structuring Element
+	se2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
+		 
+	# Apply Erosion method over the image with kernel
+	erosion = cv2.erode(thresh,se1,iterations = 1)
+
+	# Apply Dilation method over the image with kernel
+	dilation = cv2.dilate(thresh,se2,iterations = 1)
+
+	# Noise removal using Morphological closing operation
+	closing = cv2.morphologyEx(dilation, cv2.MORPH_CLOSE, kernel, iterations = 4) 
+
+	# Noise removal using Morphological opening operation
+	opening = cv2.morphologyEx(erosion, cv2.MORPH_OPEN, kernel, iterations = 1)
+
+###########################################################################################################################
+	
+	dilation = 255 - dilation # Complementing Operation
+	
+	_, contours, _ = cv2.findContours(dilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+	print("{} Objects have detected!".format(len(contours))) 
+	
+	original = cv2.imread(path, 1)
+	
+	original = cv2.cvtColor(original, cv2.COLOR_BGR2RGB)
+
+	sayac = 0
+	for i in contours:
+		# perimeter = cv2.arcLength(i,True)
+		# if perimeter > 20:
+		sayac = sayac +1
+			#cv2.drawContours(img, contours, -1, (0, 0, 255), 2)
+		x,y,w,h = cv2.boundingRect(i)
+		cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
+		cv2.putText(img, str(sayac), (x+10, y+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+		
+		#plt.plot(cx, cy, color='red', marker='o', linestyle='dashed', linewidth=2, markersize=12)  # belilenen noktaya x isareti koy.
+		#cv2.putText(img, 'x', (cx, cy), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)
+		#cv2.putText(closing, str(sayac), (cx, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 1)
+
+	print("{} Objects have drown!".format(sayac))
+	
+###########################################################################################################################
+	# output = [original, img]
+	# titles = ['Original', 'Contours']
+	
+	
+	# for i in range(2):
+	# 	plt.subplot(1, 2, i+1)
+	# 	plt.imshow(output[i])
+	# 	plt.title(titles[i])
+	# 	plt.xticks([])
+	# 	plt.yticks([])
+
+	cv2.imshow('Orignal Image', img)
+	#cv2.imshow('Erosion Image', erosion) 
+	cv2.imshow('Dilation Image', dilation) 
+	cv2.imshow('Closing Image', closing) 
+	cv2.imshow('Opening Image', opening) 
+
+
+	plt.show() 
+	cv2.waitKey(0)
+	cv2.destroyAllWindows() 
+
+if __name__ == "__main__":
+	main()

ImgSegment07.py

@@ -0,0 +1,70 @@
+import cv2
+import numpy as np
+import imutils
+
+def nothing(x):
+	pass
+
+# Load an image
+path = "C:\\Users\\enesa\\Documents\\MATLAB\\final3.PNG"
+img = cv2.imread(path, 1)
+
+# Resize The image
+# if img.shape[1] > 600:
+# 	img = imutils.resize(img, width=600)
+
+if img.shape[0] > 400:
+     img = imutils.resize(img, height=500)
+
+# Create a window
+cv2.namedWindow('Finding Treshold')
+
+# create trackbars for treshold change
+cv2.createTrackbar('Treshold','Finding Treshold', 0, 255, nothing)
+
+
+while(1):
+  
+	# Clone original image to not overlap drawings
+	clone = img.copy()
+	
+	# Convert to gray
+	gray = cv2.cvtColor(clone, cv2.COLOR_BGR2GRAY)
+	
+	# get current positions of four trackbars
+	r = cv2.getTrackbarPos('Treshold','Finding Treshold')
+	
+	# Thresholding the gray image
+	ret,thresh = cv2.threshold(gray, r, 255, cv2.THRESH_BINARY)
+	
+	# To remove the noise in the image with a 5x5 Gaussian filter.
+	blur = cv2.GaussianBlur(thresh, (5, 5), 0) 
+	
+	# Detect edges
+	edges = cv2.Canny(blur, 50, 150)
+	
+	# Find contours
+	_, contours, _= cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+	contour_list = []
+
+	for i in contours:
+		area = cv2.contourArea(i)
+		if (area > 30):
+			contour_list.append(i)
+	
+	# Draw contours on the original image
+	cv2.drawContours(clone, contour_list,  -1, (255,0,0), 2)
+  
+
+	#Displaying the results     
+	cv2.imshow('Detecting Objects', clone)
+	cv2.imshow("Treshholding", thresh)
+	
+	# ESC to break
+	k = cv2.waitKey(1) & 0xFF
+	if k == 27:
+		break
+
+# close all open windows
+cv2.destroyAllWindows()

OpenCamera.py

@@ -0,0 +1,37 @@
+#HIGH PASS FILTERS can perform these actions:
+# edge detection --> using Hough Line Transform
+# This code only for opening Camera
+
+
+import cv2
+#import numpy as np
+#import matplotlib.pyplot as plt
+
+
+def main():
+
+	windowName = 'Hough Line Transform'
+
+	cap = cv2.VideoCapture(0)
+
+	if cap.isOpened():
+		ret, frame = cap.read()
+	else:
+		ret = False	
+
+	while ret:
+		
+		ret, frame = cap.read()
+		
+
+		cv2.imshow(windowName, frame)
+
+		if cv2.waitKey(1)==27:
+			break
+
+	cv2.destroyAllWindows()
+	cap.release()		
+
+if __name__ == '__main__':
+	main()
+

RemoveNoise.py

@@ -0,0 +1,53 @@
+# We will see the Median Filter is pretty useful to remove salt and pepper noise  from an image.
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+
+def main():
+
+	img_path = "D:\\Dataset\\coins.png"
+	img = cv2.imread(img_path, 1) # takes img as bgr
+	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+	output = np.zeros(img.shape, dtype = np.uint8)  # Creates a zeros matrix the same size  img.shape for applying noise.
+	p = 0.2
+
+	for i in range(img.shape[0]): # img.shape[0] shows the row of the image
+		for j in range(img.shape[1]): # img.shape[1] shows the column of the image
+			r = random.random()
+			if r < p/2:
+				output[i][j] = [0, 0, 0] #pepper noise sprinkles
+			elif r < p:
+				output[i][j] = [255, 255, 255] #salt noise sprinkles
+			else:
+				output[i][j] = img[i][j]
+
+
+	cv2.imshow('Noisy Image', output)
+	cv2.waitKey(0)
+	cv2.destroyAllWindows()
+
+	kernel33 = np.ones((3,3), np.float32)/9 # 3-by-3 neighborhood avarage filter
+
+	average = cv2.filter2D(output, -1, kernel33) # Apply the average filter to remove noises.
+	gaussian = cv2.GaussianBlur(output, (3,3), 0)
+	median = cv2.medianBlur(output, 3) 
+	bilateral = cv2.bilateralFilter(output, 9, 75, 75)
+
+	outputs = [img, output, average, gaussian, median, bilateral]
+
+	titles = ['Original', 'Noisy', 'AverageFilter', 'GaussianBlur', 'MedianBlur', 'BilateralFilter']
+
+	for i in range(6):
+		plt.subplot(2, 3, i+1) 
+		plt.imshow(outputs[i])
+		plt.title(titles[i])
+		plt.xticks([])
+		plt.yticks([])
+
+	plt.show()
+
+if __name__ == '__main__':
+	main()

Segmentation01.py

@@ -0,0 +1,37 @@
+#Image Segmentation01
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def main():
+
+	img_path = "C:\\Users\\enesa\\Documents\\MATLAB\\filtresim2.png"
+	img = cv2.imread(img_path, 1) # takes img as bgr
+	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+	cv2.imshow('Image', img)
+
+	
+	# hist = cv2.calcHist([img],[0],None,[256],[0,256])
+	# plt.hist(img.ravel(),256,[0,256])
+	# plt.title('Histogram for Image')
+
+	ret,thresh1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+	cv2.imshow('Tresholding Image', thresh1)
+
+	plt.subplot(1, 2, 1) 
+	plt.imshow(img)
+	plt.title('Original Image')
+
+	plt.subplot(1, 2, 2)
+	plt.imshow(thresh1)
+	plt.title('Tresholding Image = 100')
+
+	plt.show()
+	cv2.waitKey(0)
+	cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+	main()