commited

app.py

@@ -0,0 +1,138 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import math
+A = np.array([[3, 0], [4, 5]])
+# A[1][1] = user_input_matrix()[1][1]
+axis_limit = [-8,8]
+
+theta = np.linspace(0, 2*np.pi, 100)
+x = np.cos(theta)
+y = np.sin(theta)
+circle = np.vstack((x, y))
+
+# Perform SVD on the scaling matrix
+U, s, Vt = np.linalg.svd(A)
+horizontal_scale_factor,vertical_scale_factor = s[0], s[1]
+clockwise_angle = math.degrees(math.acos(Vt[0][0]))
+anticlockwise_angle = math.degrees(math.acos(U[0][0]))
+s = np.diag(s)
+
+# Stage 1>>>>> Clockwise rotation
+right_rot = Vt @ circle
+
+# Stage 2 >>>>> Horizontal and vertical Scaling
+scale_right_rot = s @ right_rot
+
+#Stage 3 >>>>> Anticlock wise rotation
+ellipse = U @ scale_right_rot
+
+
+
+fig, ((ax1, ax2),(ax3,ax4)) = plt.subplots(2, 2, figsize=(15, 15), subplot_kw={'aspect': 'equal'})
+fig.suptitle('Transformation using SVD')
+
+def circle_plot():
+
+
+    # Plot circle
+    ax1.plot(circle[0],circle[1])
+    ax1.set_xlim(axis_limit)
+    ax1.set_ylim(axis_limit)
+    ax1.set_title('Stage-1-Original Circle')
+
+    # Indicating point P
+    x = circle[0, 30]  # x-coordinate of the point
+    y = circle[1, 30]  # y-coordinate of the point
+    ax1.plot(x, y, 'ro')  # plot the point
+    ax1.text(x+0.05, y+0.05, 'P')  # add the label
+    # ax1.axis('equal')
+
+    # Indicating Point Q
+    x = circle[0, 50]  # x-coordinate of the point
+    y = circle[1, 50]  # y-coordinate of the point
+    ax1.plot(x, y, 'o',color = 'green')  # plot the point
+    ax1.text(x+0.1, y+0.1, 'Q')  # add the label
+    plt.show()
+
+
+    
+def stage1():
+    # Stage 1>>>> Plot clockwise rotated circle
+    ax2.plot(right_rot[0],right_rot[1])
+    ax2.set_xlim(axis_limit)
+    ax2.set_ylim(axis_limit)
+    # ax2.axis('equal')
+    ax2.set_title('Stage-2 Clockwise rotation')
+    ax2.text(axis_limit[0]+0.4, axis_limit[1]-1, f'Clockwise rotation Angle(in degree) = {clockwise_angle}') 
+
+    # Corresponding point P 
+    x = right_rot[0, 30] 
+    y = right_rot[1, 30]  
+    ax2.plot(x, y, 'ro')  
+    ax2.text(x+0.05, y+0.05, 'P') 
+    # ax1.axis('equal')
+
+    # Corresponding point Q 
+    x = right_rot[0, 50] 
+    y = right_rot[1, 50]  
+    ax2.plot(x, y, 'o',color = 'green') 
+    ax2.text(x+0.1, y+0.1, 'Q')  
+    plt.show()
+    
+    
+    
+def stage2():
+    # Stage 2>>>> Horizontal/Verticale scaling
+    ax3.plot(scale_right_rot[0],scale_right_rot[1])
+    ax3.set_xlim(axis_limit)
+    ax3.set_ylim(axis_limit)
+    # ax3.axis('equal')
+    ax3.set_title('Stage-3 Scaling')
+    ax3.text(axis_limit[0]+0.4, axis_limit[1]-1, f'Horizotal Scale factor = { round(horizontal_scale_factor, 2)}')
+    ax3.text(axis_limit[0]+0.4, axis_limit[1]-2, f'Vertical Scale factor = { round(vertical_scale_factor, 2)}')
+
+    # # Corresponding point P
+    x = scale_right_rot[0, 30] 
+    y = scale_right_rot[1, 30]  
+    ax3.plot(x, y, 'ro')  
+    ax3.text(x+0.05, y+0.05, 'P')  
+    # ax1.axis('equal')
+
+    # Corresponding point Q 
+    x = scale_right_rot[0, 50]  
+    y = scale_right_rot[1, 50]  
+    ax3.plot(x, y, 'o',color = 'green')  
+    ax3.text(x+0.1, y+0.1, 'Q')  
+    plt.show()
+
+    
+    
+def stage3():
+    # Stage 3>>>>>> Anticlockwise rotation
+    ax4.plot(ellipse[0], ellipse[1])
+    ax4.set_xlim(axis_limit)
+    ax4.set_ylim(axis_limit)
+    # ax4.axis('equal')
+    ax4.set_title('Stage-4 Anticlockwise rotation')
+    ax4.text(axis_limit[0]+0.4, axis_limit[1]-1, f'Anti Clockwise rotation Angle(in degree) = {round(anticlockwise_angle, 2) }')
+    # ax4.ylim(-2,2)
+
+
+    # Corresponding point P
+    x = ellipse[0, 30] 
+    y = ellipse[1, 30]  
+    ax4.plot(x, y, 'ro') 
+    ax4.text(x+0.05, y+0.05, 'P')  
+    # ax1.axis('equal')
+
+    # Corresponding point Q
+    x = ellipse[0, 50] 
+    y = ellipse[1, 50]  
+    ax4.plot(x, y, 'o',color = 'tab:green')  
+    ax4.text(x+0.1, y+0.1, 'Q')  
+    plt.show()
+
+# circle_plot()
+# stage1()
+# stage2()
+# stage3()

discription.md

@@ -0,0 +1,14 @@
+Image transformation using SVD (Singular Value Decomposition) is a technique for compressing and manipulating images. SVD is a matrix factorization method that factorizes a matrix into three matrices, including a diagonal matrix, a left singular vector matrix, and a right singular vector matrix. 
+
+Given a matrix A, the SVD is a factorization of the form:
+
+## A = U * S * V^T
+<br>
+where U and V are orthogonal matrices, and S is a diagonal matrix of singular values.
+![SVD image](SVD.png)
+<br>
+U is called anti-clockwise rotation matrix
+S is scaling matrix. First element is horizontal scaling factor and the second image is vertical scaling factor.
+V^T is clockwise totation matrix.
+
+On matrix multiplication of this matrices with a 2D image will result in corresponding transformation.

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+pandas
+requests
+matplotlib
+math