Code Files Added

Author: packtprasadr

Module 2/1/convolution.py

@@ -0,0 +1,22 @@
+import cv2
+import numpy as np
+
+img = cv2.imread('../images/input_sharp_edges.jpg')
+rows, cols = img.shape[:2]
+
+kernel_identity = np.array([[0,0,0], [0,1,0], [0,0,0]])
+kernel_3x3 = np.ones((3,3), np.float32) / 9.0
+kernel_5x5 = np.ones((5,5), np.float32) / 25.0
+
+cv2.imshow('Original', img)
+
+output = cv2.filter2D(img, -1, kernel_identity)
+cv2.imshow('Identity filter', output)
+
+output = cv2.filter2D(img, -1, kernel_3x3)
+cv2.imshow('3x3 filter', output)
+
+output = cv2.filter2D(img, -1, kernel_5x5)
+cv2.imshow('5x5 filter', output)
+
+cv2.waitKey()

Module 2/1/edge_detection.py

@@ -0,0 +1,22 @@
+import cv2
+import numpy as np
+
+img = cv2.imread('../images/input_train.jpg', cv2.IMREAD_GRAYSCALE)
+rows, cols = img.shape
+
+sobel_horizontal_1 = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
+sobel_horizontal_2 = cv2.Sobel(img, cv2.CV_64F, 2, 0, ksize=5)
+sobel_horizontal_3 = cv2.Sobel(img, cv2.CV_64F, 3, 0, ksize=5)
+sobel_vertical = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
+laplacian = cv2.Laplacian(img, cv2.CV_64F)
+canny = cv2.Canny(img, 50, 240)
+
+cv2.imshow('Original', img)
+#cv2.imshow('Sobel horizontal 1', sobel_horizontal_1)
+#cv2.imshow('Sobel horizontal 2', sobel_horizontal_2)
+#cv2.imshow('Sobel horizontal 3', sobel_horizontal_3)
+#cv2.imshow('Sobel vertical', sobel_vertical)
+cv2.imshow('Laplacian', laplacian)
+cv2.imshow('Canny', canny)
+
+cv2.waitKey()

Module 2/1/histogram.py

@@ -0,0 +1,24 @@
+import cv2
+import numpy as np
+
+img = cv2.imread('../images/input_histogram.jpg', 0)
+histeq = cv2.equalizeHist(img)
+
+#cv2.imshow('Input', img)
+#cv2.imshow('Histogram equalized', histeq)
+
+##################
+# Histogram equalization of color images
+
+img = cv2.imread('../images/input_histogram_color.jpg')
+
+img_yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
+img_yuv[:,:,0] = cv2.equalizeHist(img_yuv[:,:,0])
+
+img_output = cv2.cvtColor(img_yuv, cv2.COLOR_YUV2BGR)
+
+cv2.imshow('Color input image', img)
+cv2.imshow('Histogram equalized', img_output)
+
+cv2.waitKey()
+

Module 2/1/image_filters.py

