コード例 #1
0
def main():

  fnames = ['aloe-texture', 'cones-texture', 'rocks1-texture', 'teddy-texture', 'garnics1-texture', 'box-1-texture', 'scene05-texture', 'scene01-texture',
            'table1-texture', 'blue-pan-texture', 'red-plate-texture', 'lampshade1-texture', 'breakfast-1-texture', 'plastic-texture', 'cups1-texture']
  path = './texture-evaluation/texture-values/'

  for fname in fnames:
    arr = np.loadtxt(path+fname+'.dat', dtype=float)
    plt.plot_array('Texture', arr, 2, 6, path + 'plots/' + fname)
コード例 #2
0
def main():

    fnames = [
        'aloe-texture', 'cones-texture', 'rocks1-texture', 'teddy-texture',
        'garnics1-texture', 'box-1-texture', 'scene05-texture',
        'scene01-texture', 'table1-texture', 'blue-pan-texture',
        'red-plate-texture', 'lampshade1-texture', 'breakfast-1-texture',
        'plastic-texture', 'cups1-texture'
    ]
    path = './texture-evaluation/texture-values/'

    for fname in fnames:
        arr = np.loadtxt(path + fname + '.dat', dtype=float)
        plt.plot_array('Texture', arr, 2, 6, path + 'plots/' + fname)
コード例 #3
0
def view_disparity(path, disparity_min, disparity_max, occlusion_range):

  arr_sparse_disparity_incons = abs(np.loadtxt(path+'sparse_disparity_incons.dat'))
  arr_sparse_disparity_cons = abs(np.loadtxt(path+'sparse_disparity_cons.dat'))

  arr_average_disparity = abs(np.loadtxt(path+'average-disparity.dat'))
  arr_average_disparity_lines = abs(np.loadtxt(path+'average-disparity-lines.dat'))
  arr_edge_disparity = abs(np.loadtxt(path+'edge-disparity.dat'))
  arr_edge_disparity_final = abs(np.loadtxt(path+'edge-disparity-final.dat'))
  arr_initial_disparity = abs(np.loadtxt(path+'initial-disparity.dat'))
  arr_sigma_map = np.loadtxt(path+'sigma-map.dat')
  arr_occlusion_map = np.loadtxt(path+'occlusion-map.dat')
  arr_outliers_map = np.loadtxt(path+'outliers-map.dat')
  arr_edge_disparity_mask = np.loadtxt(path+'edge-disparity-mask.dat')
  arr_sparse_filtered = abs(np.loadtxt(path+'sparse-disparity-filtered.dat'))

  # get size
  height = arr_sparse_disparity_cons.shape[0]
  width = arr_sparse_disparity_cons.shape[1]

  print 'height = ', height
  print 'width = ', width

  # plot inconsistent sparse disparity map
  min_val = disparity_min
  max_val = disparity_max

  arr_sparse_disparity_incons[0:height,0:occlusion_range] = 'nan'
  arr_average_disparity[0:height,0:occlusion_range] = 'nan'
  arr_average_disparity_lines[0:height,0:occlusion_range] = 'nan'
  arr_edge_disparity[0:height,0:occlusion_range] = 'nan'
  arr_edge_disparity_final[0:height,0:occlusion_range] = 'nan'
  arr_initial_disparity[0:height,0:occlusion_range] = 'nan'
  arr_occlusion_map[0:height,0:occlusion_range] = 'nan'
  arr_edge_disparity_mask[0:height,0:occlusion_range] = 'nan'
  arr_sigma_map[0:height,0:occlusion_range] = 'nan'
  arr_outliers_map[0:height,0:occlusion_range] = 'nan'

  plt.plot_array('Inconsistent sparse disparity map (phase-based)', arr_sparse_disparity_incons, min_val, max_val, path+'sparse-disparity-incons')

  plt.plot_array('Consistent sparse disparity map (phase-based)', arr_sparse_disparity_cons, min_val, max_val, path+'sparse-disparity-cons')
  plt.plot_array('Filtered sparse disparity map', arr_sparse_filtered, min_val, max_val, path+'sparse-disparity-filtered')
  plt.plot_array('Average disparity', arr_average_disparity, min_val, max_val, path+'average-disparity')
  plt.plot_array('Average disparity (lines)', arr_average_disparity_lines, min_val, max_val, path+'average-disparity-lines')

  # make borders thicker
  extend_border_horizontal(arr_edge_disparity)
  extend_border_vertical(arr_edge_disparity)

  extend_border_horizontal(arr_edge_disparity_final)
  extend_border_vertical(arr_edge_disparity_final)

  extend_sigma_horizontal(arr_sigma_map,0.3)
  extend_sigma_vertical(arr_sigma_map,0.3)

  # replace zeros by NaN values
  for i in range(1,height):
    for j in range(1,width):

      if(arr_edge_disparity_final[i,j] != 0):
        arr_initial_disparity[i,j] = arr_edge_disparity_final[i,j]
    
      if(arr_edge_disparity[i,j] == 0):
        arr_edge_disparity[i,j] = 'nan'

      if(arr_edge_disparity_final[i,j] == 0):
        arr_edge_disparity_final[i,j] = 'nan'

      if(arr_edge_disparity_mask[i,j] == 0):
        arr_edge_disparity_mask[i,j] = 'nan'

      if(arr_occlusion_map[i,j] == 0):
        arr_occlusion_map[i,j] = 'nan'

      if(arr_outliers_map[i,j] == 0):
        arr_outliers_map[i,j] = 'nan'

  plt.plot_array('Edge disparity', arr_edge_disparity, min_val, max_val, path+'edge-disparity')
  plt.plot_array('Final edge disparity', arr_edge_disparity_final, min_val, max_val, path+'edge-disparity-final')

  plt.plot_array('Initial disparity', arr_initial_disparity, min_val, max_val, path+'initial-disparity')

  #plot_array('Sigma map', arr_sigma_map, arr_sigma_map.min(), arr_sigma_map.max(), 'sigma-map')
  plt.plot_array('Sigma map', arr_sigma_map, 0, 1, path+'sigma-map')

  #plot_array('Occlusion map', arr_occlusion_map, arr_occlusion_map.min(), arr_occlusion_map.max(), 'occlusion-map')
  plt.plot_array('Occlusion map', arr_occlusion_map, 0, 1, path+'occlusion-map')
  plt.plot_array('Outliers map', arr_outliers_map, 0, 1, path+'outliers-map')
  plt.plot_array('Edge disparity mask', arr_edge_disparity_mask, 0, 1, path+'edge-disparity-mask')
