def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ # Get the Ix and Iy derivatives of the image using the filters [1, 0, −1], [1, 0, −1]T respectively : conovlve_der = np.array([[1, 0, -1]]) x_der = convolve2d(im, conovlve_der, mode='same', boundary='symm') y_der = convolve2d(im, conovlve_der.T, mode='same', boundary='symm') # Blur the images: ix2,iy2,ixiy with kernel size 3 ix2 = sol4_utils.blur_spatial(np.multiply(x_der, x_der), KERNEL_FOR_BLUR) iy2 = sol4_utils.blur_spatial(np.multiply(y_der, y_der), KERNEL_FOR_BLUR) ixiy = sol4_utils.blur_spatial(np.multiply(x_der, y_der), KERNEL_FOR_BLUR) # measure how big the eigenvalues of this matrix : det_m = (ix2 * iy2) - (ixiy * ixiy) trace_m = ix2 + iy2 result_R = det_m - (K_FOR_EIGAN_VAL * (trace_m * trace_m)) # finding the corners : corners = np.argwhere(non_maximum_suppression(result_R)) # flipping the coordinates : return np.fliplr(corners)
def harris_corner_detector(im): """ Detects harris corners. :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ dx = convolve(im, DERIVATIVE_FILTER) dy = convolve(im, DERIVATIVE_FILTER.transpose()) ix_sqr = sol4_utils.blur_spatial(np.square(dx), KERNEL_SIZE) iy_sqr = sol4_utils.blur_spatial(np.square(dy), KERNEL_SIZE) ix_iy = sol4_utils.blur_spatial(np.multiply(dx, dy), KERNEL_SIZE) m1 = np.dstack([ix_sqr, ix_iy]) m2 = np.dstack([ix_iy, iy_sqr]) m = np.concatenate([m1[..., np.newaxis], m2[..., np.newaxis]], axis=3) response = np.linalg.det(m) - HCD_K * np.square( np.trace(m, axis1=2, axis2=3)) bin_response = non_maximum_suppression(response) # preparing indices in [x,y] format idx = np.indices(im.shape) idx = np.dstack([idx[1], idx[0]]) max_idx = idx[bin_response != 0] return max_idx
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ i_x = convolve(im, CONVOLUTION_DER.reshape(1, 3)) i_y = convolve(im, (CONVOLUTION_DER.T).reshape(3, 1)) i_x_2 = sol4_utils.blur_spatial(np.multiply(i_x, i_x), DEFAULT_KERNEL_SIZE) i_x_i_y = sol4_utils.blur_spatial(np.multiply(i_x, i_y), DEFAULT_KERNEL_SIZE) i_y_2 = sol4_utils.blur_spatial(np.multiply(i_y, i_y), DEFAULT_KERNEL_SIZE) det = np.multiply(i_x_2, i_y_2) - np.multiply(i_x_i_y, i_x_i_y) trace = i_x_2 + i_y_2 # R = det(M ) − k(trace(M ))2 r = det - (K_COEFFICIENT * (np.multiply(trace, trace))) binary_max = non_maximum_suppression(r) max_matrix = np.array(np.nonzero(binary_max)).T return np.flip(max_matrix)
def calculate_matrix(im): der_x_im, der_y_im = util.conv_der(im) matrix_1 = util.blur_spatial(der_x_im * der_x_im, 3) matrix_2 = util.blur_spatial(der_x_im * der_y_im, 3) matrix_3 = util.blur_spatial(der_y_im * der_x_im, 3) matrix_4 = util.blur_spatial(der_y_im * der_y_im, 3) return matrix_1,matrix_2,matrix_3,matrix_4
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ # calculate derivative Ix = convolve(im, DERIVATIVE_FILTER) Iy = convolve(im, DERIVATIVE_FILTER.T) # create matrix M M = np.array([[ sol4_utils.blur_spatial(Ix * Ix, KERNEL_SIZE), sol4_utils.blur_spatial(Ix * Iy, KERNEL_SIZE) ], [ sol4_utils.blur_spatial(Iy * Ix, KERNEL_SIZE), sol4_utils.blur_spatial(Iy * Iy, KERNEL_SIZE) ]]) det_M = (M[0, 0] * M[1, 1]) - (M[0, 1] * M[1, 0]) trace_M = M[0, 0] + M[1, 1] R = det_M - K * (np.power(trace_M, POWER)) bool_im = non_maximum_suppression(R.T) corners = np.where(bool_im) corners_arr = np.stack(corners, axis=1) return corners_arr
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ # 1) let us create the derevatives: kernel = np.array([[1, 0, -1]]).astype(np.float64) Ix = convolve(im, kernel) Iy = convolve(im, kernel.T) # 2) Create M Ix2 = ut.blur_spatial(Ix * Ix, 3) Iy2 = ut.blur_spatial(Iy * Iy, 3) Ixy = ut.blur_spatial(Iy * Ix, 3) # M = np.stack((Ix2, Ixy, Ixy, Iy2), axis=-1).reshape((im.shape[0], im.shape[1], 2, 2)) # Det(M) - K * (trace(M)) ^ 2 R = ((Ix2 * Iy2) - (Ixy * Ixy)) - (0.04 * np.square(Ix2 + Iy2)) points = np.array(np.where(non_maximum_suppression(R))) # Return the relevant indices as (col, row) and NOT (row, col) as usual. return np.array([points[1], points[0]]).T
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ k = 0.04 filter = np.reshape(np.asarray([1, 0, -1]), (1, 3)) filter_transpose = np.reshape(filter, (3, 1)) I_x = convolve(im, filter) I_y = convolve(im, filter_transpose) I_xx = np.multiply(I_x, I_x) I_yy = np.multiply(I_y, I_y) I_xy = np.multiply(I_x, I_y) blur_x = sol4_utils.blur_spatial(I_xx, 3) blur_y = sol4_utils.blur_spatial(I_yy, 3) blur_xy = sol4_utils.blur_spatial(I_xy, 3) det_M = blur_x * blur_y - np.square(blur_xy) trace = blur_x + blur_y R = det_M - k * np.square(trace) maxima_points = non_maximum_suppression(R) corner_points_arr = np.argwhere(maxima_points.T) return corner_points_arr
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ x_der_vec = np.array([1, 0, -1])[np.newaxis, :] y_der_vec = x_der_vec.T I_x = convolve2d(im, x_der_vec, mode='same', boundary='symm') I_y = convolve2d(im, y_der_vec, mode='same', boundary='symm') I_xx = I_x * I_x I_yy = I_y * I_y I_xy = I_x * I_y blur_I_xx = sol4_utils.blur_spatial(I_xx, 3) blur_I_yy = sol4_utils.blur_spatial(I_yy, 3) blur_I_xy = sol4_utils.blur_spatial(I_xy, 3) det = blur_I_xx * blur_I_yy - blur_I_xy * blur_I_xy trace = blur_I_xx + blur_I_yy R = det - 0.04 * (trace**2) corners = non_maximum_suppression(R) cor_arr = np.where(corners > 0) points = np.dstack((cor_arr[1], cor_arr[0]))[0] return points
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ d_filter = np.array([[1], [0], [-1]]) # Get the Ix and Iy derivatives of the image using the filters i_x = scipy.ndimage.filters.convolve(im, d_filter.transpose()) i_y = scipy.ndimage.filters.convolve(im, d_filter) # Blur the images: Ix 2 , Iy 2 , Ix Iy and create matrix m for each pixel m = np.zeros((im.shape[0], im.shape[1], 2, 2)) m[:, :, 0, 0] = sol4_utils.blur_spatial((i_x * i_x), 3) m[:, :, 1, 1] = sol4_utils.blur_spatial((i_y * i_y), 3) m[:, :, 1, 0] = sol4_utils.blur_spatial((i_y * i_x), 3) m[:, :, 0, 1] = sol4_utils.blur_spatial((i_y * i_x), 3) # find response image R k = 0.04 r = np.linalg.det(m) - k * np.square(np.trace(m, axis1=2, axis2=3)) # find the corners - the local maximum points of R max_r = non_maximum_suppression(r) corners = np.array(np.nonzero(max_r)) # create array with shape (N,2) of [x,y] key point locations in im. return np.array([corners[1], corners[0]]).transpose()
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ conv_vec = np.array([[1, 0, -1]]) x_der = convolve(im, conv_vec) y_der = convolve(im, conv_vec.transpose()) x_der_2 = sol4_utils.blur_spatial(x_der * x_der, 3) y_der_2 = sol4_utils.blur_spatial(y_der * y_der, 3) x_y_der = sol4_utils.blur_spatial(x_der * y_der, 3) y_x_der = sol4_utils.blur_spatial(y_der * x_der, 3) response = (x_der_2 * y_der_2 - x_y_der * y_x_der) - K * (x_der_2 + y_der_2)**2 bool_response = non_maximum_suppression(response) coor_arr = np.where(bool_response) coor_arr = [coor_arr[1], coor_arr[0]] coor_arr = np.column_stack(coor_arr) return coor_arr
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ # setting up k var as instructed in exercise k = 0.04 # calculating deriv in x and y orientation dx = ndimage.filters.convolve(im, deriv_vec, mode='nearest') dy = ndimage.filters.convolve(im, np.transpose(deriv_vec), mode='nearest') #TODO: check if multiplication is element-wise (np.multiply) or regular (np.dot) dx_pow = sol4_utils.blur_spatial(np.multiply(dx, dx), KERNEL_SIZE) dy_pow = sol4_utils.blur_spatial(np.multiply(dy, dy), KERNEL_SIZE) dx_dy_mul = sol4_utils.blur_spatial(np.multiply(dx, dy), KERNEL_SIZE) dy_dx_mul = sol4_utils.blur_spatial(np.multiply(dy, dx), KERNEL_SIZE) # calculating trace and it's power trace = np.add(dx_pow, dy_pow) trace_pow = np.multiply(trace, trace) # calculating determinant of matrix M det_ad = np.multiply(dx_pow, dy_pow) det_bc = np.multiply(dx_dy_mul, dy_dx_mul) det_M = np.subtract(det_ad, det_bc) # calculating response for each pixel in the image response_im = np.subtract(det_M, k * trace_pow) max_response = non_maximum_suppression(response_im) return np.stack(np.flip(np.where(max_response), axis=0), axis=-1)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ im_derivative_x = get_derivative(im, axis=0) im_derivative_y = get_derivative(im, axis=1) # Construct matrix M blurred_der_x_squared = sol4_utils.blur_spatial(im_derivative_x**2, 3) blurred_der_y_squared = sol4_utils.blur_spatial(im_derivative_y**2, 3) blurred_der_xy = sol4_utils.blur_spatial(im_derivative_x * im_derivative_y, 3) blurred_der_yx = sol4_utils.blur_spatial(im_derivative_y * im_derivative_x, 3) # Calculate det and tr matrices and then R det_m = blurred_der_x_squared * blurred_der_y_squared - blurred_der_xy * blurred_der_yx trace_m = blurred_der_x_squared + blurred_der_y_squared R = non_maximum_suppression(det_m - (harris_k * (trace_m**2))) result = np.argwhere(R.T) return result
def get_R(im): Ix = scipy.signal.convolve2d(im, X_DER_CONV, mode="same", boundary="symm") Iy = scipy.signal.convolve2d(im, Y_DER_CONV, mode="same", boundary="symm") Ix2 = sol4_utils.blur_spatial(Ix * Ix, 3) Iy2 = sol4_utils.blur_spatial(Iy * Iy, 3) IxIy = sol4_utils.blur_spatial(Ix * Iy, 3) m_traces = Ix2 + Iy2 m_dets = (Ix2 * Iy2) - (IxIy * IxIy) return m_dets - K * m_traces * m_traces
def get_M(im): """ :param im: grayscale image: numpy array of dtype float64 :return: Ix^2, Iy^2, IxIy : numpy arrays of dtype float64 """ x_der = derivative(im, get_der(X_DEV)) y_der = derivative(im, get_der(Y_DEV)) Ixy = x_der * y_der return sol4_utils.blur_spatial(np.square(x_der), BLUR_SIZE),\ sol4_utils.blur_spatial(np.square(y_der), BLUR_SIZE),\ sol4_utils.blur_spatial(Ixy, BLUR_SIZE)
def harris_corner_detector(im): der_array = np.array([1,0,-1]).reshape(3,1) Ix = scipy.ndimage.filters.convolve(im, der_array) Iy = scipy.ndimage.filters.convolve(im, np.transpose(der_array)) kernel = sol4_utils.get_guassian(3) IxIx = sol4_utils.blur_spatial(Ix*Ix, kernel) IxIy = sol4_utils.blur_spatial(Ix*Iy, kernel) IyIx = sol4_utils.blur_spatial(Iy*Ix, kernel) IyIy = sol4_utils.blur_spatial(Iy*Iy, kernel) R = (IxIx*IyIy-IyIx*IxIy) - 0.04*((IxIx+IyIy)**2) binary_local_maximum = sol4_add.non_maximum_suppression(R) return np.transpose(np.roll(np.nonzero(binary_local_maximum), 1, axis=0))
def harris_mat(I_x, I_y, kernel_size): """ genreate the harris matrix :param I_x:#x derivatives :param I_y: :param kernel_size: :return: harris matrix elements """ I_x2 = sol4_utils.blur_spatial(I_x**2, kernel_size) I_y2 = sol4_utils.blur_spatial(I_y**2, kernel_size) I_yx = sol4_utils.blur_spatial(I_y * I_x, kernel_size) return I_x2, I_y2, I_yx
def harris_corner_detector(im): div = (np.array([-1, 0, 1])).reshape(1, 3) Ix = convolve(im, div) Iy = convolve(im, np.transpose(div)) IxIx = sol4_utils.blur_spatial(Ix * Ix, 3) IxIy = sol4_utils.blur_spatial(Ix * Iy, 3) IyIy = sol4_utils.blur_spatial(Iy * Iy, 3) k = 0.04 M = np.dstack((IxIx, IxIy, IxIy, IyIy)) M = M.reshape(M.shape[0], M.shape[1], 2, 2) R = np.linalg.det(M[:, :]) - k * (np.trace(M, axis1=2, axis2=3)**2) ret = np.dstack(np.where(sol4_add.non_maximum_suppression(R.transpose()))) return ret.reshape(ret.shape[1], 2)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ der_im_x = scipy.ndimage.filters.convolve(im, X_DERIVATIVE) der_im_y = scipy.ndimage.filters.convolve(im, Y_DERIVATIVE) blur_im_x = sol4_utils.blur_spatial((der_im_x * der_im_x), 3) blur_im_y = sol4_utils.blur_spatial((der_im_y * der_im_y), 3) blur_xy = sol4_utils.blur_spatial((der_im_x * der_im_y), 3) R = blur_im_x * blur_im_y - blur_xy * blur_xy - K * np.power( (blur_im_x * blur_im_y), 2) bool_im = non_maximum_suppression(R) return np.argwhere(np.transpose(bool_im))
def harris_corner_detector(im): ############################################################# # implements harris method for corner detection ############################################################# dx = np.array([[1, 0, -1]]) dy = dx.transpose() Ix = sg.convolve2d(im, dx, mode="same") Iy = sg.convolve2d(im, dy, mode="same") Ix_blur = sut.blur_spatial(Ix**2, 3) Iy_blur = sut.blur_spatial(Iy**2, 3) IxIy_blur = sut.blur_spatial(Ix * Iy, 3) # compute determinant and trace of M det = Ix_blur * Iy_blur - IxIy_blur**2 tr = Ix_blur + Iy_blur R = det - 0.04 * (tr**2) return np.transpose(np.nonzero(sad.non_maximum_suppression(R)))
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ con_der_vec = np.array([1, 0, -1]).reshape((1, 3)) I_x = convolve(im, con_der_vec) I_y = convolve(im, con_der_vec.T) I_x_2 = sol4_utils.blur_spatial(I_x * I_x, 3) I_y_2 = sol4_utils.blur_spatial(I_y * I_y, 3) I_x_y = sol4_utils.blur_spatial(I_x * I_y, 3) R_mat = I_x_2 * I_y_2 - I_x_y * I_x_y - 0.04 * np.power(I_x_2 + I_y_2, 2) R_mat = non_maximum_suppression(R_mat) return np.argwhere(R_mat.T)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing a greyscale image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ Ix = get_image_derivative(im, X_DERIVATIVE) Iy = get_image_derivative(im, Y_DERIVATIVE) Ix2_blur = sol4_utils.blur_spatial((Ix * Ix), DERIVATIVES_BLUR_KERNEL_SIZE) Iy2_blur = sol4_utils.blur_spatial((Iy * Iy), DERIVATIVES_BLUR_KERNEL_SIZE) IxIy_blur = sol4_utils.blur_spatial((Ix * Iy), DERIVATIVES_BLUR_KERNEL_SIZE) IyIx = Iy * Ix R_matrix = calc_r_for_harris(Ix2_blur, IxIy_blur, IyIx, Iy2_blur) corners_im = non_maximum_suppression(R_matrix) return get_corners_coordinates(corners_im)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ dx = scipy.signal.convolve2d(im, der_vec, mode='same', boundary='symm') dy = scipy.signal.convolve2d(im, der_vec.T, mode='same', boundary='symm') blur_ix_squared = sol4_utils.blur_spatial(dx * dx, KERNEL_SIZE) blur_iy_squared = sol4_utils.blur_spatial(dy * dy, KERNEL_SIZE) blur_ix_iy = sol4_utils.blur_spatial(dx * dy, KERNEL_SIZE) det_m = blur_ix_squared * blur_iy_squared - blur_ix_iy * blur_ix_iy trace_m = blur_iy_squared + blur_ix_squared R = det_m - K * np.square(trace_m) R = non_maximum_suppression(R) return np.flip(np.argwhere(R).reshape(-1, 2), axis=1)
def harris_corner_detector(im: np.ndarray) -> np.ndarray: """ extract harris-corner key feature points :param im: the image to extract key points :return: An array with shape (N,2) of [x,y] key points locations in im. """ ix = sol4_utils.sp_signal.convolve2d(im, DER_FILTER, 'same', 'wrap') iy = sol4_utils.sp_signal.convolve2d(im, DER_FILTER.T, 'same', 'wrap') ix_2 = sol4_utils.blur_spatial(ix**2, BLUR_SIZE) iy_2 = sol4_utils.blur_spatial(iy**2, BLUR_SIZE) ix_iy = sol4_utils.blur_spatial(ix * iy, BLUR_SIZE) r = ix_2 * iy_2 - ix_iy**2 - K * (ix_2 + iy_2)**2 # R - the response of the max_of_r = sol4_add.non_maximum_suppression(r) pos = np.transpose(np.nonzero( max_of_r)) # array of the indices of non-zero pixels in max_of_r pos_for_spread = np.transpose(np.array( [pos[:, 1], pos[:, 0]])) # school function works with [yx] return pos_for_spread
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing a gray scale image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ if len(im.shape) > 2: return # getting derivatives etc. dx, dy = convolve(im, X_DER), convolve(im, Y_DER) dx_2, dy_2, dxy = np.multiply(dx, dx), np.multiply(dy, dy), np.multiply(dx, dy) dx_2, dy_2, dxy = sol4_utils.blur_spatial(dx_2, 3), sol4_utils.blur_spatial(dy_2, 3), sol4_utils.blur_spatial(dxy, 3) # computing response r = (np.multiply(dx_2, dy_2) - np.multiply(dxy, dxy)) - K * ((dx_2 + dy_2) ** 2) arr = np.argwhere(non_maximum_suppression(r)) fixed_arr = np.empty(arr.shape) fixed_arr[:, 1], fixed_arr[:, 0] = arr[:, 0], arr[:, 1] return fixed_arr
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ deriv_vec = np.asarray([1, 0, -1]).reshape(1, 3) x_deriv = convolve(im, deriv_vec) y_deriv = convolve(im, deriv_vec.T) blur_x_squared = sol4_utils.blur_spatial(x_deriv * x_deriv, FILTER_SIZE) blur_y_squared = sol4_utils.blur_spatial(y_deriv * y_deriv, FILTER_SIZE) blur_xy = sol4_utils.blur_spatial(x_deriv * y_deriv, FILTER_SIZE) M_det = blur_x_squared * blur_y_squared - blur_xy * blur_xy M_trace = blur_y_squared + blur_y_squared R = M_det - 0.04 * (M_trace * M_trace) # response image R_local_max = non_maximum_suppression(R) all_true_values = np.argwhere(R_local_max) return np.flip(all_true_values, axis=1) # ordered as [column,row] i.e. [x,y]
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ dx = convolve(im, DERIVATIVE_X_DIRECTION, mode='wrap') dy = convolve(im, DERIVATIVE_Y_DIRECTION, mode='wrap') dx_2 = sol4_utils.blur_spatial(np.power(dx, 2), 3).flatten() dy_2 = sol4_utils.blur_spatial(np.power(dy, 2), 3).flatten() dxy = sol4_utils.blur_spatial(np.multiply(dx, dy), 3).flatten() m_matrix = (np.array((dx_2, dxy, dxy, dy_2)).T).reshape(dxy.shape[0], 2, 2) response_im = ( np.linalg.det(m_matrix) - 0.04 * np.power(np.matrix.trace(m_matrix, axis1=2), 2)).reshape( im.shape) points = np.argwhere(non_maximum_suppression(response_im)) return np.flip(points, axis=1)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ ix = convolve2d(im, CONV_VEC, mode='same', boundary='symm') iy = convolve2d(im, CONV_VEC.T, mode='same', boundary='symm') ix_square = sol4_utils.blur_spatial(ix * ix, BLUR_KERNEL_SIZE) iy_square = sol4_utils.blur_spatial(iy * iy, BLUR_KERNEL_SIZE) ix_iy = sol4_utils.blur_spatial(ix * iy, BLUR_KERNEL_SIZE) det_m = ix_square * iy_square - ix_iy * ix_iy # det of M for each pixel trace_m = ix_square + iy_square # trace of M for each pixel r_matrix = det_m - HARRIS_K * (trace_m**2) # response image of im corners = non_maximum_suppression(r_matrix) corners = np.nonzero(corners) return np.transpose( (corners[1], corners[0])) # row is y coord and col is x coord
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ i_x = convolve(im, np.array([[1, 0, -1]])) i_y = convolve(im, np.array([[1], [0], [-1]])) i_x_2 = sol4_utils.blur_spatial(i_x * i_x, 3) i_y_2 = sol4_utils.blur_spatial(i_y * i_y, 3) i_x_y = sol4_utils.blur_spatial(i_x * i_y, 3) i_y_x = sol4_utils.blur_spatial(i_y * i_x, 3) # determinant det = (i_x_2 * i_y_2) - (i_x_y * i_y_x) # trace trace = i_x_2 + i_y_2 harris_response = det - 0.04 * (trace * trace) r_after_nms = np.transpose(non_maximum_suppression(harris_response)) return np.argwhere(r_after_nms == 1)
def harris_corner_detector(im): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ d = np.array(DERIV_VEC).reshape(3, 1) Ix = scipy.signal.convolve2d(im, d, mode='same', boundary='symm') Iy = scipy.signal.convolve2d(im, d.T, mode='same', boundary='symm') Ix__blur = sol4_utils.blur_spatial(Ix**2, DERIV_VEC_SIZE) Iy_blur = sol4_utils.blur_spatial(Iy**2, DERIV_VEC_SIZE) Ixy_blur = sol4_utils.blur_spatial(Ix * Iy, DERIV_VEC_SIZE) detM = Ix__blur * Iy_blur - Ixy_blur**2 traceM = Ix__blur + Iy_blur R = detM - K * (traceM**2) binary_im = non_maximum_suppression(R) xy_corners = np.where(binary_im) yx_corners = np.vstack((xy_corners[1], xy_corners[0])) return yx_corners.T
def harris_corner_detector(im, M=None): """ Detects harris corners. Make sure the returned coordinates are x major!!! :param im: A 2D array representing an image. :return: An array with shape (N,2), where ret[i,:] are the [x,y] coordinates of the ith corner points. """ der_filter = np.array([1, 0, -1]).reshape(1, 3) Ix = convolve(im, der_filter) Iy = convolve(im, der_filter.T) Ix_sqaured = sol4_utils.blur_spatial(np.square(Ix), KERNEL_SIZE) Iy_sqaured = sol4_utils.blur_spatial(np.square(Iy), KERNEL_SIZE) Ix_y = sol4_utils.blur_spatial(Ix * Iy, KERNEL_SIZE) det_M = (Ix_sqaured * Iy_sqaured) - (np.square(Ix_y)) trace_M = Ix_sqaured + Iy_sqaured # M = np.array([[Ix_sqaured, Ix_y],[Iy_x, Iy_sqaured]]) R = det_M - (K * np.square(trace_M)) bin_im = non_maximum_suppression(R) y, x = np.where(bin_im) return np.stack((x, y)).T