@@ -0,0 +1,69 @@
+# http://lodev.org/cgtutor/filtering.html
+
+import cv2
+import numpy as np
+
+#img = cv2.imread('../images/input_sharp_edges.jpg', cv2.IMREAD_GRAYSCALE)
+img = cv2.imread('../images/input_tree.jpg')
+rows, cols = img.shape[:2]
+#cv2.imshow('Original', img)
+
+###################
+# Motion Blur
+size = 15
+kernel_motion_blur = np.zeros((size, size))
+kernel_motion_blur[int((size-1)/2), :] = np.ones(size)
+kernel_motion_blur = kernel_motion_blur / size
+output = cv2.filter2D(img, -1, kernel_motion_blur)
+#cv2.imshow('Motion Blur', output)
+
+###################
+# Sharpening
+kernel_sharpen_1 = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+kernel_sharpen_2 = np.array([[1,1,1], [1,-7,1], [1,1,1]])
+kernel_sharpen_3 = np.array([[-1,-1,-1,-1,-1], 
+ [-1,2,2,2,-1], 
+ [-1,2,8,2,-1],
+ [-1,2,2,2,-1],
+ [-1,-1,-1,-1,-1]]) / 8.0
+output_1 = cv2.filter2D(img, -1, kernel_sharpen_1)
+output_2 = cv2.filter2D(img, -1, kernel_sharpen_2)
+output_3 = cv2.filter2D(img, -1, kernel_sharpen_3)
+#cv2.imshow('Sharpening', output_1)
+#cv2.imshow('Excessive Sharpening', output_2)
+#cv2.imshow('Edge Enhancement', output_3)
+
+###################
+# Embossing
+img_emboss_input = cv2.imread('../images/input_house.jpg')
+kernel_emboss_1 = np.array([[0,-1,-1],
+ [1,0,-1],
+ [1,1,0]])
+kernel_emboss_2 = np.array([[-1,-1,0],
+ [-1,0,1],
+ [0,1,1]])
+kernel_emboss_3 = np.array([[1,0,0],
+ [0,0,0],
+ [0,0,-1]])
+gray_img = cv2.cvtColor(img_emboss_input,cv2.COLOR_BGR2GRAY)
+output_1 = cv2.filter2D(gray_img, -1, kernel_emboss_1)
+output_2 = cv2.filter2D(gray_img, -1, kernel_emboss_2)
+output_3 = cv2.filter2D(gray_img, -1, kernel_emboss_3)
+cv2.imshow('Input', img_emboss_input) 
+cv2.imshow('Embossing - South West', output_1 + 128)
+cv2.imshow('Embossing - South East', output_2 + 128)
+cv2.imshow('Embossing - North West', output_3 + 128)
+
+###################
+# Erosion and dilation
+
+img = cv2.imread('../images/input_morphology.png',0)
+kernel = np.ones((5,5), np.uint8)
+img_erosion = cv2.erode(img, kernel, iterations=1)
+img_dilation = cv2.dilate(img, kernel, iterations=1)
+#cv2.imshow('Input', img)
+#cv2.imshow('Erosion', img_erosion)
+#cv2.imshow('Dilation', img_dilation)
+
+cv2.waitKey()
+

Module 2/1/vignette.py

@@ -0,0 +1,36 @@
+import cv2
+import numpy as np
+
+img = cv2.imread('../images/input_flowers.jpg')
+rows, cols = img.shape[:2]
+
+kernel_x = cv2.getGaussianKernel(cols,200)
+kernel_y = cv2.getGaussianKernel(rows,200)
+kernel = kernel_y * kernel_x.T
+mask = 255 * kernel / np.linalg.norm(kernel)
+output = np.copy(img)
+
+for i in range(3):
+ output[:,:,i] = output[:,:,i] * mask
+
+#cv2.imshow('Original', img)
+#cv2.imshow('Vignette', output)
+
+################
+# Shifting the focus
+
+kernel_x = cv2.getGaussianKernel(int(1.5*cols),200)
+kernel_y = cv2.getGaussianKernel(int(1.5*rows),200)
+kernel = kernel_y * kernel_x.T
+mask = 255 * kernel / np.linalg.norm(kernel)
+mask = mask[int(0.5*rows):, int(0.5*cols):]
+output = np.copy(img)
+
+for i in range(3):
+ output[:,:,i] = output[:,:,i] * mask
+
+cv2.imshow('Input', img)
+cv2.imshow('Vignette with shifted focus', output)
+
+
+cv2.waitKey()

Module 2/10/find_fund_matrix.py

