Added problem set - 5's p1 and p2

Author: kalyan0510

ps_2/ps2.py

@@ -54,8 +54,8 @@ def test_disparity_on_noise(disparity_compute, noise_type, object_name_prefix='p
             imread_from_rep('pair1-D_L', grey_scale=True),
             imread_from_rep('pair1-D_R', grey_scale=True)],
            ['left', 'right', 'd_l', 'd_r', 'd_l noise', 'd_r noise', 'ground truth l', 'ground truth l'], shape=(4, 2))
-    imsave(d_l_noise, 'output/ ps2-3-a-1.png')
-    imsave(d_r_noise, 'output/ ps2-3-a-2.png')
+    imsave(d_l_noise, 'output/ps2-3-a-1.png')
+    imsave(d_r_noise, 'output/ps2-3-a-2.png')
 
 
 def p3():

ps_4/helper.py

@@ -6,11 +6,9 @@
 from scipy.spatial import ConvexHull
 
 
-def im_der(im, with_norm=False):
+def im_der(im):
     gx = cv.Sobel(im, cv.CV_64F, 1, 0, ksize=3)
     gy = cv.Sobel(im, cv.CV_64F, 0, 1, ksize=3)
-    if not with_norm:
-        return gx, gy
     return gx, gy,
 
 

ps_5/helper.py