コード例 #4
0
def surface_fitting_robust_lsq(local_folder, arr_segments, arr_init_disp, arr_edge_disp, disp_min, disp_max):

    # get segment labels
    labels = set(np.unique(arr_segments)).difference((0,))
    # print 'labels = ', labels

    # matrix with regression weights
    arr_regr_weights_init = np.zeros(arr_init_disp.shape, dtype=float)

    arr_regr_weights_init[arr_init_disp.nonzero()] = 0.3
    arr_regr_weights_init[arr_edge_disp.nonzero()] = 1.0

    # initial sparse disparity maps without outliers for a specific model
    disparity_init_const = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_init_planar = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_init_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # weights for sparse disparity values without outliers
    weights_const = np.zeros(arr_init_disp.shape, dtype=float)
    weights_planar = np.zeros(arr_init_disp.shape, dtype=float)
    weights_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # dense disparity maps obtained using a specific model
    disparity_const = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_planar = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # final dense disparity map after the model selection
    disparity_final = np.zeros(arr_init_disp.shape, dtype=float)

    t1 = dt.datetime.now()

    # go over all segments and fit sparse disparity input to the model
    for label in labels:

        # print ''
        # print 'current label = ', label

        # masks of the considered segment and its sparse disparity map
        segment_mask = (arr_segments == label) * 1
        disparity_mask = (arr_init_disp > 0) * segment_mask * 1

        # disparity of the current segment
        disparity = arr_init_disp * disparity_mask

        if disparity.sum() == 0:
            continue

        segment_regr_weights = np.zeros(disparity.shape, dtype=float)
        segment_regr_weights = (disparity > 0) * arr_regr_weights_init

        # get the robust least squares solution for the current segment
        # and for const, planar, and quadric models

        # get indices of given disparity values
        indices = disparity.nonzero()

        x = np.zeros(len(indices[1]))
        y = np.zeros(len(indices[0]))

        x[:] = indices[1]
        y[:] = indices[0]

        z_ones = np.ones([x.size, 1])
        Z = disparity

        segment_regr_weights_fl = segment_regr_weights[segment_regr_weights.nonzero()].flatten()
        segment_regr_weights = np.reshape(segment_regr_weights_fl, ([len(segment_regr_weights_fl), 1]))

        # constant model
        X = z_ones
        a_lsq_const, abs_res_scale_const = robust_lsq.get_dense_disparity_robust_lsq(X, Z, segment_regr_weights)
        mad_const, w_const, d_const = estimate_weights.estimate_weights(
            X, Z, a_lsq_const, abs_res_scale_const, segment_regr_weights, disparity.shape
        )

        # planar model
        X = np.hstack((np.reshape(x, ([len(x), 1])), np.reshape(y, ([len(y), 1])), z_ones))
        a_lsq_planar, abs_res_scale_planar = robust_lsq.get_dense_disparity_robust_lsq(X, Z, segment_regr_weights)
        mad_planar, w_planar, d_planar = estimate_weights.estimate_weights(
            X, Z, a_lsq_planar, abs_res_scale_planar, segment_regr_weights, disparity.shape
        )

        # quadric model
        x2 = x ** 2
        y2 = y ** 2
        xy = x * y

        # v1 = np.reshape(x2, ([len(x2),1]))
        # v2 = np.reshape(y2, ([len(y2),1]))
        # v3 = np.reshape(x, ([len(x),1]))
        # v4 = np.reshape(y, ([len(y),1]))

        v1 = np.reshape(x2, ([len(x2), 1]))
        v2 = np.reshape(y2, ([len(y2), 1]))
        v3 = np.reshape(xy, ([len(xy), 1]))
        v4 = np.reshape(x, ([len(x), 1]))
        v5 = np.reshape(y, ([len(y), 1]))

        # X = np.hstack((v1, v2, v3, v4, z_ones))
        X = np.hstack((v1, v2, v3, v4, v5, z_ones))
        a_lsq_quadric, abs_res_scale_quadric = robust_lsq.get_dense_disparity_robust_lsq(X, Z, segment_regr_weights)
        mad_quadric, w_quadric, d_quadric = estimate_weights.estimate_weights(
            X, Z, a_lsq_quadric, abs_res_scale_quadric, segment_regr_weights, disparity.shape
        )

        # calculate disparity for the current segment based on the found model
        segment_indices = segment_mask.nonzero()

        disparity_init_const[segment_indices] = d_const[segment_indices]
        disparity_init_planar[segment_indices] = d_planar[segment_indices]
        disparity_init_quadric[segment_indices] = d_quadric[segment_indices]

        weights_const[segment_indices] = w_const[segment_indices]
        weights_planar[segment_indices] = w_planar[segment_indices]
        weights_quadric[segment_indices] = w_quadric[segment_indices]

        x_s = np.zeros(len(segment_indices[1]))
        y_s = np.zeros(len(segment_indices[0]))

        x_s[:] = segment_indices[1]
        y_s[:] = segment_indices[0]

        # calculate disparity values according to found models
        disparity_const[segment_indices] = a_lsq_const[0]
        disparity_planar[segment_indices] = a_lsq_planar[0] * x_s + a_lsq_planar[1] * y_s + a_lsq_planar[2]
        # disparity_quadric[ segment_indices ] = a_lsq_quadric[0]*x_s*x_s + a_lsq_quadric[1]*y_s*y_s + a_lsq_quadric[2]*x_s + a_lsq_quadric[3]*y_s + a_lsq_quadric[4]
        disparity_quadric[segment_indices] = (
            a_lsq_quadric[0] * x_s * x_s
            + a_lsq_quadric[1] * y_s * y_s
            + a_lsq_quadric[2] * x_s * y_s
            + a_lsq_quadric[3] * x_s
            + a_lsq_quadric[4] * y_s
            + a_lsq_quadric[5]
        )

        # select the best model
        winner = np.argmin([mad_const, mad_planar, mad_quadric])

        if winner == 0:
            disparity_final[segment_indices] = disparity_const[segment_indices]
        elif winner == 1:
            disparity_final[segment_indices] = disparity_planar[segment_indices]
        elif winner == 2:
            disparity_final[segment_indices] = disparity_quadric[segment_indices]

    # calculated elapsed time
    t2 = dt.datetime.now()
    ms = (t2 - t1).microseconds / 1e3
    print "Robust LSQ, elapsed time = ", ms, " ms"
    print ""

    # replace zeros by NaN values just for displaying
    disparity_init_const[(disparity_init_const == 0).nonzero()] = "nan"
    disparity_init_planar[(disparity_init_planar == 0).nonzero()] = "nan"
    disparity_init_quadric[(disparity_init_quadric == 0).nonzero()] = "nan"

    arr_regr_weights_init[(arr_regr_weights_init == 0).nonzero()] = "nan"

    weights_const[(weights_const == 0).nonzero()] = "nan"
    weights_planar[(weights_planar == 0).nonzero()] = "nan"
    weights_quadric[(weights_quadric == 0).nonzero()] = "nan"

    plt.plot_array(
        "Initial disparity (robust, const)",
        disparity_init_const,
        disp_min,
        disp_max,
        local_folder + "init-disparity-rob-const",
    )
    plt.plot_array(
        "Initial disparity (robust, planar)",
        disparity_init_planar,
        disp_min,
        disp_max,
        local_folder + "init-disparity-rob-planar",
    )
    plt.plot_array(
        "Initial disparity (robust, quadric)",
        disparity_init_quadric,
        disp_min,
        disp_max,
        local_folder + "init-disparity-rob-quadric",
    )

    plt.plot_array("Regression weights", arr_regr_weights_init, 0, 1, local_folder + "regression-weight")

    w_min = 0.0
    w_max = 0.37

    plt.plot_array("Weights (robust, const)", weights_const, w_min, w_max, local_folder + "weights-rob-const")
    plt.plot_array("Weights (robust, planar)", weights_planar, w_min, w_max, local_folder + "weights-rob-planar")
    plt.plot_array("Weights (robust, quadric)", weights_quadric, w_min, w_max, local_folder + "weights-rob-quadric")

    return disparity_const, disparity_planar, disparity_quadric, disparity_final