@@ -0,0 +1,104 @@
+import argparse
+
+import cv2
+import numpy as np
+
+def build_arg_parser():
+ parser = argparse.ArgumentParser(description='Find fundamental matrix \
+ using the two input stereo images and draw epipolar lines')
+ parser.add_argument("--img-left", dest="img_left", required=True,
+ help="Image captured from the left view")
+ parser.add_argument("--img-right", dest="img_right", required=True,
+ help="Image captured from the right view")
+ parser.add_argument("--feature-type", dest="feature_type", 
+ required=True, help="Feature extractor that will be used; can be either 'sift' or 'surf'")
+ return parser
+
+def draw_lines(img_left, img_right, lines, pts_left, pts_right):
+ h,w = img_left.shape
+ img_left = cv2.cvtColor(img_left, cv2.COLOR_GRAY2BGR)
+ img_right = cv2.cvtColor(img_right, cv2.COLOR_GRAY2BGR)
+
+ for line, pt_left, pt_right in zip(lines, pts_left, pts_right):
+ x_start,y_start = map(int, [0, -line[2]/line[1] ])
+ x_end,y_end = map(int, [w, -(line[2]+line[0]*w)/line[1] ])
+ color = tuple(np.random.randint(0,255,2).tolist())
+ cv2.line(img_left, (x_start,y_start), (x_end,y_end), color,1)
+ cv2.circle(img_left, tuple(pt_left), 5, color, -1)
+ cv2.circle(img_right, tuple(pt_right), 5, color, -1)
+
+ return img_left, img_right
+
+def get_descriptors(gray_image, feature_type):
+ if feature_type == 'surf':
+ feature_extractor = cv2.SURF()
+
+ elif feature_type == 'sift':
+ feature_extractor = cv2.SIFT()
+
+ else:
+ raise TypeError("Invalid feature type; should be either 'surf' or 'sift'")
+
+ keypoints, descriptors = feature_extractor.detectAndCompute(gray_image, None)
+ return keypoints, descriptors
+
+if __name__=='__main__':
+ args = build_arg_parser().parse_args()
+ img_left = cv2.imread(args.img_left,0) # left image
+ img_right = cv2.imread(args.img_right,0) # right image
+ feature_type = args.feature_type
+
+ if feature_type not in ['sift', 'surf']:
+ raise TypeError("Invalid feature type; has to be either 'sift' or 'surf'")
+
+ scaling_factor = 1.0
+ img_left = cv2.resize(img_left, None, fx=scaling_factor, 
+ fy=scaling_factor, interpolation=cv2.INTER_AREA)
+ img_right = cv2.resize(img_right, None, fx=scaling_factor, 
+ fy=scaling_factor, interpolation=cv2.INTER_AREA)
+
+ kps_left, des_left = get_descriptors(img_left, feature_type)
+ kps_right, des_right = get_descriptors(img_right, feature_type)
+
+ # FLANN parameters
+ FLANN_INDEX_KDTREE = 0
+ index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
+ search_params = dict(checks=50)
+
+ # Get the matches based on the descriptors
+ flann = cv2.FlannBasedMatcher(index_params, search_params)
+ matches = flann.knnMatch(des_left, des_right, k=2)
+
+ pts_left_image = []
+ pts_right_image = []
+
+ # ratio test to retain only the good matches
+ for i,(m,n) in enumerate(matches):
+ if m.distance < 0.7*n.distance:
+ pts_left_image.append(kps_left[m.queryIdx].pt)
+ pts_right_image.append(kps_right[m.trainIdx].pt)
+
+ pts_left_image = np.float32(pts_left_image)
+ pts_right_image = np.float32(pts_right_image)
+ F, mask = cv2.findFundamentalMat(pts_left_image, pts_right_image, cv2.FM_LMEDS)
+
+ # Selecting only the inliers 
+ pts_left_image = pts_left_image[mask.ravel()==1]
+ pts_right_image = pts_right_image[mask.ravel()==1]
+
+ # Drawing the lines on left image and the corresponding feature points on the right image
+ lines1 = cv2.computeCorrespondEpilines(pts_right_image.reshape(-1,1,2), 2, F)
+ lines1 = lines1.reshape(-1,3)
+ img_left_lines, img_right_pts = draw_lines(img_left, img_right, lines1, pts_left_image, pts_right_image)
+
+ # Drawing the lines on right image and the corresponding feature points on the left image
+ lines2 = cv2.computeCorrespondEpilines(pts_left_image.reshape(-1,1,2), 1,F)
+ lines2 = lines2.reshape(-1,3)
+ img_right_lines, img_left_pts = draw_lines(img_right, img_left, lines2, pts_right_image, pts_left_image)
+
+ cv2.imshow('Epi lines on left image', img_left_lines)
+ cv2.imshow('Feature points on right image', img_right_pts)
+ cv2.imshow('Epi lines on right image', img_right_lines)
+ cv2.imshow('Feature points on left image', img_left_pts)
+ cv2.waitKey()
+ cv2.destroyAllWindows()

