def combining_transforms():
X = util.test_object(1)
#------------------------------------------------------------------#
# TODO: Experiment with combining transformation matrices.
X_t = reg.reflect(-1, 1).dot(reg.rotate(np.pi / 2)).dot(X)
X_u = reg.shear(2, 1).dot(reg.reflect(1, -1)).dot(X)
X_v = reg.reflect(1, -1).dot(reg.shear(2, 1)).dot(X)
X_w = reg.rotate(np.pi / 2).dot(reg.shear(2, 1)).dot(X)
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-8, 8), ylim=(-8, 8))
ax2 = fig.add_subplot(142, xlim=(-8, 8), ylim=(-8, 8))
ax3 = fig.add_subplot(143, xlim=(-8, 8), ylim=(-8, 8))
ax4 = fig.add_subplot(144, xlim=(-8, 8), ylim=(-8, 8))
util.plot_object(ax1, X_t)
util.plot_object(ax2, X_u)
util.plot_object(ax3, X_v)
util.plot_object(ax4, X_w)
ax1.set_title('reflect, rotate')
ax2.set_title('shear, reflect')
ax3.set_title('reflect, shear')
ax4.set_title('rotate, shear')
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
def combining_transforms():
X = util.test_object(1)
#------------------------------------------------------------------#
# TODO: Experiment with combining transformation matrices.
Example_1_temp = reg.rotate(5 * np.pi / 3).dot(X)
Example_1_result = reg.reflect(-1, 1).dot(Example_1_temp)
Example2 = reg.reflect(-1, 1).dot(X)
Example2_result = reg.rotate(np.pi / 2).dot(Example2)
Example2_reversed = reg.rotate(np.pi / 2).dot(X)
Example2_reversed_result = reg.rotate(5 * np.pi / 3).dot(X)
#plotting
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-4, 4), ylim=(-4, 4))
ax2 = fig.add_subplot(142, xlim=(-4, 4), ylim=(-4, 4))
ax3 = fig.add_subplot(143, xlim=(-4, 4), ylim=(-4, 4))
util.plot_object(ax1, X)
util.plot_object(ax2, Example2_result)
util.plot_object(ax3, Example2_reversed_result)
ax1.set_title('Original')
ax2.set_title('Reflection, rotation')
ax3.set_title('Reversed')
ax1.grid()
ax2.grid()
ax3.grid()
def combining_transforms():
X = util.test_object(1)
X_1 = X
X_2 = reg.rotate(3 * np.pi / 4).dot(X)
X_3 = reg.reflect(-1, 1).dot(reg.rotate(3 * np.pi / 4).dot(X))
X_4 = reg.shear(0.1, 0.2).dot(
reg.reflect(-1, 1).dot(reg.rotate(3 * np.pi / 4).dot(X)))
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-4, 4), ylim=(-4, 4))
ax2 = fig.add_subplot(142, xlim=(-4, 4), ylim=(-4, 4))
ax3 = fig.add_subplot(143, xlim=(-4, 4), ylim=(-4, 4))
ax4 = fig.add_subplot(144, xlim=(-4, 4), ylim=(-4, 4))
util.plot_object(ax1, X_1)
util.plot_object(ax2, X_2)
util.plot_object(ax3, X_3)
util.plot_object(ax4, X_4)
ax1.set_title('Original')
ax2.set_title('Then rotate')
ax3.set_title('Now reflect over x')
ax4.set_title('Lastly, shear')
for ax_obj in [ax1, ax2, ax3, ax4]:
ax_obj.grid()
def combining_transforms():
X = util.test_object(1)
X_shear_reflect = reg.reflect(-1, 1).dot(reg.shear(0.5, 0.2).dot(X))
X_reflect_shear = reg.shear(0.5, 0.2).dot(reg.reflect(-1, 1).dot(X))
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-4, 4), ylim=(-4, 4))
ax2 = fig.add_subplot(142, xlim=(-4, 4), ylim=(-4, 4))
ax3 = fig.add_subplot(143, xlim=(-4, 4), ylim=(-4, 4))
ax4 = fig.add_subplot(144, xlim=(-4, 4), ylim=(-4, 4))
util.plot_object(ax1, X)
util.plot_object(ax2, X_shear_reflect)
util.plot_object(ax3, X_reflect_shear)
util.plot_object(ax4, X)
ax1.set_title('Original')
ax2.set_title('shear_reflect')
ax3.set_title('reflect_shear')
ax4.set_title('Original')
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
fig.show()
def transforms_test():
X = util.test_object(1)
X_rot = reg.rotate(3*np.pi/4).dot(X)
X_shear = reg.shear(0.1, 0.2).dot(X)
X_reflect = reg.reflect(-1, -1).dot(X)
fig = plt.figure(figsize=(12,5))
ax1 = fig.add_subplot(141, xlim=(-4,4), ylim=(-4,4))
ax2 = fig.add_subplot(142, xlim=(-4,4), ylim=(-4,4))
ax3 = fig.add_subplot(143, xlim=(-4,4), ylim=(-4,4))
ax4 = fig.add_subplot(144, xlim=(-4,4), ylim=(-4,4))
util.plot_object(ax1, X)
util.plot_object(ax2, X_rot)
util.plot_object(ax3, X_shear)
util.plot_object(ax4, X_reflect)
ax1.set_title('Original')
ax2.set_title('Rotation')
ax3.set_title('Shear')
ax4.set_title('Reflection')
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
def combining_transforms():
X = util.test_object(1)
X_rot = reg.rotate(3 * np.pi / 7).dot(X)
X_shear = reg.shear(0.3, 0.22).dot(X)
X_rot_shear = reg.shear(0.1, 0.3).dot(X_rot)
X_shear_reflect = reg.reflect(-1, 1).dot(X_shear)
X_multicom = reg.rotate(np.pi / 3).dot(X_rot_shear)
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-4, 4), ylim=(-4, 4))
ax2 = fig.add_subplot(142, xlim=(-4, 4), ylim=(-4, 4))
ax3 = fig.add_subplot(143, xlim=(-4, 4), ylim=(-4, 4))
ax4 = fig.add_subplot(144, xlim=(-4, 4), ylim=(-4, 4))
util.plot_object(ax1, X)
util.plot_object(ax2, X_rot_shear)
util.plot_object(ax3, X_shear_reflect)
util.plot_object(ax4, X_multicom)
ax1.set_title('Original')
ax2.set_title('Combination 1')
ax3.set_title('Combination 2')
ax4.set_title('Combination 3')
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
def combining_transforms():
X = util.test_object(1)
#------------------------------------------------------------------#
# TODO: Experiment with combining transformation matrices.
X_t = reg.rotate(np.pi/2).dot(X)*reg.reflect(-1,1).dot(X)
return X_t
def combining_transforms():
X = util.test_object(1)
T = reg.reflect(-1, 1).dot(reg.rotate(np.pi / 2))
X_t = T.dot(X)
fig = plt.figure(figsize=(5, 5))
ax1 = fig.add_subplot(111)
ax1.grid()
util.plot_object(ax1, X)
util.plot_object(ax1, X_t)
def combining_transforms():
X = util.test_object(1)
#------------------------------------------------------------------#
# Experiment with combining transformation matrices.
X1_1 = reg.rotate(np.pi / 4).dot(reg.reflect(-1, 1).dot(X))
X1_2 = reg.reflect(-1, 1).dot(reg.rotate(np.pi / 4).dot(X))
X2_1 = reg.shear(0.6, 0.3).dot(reg.reflect(-1, -1).dot(X))
X2_2 = reg.shear(0.6, 0.3).dot(reg.reflect(-1, 1).dot(X))
X3_1 = reg.reflect(-1, 1).dot(reg.shear(0.6, 0.3).dot(X))
X3_2 = reg.shear(0.6, 0.3).dot(reg.reflect(-1, 1).dot(X))
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(141, xlim=(-4, 4), ylim=(-4, 4))
ax2 = fig.add_subplot(142, xlim=(-4, 4), ylim=(-4, 4))
ax3 = fig.add_subplot(143, xlim=(-4, 4), ylim=(-4, 4))
ax4 = fig.add_subplot(144, xlim=(-4, 4), ylim=(-4, 4))
util.plot_object(ax1, X)
util.plot_object(ax2, X1_1)
util.plot_object(ax2, X1_2)
util.plot_object(ax3, X2_1)
util.plot_object(ax3, X2_2)
util.plot_object(ax4, X3_1)
util.plot_object(ax4, X3_2)
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
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 combining_transforms():
X = util.test_object(1)
#------------------------------------------------------------------#
X_t = reg.reflect(-1,1).dot(reg.rotate(2)).dot(X)