コード例 #5
0
def view_disparity(path, disparity_min, disparity_max, occlusion_range):

    arr_sparse_disparity_incons = abs(
        np.loadtxt(path + 'sparse_disparity_incons.dat'))
    arr_sparse_disparity_cons = abs(
        np.loadtxt(path + 'sparse_disparity_cons.dat'))

    arr_average_disparity = abs(np.loadtxt(path + 'average-disparity.dat'))
    arr_average_disparity_lines = abs(
        np.loadtxt(path + 'average-disparity-lines.dat'))
    arr_edge_disparity = abs(np.loadtxt(path + 'edge-disparity.dat'))
    arr_edge_disparity_final = abs(
        np.loadtxt(path + 'edge-disparity-final.dat'))
    arr_initial_disparity = abs(np.loadtxt(path + 'initial-disparity.dat'))
    arr_sigma_map = np.loadtxt(path + 'sigma-map.dat')
    arr_occlusion_map = np.loadtxt(path + 'occlusion-map.dat')
    arr_outliers_map = np.loadtxt(path + 'outliers-map.dat')
    arr_edge_disparity_mask = np.loadtxt(path + 'edge-disparity-mask.dat')
    arr_sparse_filtered = abs(
        np.loadtxt(path + 'sparse-disparity-filtered.dat'))

    # get size
    height = arr_sparse_disparity_cons.shape[0]
    width = arr_sparse_disparity_cons.shape[1]

    print 'height = ', height
    print 'width = ', width

    # plot inconsistent sparse disparity map
    min_val = disparity_min
    max_val = disparity_max

    arr_sparse_disparity_incons[0:height, 0:occlusion_range] = 'nan'
    arr_average_disparity[0:height, 0:occlusion_range] = 'nan'
    arr_average_disparity_lines[0:height, 0:occlusion_range] = 'nan'
    arr_edge_disparity[0:height, 0:occlusion_range] = 'nan'
    arr_edge_disparity_final[0:height, 0:occlusion_range] = 'nan'
    arr_initial_disparity[0:height, 0:occlusion_range] = 'nan'
    arr_occlusion_map[0:height, 0:occlusion_range] = 'nan'
    arr_edge_disparity_mask[0:height, 0:occlusion_range] = 'nan'
    arr_sigma_map[0:height, 0:occlusion_range] = 'nan'
    arr_outliers_map[0:height, 0:occlusion_range] = 'nan'

    plt.plot_array('Inconsistent sparse disparity map (phase-based)',
                   arr_sparse_disparity_incons, min_val, max_val,
                   path + 'sparse-disparity-incons')

    plt.plot_array('Consistent sparse disparity map (phase-based)',
                   arr_sparse_disparity_cons, min_val, max_val,
                   path + 'sparse-disparity-cons')
    plt.plot_array('Filtered sparse disparity map', arr_sparse_filtered,
                   min_val, max_val, path + 'sparse-disparity-filtered')
    plt.plot_array('Average disparity', arr_average_disparity, min_val,
                   max_val, path + 'average-disparity')
    plt.plot_array('Average disparity (lines)', arr_average_disparity_lines,
                   min_val, max_val, path + 'average-disparity-lines')

    # make borders thicker
    extend_border_horizontal(arr_edge_disparity)
    extend_border_vertical(arr_edge_disparity)

    extend_border_horizontal(arr_edge_disparity_final)
    extend_border_vertical(arr_edge_disparity_final)

    extend_sigma_horizontal(arr_sigma_map, 0.3)
    extend_sigma_vertical(arr_sigma_map, 0.3)

    # replace zeros by NaN values
    for i in range(1, height):
        for j in range(1, width):

            if (arr_edge_disparity_final[i, j] != 0):
                arr_initial_disparity[i, j] = arr_edge_disparity_final[i, j]

            if (arr_edge_disparity[i, j] == 0):
                arr_edge_disparity[i, j] = 'nan'

            if (arr_edge_disparity_final[i, j] == 0):
                arr_edge_disparity_final[i, j] = 'nan'

            if (arr_edge_disparity_mask[i, j] == 0):
                arr_edge_disparity_mask[i, j] = 'nan'

            if (arr_occlusion_map[i, j] == 0):
                arr_occlusion_map[i, j] = 'nan'

            if (arr_outliers_map[i, j] == 0):
                arr_outliers_map[i, j] = 'nan'

    plt.plot_array('Edge disparity', arr_edge_disparity, min_val, max_val,
                   path + 'edge-disparity')
    plt.plot_array('Final edge disparity', arr_edge_disparity_final, min_val,
                   max_val, path + 'edge-disparity-final')

    plt.plot_array('Initial disparity', arr_initial_disparity, min_val,
                   max_val, path + 'initial-disparity')

    #plot_array('Sigma map', arr_sigma_map, arr_sigma_map.min(), arr_sigma_map.max(), 'sigma-map')
    plt.plot_array('Sigma map', arr_sigma_map, 0, 1, path + 'sigma-map')

    #plot_array('Occlusion map', arr_occlusion_map, arr_occlusion_map.min(), arr_occlusion_map.max(), 'occlusion-map')
    plt.plot_array('Occlusion map', arr_occlusion_map, 0, 1,
                   path + 'occlusion-map')
    plt.plot_array('Outliers map', arr_outliers_map, 0, 1,
                   path + 'outliers-map')
    plt.plot_array('Edge disparity mask', arr_edge_disparity_mask, 0, 1,
                   path + 'edge-disparity-mask')