Module 2/10/stereo_match.py

@@ -0,0 +1,95 @@
+import argparse
+
+import cv2
+import numpy as np
+
+def build_arg_parser():
+ parser = argparse.ArgumentParser(description='Reconstruct the 3D map from \
+ the two input stereo images. Output will be saved in \'output.ply\'')
+ parser.add_argument("--image-left", dest="image_left", required=True,
+ help="Input image captured from the left")
+ parser.add_argument("--image-right", dest="image_right", required=True,
+ help="Input image captured from the right")
+ parser.add_argument("--output-file", dest="output_file", required=True,
+ help="Output filename (without the extension) where the point cloud will be saved")
+ return parser
+
+def create_output(vertices, colors, filename):
+ colors = colors.reshape(-1, 3)
+ vertices = np.hstack([vertices.reshape(-1,3), colors])
+
+ ply_header = '''ply
+ format ascii 1.0
+ element vertex %(vert_num)d
+ property float x
+ property float y
+ property float z
+ property uchar red
+ property uchar green
+ property uchar blue
+ end_header
+ '''
+
+ with open(filename, 'w') as f:
+ f.write(ply_header % dict(vert_num=len(vertices)))
+ np.savetxt(f, vertices, '%f %f %f %d %d %d')
+
+if __name__ == '__main__':
+ args = build_arg_parser().parse_args()
+ image_left = cv2.imread(args.image_left)
+ image_right = cv2.imread(args.image_right)
+ output_file = args.output_file + '.ply'
+
+ if image_left.shape[0] != image_right.shape[0] or \
+ image_left.shape[1] != image_right.shape[1]:
+ raise TypeError("Input images must be of the same size")
+
+ # downscale images for faster processing
+ image_left = cv2.pyrDown(image_left) 
+ image_right = cv2.pyrDown(image_right)
+
+ # disparity range is tuned for 'aloe' image pair
+ win_size = 1
+ min_disp = 16
+ max_disp = min_disp * 9
+ num_disp = max_disp - min_disp # Needs to be divisible by 16
+ stereo = cv2.StereoSGBM(minDisparity = min_disp,
+ numDisparities = num_disp,
+ SADWindowSize = win_size,
+ uniquenessRatio = 10,
+ speckleWindowSize = 100,
+ speckleRange = 32,
+ disp12MaxDiff = 1,
+ P1 = 8*3*win_size**2,
+ P2 = 32*3*win_size**2,
+ fullDP = True
+ )
+
+ print "\nComputing the disparity map ..."
+ disparity_map = stereo.compute(image_left, image_right).astype(np.float32) / 16.0
+
+ print "\nGenerating the 3D map ..."
+ h, w = image_left.shape[:2]
+ focal_length = 0.8*w 
+
+ # Perspective transformation matrix
+ Q = np.float32([[1, 0, 0, -w/2.0],
+ [0,-1, 0, h/2.0], 
+ [0, 0, 0, -focal_length], 
+ [0, 0, 1, 0]])
+
+ points_3D = cv2.reprojectImageTo3D(disparity_map, Q)
+ colors = cv2.cvtColor(image_left, cv2.COLOR_BGR2RGB)
+ mask_map = disparity_map > disparity_map.min()
+ output_points = points_3D[mask_map]
+ output_colors = colors[mask_map]
+
+ print "\nCreating the output file ...\n"
+ create_output(output_points, output_colors, output_file)
+
+ #cv2.imshow('Left Image', image_left)
+ #cv2.imshow('Right Image', image_right)
+ #cv2.imshow('Disparity Map', (disparity_map - min_disp) / num_disp)
+ #cv2.waitKey()
+ #cv2.destroyAllWindows()
+