def arbitrary_rotation(): X = util.test_object(1) # The object that is rotated Xh = util.c2h(X) # Convert the object vectors to homogeneous coords t = X[:, 0] # First vertex to rotate around # Define separate transformations in homogeneous coords T_ftrans = util.t2h(reg.identity(), -1 * t) # Translate to ensure first vertex is in the origin T_rot = util.t2h(reg.rotate(np.pi / 4), np.array([0, 0])) # Rotate 45 degrees T_btrans = util.t2h(reg.identity(), t) # Translate back to the original position # Create the final transformation matrix T = T_btrans.dot(T_rot.dot(T_ftrans)) #------------------------------------------------------------------# # TODO: TODO: Perform rotation of the test shape around the first vertex #------------------------------------------------------------------# # Transform X_rot = T.dot(Xh) # Plot fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) #------------------------------------------------------------------# # Perform rotation of the test shape around the first vertex t = -X[:, 0] Trot = reg.rotate(np.pi / 4) Throt = util.t2h(Trot, np.zeros([1, np.size(Trot, axis=1)])) th = util.t2h(reg.identity(), t) thin = np.linalg.inv(th) T = thin.dot(Throt.dot(th)) #------------------------------------------------------------------# X_rot = T.dot(Xh) fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) #------------------------------------------------------------------# # TODO: Perform rotation of the test shape around the first vertex Xt = X[:, 0] phi = (45 / 180) * np.pi #matrix to move the figure to new origin translate_matrix = util.t2h(reg.identity(), -Xt) translate_matrix[2][ 2] = 1 #add the 1 in de third row and column to get 'ones'on the diagonal rotate_matrix = np.array([[np.cos(phi), -np.sin(phi), 0], [np.sin(phi), np.cos(phi), 0], [0, 0, 1]]) #matrix to move the figure back to original origin translate_matrix_2 = util.t2h(reg.identity(), Xt) translate_matrix_2[2][ 2] = 1 #add the 1 in de third row and column to get 'ones'on the diagonal T = (rotate_matrix.dot(translate_matrix)) #rotate the moved figure T = translate_matrix_2.dot(T) #move the figure back #------------------------------------------------------------------# X_rot = T.dot(Xh) fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) #the object in homogeneous form #------------------------------------------------------------------# Xt = np.array(X[:, 0]) T_rot = reg.rotate(np.pi / 4) Xt_down = util.t2h( reg.identity(), -Xt) #with Xt being the translation vector set into homogeneous form Xt_up = util.t2h(reg.identity(), Xt) T_rot = util.t2h(T_rot, np.array( [0, 0])) #with T being the rotational vector set into homogeneous form T = Xt_up.dot(T_rot).dot(Xt_down) X_fin = T.dot(Xh) #------------------------------------------------------------------# fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_fin) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def affine_mi(I, Im, x): # Computes mutual information between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # MI - mutual information between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 Tro = rotate(x[0]) Tsc = scale(x[1], x[2]) Tsh = shear(x[3], x[4]) Trss = Tro.dot(Tsc).dot(Tsh) Th = util.t2h(Trss, [x[5], x[6]]) Im_t = Th.dot(Im) p = joint_histogram(I, Im_t, NUM_BINS) MI = mutual_information(p) return MI, Im_t, Th
def affine_corr(I, Im, x): # Computes normalized cross-correlation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-correlation between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 Tro = rotate(x[0]) Tsc = scale(x[1], x[2]) Tsh = shear(x[3], x[4]) Trss = Tro.dot(Tsc).dot(Tsh) Th = util.t2h(Trss, [x[5], x[6]]) Im_t, Xt = image_transform(Im, Th) C = correlation(I, Im_t) return C, Im_t, Th
def affine_corr(I, Im, x, MI): # Computes normalized cross-correlation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-correlation between I and T(Im) # Im_t - transformed moving image T(Im) Tro = reg.rotate(x[0]) Tsc = reg.scale(x[1], x[2]) Tsh = reg.shear(x[3], x[4]) Trss = Tro.dot(Tsc).dot(Tsh) Th = util.t2h(Trss, [x[5], x[6]]) Im_t, Xt = reg.image_transform(Im, Th) if MI: p = joint_histogram(I, Im_t) S = reg.mutual_information(p) else: S = reg.correlation(I, Im_t) return S, Im_t, Th
def rigid_corr(I, Im, x, MI): # Computes normalized cross-correlation between a fixed and # a moving image transformed with a rigid transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle and the remaining two elements # are the translation # Output: # C - normalized cross-correlation between I and T(Im) # Im_t - transformed moving image T(Im) SCALING = 100 # the first element is the rotation angle T = reg.rotate(x[0]) Th = util.t2h(T, x[1:] * SCALING) # transform the moving image Im_t, Xt = reg.image_transform(Im, Th) # compute the similarity between the fixed and transformed moving image if MI: p = joint_histogram(I, Im_t) S = reg.mutual_information(p) else: S = reg.correlation(I, Im_t) return S, Im_t, Th
def correlation_test(): I = plt.imread('../data/cameraman.tif') Th = util.t2h(reg.identity(), np.array([10, 20])) J, _ = reg.image_transform(I, Th) C1 = reg.correlation(I, I) # the self correlation should be very close to 1 assert abs(C1 - 1) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" inv_lin_tr = np.array([[0,1],[1,0]]) T = util.t2h(reg.identity(),np.array([0,0])) K,_ = reg.image_transform(I,T) C2 = reg.correlation(I,K) assert abs(C2-1) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" print('Test successful!')
def affine_mi(I, Im, x): # Computes mutual information between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # MI - mutual information between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 T_rot = rotate(x[0]) T_scale = scale(x[1],x[2]) T_shear = shear(x[3],x[4]) T = T_rot.dot(T_scale).dot(T_shear) Th = util.t2h(T, x[5:]*SCALING) Im_t, Xt = image_transform(Im, Th) p = joint_histogram(I,Im_t) MI = mutual_information(p) return MI, Im_t, Th
def affine_corr(I, Im, x): # Computes normalized cross-corrleation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the roation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-corrleation between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# rot = x[0] sx, sy = x[1], x[2] cx, cy = x[3], x[4] transl = x[5:7] T_rot = rotate(rot) T_scal = scale(sx, sy) T_shear = shear(cx, cy) T = T_shear.dot(T_scal.dot(T_rot)) Th = util.t2h(T, transl * SCALING) Im_t = Th.dot(Im) C = correlation(I, Im_t) #------------------------------------------------------------------# return C, Im_t, Th
def affine_corr(I, Im, x): # Computes normalized cross-corrleation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the roation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-corrleation between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# # TODO: Implement the missing functionality T_rot = rotate(x[0]) T_scale = scale(x[1], x[2]) T_shear = shear(x[3], x[4]) T = T_rot.dot(T_scale.dot(T_shear)) Th = util.t2h(T, x[5:] * SCALING) Im_t, Xt = image_transform(Im, Th) C = correlation(I, Im_t) #------------------------------------------------------------------# return C, Im_t, Th
def affine_mi(I, Im, x): # Computes mutual information between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # MI - mutual information between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# T = rotate(x[0]) S = scale(x[1],x[2]).dot(T) Sh = shear(x[3],x[4]).dot(S) Th = util.t2h(T, np.array(x[5:])*SCALING) Im_t, Xt = image_transform(Im, Th) C = correlation(I, Im_t) p = joint_histogram(I, Im, NUM_BINS) MI = mutual_information(p) plt.imshow(Im_t) #------------------------------------------------------------------# return MI, Im_t, Th
def affine_mi(I, Im, x): # Computes mutual information between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # MI - mutual information between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# # TODO: Implement the missing functionality T= rotate(x[0]).dot(scale(x[1],x[2])).dot(shear(x[3],x[4])) Th=util.t2h(T,SCALING*np.array([x[5],x[6]])) Im_t=image_transform(Im,Th)[0] MI=mutual_information(joint_histogram(I,Im_t,NUM_BINS)) #------------------------------------------------------------------# return MI, Im_t, Th
def affine_corr(I, Im, x): # Computes normalized cross-correlation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the affine transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-correlation between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 # Assemble transformation matrix (according to parameter sequence) T_rot = rotate(x[0]) T_scale = scale(x[1], x[2]) T_shear = shear(x[3], x[4]) T = T_shear.dot(T_scale.dot(T_rot)) Th = util.t2h(T, x[5:] * SCALING) #Transform moving image Im_t, Xt = image_transform(Im, Th) #Calculate correlation between images C = correlation(I,Im_t) return C, Im_t, Th
def ls_affine_test(): X = util.test_object(1) # convert to homogeneous coordinates Xh = util.c2h(X) T_rot = reg.rotate(np.pi / 4) T_scale = reg.scale(1.2, 0.9) T_shear = reg.shear(0.2, 0.1) T = util.t2h(T_rot.dot(T_scale).dot(T_shear), [10, 20]) Xm = T.dot(Xh) Te = reg.ls_affine(Xh, Xm) Xmt = Te.dot(Xm) fig = plt.figure(figsize=(12, 5)) ax1 = fig.add_subplot(131) ax2 = fig.add_subplot(132) ax3 = fig.add_subplot(133) util.plot_object(ax1, Xh) util.plot_object(ax2, Xm) util.plot_object(ax3, Xmt) ax1.set_title('Test shape') ax2.set_title('Arbitrary transformation') ax3.set_title('Retrieved test shape') ax1.grid() ax2.grid() ax3.grid()
def affine_corr(I, Im, x): # Computes normalized cross-corrleation between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the roation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # C - normalized cross-corrleation between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# # TODO: Implement the missing functionality #X[0]: rotation angle #X[1] and X[2]: scaling parameters #X[3] and X[4]: shearing parameters #X[5] and X[6]: translation T= rotate(x[0]).dot(scale(x[1],x[2])).dot(shear(x[3],x[4])) Th=util.t2h(T,SCALING*np.array([x[5],x[6]])) Im_t=image_transform(Im,Th)[0] C=correlation(I,Im_t) #------------------------------------------------------------------# return C, Im_t, Th
def affine_corr(I, Im, x, return_transform=True): """Computes normalized cross-correlation between a fixed and a moving image transformed with an affine transformation. Input: I - fixed image Im - moving image x - parameters of the rigid transform: the first element is the roation angle, the second and third are the scaling parameters, the fourth and fifth are the shearing parameters and the remaining two elements are the translation return_transform: Flag for controlling the return values Output: C - normalized cross-correlation between I and T(Im) Im_t - transformed moving image T(Im) Th - transformation matrix (only returned if return_transform=True) """ NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# # TODO: Implement the missing functionality Th = rotate(x[0]).dot(scale(x[1], x[2])).dot(shear(x[3], x[4])) Th = util.t2h(Th, x[5:7] * SCALING) Im_t, Xt = np.array(image_transform(Im, Th)) C = correlation(I, Im_t) #------------------------------------------------------------------# if return_transform: return C, Im_t, Th else: return C
def correlation_test(): I = plt.imread('../data/cameraman.tif') Th = util.t2h(reg.identity(), np.array([10, 20])) J, _ = reg.image_transform(I, Th) C1 = reg.correlation(I, I) # the self correlation should be very close to 1 assert abs( C1 - 1 ) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" #------------------------------------------------------------------# # TODO: Implement a few more tests of the correlation definition #correlation when two signals are exaclty opposite should be very close to -1 C2 = reg.correlation(I, -I) assert abs( C2 + 1 ) < 10e-10, "Correlation function is incorrectly implemented (opposite self correlation test)" #detect corrrelation of two signals with different amplitudes should be 1 C3 = reg.correlation(I, I / 2) assert abs( C3 - 1 ) < 10e-10, "Correlation function is incorrectly implemented (different amplitude self correlation test)" C4 = reg.correlation(I, J) print(C4) assert abs( C4 - 1 ) < 10e-1, "Correlation function is incorrectly implemented (two diff images no correlation)" #------------------------------------------------------------------# print('Test successful!')
def correlation_test(): I = plt.imread('../data/t1_demo.tif') Th = util.t2h(reg.identity(), np.array([10, 20])) J, _ = reg.image_transform(I, Th) K, _ = reg.image_transform(J, Th) C1 = reg.correlation(I, I) C2 = reg.correlation(J, J) # the self correlation should be very close to 1 assert abs( C1 - 1 ) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" assert abs( C2 - 1 ) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" C3 = reg.correlation(I, J) C4 = reg.correlation(I, K) print("Correlation between images with slight translocation:", C3) print("Correlation between images with big translocation:", C4, "\n") print('Test successful!') ######## print("\n\nAnd now for a test on the joint probability histogram: \n") p = reg.joint_histogram(I, J) assert abs(1 - float(np.sum(p))) < 0.01, "Mass probability function error..." print("Test successful!")
def affine_mi_adapted(I, Im, x): # Computes mutual information between a fixed and # a moving image transformed with an affine transformation. # Input: # I - fixed image # Im - moving image # x - parameters of the rigid transform: the first element # is the rotation angle, the second and third are the # scaling parameters, the fourth and fifth are the # shearing parameters and the remaining two elements # are the translation # Output: # MI - mutual information between I and T(Im) # Im_t - transformed moving image T(Im) NUM_BINS = 64 SCALING = 100 #------------------------------------------------------------------# # TODO: Implement the missing functionality T_rotate = reg.rotate(x[0]) T_scaled = reg.scale(x[1], x[2]) T_shear = reg.shear(x[3], x[4]) t = np.array(x[5:]) * SCALING T_total = T_shear.dot((T_scaled).dot(T_rotate)) Th = util.t2h(T_total, t) Im_t, Xt = reg.image_transform(Im, Th) p = reg.joint_histogram(Im, Im_t) MI = reg.mutual_information(p) #------------------------------------------------------------------# return MI
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) p_rot = X[:, 0] T_to_zero = util.t2h(reg.identity(), -p_rot) T_return = util.t2h(reg.identity(), p_rot) T_rot = util.t2h(reg.rotate(45)) T = T_return.dot(T_rot.dot(T_to_zero)) X_rot = T.dot(Xh) fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid() fig.show()
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) #------------------------------------------------------------------# # TODO: Perform rotation of the test shape around the first vertex Xt = X[:, 0] T = util.t2h(reg.rotate(np.pi / 4), Xt).dot(util.t2h(reg.identity(), -Xt)) #------------------------------------------------------------------# X_rot = T.dot(Xh) fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def image_transform_test(): I = plt.imread('8dc00-mia/data/cameraman.tif') # 45 deg. rotation around the image center T_1 = util.t2h(reg.identity(), 128 * np.ones(2)) T_2 = util.t2h(reg.rotate(np.pi / 4), np.zeros(2)) T_3 = util.t2h(reg.identity(), -128 * np.ones(2)) T_rot = T_1.dot(T_2).dot(T_3) # 45 deg. rotation around the image center followed by shearing T_shear = util.t2h(reg.shear(0.0, 0.5), np.zeros(2)).dot(T_rot) # scaling in the x direction and translation T_scale = util.t2h(reg.scale(1.5, 1), np.array([10, 20])) It1, Xt1 = reg.image_transform(I, T_rot) It2, Xt2 = reg.image_transform(I, T_shear) It3, Xt3 = reg.image_transform(I, T_scale) fig = plt.figure(figsize=(12, 5)) ax1 = fig.add_subplot(131) im11 = ax1.imshow(I) im12 = ax1.imshow(It1, alpha=0.7) ax2 = fig.add_subplot(132) im21 = ax2.imshow(I) im22 = ax2.imshow(It2, alpha=0.7) ax3 = fig.add_subplot(133) im31 = ax3.imshow(I) im32 = ax3.imshow(It3, alpha=0.7) ax1.set_title('Rotation') ax2.set_title('Shearing') ax3.set_title('Scaling') plt.show()
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) # ------------------------------------------------------------------# Tlat = util.t2h(reg.identity(), np.array(X[:, 0])) Tlat_down = util.t2h(reg.identity(), -np.array(X[:, 0])) T_rot = reg.rotate(np.pi / 4) T_rot_hom = util.t2h(T_rot, np.array([0, 0])) T_tot = Tlat.dot(T_rot_hom).dot(Tlat_down) X_fin = T_tot.dot(Xh) # ------------------------------------------------------------------# fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_fin) ax1.set_xlim(ax1.get_ylim()) ax1.grid()
def correlation_test(): I = plt.imread('../data/cameraman.tif') Th = util.t2h(reg.identity(), np.array([10,20])) J, _ = reg.image_transform(I, Th) C1 = reg.correlation(I, I) # the self correlation should be very close to 1 assert abs(C1 - 1) < 10e-10, "Correlation function is incorrectly implemented (self correlation test)" #------------------------------------------------------------------# # TODO: Implement a few more tests of the correlation definition #------------------------------------------------------------------# print('Test successful!')
def mutual_information_test(): I = plt.imread('../data/cameraman.tif') I_mirror, _ = reg.image_transform(I, util.t2h(reg.reflect(-1, 1))) error_msg = "Mutual Information function is incorrectly implemented" # mutual information of an image with itself p1 = reg.joint_histogram(I, I) p2 = reg.joint_histogram(I, I_mirror) MI1 = reg.mutual_information(p1) MI2 = reg.mutual_information(p2) assert 1 - MI1 < 10e-10, error_msg + " (self MI should be 1)" assert MI2 < 0.8, error_msg + " (mirrored image gives MI above 0.8 (strange))" print('MI test successful!')
def arbitrary_rotation(): X = util.test_object(1) Xh = util.c2h(X) #------------------------------------------------------------------# # TODO: TODO: Perform rotation of the test shape around the first vertex #------------------------------------------------------------------# tdown = X[:, 0] * -1 tup = X[:, 0] tdown = util.t2h(reg.identity(), tdown) tup = util.t2h(reg.identity(), tup) r = util.t2h(reg.rotate(45), [0, 0]) T = tup.dot(r.dot(tdown)) X_rot = T.dot(Xh) fig = plt.figure(figsize=(5, 5)) ax1 = fig.add_subplot(111) util.plot_object(ax1, X) util.plot_object(ax1, X_rot) ax1.set_xlim(ax1.get_ylim()) ax1.grid() plt.show()
def correlation_test(): I = plt.imread('../data/cameraman.tif') Th = util.t2h(reg.identity(), np.array([10, 20])) J, _ = reg.image_transform(I, Th) error_msg = "Correlation function is incorrectly implemented" C1 = reg.correlation(I, I) C2 = reg.correlation(I, J) C3 = reg.correlation(I, np.ones_like(I)) # the self correlation should be very close to 1 assert abs(C1 - 1) < 10e-10, error_msg + " (self correlation should be 1)" assert C1 >= -1, error_msg + " (self correlation is should be more than -1)" assert C2 <= 1, error_msg + " (translation correlation should be less than 1)" assert C2 >= -1, error_msg + " (translation correlation should be more than -1)" print('Correlation test successful!')
def rigid_corr(I, Im, x, return_transform=True): """Computes normalized cross-correlation between a fixed and a moving image transformed with a rigid transformation. Input: I - fixed image Im - moving image x - parameters of the rigid transform: the first element is the rotation angle and the remaining two elements are the translation return_transform: Flag for controlling the return values Output: C - normalized cross-correlation between I and T(Im) Im_t - transformed moving image T(Im) Th - transformation matrix (only returned if return_transform=True) """ SCALING = 100 # the first element is the rotation angle T = rotate(x[0]) # the remaining two elements are the translation # # the gradient ascent/descent method work best when all parameters # of the function have approximately the same range of values # this is not the case for the parameters of rigid registration # where the transformation matrix usually takes much smaller # values compared to the translation vector this is why we pass a # scaled down version of the translation vector to this function # and then scale it up when computing the transformation matrix Th = util.t2h(T, x[1:] * SCALING) # transform the moving image Im_t, Xt = image_transform(Im, Th) # compute the similarity between the fixed and transformed # moving image C = correlation(I, Im_t) if return_transform: return C, Im_t, Th else: return C