コード例 #6
0
def surface_fitting_robust_lsq(local_folder, arr_segments, arr_init_disp,
                               arr_edge_disp, disp_min, disp_max):

    # get segment labels
    labels = set(np.unique(arr_segments)).difference((0, ))
    #print 'labels = ', labels

    # matrix with regression weights
    arr_regr_weights_init = np.zeros(arr_init_disp.shape, dtype=float)

    arr_regr_weights_init[arr_init_disp.nonzero()] = 0.3
    arr_regr_weights_init[arr_edge_disp.nonzero()] = 1.0

    # initial sparse disparity maps without outliers for a specific model
    disparity_init_const = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_init_planar = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_init_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # weights for sparse disparity values without outliers
    weights_const = np.zeros(arr_init_disp.shape, dtype=float)
    weights_planar = np.zeros(arr_init_disp.shape, dtype=float)
    weights_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # dense disparity maps obtained using a specific model
    disparity_const = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_planar = np.zeros(arr_init_disp.shape, dtype=float)
    disparity_quadric = np.zeros(arr_init_disp.shape, dtype=float)

    # final dense disparity map after the model selection
    disparity_final = np.zeros(arr_init_disp.shape, dtype=float)

    t1 = dt.datetime.now()

    # go over all segments and fit sparse disparity input to the model
    for label in labels:

        #print ''
        #print 'current label = ', label

        # masks of the considered segment and its sparse disparity map
        segment_mask = (arr_segments == label) * 1
        disparity_mask = (arr_init_disp > 0) * segment_mask * 1

        # disparity of the current segment
        disparity = arr_init_disp * disparity_mask

        if disparity.sum() == 0:
            continue

        segment_regr_weights = np.zeros(disparity.shape, dtype=float)
        segment_regr_weights = (disparity > 0) * arr_regr_weights_init

        # get the robust least squares solution for the current segment
        # and for const, planar, and quadric models

        # get indices of given disparity values
        indices = disparity.nonzero()

        x = np.zeros(len(indices[1]))
        y = np.zeros(len(indices[0]))

        x[:] = indices[1]
        y[:] = indices[0]

        z_ones = np.ones([x.size, 1])
        Z = disparity

        segment_regr_weights_fl = segment_regr_weights[
            segment_regr_weights.nonzero()].flatten()
        segment_regr_weights = np.reshape(segment_regr_weights_fl,
                                          ([len(segment_regr_weights_fl), 1]))

        # constant model
        X = z_ones
        a_lsq_const, abs_res_scale_const = robust_lsq.get_dense_disparity_robust_lsq(
            X, Z, segment_regr_weights)
        mad_const, w_const, d_const = estimate_weights.estimate_weights(
            X, Z, a_lsq_const, abs_res_scale_const, segment_regr_weights,
            disparity.shape)

        # planar model
        X = np.hstack(
            (np.reshape(x, ([len(x), 1])), np.reshape(y,
                                                      ([len(y), 1])), z_ones))
        a_lsq_planar, abs_res_scale_planar = robust_lsq.get_dense_disparity_robust_lsq(
            X, Z, segment_regr_weights)
        mad_planar, w_planar, d_planar = estimate_weights.estimate_weights(
            X, Z, a_lsq_planar, abs_res_scale_planar, segment_regr_weights,
            disparity.shape)

        # quadric model
        x2 = x**2
        y2 = y**2
        xy = x * y

        #v1 = np.reshape(x2, ([len(x2),1]))
        #v2 = np.reshape(y2, ([len(y2),1]))
        #v3 = np.reshape(x, ([len(x),1]))
        #v4 = np.reshape(y, ([len(y),1]))

        v1 = np.reshape(x2, ([len(x2), 1]))
        v2 = np.reshape(y2, ([len(y2), 1]))
        v3 = np.reshape(xy, ([len(xy), 1]))
        v4 = np.reshape(x, ([len(x), 1]))
        v5 = np.reshape(y, ([len(y), 1]))

        #X = np.hstack((v1, v2, v3, v4, z_ones))
        X = np.hstack((v1, v2, v3, v4, v5, z_ones))
        a_lsq_quadric, abs_res_scale_quadric = robust_lsq.get_dense_disparity_robust_lsq(
            X, Z, segment_regr_weights)
        mad_quadric, w_quadric, d_quadric = estimate_weights.estimate_weights(
            X, Z, a_lsq_quadric, abs_res_scale_quadric, segment_regr_weights,
            disparity.shape)

        # calculate disparity for the current segment based on the found model
        segment_indices = segment_mask.nonzero()

        disparity_init_const[segment_indices] = d_const[segment_indices]
        disparity_init_planar[segment_indices] = d_planar[segment_indices]
        disparity_init_quadric[segment_indices] = d_quadric[segment_indices]

        weights_const[segment_indices] = w_const[segment_indices]
        weights_planar[segment_indices] = w_planar[segment_indices]
        weights_quadric[segment_indices] = w_quadric[segment_indices]

        x_s = np.zeros(len(segment_indices[1]))
        y_s = np.zeros(len(segment_indices[0]))

        x_s[:] = segment_indices[1]
        y_s[:] = segment_indices[0]

        # calculate disparity values according to found models
        disparity_const[segment_indices] = a_lsq_const[0]
        disparity_planar[segment_indices] = a_lsq_planar[
            0] * x_s + a_lsq_planar[1] * y_s + a_lsq_planar[2]
        #disparity_quadric[ segment_indices ] = a_lsq_quadric[0]*x_s*x_s + a_lsq_quadric[1]*y_s*y_s + a_lsq_quadric[2]*x_s + a_lsq_quadric[3]*y_s + a_lsq_quadric[4]
        disparity_quadric[
            segment_indices] = a_lsq_quadric[0] * x_s * x_s + a_lsq_quadric[
                1] * y_s * y_s + a_lsq_quadric[2] * x_s * y_s + a_lsq_quadric[
                    3] * x_s + a_lsq_quadric[4] * y_s + a_lsq_quadric[5]

        # select the best model
        winner = np.argmin([mad_const, mad_planar, mad_quadric])

        if winner == 0:
            disparity_final[segment_indices] = disparity_const[segment_indices]
        elif winner == 1:
            disparity_final[segment_indices] = disparity_planar[
                segment_indices]
        elif winner == 2:
            disparity_final[segment_indices] = disparity_quadric[
                segment_indices]

    # calculated elapsed time
    t2 = dt.datetime.now()
    ms = (t2 - t1).microseconds / 1e3
    print 'Robust LSQ, elapsed time = ', ms, ' ms'
    print ''

    # replace zeros by NaN values just for displaying
    disparity_init_const[(disparity_init_const == 0).nonzero()] = 'nan'
    disparity_init_planar[(disparity_init_planar == 0).nonzero()] = 'nan'
    disparity_init_quadric[(disparity_init_quadric == 0).nonzero()] = 'nan'

    arr_regr_weights_init[(arr_regr_weights_init == 0).nonzero()] = 'nan'

    weights_const[(weights_const == 0).nonzero()] = 'nan'
    weights_planar[(weights_planar == 0).nonzero()] = 'nan'
    weights_quadric[(weights_quadric == 0).nonzero()] = 'nan'

    plt.plot_array('Initial disparity (robust, const)', disparity_init_const,
                   disp_min, disp_max,
                   local_folder + 'init-disparity-rob-const')
    plt.plot_array('Initial disparity (robust, planar)', disparity_init_planar,
                   disp_min, disp_max,
                   local_folder + 'init-disparity-rob-planar')
    plt.plot_array('Initial disparity (robust, quadric)',
                   disparity_init_quadric, disp_min, disp_max,
                   local_folder + 'init-disparity-rob-quadric')

    plt.plot_array('Regression weights', arr_regr_weights_init, 0, 1,
                   local_folder + 'regression-weight')

    w_min = 0.0
    w_max = 0.37

    plt.plot_array('Weights (robust, const)', weights_const, w_min, w_max,
                   local_folder + 'weights-rob-const')
    plt.plot_array('Weights (robust, planar)', weights_planar, w_min, w_max,
                   local_folder + 'weights-rob-planar')
    plt.plot_array('Weights (robust, quadric)', weights_quadric, w_min, w_max,
                   local_folder + 'weights-rob-quadric')

    return disparity_const, disparity_planar, disparity_quadric, disparity_final