@@ -0,0 +1,91 @@
+import numpy as np
+import cv2 as cv
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+import matplotlib.pyplot as plt
+
+
+def get_pixel_derivatives(im_t0, im_t1):
+    t0, t1 = im_t0.astype(np.float32), im_t1.astype(np.float32)
+    ix, iy = np.zeros(t0.shape, dtype=np.float32), np.zeros(t0.shape, dtype=np.float32)
+    ix[1:-1, 1:-1, ...] = t0[1:-1, 2:, ...] - t0[1:-1, :-2, ...]
+    iy[1:-1, 1:-1, ...] = t0[2:, 1:-1, ...] - t0[:-2, 1:-1, ...]
+    return ix, iy, (t0 - t1).astype(np.float32)
+
+
+def lucas_kanade(im0, im1, k_shape=(5, 5)):
+    ix, iy, it = get_pixel_derivatives(im0, im1)
+    grad_prods = [ix * ix, ix * iy, iy * iy, ix * it, iy * it]
+    grad_prods = [np.sum(grad_prod, axis=2) for grad_prod in grad_prods] if len(im0.shape) == 3 else grad_prods
+    wgps = [cv.GaussianBlur(grad_prod, k_shape, 0) for grad_prod in grad_prods]
+    wgps = np.concatenate([wgp[:, :, np.newaxis] for wgp in wgps], axis=2)
+    m_flow = np.zeros(im0.shape[:2] + (2,), dtype=np.float32)
+    (w_h, w_l) = map(lambda x: (x - 1) // 2, k_shape)
+    for i in range(w_h, im0.shape[0] - w_h):
+        for j in range(w_l, im0.shape[1] - w_l):
+            a = [[wgps[i, j, 0], wgps[i, j, 1]], [wgps[i, j, 1], wgps[i, j, 2]]]
+            b = [[-wgps[i, j, 3]], [-wgps[i, j, 4]]]
+            uv, _, rank, _ = np.linalg.lstsq(a, b, rcond=0.1)
+            m_flow[i, j, 0] = uv[0] if rank == 2 else 0
+            m_flow[i, j, 1] = uv[1] if rank == 2 else 0
+    return -m_flow
+
+
+def get_flow_arrows(flow, gap=None, show_arrows_on_plt=False):
+    gap = [gap, flow.shape[0] // 30][gap is None]
+    x = np.arange(0, flow.shape[1], 1)
+    y = np.arange(0, flow.shape[0], 1)
+    x, y = np.meshgrid(x, y)
+    fig = plt.figure()
+    axs = fig.add_axes([0, 0, 1, 1], frameon=False)
+    fig.patch.set_alpha(0)
+    axs.patch.set_alpha(0)
+    canvas = FigureCanvas(fig)
+    plt.quiver(x[::gap, ::gap], y[::-gap, ::-gap], flow[::gap, ::gap, 0], -flow[::gap, ::gap, 1], color='red')
+    axs.axis('off')
+    axs.margins(0)
+    canvas.draw()
+    image_from_plot = np.frombuffer(fig.canvas.tostring_argb(), dtype=np.uint8)
+    image_from_plot = image_from_plot.reshape(fig.canvas.get_width_height()[::-1] + (4,))
+    if not show_arrows_on_plt:
+        plt.close(fig)
+    return cv.resize(image_from_plot, dsize=flow.shape[1::-1])
+
+
+def add_flow_over_im(im, flow, show_arrows_on_plt=False):
+    im = im.copy()
+    if len(im.shape) == 2:
+        im = cv.cvtColor(im, cv.COLOR_GRAY2RGB)
+    arrows_arbg = get_flow_arrows(flow, show_arrows_on_plt=show_arrows_on_plt)
+    alpha = arrows_arbg[:, :, 0]
+    for i in range(3):
+        im[:, :, i] = (alpha / 255.0) * arrows_arbg[:, :, 1 + i] + ((255.0 - alpha) / 255.0) * im[:, :, i]
+    return im
+
+
+def reduce(im):
+    im_blur = cv.GaussianBlur(im, (5, 5), 0)
+    return im_blur[::2, ::2, ...]
+
+
+def expand(im, dst_size):
+    return cv.GaussianBlur(cv.resize(im, dst_size[1::-1], interpolation=cv.INTER_NEAREST), (5, 5), 0)
+
+
+def gaussian_pyramid(im, max_l=np.PINF):
+    levels = min(int(np.log2(min(im.shape[:2])) + 1), max_l)
+    g_pyr = [im]
+    [g_pyr.append(reduce(g_pyr[-1])) for i in range(levels-1)]
+    return g_pyr
+
+
+def laplacian_pyramid(im, max_l=np.PINF):
+    levels = min(int(np.log2(min(im.shape[:2])) + 1), max_l)
+    l_pyr = [im]
+    for i in range(levels - 1):
+        tmp = reduce(l_pyr[-1])
+        l_pyr[-1] = l_pyr[-1].astype(np.int32) - expand(tmp, l_pyr[-1].shape).astype(np.int32)
+        l_pyr.append(tmp)
+    return l_pyr
+
+
+

ps_5/input/DataSeq1/yos_img_01.jpg

@@ -0,0 +1,69 @@
+import numpy as np
+from ps_5.helper import lucas_kanade, add_flow_over_im, reduce, gaussian_pyramid, expand, laplacian_pyramid
+from ps_hepers.helpers import imread_from_rep, imshow, np_load, imsave, np_save, imfix_scale
+
+
+def p1_a():
+    a = imread_from_rep('TestSeq/Shift0', grey_scale=True)
+    b = imread_from_rep('TestSeq/ShiftR2', grey_scale=True)
+    c = imread_from_rep('TestSeq/ShiftR5U5', grey_scale=True)
+    d = imread_from_rep('TestSeq/ShiftR10', grey_scale=True)
+    e = imread_from_rep('TestSeq/ShiftR20', grey_scale=True)
+    f = imread_from_rep('TestSeq/ShiftR40', grey_scale=True)
+
+    #a
+    flow1 = lucas_kanade(a, b, (15, 15))
+    a_flow1 = add_flow_over_im(a, flow1)
+    flow2 = lucas_kanade(a, c, (47, 47))
+    a_flow2 = add_flow_over_im(a, flow2)
+    imsave(a_flow1, 'output/ps5-1-a-1.png')
+    imsave(a_flow2, 'output/ps5-1-a-2.png')
+    imshow([a_flow1, a_flow2], ['right shift', 'top right shift'], cmap='gray')
+
+    #b
+    flow_ims = [add_flow_over_im(a, lucas_kanade(a, x, (47, 47))) for x in [d, e, f]]
+    imshow(flow_ims,['r10', 'r20', 'r40'], shape=(3,1))
+    [imsave(im, 'output/ps5-1-b-%s.png' % (i+1)) for i, im in zip(range(len(flow_ims)), flow_ims)]
+
+
+def p1_exp():
+    im_names = ['TestSeq/Shift0', 'TestSeq/ShiftR5U5']
+    w_start = 5
+    w_end = 81
+    window_range = np.arange(w_start, w_end, 2)
+    exp_name = ','.join([i.replace('/', '-') for i in im_names])
+    w_range_as_str = 'w%s-%s' % (w_start, w_end)
+    a = imread_from_rep(im_names[0], grey_scale=True)
+    b = imread_from_rep(im_names[1], grey_scale=True)
+    flow_window_list = np_load(len(window_range), 'objects/flow_%s_%s.npy' % (w_range_as_str, exp_name))
+    if flow_window_list is None or len(flow_window_list) != len(window_range):
+        flow_window_list = []
+        for w in window_range:
+            print('processing images for motion flow with window size %s' % w)
+            flow1 = add_flow_over_im(a, lucas_kanade(a, b, (w, w)))
+            flow_window_list.append((w, flow1))
+            imsave(flow1, 'observations/flow_%s_w_size_%s.png' % (exp_name, w))
+    np_save(np.asarray(flow_window_list, dtype=object), 'objects/flow_%s_%s.npy' % (w_range_as_str, exp_name))
+
+    def update_exp(x, axs, sliders, buttons):
+        i = np.abs(window_range - sliders[0].val).argmin()
+        return [0], [flow_window_list[i][1]]
+
+    slider_attr = [{'label': 'Window Size', 'valmin': w_start, 'valmax': w_end, 'valstep': 2}]
+    imshow(flow_window_list[0][1], [' Detected Optical Flow'], slider_attr=slider_attr, slider_callback=[update_exp])
+
+
+def p2():
+    im = imread_from_rep('DataSeq1/yos_img_01', extension='.jpg')
+    g_py = gaussian_pyramid(im, 4)
+    imshow(g_py)
+    [imsave(g_py[i], 'output/ps5-2-a-%s.png' % (i+1)) for i in range(len(g_py))]
+    l_py = laplacian_pyramid(im, 4)
+    imshow([imfix_scale(i) for i in l_py])
+    [imsave(g_py[i], 'output/ps5-2-b-%s.png' % (i+1)) for i in range(len(g_py))]
+
+
+if __name__ == '__main__':
+    # p1_a()
+    # p1_exp()
+    p2()

ps_5/input/DataSeq1/yos_img_02.jpg

@@ -116,7 +116,7 @@ def imshow(im, im_title=None, shape=None, interpolation='bilinear', cmap=None, s
             axs[i].imshow(im[i], interpolation=interpolation, cmap=cmap)
         else:
             axs[i].imshow(im[i], interpolation=interpolation)
-        axs_title = '%s $%sx%s$  $mn=%s$  $mx=%s$ ' % (
+        axs_title = '%s $%sx%s$\n$mn=%.3f$  $mx=%.3f$ ' % (
             im_title if not type(im_title) == list else im_title[i], im[i].shape[0], im[i].shape[1], np.min(im[i]),
             np.max(im[i]))
         axs[i].set_title(axs_title, fontweight='bold')