def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gray_smooth = cv.GaussianBlur(gray, (5, 5), 4, 4) edges = cv.Canny(gray_smooth, 80, 180) ps.display_image("edges", edges) ps.save_image("ps1-5-a", edges) x = extract_edges(edges) rmin = int(input("enter the minimum raidus\n")) rmax = int(input("enter the max radius\n")) circles_in_image = hough_space_circle(x, rmin, rmax) #centers = detecting_circle_using_chord(x) for j in circles_in_image: if (j[2] >= rmin and j[2] < rmax): cv.circle(img, (j[0], j[1]), j[2], (0, 255, 0)) ps.display_image("cirlces in image", img) ps.save_image("ps1-5-b", img) return 0
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 ps.display_image("Image", img) monochrome_image = img[:, :, 1] ps.display_image("monochrome image", monochrome_image) monochrome_smooth_image = cv.GaussianBlur(monochrome_image, (5, 5), 4, 4) ps.display_image("smoothened monochrome image", monochrome_smooth_image) ps.save_image("ps1-4-a", monochrome_smooth_image) edges_smooth_monochrome = cv.Canny(monochrome_smooth_image, 100, 210) ps.display_image("edges in the smoothed monochrome image", edges_smooth_monochrome) ps.save_image("ps1-4-b", edges_smooth_monochrome) hough_space = ps.hough_transform(edges_smooth_monochrome, monochrome_smooth_image) ps.plot_3d_graphs(hough_space, "hough_space_ps1-4-c") #measuring time to detect lines in the image img1 = ps.detect_line_in_image(hough_space, monochrome_smooth_image, 0.5) ps.display_image("Lines in the image are", img1) ps.save_image("ps1-4-c-1", img1)
def make_template(y, x, kernel, left_image): template = np.zeros((kernel, kernel)) kernel_half = int(kernel / 2) for i in range(-kernel_half, kernel_half): for j in range(-kernel_half, kernel_half): template[y + i, x + j] = left_image[y + i, x + j] ps.display_image("Template", template)
def draw_line(description, angle, corners, img): for i in range(0, len(corners)): x1 = int(corners[i][1]) y1 = int(corners[i][0]) x2 = int(x1 + 10 * np.cos(angle[y1, x1])) y2 = int(y1 + 10 * np.sin(angle[y1, x1])) cv.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2) ps.display_image(description, img)
def ransac(corner1, corner2, matching, img1, img2): img3 = np.concatenate((img1, img2), axis=1) best = 0 best_offset_x = -1 best_offset_y = -1 gray1 = cv.cvtColor(img1, cv.COLOR_BGR2GRAY) gray2 = cv.cvtColor(img2, cv.COLOR_BGR2GRAY) # no of iterations is 1000 temp_img1 = np.asarray(gray1) temp_img2 = np.asarray(gray2) h, w = temp_img1.shape[0:2] for i in range(200): print("iteration {}".format(i)) inliers = 0 index = np.random.randint(0, len(matching)) x1 = int(corner1[index][1]) y1 = int(corner1[index][0]) k1 = int(matching[index]) x2 = int(corner2[k1][1]) y2 = int(corner2[k1][0]) offset_x = x2 - x1 offset_y = y2 - y1 for j in range(h): for k in range(w): m = j + offset_y n = k + offset_x if (m < h and m >= 0 and n >= 0 and n < w): ssd = (temp_img1[j][k] - temp_img2[m][n])**2 if (ssd < 25): inliers += 1 if (inliers > best): best = inliers best_offset_x = offset_x best_offset_y = offset_y print(best, best_offset_x, best_offset_y) for i in range(30): x1 = int(corner1[i][1]) y1 = int(corner1[i][0]) x2 = int(x1 + best_offset_x) y2 = int(y1 + best_offset_y) if (x2 < w and y2 < h and y2 >= 0 and x2 >= 0): color1 = (list(np.random.choice(range(256), size=3))) color = [int(color1[0]), int(color1[1]), int(color1[2])] cv.circle(img3, (x1, y1), 2, color, 2) cv.circle(img3, (x2 + w, y2), 2, color, 2) cv.line(img3, (x1, y1), (x2 + w, y2), color, 1) ps.display_image("ransac image", img3)
def draw_keypoints(corner1, corner2, matching, img3, w1): for i in range(35): index = np.random.randint(0, len(corner1)) x1 = int(corner1[index][1]) y1 = int(corner1[index][0]) k = int(matching[index]) x2 = int(corner2[k][1] + w1) y2 = int(corner2[k][0]) #breakpoint() color1 = (list(np.random.choice(range(256), size=3))) color = [int(color1[0]), int(color1[1]), int(color1[2])] cv.circle(img3, (x1, y1), 2, color, 2) cv.circle(img3, (x2, y2), 2, color, 2) cv.line(img3, (x1, y1), (x2, y2), color, 2) ps.display_image("matched", img3)
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gray_smooth = cv.GaussianBlur(gray, (5, 5), 4, 4) edges = cv.Canny(gray, 100, 200) ps.display_image("edges", edges) ps.save_image("ps1-1", edges)
def matching_descriptors1(kp1, des1, kp2, des2): bf = cv.BFMatcher() matches = bf.knnMatch(des1, des2, k=2) # Apply ratio test good = [] for m, n in matches: if m.distance < 0.8 * n.distance: good.append([m]) # cv.drawMatchesKnn expects list of lists as matches. #breakpoint() img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, good, None, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS) ps.display_image("matching", img3)
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 corners = harris_Corners(img, 5) key_points = non_maximum_supression(corners, img) for m in key_points: i = int(m[0]) j = int(m[1]) cv.circle(img, (j, i), 2, [0, 0, 255], 2) ps.display_image("after nms ", img)
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 smooth = cv.GaussianBlur(img, (3, 3), 0) gray = cv.cvtColor(smooth, cv.COLOR_BGR2GRAY) grad_x = cv.Sobel(gray, -1, 1, 0, ksize=3) grad_y = cv.Sobel(gray, -1, 0, 1, ksize=3) img3 = np.concatenate((grad_x, grad_y), axis=1) img3[img3 > 0] = 255 img3[img3 == 0] = 128 img3[img3 < 0] = 0 ps.display_image("concatenated image", img3)
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gray_smooth = cv.GaussianBlur(gray, (5, 5), 4, 4) edges_original = cv.Canny(gray, 140, 210) ps.display_image("edges in the original image", edges_original) ps.save_image("ps1-3-a", gray_smooth) ps.save_image("ps1-3-b-1", edges_original) edges_smoothed = cv.Canny(gray_smooth, 140, 210) ps.display_image("edges in the smoothened image", edges_smoothed) ps.save_image("ps1-3-b-2", edges_smoothed) hough_space = ps.hough_transform(edges_smoothed, gray_smooth) #display_image("Displaying 3D plot of the hough space",hough_space) ps.plot_3d_graphs(hough_space, "hough_space_ps1-3") smooth = ps.detect_line_in_image(hough_space, img, 0.5) ps.display_image("PS3", img) ps.save_image("ps1-3-c", img)
def main(argv): if(len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0],cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 ps.display_image("Image", img) print(type(img)) print(img.size,img.ndim, img.shape) smooth_image = cv.GaussianBlur(img,(5,5),4,4) gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) ps.display_image("gray image ",gray) gray_smooth_image = cv.GaussianBlur(gray,(5,5),4,4) ps.display_image(" gray smoothened image", gray_smooth_image) lower_threshold = int(input("enter the lower threshold value for canny\n")) upper_threshold = int(input("enter the upper threshold value for canny\n")) edges_smooth = cv.Canny(gray_smooth_image,lower_threshold,upper_threshold) ps.display_image("edges in the smoothed monochrome image", edges_smooth) e1 = cv.getTickCount() hough_space = ps.hough_transform(edges_smooth, gray_smooth_image) #ps.plot_3d_graphs(hough_space) #measuring time to detect lines in the image threshold = float(input("enter the hough accululator threshold value\n")) #img1 = ps.detect_line_in_image(edges_smooth,hough_space,smooth_image,threshold) img1 = ps.detect_line_in_image(hough_space,smooth_image,threshold) e2 = cv.getTickCount() time_taken = (e2 -e1)/cv.getTickFrequency() print("The time taken to calculate the lines in the image is {} seconds\n".format(time_taken)) ps.display_image("Lines in the image are",img1) ps.save_image("ps1-6-a", img1)
def main(argv): if (len(argv) < 1): print("not enough parameters\n") print("usage PS1-1.py <path to image>\n") return -1 img = cv.imread(argv[0], cv.IMREAD_COLOR) if img is None: print("Error opening image\n") return -1 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gray_smooth = cv.GaussianBlur(gray, (5, 5), 4, 4) edges = cv.Canny(gray, 100, 200) ps.display_image("edges", edges) hough_space = ps.hough_transform(edges, gray) ps.plot_3d_graphs(hough_space) img = ps.detect_line_in_image(hough_space, img, 0.6) ps.display_image("lines in the image are", img) ps.save_image("ps1-2", img)
r - rmin] hough_space = threshold_image_circle(hough_accumulator, maximum_accumulator_value) result = detect_circles_in_hough_space(hough_space, 0.5, offset_x, offset_y, rmin) return result def extract_edges(edge_image): return [(x, y) for x in range(edge_image.shape[0]) for y in range(edge_image.shape[1]) if edge_image[x, y] == 255] img = cv.imread('../image/ps1-input1.jpg', cv.IMREAD_COLOR) monochrome_image = img[:, :, 1] ps.display_image("original image", img) ps.display_image("monochrome image", monochrome_image) monochrome_smooth_image = cv.GaussianBlur(monochrome_image, (5, 5), 4, 4) ps.display_image("smoothened monochrome image", monochrome_smooth_image) edges_smooth_monochrome = cv.Canny(monochrome_smooth_image, 100, 210) ps.display_image("edges in the smoothed monochrome image", edges_smooth_monochrome) x = extract_edges(edges_smooth_monochrome) circles_in_image = hough_space_circle(x, 1, 10) #centers = detecting_circle_using_chord(x) for j in circles_in_image: cv.circle(img, (j[0], j[1]), j[2], (0, 255, 0)) ps.display_image("cirlces in image", img)
def ransac_affine(corner1, corner2, matching, img1, img2): breakpoint() best = 0 img3 = np.concatenate((img1, img2), axis=1) gray1 = cv.cvtColor(img1, cv.COLOR_BGR2GRAY) gray2 = cv.cvtColor(img2, cv.COLOR_BGR2GRAY) # no of iterations is 1000 temp_img1 = np.asarray(gray1) temp_img2 = np.asarray(gray2) h, w = temp_img1.shape for i in range(50): print("iteration {}".format(i)) inliers = 0 index1 = np.random.randint(0, len(matching)) index2 = np.random.randint(0, len(matching)) if (index1 == index2): continue A = np.zeros((4, 4)) B = np.zeros((4, 1)) u1 = corner1[index1][1] v1 = corner1[index1][0] u2 = corner1[index2][1] v2 = corner1[index2][0] n1 = int(matching[index1]) n2 = int(matching[index2]) x1 = corner2[n1][1] y1 = corner2[n1][0] x2 = corner2[n2][1] y2 = corner2[n2][0] A[0] = [u1, -v1, 1, 0] A[1] = [v1, u1, 0, 1] A[2] = [u2, -v2, 1, 0] A[3] = [v2, u2, 0, 1] C = np.array([x1, y1, x2, y2]) B = np.transpose(C) X = np.linalg.solve(A, B) H = np.ones((3, 2)) H = np.array([[X[0], -X[1], X[2]], [X[1], X[0], X[3]]]) for j in range(h): for k in range(w): p1 = [k, j, 1] p1 = np.transpose(p1) p2 = np.matmul(H, p1) m = int(p2[1]) n = int(p2[0]) if (m >= 0 and m < h and n >= 0 and n < w): ssd = (temp_img1[p1[1], p1[0]] - temp_img2[m, n])**2 if (ssd < 25): inliers += 1 if (inliers > best): best = inliers best_homography = np.asarray(H) print(best_homography) for i in range(50): x1 = int(corner1[i][1]) y1 = int(corner1[i][0]) p1 = [x1, y1, 1] p2 = np.matmul(best_homography, np.transpose(p1)) x2 = int(p2[0]) y2 = int(p2[1]) if (x2 < w and y2 < h and y2 >= 0 and x2 >= 0): color1 = (list(np.random.choice(range(256), size=3))) color = [int(color1[0]), int(color1[1]), int(color1[2])] cv.circle(img3, (x1, y1), 2, color, 2) cv.circle(img3, (x2 + w, y2), 2, color, 2) cv.line(img3, (x1, y1), (x2 + w, y2), color, 1) ps.display_image("ransac image", img3)