コード例 #7
0
def surface_fitting(output_path, occlusion_range, disp_min, disp_max):

  #fname_segments = './segments-left.dat'             # input left segments
  #fname_cons_disp = './sparse_disparity_cons.dat'    # consistent sparse disparity estimated by the phase-based method
  #fname_edge_disp = './edge-disparity-final.dat'     # edge disparity map
  #fname_init_disp = './initial-disparity.dat'        # initial disparity map

  fname_segments = output_path + 'segments-left.dat'             # input left segments
  fname_cons_disp = output_path + 'sparse_disparity_cons.dat'    # consistent sparse disparity estimated by the phase-based method
  fname_edge_disp = output_path + 'edge-disparity-final.dat'     # edge disparity map
  fname_init_disp = output_path + 'initial-disparity.dat'        # initial disparity map

  #local_folder = './tmp/'  # folder for final results
  #occlusion_range = 32     # range of a half-occlusion area (for left segments)
  
  # min and max disparity values for color scaling
  #disp_min = 0
  #disp_max = 50#45#48#50
  
  arr_segments = np.loadtxt(fname_segments, dtype=float)
  arr_cons_disp = abs(np.loadtxt(fname_cons_disp, dtype=float))
  arr_edge_disp = np.loadtxt(fname_edge_disp, dtype=float)
  arr_init_disp = np.loadtxt(fname_init_disp, dtype=float)

  # replace 'NaN's by zeros
  arr_init_disp = np.nan_to_num(arr_init_disp)
  arr_cons_disp = np.nan_to_num(arr_cons_disp)

  # clean input segments and find regions remained unfound after segmentation
  arr_segments, arr_segments_gaps, arr_segments_final = find_small_segments.detect_small_segments(arr_segments, occlusion_range)
  
  # save clean segments, segmentation gaps and final segments (clean segments + filled gaps)
  segment_colors = plt.generate_colors()
  find_small_segments.save_segments(output_path + 'segments-left-original', arr_segments, segment_colors)
  find_small_segments.save_segments(output_path + 'segments-left-gaps', arr_segments_gaps, segment_colors)
  find_small_segments.save_segments(output_path + 'segments-left-final', arr_segments_final, segment_colors)
  
  # for segments with a few estimations in the initial map use input consistent disparity
  arr_init_disp = disparity_operations.complement_initial_disparity(arr_segments, arr_init_disp, arr_cons_disp)
  
  # CASE 1: regular least squares (for both segment gaps and segments)
  disparity_gaps_reg_const, disparity_gaps_reg_planar, disparity_gaps_reg_quadric = fitting_regular_lsq.surface_fitting_regular_lsq(arr_segments_gaps, arr_cons_disp)
  disparity_reg_const, disparity_reg_planar, disparity_reg_quadric = fitting_regular_lsq.surface_fitting_regular_lsq(arr_segments, arr_init_disp)
  
  # go over gap labels and fill gaps in all maps by const disparity values
  for lb in set(np.unique(arr_segments_gaps)).difference((0,)):
  
    disparity_reg_const[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_reg_const[ (arr_segments_gaps == lb).nonzero() ]
    disparity_reg_planar[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_reg_const[ (arr_segments_gaps == lb).nonzero() ]
    disparity_reg_quadric[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_reg_const[ (arr_segments_gaps == lb).nonzero() ]
  
  
  # CASE 2: robust least squares (for both segment gaps and segments)
  disparity_gaps_rob_const, disparity_gaps_rob_planar, disparity_gaps_rob_quadric, disparity_gaps_rob_final = fitting_robust_lsq.surface_fitting_robust_lsq(output_path, arr_segments_gaps, arr_cons_disp, arr_edge_disp, disp_min, disp_max)
  disparity_rob_const, disparity_rob_planar, disparity_rob_quadric, disparity_rob_final = fitting_robust_lsq.surface_fitting_robust_lsq(output_path, arr_segments, arr_init_disp, arr_edge_disp, disp_min, disp_max)  

  # go over gap labels and fill gaps in all maps by const disparity values
  for lb in set(np.unique(arr_segments_gaps)).difference((0,)):
  
    disparity_rob_const[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_rob_const[ (arr_segments_gaps == lb).nonzero() ]
    disparity_rob_planar[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_rob_const[ (arr_segments_gaps == lb).nonzero() ]
    disparity_rob_quadric[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_rob_const[ (arr_segments_gaps == lb).nonzero() ]
    disparity_rob_final[ (arr_segments_gaps == lb).nonzero() ] = disparity_gaps_rob_const[ (arr_segments_gaps == lb).nonzero() ]

    
  # perform interpolation of disparity values for empty pixels
  disparity_reg_const = disparity_operations.disparity_interpolation(disparity_reg_const, arr_segments_final, occlusion_range)
  disparity_reg_planar = disparity_operations.disparity_interpolation(disparity_reg_planar, arr_segments_final, occlusion_range)
  disparity_reg_quadric = disparity_operations.disparity_interpolation(disparity_reg_quadric, arr_segments_final, occlusion_range)
  
  disparity_rob_const = disparity_operations.disparity_interpolation(disparity_rob_const, arr_segments_final, occlusion_range)
  disparity_rob_planar = disparity_operations.disparity_interpolation(disparity_rob_planar, arr_segments_final, occlusion_range)
  disparity_rob_quadric = disparity_operations.disparity_interpolation(disparity_rob_quadric, arr_segments_final, occlusion_range)
  disparity_rob_final = disparity_operations.disparity_interpolation(disparity_rob_final, arr_segments_final, occlusion_range)
  
  # PLOT DATA  
  
  # replace zeros by NaN to make them white in plots
  arr_edge_disp[ (arr_edge_disp == 0).nonzero() ] = 'nan'
  arr_init_disp[ (arr_init_disp == 0).nonzero() ] = 'nan'
  arr_cons_disp[ (arr_cons_disp == 0).nonzero() ] = 'nan'

  disparity_reg_const[ (disparity_reg_const == 0).nonzero() ] = 'nan'
  disparity_reg_planar[ (disparity_reg_planar == 0).nonzero() ] = 'nan'
  disparity_reg_quadric[ (disparity_reg_quadric == 0).nonzero() ] = 'nan'

  disparity_gaps_reg_const[ (disparity_gaps_reg_const == 0).nonzero() ] = 'nan'
  disparity_gaps_reg_planar[ (disparity_gaps_reg_planar == 0).nonzero() ] = 'nan'
  disparity_gaps_reg_quadric[ (disparity_gaps_reg_quadric == 0).nonzero() ] = 'nan'

  disparity_gaps_rob_const[ (disparity_gaps_rob_const == 0).nonzero() ] = 'nan'
  disparity_gaps_rob_planar[ (disparity_gaps_rob_planar == 0).nonzero() ] = 'nan'
  disparity_gaps_rob_quadric[ (disparity_gaps_rob_quadric == 0).nonzero() ] = 'nan'

  disparity_rob_const[ (disparity_rob_const == 0).nonzero() ] = 'nan'
  disparity_rob_planar[ (disparity_rob_planar == 0).nonzero() ] = 'nan'
  disparity_rob_quadric[ (disparity_rob_quadric == 0).nonzero() ] = 'nan'
  disparity_rob_final[ (disparity_rob_final == 0).nonzero() ] = 'nan'

  plt.plot_array('Consistent sparse disparity (phase-based)', arr_cons_disp, disp_min, disp_max, output_path + 'sparse-disparity-consistent')
  plt.plot_array('Edge Disparity', arr_edge_disp, disp_min, disp_max, output_path + 'edge-disparity')
  plt.plot_array('Initial Disparity', arr_init_disp, disp_min, disp_max, output_path + 'init-disparity')

  plt.plot_array('Final Disparity (regular LSQ, const)', disparity_reg_const, disp_min, disp_max, output_path + 'dense-disparity-reg-const')
  plt.plot_array('Final Disparity (regular LSQ, planar)', disparity_reg_planar, disp_min, disp_max, output_path + 'dense-disparity-reg-planar')
  plt.plot_array('Final Disparity (regular LSQ, quadric)', disparity_reg_quadric, disp_min, disp_max, output_path + 'dense-disparity-reg-quadric')

  #plt.plot_array('Gaps Disparity (regular LSQ, const)', disparity_gaps_reg_const, disp_min, disp_max, local_folder + 'dense-disparity-gaps-reg-const')
  #plt.plot_array('Gaps Disparity (regular LSQ, planar)', disparity_gaps_reg_planar, disp_min, disp_max, local_folder + 'dense-disparity-gaps-reg-planar')
  #plt.plot_array('Gaps Disparity (regular LSQ, quadric)', disparity_gaps_reg_quadric, disp_min, disp_max, local_folder + 'dense-disparity-gaps-reg-quadric')

  #plt.plot_array('Gaps Disparity (robust LSQ, const)', disparity_gaps_rob_const, disp_min, disp_max, local_folder + 'dense-disparity-gaps-rob-const')
  #plt.plot_array('Gaps Disparity (robust LSQ, planar)', disparity_gaps_rob_planar, disp_min, disp_max, local_folder + 'dense-disparity-gaps-rob-planar')
  #plt.plot_array('Gaps Disparity (robust LSQ, quadric)', disparity_gaps_rob_quadric, disp_min, disp_max, local_folder + 'dense-disparity-gaps-rob-quadric')

  plt.plot_array('Final Disparity (robust LSQ, const)', disparity_rob_const, disp_min, disp_max, output_path + 'dense-disparity-rob-const')
  plt.plot_array('Final Disparity (robust LSQ, planar)', disparity_rob_planar, disp_min, disp_max, output_path + 'dense-disparity-rob-planar')
  plt.plot_array('Final Disparity (robust LSQ, quadric)', disparity_rob_quadric, disp_min, disp_max, output_path + 'dense-disparity-rob-quadric')
  plt.plot_array('Final Disparity (robust, model selection)', disparity_rob_final, disp_min, disp_max, output_path + 'dense-disparity-rob-final')
  
  # save estimated disparities as text files
  np.savetxt(output_path + 'dense-disparity-reg-const.dat', disparity_reg_const)
  np.savetxt(output_path + 'dense-disparity-reg-planar.dat', disparity_reg_planar)
  np.savetxt(output_path + 'dense-disparity-reg-quadric.dat', disparity_reg_quadric)
  
  np.savetxt(output_path + 'dense-disparity-rob-const.dat', disparity_rob_const)
  np.savetxt(output_path + 'dense-disparity-rob-planar.dat', disparity_rob_planar)
  np.savetxt(output_path + 'dense-disparity-rob-quadric.dat', disparity_rob_quadric)
  
  np.savetxt(output_path + 'dense-disparity-rob-final.dat', disparity_rob_final)
  
  return disparity_rob_final