Completed problem set 4 + refactorings

Author: kalyan0510

Diff for: ps_0/ps0.py

@@ -60,8 +60,9 @@ def p5():
     imsave(im_blue, 'output/ps0-5-b-1.png')
 
 
-p1()
-p2()
-p3()
-p4()
-p5()
+if __name__ == '__main__':
+    p1()
+    p2()
+    p3()
+    p4()
+    p5()

Diff for: ps_1/ps1.py

@@ -60,8 +60,7 @@ def update_threshold(x, axs, sliders, buttons):
         print(sliders[0].val, sliders[1].val)
         return [1], [cv.Canny(im, sliders[0].val, sliders[1].val)]
 
-    imshow([im, edges], ['original', 'canny edges'], slider_attr=slider_attr,
-           slider_callback=[update_threshold] * 2)
+    imshow([im, edges], ['original', 'canny edges'], slider_attr=slider_attr, slider_callback=[update_threshold] * 2)
 
 
 def hough_lines_acc(edges, theta_range=np.arange(-180, 180)):
@@ -110,14 +109,14 @@ def round_range(start, end, max):
     size = [[size[i] + 1, size[i]][size[i] % 2] for i in range(len(acc.shape))]
     bounds = [(size[i] - 1) // 2 for i in range(len(acc.shape))]
     pts = []
-    max_peak = np.max(acc)
+    threshold_val = acc.min()*(1-threshold) + acc.max()*threshold
     while len(pts) < npeaks:
         index = np.unravel_index(np.asarray(acc).argmax(), acc.shape)
-        if len(index) == 2 and acc[index[0], index[1]] >= threshold * max_peak and acc[index[0], index[1]] > 0:
+        if len(index) == 2 and acc[index[0], index[1]] >= threshold_val and acc[index[0], index[1]] > 0:
             pts.append((index[0], index[1]))
             acc[np.ix_(round_range(index[0] - bounds[0], index[0] + bounds[0] + 1, acc.shape[0]),
                        round_range(index[1] - bounds[1], index[1] + bounds[1] + 1, acc.shape[1]))] = 0
-        elif len(index) == 3 and acc[index[0], index[1], index[2]] >= threshold * max_peak and acc[
+        elif len(index) == 3 and acc[index[0], index[1], index[2]] >= threshold_val and acc[
             index[0], index[1], index[2]] > 0:
             pts.append((index[0], index[1], index[2]))
             acc[np.ix_(round_range(index[0] - bounds[0], index[0] + bounds[0] + 1, acc.shape[0]),
@@ -239,8 +238,7 @@ def update_exp(x, axs, sliders, buttons):
         return [0, 1], [draw_line_on_im(np.zeros(im.shape), lines_p_c), draw_line_on_im(np.zeros(im.shape), lines_p_m)]
 
     imshow([draw_line_on_im(np.zeros(im.shape), lines_p_c), draw_line_on_im(np.zeros(im.shape), lines_p_m)],
-           ['custom hough peak', 'matlab\'s hough peak'],
-           slider_attr=slider_attr, slider_callback=[update_exp] * 2)
+           ['custom hough peak', 'matlab\'s hough peak'], slider_attr=slider_attr, slider_callback=[update_exp] * 2)
 
 
 def p3():
@@ -266,8 +264,8 @@ def update_exp(x, axs, sliders, buttons):
     slider_attr = [{'label': 'num peaks', 'valmin': 0, 'valmax': 99, 'valstep': 1},
                    {'label': 'hough peak threshold', 'valmin': 0.1, 'valmax': .99}]
     imshow([im_noise, blur_im_noise, edge_noise, edge_blur_noise, zeros, zeros],
-           ['im_noise', 'blur_im_noise', 'edge_noise', 'edge_blur_noise', 'noise lines', 'blur lines'],
-           slider_attr=slider_attr, slider_callback=[update_exp] * 2, shape=(3, 2))
+           ['im_noise', 'blur_im_noise', 'edge_noise', 'edge_blur_noise', 'noise lines', 'blur lines'], shape=(3, 2),
+           slider_attr=slider_attr, slider_callback=[update_exp] * 2)
 
 
 def p4():
@@ -434,7 +432,7 @@ def p8():
     imshow([edge, im_color])
 
 
-""" Run just the methods you need, else you will go through a lot of interactive canvas popups """
+""" Run just the methods that are needed, else the session will go through a lot of interactive canvas popups """
 # testing_imshow()
 # p1()
 # p2_experiment()

Diff for: ps_2/disparity_ncorr.py

@@ -25,8 +25,8 @@ def compute_stereo_on_slice(i_th):
         for j in range(w_l, left.shape[1] - w_l):
             (d, ncorr) = (0, np.NINF)
             for j_i in range(max(w_l, j - max_disp), min(left.shape[1] - w_l, j + max_disp)):
-                l_w = left[get_window_ix(left, (i_th, j), window_shape)] * 1.0
-                r_w = right[get_window_ix(right, (i_th, j_i), window_shape)] * 1.0
+                l_w = left[get_window_ix(left.shape, (i_th, j), window_shape)] * 1.0
+                r_w = right[get_window_ix(right.shape, (i_th, j_i), window_shape)] * 1.0
                 l_w = (l_w - np.average(l_w))
                 r_w = (r_w - np.average(r_w))
                 std_p = l_w.std() * r_w.std()

Diff for: ps_2/disparity_ssd.py

@@ -26,8 +26,8 @@ def compute_stereo_on_slice(i):
         for j in range(w_l, left.shape[1] - w_l):
             (d, ssd) = (0, np.PINF)
             for j_i in range(max(w_l, j - max_disp), min(left.shape[1] - w_l, j + max_disp)):
-                l_w = left[get_window_ix(left, (i, j), window_shape)] * 1.0
-                r_w = right[get_window_ix(right, (i, j_i), window_shape)] * 1.0
+                l_w = left[get_window_ix(left.shape, (i, j), window_shape)] * 1.0
+                r_w = right[get_window_ix(right.shape, (i, j_i), window_shape)] * 1.0
                 ssd_i = np.sum(np.square(np.subtract(l_w, r_w)))
                 (d, ssd) = (j_i - j if ssd_i < ssd else d, min(ssd_i, ssd))
             d_map_slice[j] = d

Diff for: ps_2/objects/p2_disparities(pair1-L copy,pair1-R copy).npy

@@ -0,0 +1,86 @@
+import numpy as np
+
+
+def construct_a_mat(pts_world, pts_proj):
+    a = []
+    for (x, y, z), (u, v) in zip(pts_world, pts_proj):
+        a.append([x, y, z, 1, 0, 0, 0, 0, -u * x, -u * y, -u * z, -u])
+        a.append([0, 0, 0, 0, x, y, z, 1, -v * x, -v * y, -v * z, -v])
+    return np.asarray(a)
+
+
+def construct_f_mat(pts_im_left, pts_im_right):
+    f = []
+    for (u, v, *rest), (u_, v_, *rest) in zip(pts_im_left, pts_im_right):
+        f.append([u_ * u, u_ * v, u_, v_ * u, v_ * v, v_, u, v, 1])
+    return np.asarray(f)
+
+
+def solve_for_svd(a):
+    w, v = np.linalg.eig(np.matmul(a.T, a))
+    m = v[:, w.argmin()]
+    return m
+
+
+def solve_with_leastsq(a):
+    b = -a[:, -1]
+    a = a[:, 0:-1]
+    m, res, _, _ = np.linalg.lstsq(a, b, rcond=None)
+    return np.append(m, 1)
+
+
+def solve_for_m_svd(pts_world, pts_proj):
+    a = construct_a_mat(pts_world, pts_proj)
+    return solve_for_svd(a).reshape((3, 4))
+
+
+def solve_for_m_leastsq(pts_world, pts_proj):
+    a = construct_a_mat(pts_world, pts_proj)
+    return solve_with_leastsq(a).reshape((3, 4))
+
+
+def solve_for_f_svd(pts_im1, pts_im2):
+    a = construct_f_mat(pts_im1, pts_im2)
+    return solve_for_svd(a).reshape((3, 3))
+
+
+def solve_for_f_leastsq(pts_im1, pts_im2):
+    a = construct_f_mat(pts_im1, pts_im2)
+    return solve_with_leastsq(a).reshape((3, 3))
+
+
+def fix_f_rank(f):
+    u, s, vh = np.linalg.svd(f)
+    s[s.argmin()] = 0
+    return np.matmul(np.matmul(u, np.diag(s)), vh)
+
+
+def get_epipolar_line_ends(f, pts_b, im_shape, t=None):
+    pts_b_t = np.append(np.asarray(pts_b), np.ones((len(pts_b), 1)), axis=1).T
+    l_l = np.cross([0, 0, 1], [im_shape[0], 0, 1])
+    l_r = np.cross([0, im_shape[1], 1], [im_shape[0], im_shape[1], 1])
+    l_a = np.matmul(f.T, pts_b_t)
+    if t is not None:
+        l_a = np.matmul(t.T, l_a)
+    skew = lambda x: np.array([[0, -x[2], x[1]], [x[2], 0, -x[0]], [-x[1], x[0], 0]])
+    p_l = np.matmul(skew(l_l).T, l_a).T
+    p_r = np.matmul(skew(l_r).T, l_a).T
+    p_l = np.asarray([(int(x[0] / x[2]), int(x[1] / x[2])) for x in p_l])
+    p_r = np.asarray([(int(x[0] / x[2]), int(x[1] / x[2])) for x in p_r])
+    return tuple(zip(p_l, p_r))
+
+
+def get_transformation_mat_2d(points):
+    s_a = 1 / np.max(points)
+    t_a_s = np.diag([s_a, s_a, 1])
+    c_a = np.mean(points, axis=0)
+    t_a_c = np.asarray([[1, 0, -c_a[0]], [0, 1, -c_a[1]], [0, 0, 1]])
+    return np.matmul(t_a_s, t_a_c)
+
+
+def calculate_residual(m, pts_world, pts_proj):
+    pts_world_mat = np.append(np.asarray(pts_world), np.ones((len(pts_world), 1)), axis=1).T
+    pts_proj_est = np.matmul(m, pts_world_mat)
+    pts_proj_est_non_homo = pts_proj_est.T[:, 0:2] / pts_proj_est.T[:, [2, 2]]
+    ssd_error = np.linalg.norm(pts_proj_est_non_homo - np.asarray(pts_proj))
+    return np.sqrt(ssd_error)

Diff for: ps_2/objects/p4_disparities(pair0-L copy,pair0-R copy).npy

@@ -2,92 +2,14 @@
 import cv2 as cv
 import numpy as np
 
+from ps_3.helper import construct_a_mat, solve_for_m_svd, calculate_residual, solve_for_m_leastsq, solve_for_f_svd, \
+    fix_f_rank, get_epipolar_line_ends, get_transformation_mat_2d
 from ps_hepers.helpers import read_points, imshow, imread, imsave
 
-
-def construct_a_mat(pts_world, pts_proj):
-    a = []
-    for (x, y, z), (u, v) in zip(pts_world, pts_proj):
-        a.append([x, y, z, 1, 0, 0, 0, 0, -u * x, -u * y, -u * z, -u])
-        a.append([0, 0, 0, 0, x, y, z, 1, -v * x, -v * y, -v * z, -v])
-    return np.asarray(a)
-
-
-def construct_f_mat(pts_im_left, pts_im_right):
-    f = []
-    for (u, v, *rest), (u_, v_, *rest) in zip(pts_im_left, pts_im_right):
-        f.append([u_ * u, u_ * v, u_, v_ * u, v_ * v, v_, u, v, 1])
-    return np.asarray(f)
-
-
-def solve_for_svd(a):
-    w, v = np.linalg.eig(np.matmul(a.T, a))
-    m = v[:, w.argmin()]
-    return m
-
-
-def solve_with_leastsq(a):
-    b = -a[:, -1]
-    a = a[:, 0:-1]
-    m, res, _, _ = np.linalg.lstsq(a, b, rcond=None)
-    return np.append(m, 1)
-
-
-def solve_for_m_svd(pts_world, pts_proj):
-    a = construct_a_mat(pts_world, pts_proj)
-    return solve_for_svd(a).reshape((3, 4))
-
-
-def solve_for_m_leastsq(pts_world, pts_proj):
-    a = construct_a_mat(pts_world, pts_proj)
-    return solve_with_leastsq(a).reshape((3, 4))
-
-
-def solve_for_f_svd(pts_im1, pts_im2):
-    a = construct_f_mat(pts_im1, pts_im2)
-    return solve_for_svd(a).reshape((3, 3))
-
-
-def solve_for_f_leastsq(pts_im1, pts_im2):
-    a = construct_f_mat(pts_im1, pts_im2)
-    return solve_with_leastsq(a).reshape((3, 3))
-
-
-def fix_f_rank(f):
-    u, s, vh = np.linalg.svd(f)
-    s[s.argmin()] = 0
-    return np.matmul(np.matmul(u, np.diag(s)), vh)
-
-
-def get_epipolar_line_ends(f, pts_b, im_shape, t=None):
-    pts_b_t = np.append(np.asarray(pts_b), np.ones((len(pts_b), 1)), axis=1).T
-    l_l = np.cross([0, 0, 1], [im_shape[0], 0, 1])
-    l_r = np.cross([0, im_shape[1], 1], [im_shape[0], im_shape[1], 1])
-    l_a = np.matmul(f.T, pts_b_t)
-    if t is not None:
-        l_a = np.matmul(t.T, l_a)
-    skew = lambda x: np.array([[0, -x[2], x[1]], [x[2], 0, -x[0]], [-x[1], x[0], 0]])
-    p_l = np.matmul(skew(l_l).T, l_a).T
-    p_r = np.matmul(skew(l_r).T, l_a).T
-    p_l = np.asarray([(int(x[0] / x[2]), int(x[1] / x[2])) for x in p_l])
-    p_r = np.asarray([(int(x[0] / x[2]), int(x[1] / x[2])) for x in p_r])
-    return tuple(zip(p_l, p_r))
-
-
-def get_transformation_mat_2d(points):
-    s_a = 1 / np.max(points)
-    t_a_s = np.diag([s_a, s_a, 1])
-    c_a = np.mean(points, axis=0)
-    t_a_c = np.asarray([[1, 0, -c_a[0]], [0, 1, -c_a[1]], [0, 0, 1]])
-    return np.matmul(t_a_s, t_a_c)
-
-
-def calculate_residual(m, pts_world, pts_proj):
-    pts_world_mat = np.append(np.asarray(pts_world), np.ones((len(pts_world), 1)), axis=1).T
-    pts_proj_est = np.matmul(m, pts_world_mat)
-    pts_proj_est_non_homo = pts_proj_est.T[:, 0:2] / pts_proj_est.T[:, [2, 2]]
-    ssd_error = np.linalg.norm(pts_proj_est_non_homo - np.asarray(pts_proj))
-    return np.sqrt(ssd_error)
+"""
+Problem Set - 3
+Problems: https://docs.google.com/document/d/1XsW9k_exgVwCy6CdwgUV3wLKwmFliVdmfAH74Ba4drc/pub?embedded=true
+"""
 
 
 def p1():