Refleksi

Refleksi matriks (reflection matrix) adalah matriks transformasi yang mencerminkan (memantulkan) titik-titik dalam ruang terhadap sumbu, garis, bidang, atau titik tertentu.

Refleksi mengubah arah satu atau lebih komponen vektor, seperti bayangan di cermin.

---

✅ Repleksi pada 2D (dua dimensi):

1. Refleksi terhadap sumbu-x:

\[\begin{split} \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} x \\ -y \end{bmatrix} \end{split}\]

→ Membalik titik terhadap sumbu-x (nilai y dibalik, x tetap).

2. Refleksi terhadap sumbu-y:

\[\begin{split} \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} -x \\ y \end{bmatrix} \end{split}\]

→ Membalik titik terhadap sumbu-y.

3. Refleksi terhadap garis y = x:

\[\begin{split} \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} y \\ x \end{bmatrix} \end{split}\]

→ Menukar posisi x dan y.

---

✅ ** Repleksi pada 3D (tiga dimensi)**:

Refleksi bisa dilakukan terhadap bidang seperti \(x=0\), \(y=0\), atau \(z=0\). Contoh refleksi terhadap bidang \(x=0\):

\[\begin{split} \begin{bmatrix} -1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix} \end{split}\]

---

🔧 Aplikasi Refleksi Matriks:

• Grafika komputer (cermin objek)

• Geometri transformasi

• Simulasi fisika (pantulan)

%matplotlib inline  
from math import pi, sin, cos
import matplotlib.pyplot as plt
import numpy as np

titik = np.array([[0,0],
                  [0.5,0.5],
                  [0.5,1.5],
                  [0,1],[0,0]])

koordinats = titik.transpose()
x = koordinats[0,:]
y = koordinats[1,:]

R = np.array([[0, 1],
              [1, 0]])

# Transformasi
R_trans = R @ koordinats
x_RT = R_trans[0,:]
y_RT = R_trans[1,:]

# Membuat gambar dan sumbu sumbu
fig, ax = plt.subplots()

# Plot titik-titik asal dan hasil transformasi
ax.plot(x, y, 'ro', label='Asal (Domain)')
ax.plot(x_RT, y_RT, 'bo', label='Bayangan (Codomain)')

# Hubungkan titik asal dan bayangan
for i in range(koordinats.shape[1]):
    ax.plot([x[i], x_RT[i]], [y[i], y_RT[i]], 'gray', ls='--')

# Gambar garis y = x
x_line = np.linspace(-2, 2, 100)
ax.plot(x_line, x_line, 'g--', label='Garis y = x')

# Gambar sumbu koordinat
ax.axvline(x=0, color="k", ls=":")
ax.axhline(y=0, color="k", ls=":")
ax.grid(True)
ax.axis('equal')
ax.set_xlim([-2, 2])
ax.set_ylim([-2, 2])
ax.set_title("Refleksi terhadap garis y = x")
ax.legend()
plt.show()

Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.

R1 = np.array([[0, 1],   # y = x
               [1, 0]])
R2 = np.array([[0, -1],  # y = -x
               [-1, 0]])

# Refleksi pertama (terhadap y = x)
ref1 = R1 @ koordinats
x_ref1 = ref1[0,:]
y_ref1 = ref1[1,:]

# Refleksi kedua (terhadap y = -x)
ref2 = R2 @ ref1
x_ref2 = ref2[0,:]
y_ref2 = ref2[1,:]

# Visualisasi
fig, ax = plt.subplots()

# Titik asli, refleksi 1, refleksi 2
ax.plot(x, y, 'ro', label='Asal')
ax.plot(x_ref1, y_ref1, 'bo', label='Refleksi y=x')
ax.plot(x_ref2, y_ref2, 'go', label='Refleksi y=-x')

# Garis penghubung
for i in range(koordinats.shape[1]):
    ax.plot([x[i], x_ref1[i]], [y[i], y_ref1[i]], 'r--', alpha=0.5)
    ax.plot([x_ref1[i], x_ref2[i]], [y_ref1[i], y_ref2[i]], 'b--', alpha=0.5)

# Gambar garis y = x dan y = -x
x_line = np.linspace(-2, 2, 100)
ax.plot(x_line, x_line, 'k--', label='y = x')
ax.plot(x_line, -x_line, 'k:', label='y = -x')

# Setting plot
ax.axvline(x=0, color='k', ls=':')
ax.axhline(y=0, color='k', ls=':')
ax.set_xlim([-2, 2])
ax.set_ylim([-2, 2])
ax.set_aspect('equal')
ax.grid(True)
ax.set_title("Refleksi terhadap y = x lalu y = -x")
plt.show()
print("---------------------")
print("Merah : Titik awal")
print("Biru : Cerminan")
print("Hijau : Cerminan dari -x")

---------------------
Merah : Titik awal
Biru : Cerminan
Hijau : Cerminan dari -x

# T1 Refleksi terhadap sumbu Y
%matplotlib inline  
import matplotlib.pyplot as plt
import numpy as np

# Titik awal: (2,1)
titik = np.array([[2, 1]])

koordinats = titik.transpose()  # ubah jadi kolom vektor
x = koordinats[0, :]
y = koordinats[1, :]

# Matriks refleksi terhadap sumbu Y
B = np.array([[-1, 0],
              [0, 1]])

# Transformasi refleksi
B_trans = B @ koordinats
x_LT2 = B_trans[0, :]
y_LT2 = B_trans[1, :]

# Membuat gambar
fig, ax = plt.subplots()

# Plot titik asal dan bayangan
ax.plot(x, y, 'ro', label='Asal')
ax.plot(x_LT2, y_LT2, 'bo', label='Bayangan')

# Garis penghubung (opsional)
ax.plot([x[0], x_LT2[0]], [y[0], y_LT2[0]], 'gray', ls="--")

# Gambar sumbu koordinat
ax.axvline(x=0, color="k", ls=":")
ax.axhline(y=0, color="k", ls=":")
ax.grid(True)
ax.set_xlim([-3, 3])
ax.set_ylim([-1, 3])
ax.set_aspect('equal')
ax.set_title("Refleksi Titik (2,1) terhadap Sumbu Y")
ax.legend()
plt.show()

# T1 Refleksi terhadap sumbu X
%matplotlib inline  
import matplotlib.pyplot as plt
import numpy as np

# Titik awal: (2,1)
titik = np.array([[2, 1]])

koordinats = titik.transpose()  # ubah jadi kolom vektor
x = koordinats[0, :]
y = koordinats[1, :]

# Matriks refleksi terhadap sumbu X
B = np.array([[1, 0],
              [0, -1]])

# Transformasi refleksi
B_trans = B @ koordinats
x_LT2 = B_trans[0, :]
y_LT2 = B_trans[1, :]

# Membuat gambar
fig, ax = plt.subplots()

# Plot titik asal dan bayangan
ax.plot(x, y, 'ro', label='Asal')
ax.plot(x_LT2, y_LT2, 'bo', label='Bayangan')

# Garis penghubung (opsional)
ax.plot([x[0], x_LT2[0]], [y[0], y_LT2[0]], 'gray', ls="--")

# Gambar sumbu koordinat
ax.axvline(x=0, color="k", ls=":")
ax.axhline(y=0, color="k", ls=":")
ax.grid(True)
ax.set_xlim([-3, 3])
ax.set_ylim([-3, 3])
ax.set_aspect('equal')
ax.set_title("Refleksi Titik (2,1) terhadap Sumbu X")
ax.legend()
plt.show()

# Rotasi 90 derajat
%matplotlib inline  
import matplotlib.pyplot as plt
import numpy as np

# Titik awal: (2,1)
titik = np.array([[2, 1]])

koordinats = titik.transpose()  # ubah jadi kolom vektor
x = koordinats[0, :]
y = koordinats[1, :]

# Matriks rotasi 90 derajat CCW
R = np.array([[0, -1],
              [1, 0]])

# Transformasi rotasi
R_trans = R @ koordinats
x_rot = R_trans[0, :]
y_rot = R_trans[1, :]

# Membuat gambar
fig, ax = plt.subplots()

# Plot titik asal dan hasil rotasi
ax.plot(x, y, 'ro', label='Asal')
ax.plot(x_rot, y_rot, 'bo', label='Rotasi 90°')

# Garis penghubung (opsional)
ax.plot([x[0], x_rot[0]], [y[0], y_rot[0]], 'gray', ls="--")

# Gambar sumbu koordinat
ax.axvline(x=0, color="k", ls=":")
ax.axhline(y=0, color="k", ls=":")
ax.grid(True)
ax.set_xlim([-3, 3])
ax.set_ylim([-3, 3])
ax.set_aspect('equal')
ax.set_title("Rotasi Titik (2,1) Sebesar 90° CCW")
ax.legend()
plt.show()

#T4
import matplotlib.pyplot as plt
import numpy as np

# Titik awal
titik = np.array([[2, 1]]).T  # kolom vektor

# Matriks transformasi
T1 = np.array([[1, 0],
               [0, -1]])   # Refleksi sumbu X

T2 = np.array([[-1, 0],
               [0, 1]])    # Refleksi sumbu Y

T3 = np.array([[0, -1],
               [1, 0]])    # Rotasi 90° CCW

# Gabungan transformasi: T3 @ T2 @ T1
T_total = T3 @ T2 @ T1

# Terapkan transformasi gabungan ke titik
hasil = T_total @ titik

# Ekstrak koordinat
x_asal, y_asal = titik[0, 0], titik[1, 0]
x_akhir, y_akhir = hasil[0, 0], hasil[1, 0]

# Visualisasi
fig, ax = plt.subplots()
ax.plot(x_asal, y_asal, 'ro', label='Titik Asal (2,1)')
ax.plot(x_akhir, y_akhir, 'bo', label='Hasil T3·T2·T1')

# Garis bantu
ax.plot([x_asal, x_akhir], [y_asal, y_akhir], 'gray', ls="--")

# Gambar sumbu
ax.axvline(x=0, color="k", ls=":")
ax.axhline(y=0, color="k", ls=":")
ax.grid(True)
ax.set_xlim([-3, 3])
ax.set_ylim([-3, 3])
ax.set_aspect('equal')
ax.set_title("Gabungan T1 × T2 × T3 terhadap Titik (2,1)")
ax.legend()
plt.show()

# Tampilkan hasil akhir juga di konsol
print("Koordinat akhir hasil T3·T2·T1 · (2,1):", hasil.flatten())

Koordinat akhir hasil T3·T2·T1 · (2,1): [ 1 -2]

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Titik-titik objek asli (misalnya, segitiga 3D)
points = np.array([
    [1, 1, 1],
    [2, 1, 1],
    [1.5, 2, 1]
]).T  # bentuknya 3xN

# Matriks refleksi terhadap bidang x = 0
reflection_matrix = np.array([
    [-1, 0, 0],
    [ 0, 1, 0],
    [ 0, 0, 1]
])

# Lakukan refleksi
reflected_points = reflection_matrix @ points

# Buat plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Gambar objek asli (biru)
ax.plot(points[0], points[1], points[2], 'bo-', label='Asli')

# Gambar objek setelah refleksi (merah)
ax.plot(reflected_points[0], reflected_points[1], reflected_points[2], 'ro-', label='Refleksi')

# Tambahkan garis bantu bidang x = 0
x_plane = np.zeros((2, 2))
y_plane, z_plane = np.meshgrid(np.linspace(0, 3, 2), np.linspace(0, 3, 2))
ax.plot_surface(x_plane, y_plane, z_plane, alpha=0.2, color='gray')

# Set aspek dan label
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Refleksi terhadap bidang x = 0')
ax.legend()
ax.set_box_aspect([1,1,1])  # aspek rasio 1:1:1

plt.show()

Latihan

1. Carilah matriks yang menggambarkan refleksi terhadap sumbu y = x. Kalikan matrik dengan 4 titik koordinat dan plot hasilnya

2. Carilah matriks yang menggambarkan refleksi terhadap sumbu y= -x. Kalikan matrik dengan 4 titik koordinat dan plot hasilnya

Matrik Geser ( Shear Matrix)

Shear matrix atau Matriks geser. adalah jenis transformasi dalam aljabar linear dan grafika komputer, yang menggeser satu bagian dari objek ke arah tertentu tanpa mengubah volumenya.

Matriks shear “mendorong” titik-titik dalam suatu arah (biasanya horizontal atau vertikal), sedangkan titik-titik lain tetap relatif pada sumbu tertentu.

Matrik Geser pada 2D:

Misalkan kita punya titik \((x, y)\). Jika kita terapkan shear horizontal, maka titiknya berubah menjadi:

\[\begin{split} \begin{bmatrix} 1 & k \\ 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} x + ky \\ y \end{bmatrix} \end{split}\]

Artinya, sumbu-x digeser sebanding dengan nilai y (terjadi “kemiringan” arah horizontal).

Jika shear vertikal:

\[\begin{split} \begin{bmatrix} 1 & 0 \\ k & 1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} x \\ y + kx \end{bmatrix} \end{split}\]

Aplikasi:

• Dalam grafika komputer untuk menciptakan efek distorsi

• Dalam mekanika untuk menggambarkan deformasi material

• Dalam transformasi geometris computer vision

%matplotlib inline  
from math import pi, sin, cos
import matplotlib.pyplot as plt
import numpy as np

titik = np.array([[0,0],[0.5,0.5],[0.5,1.5],[0,1],[0,0]])
koordinats = titik.transpose()
x = koordinats[0,:]
y = koordinats[1,:]


S = np.array([[1,2],[0,1]])
S_coords = S@koordinats

x_LT4 = S_coords[0,:]
y_LT4 = S_coords[1,:]



fig, ax = plt.subplots()


ax.plot(x,y,'ro')
ax.plot(x_LT4,y_LT4,'bo')


ax.plot(x,y,'r',ls="--")
ax.plot(x_LT4,y_LT4,'b')


ax.axvline(x=0,color="k",ls=":")
ax.axhline(y=0,color="k",ls=":")
ax.grid(True)
ax.axis([-2,4,-1,2])
ax.set_aspect('equal')
ax.set_title("Shear");

Matrik Rotasi

Matriks rotasi adalah matriks transformasi linier yang digunakan untuk memutar vektor atau objek di ruang 2D, 3D, atau lebih tinggi tanpa mengubah bentuk atau ukurannya.

---

Matriks rotasi memutar titik atau objek sekitar asal (0,0) atau sumbu tertentu, dengan sudut tertentu (biasanya dalam radian atau derajat).

---

✅ Matriks Rotasi pada 2D

Untuk memutar vektor sebesar sudut \(\theta\) terhadap titik asal dalam bidang 2D:

\[\begin{split} R(\theta) = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix} \end{split}\]

Jika kamu punya titik \((x, y)\), maka hasil rotasinya:

\[\begin{split} \begin{bmatrix} x' \\ y' \end{bmatrix} = R(\theta) \cdot \begin{bmatrix} x \\ y \end{bmatrix} \end{split}\]

---

✅ Matriks Rotasi pada 3D

Di 3D, rotasi bisa dilakukan terhadap sumbu X, Y, atau Z.

1. Rotasi terhadap sumbu X (dengan sudut \(\theta\)):

\[\begin{split} R_x(\theta) = \begin{bmatrix} 1 & 0 & 0 \\ 0 & \cos\theta & -\sin\theta \\ 0 & \sin\theta & \cos\theta \end{bmatrix} \end{split}\]

2. Rotasi terhadap sumbu Y:

\[\begin{split} R_y(\theta) = \begin{bmatrix} \cos\theta & 0 & \sin\theta \\ 0 & 1 & 0 \\ -\sin\theta & 0 & \cos\theta \end{bmatrix} \end{split}\]

3. Rotasi terhadap sumbu Z:

\[\begin{split} R_z(\theta) = \begin{bmatrix} \cos\theta & -\sin\theta & 0 \\ \sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{bmatrix} \end{split}\]

---

🛠️ Aplikasi Matriks Rotasi:

• Grafika komputer (animasi, rotasi objek)

• Robotika (pergerakan lengan robot)

• Pemrosesan citra (rotasi gambar)

• Navigasi (GPS, drone, pesawat)

• Ilmu data spasial dan geometri

---

%matplotlib inline  
from math import pi, sin, cos
import matplotlib.pyplot as plt
import numpy as np

titik = np.array([[0,0],[0.5,0.5],[0.5,1.5],[0,1],[0,0]])
koordinats = titik.transpose()
x = koordinats[0,:]
y = koordinats[1,:]

theta = pi/6
R = np.array([[cos(theta),-sin(theta)],[sin(theta),cos(theta)]])
R_koordinats = R@koordinats

x_LT3 = R_koordinats[0,:]
y_LT3 = R_koordinats[1,:]

# membuat gambar
fig, ax = plt.subplots()

# ploting titik titik.  x dan y adalah vektor asal (domain), x_LT1 dab y_LT1 adalah bayangan (codomain)
ax.plot(x,y,'ro')
ax.plot(x_LT3,y_LT3,'bo')

# menghubungkan titik dengan baris
ax.plot(x,y,'r',ls="--")
ax.plot(x_LT3,y_LT3,'b')

# menggambar sumbu sumbu koordinat
ax.axvline(x=0,color="k",ls=":")
ax.axhline(y=0,color="k",ls=":")
ax.grid(True)
ax.axis([-2,2,-1,2])
ax.set_aspect('equal')
ax.set_title("Rotasi");

Komposisi transformasi

Komposisi transformasi (Composition of Transformations) adalah proses menggabungkan dua atau lebih transformasi geometris (seperti translasi, rotasi, refleksi, dan dilatasi) menjadi satu transformasi yang lebih kompleks.

Dalam komposisi transformasi, transformasi pertama diterapkan terlebih dahulu, dan kemudian transformasi kedua diterapkan pada hasil dari transformasi pertama. Jika lebih dari dua transformasi, proses ini dilakukan secara berurutan.

Misalnya, jika kita memiliki dua transformasi:

1. \(T_1\) (seperti rotasi)

2. \(T_2\) (seperti translasi)

Maka komposisi transformasi \(T_1 \circ T_2\) berarti:

1. Terlebih dahulu aplikasikan \(T_2\) pada titik atau objek.

2. Setelah itu, aplikasikan \(T_1\) pada hasil transformasi sebelumnya.

Matriks dan Komposisi:

Jika kita bekerja dengan matriks transformasi, komposisi dapat dilakukan dengan perkalian matriks. Misalnya, jika \(A\) adalah matriks transformasi pertama dan \(B\) adalah matriks transformasi kedua, maka komposisi transformasi tersebut adalah:

\[ C = A \times B \]

Dengan catatan:

• Matriks \(A\) diterapkan setelah \(B\).

• Urutan perkalian matriks sangat penting, karena perkalian matriks tidak komutatif (yaitu \(A \times B \neq B \times A\)).

---

Contoh Komposisi Transformasi:

Misalnya, kita ingin menggabungkan dua transformasi:

1. Rotasi 90° terhadap titik asal.

2. Translasi (geser) 5 satuan ke kanan dan 3 satuan ke atas.

Langkah-langkah:

1. Rotasi: Matriks rotasi 90°:

   \[\begin{split} R = \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix} \end{split}\]

2. Translasi: Matriks translasi 5 satuan ke kanan dan 3 satuan ke atas:

   \[\begin{split} T = \begin{bmatrix} 1 & 0 & 5 \\ 0 & 1 & 3 \\ 0 & 0 & 1 \end{bmatrix} \end{split}\]

Jika kita komposisikan translasi dan rotasi, kita harus menggabungkan matriks translasi dan rotasi ke dalam satu matriks transformasi. Hasil akhirnya akan memberikan rotasi diikuti oleh translasi.

---

Aplikasi dalam Dunia Nyata:

• Grafika komputer: Untuk menggambar dan memanipulasi objek 3D (rotasi, translasi, zooming, dll.).

• Robotika: Untuk mengarahkan robot melalui serangkaian pergerakan.

• Geometri: Untuk mempelajari bentuk dan perubahan posisi dalam ruang.

---

Latihan

1. Buatlah beberapa operasi komposisi shear, rotasi dan reflesi pada 2D untuk titik koordinat (2,2)

2. Buatlah beberapa operasi komposisi shear, rotasi dan reflesi pada 2D untuk titik koordinat (2,2) sehingga titik tersebut kembali lagi ke (2,2)

Matrik Translasi

Matriks translasi adalah matriks yang digunakan untuk mentranslasi (menggeser) titik atau objek dalam ruang. Translasi memindahkan titik dengan jarak tertentu di sepanjang sumbu tertentu, tanpa mengubah bentuk atau orientasi objek.

---

✅ Matriks Translasi pada 2D

Dalam ruang dua dimensi (2D), matriks translasi biasanya dituliskan sebagai:

\[\begin{split} T = \begin{bmatrix} 1 & 0 & tx \\ 0 & 1 & ty \\ 0 & 0 & 1 \end{bmatrix} \end{split}\]

• \(tx\) adalah jarak translasi sepanjang sumbu x (horizontal).

• \(ty\) adalah jarak translasi sepanjang sumbu y (vertikal).

Jika kita memiliki titik \((x, y)\), maka hasil translasi menjadi:

\[\begin{split} \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} = T \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} \end{split}\]

Dimana:

• \(x' = x + tx\)

• \(y' = y + ty\)

Jadi, titik \((x, y)\) akan digeser ke posisi baru \((x + tx, y + ty)\).

---

✅ Matriks Translasi pada 3D

Untuk translasi di ruang tiga dimensi (3D), matriks translasi dapat dituliskan sebagai:

\[\begin{split} T = \begin{bmatrix} 1 & 0 & 0 & tx \\ 0 & 1 & 0 & ty \\ 0 & 0 & 1 & tz \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

• \(tx\), \(ty\), dan \(tz\) adalah jarak translasi sepanjang sumbu x, y, dan z.

Jika kita memiliki titik \((x, y, z)\), maka hasil translasi menjadi:

\[\begin{split} \begin{bmatrix} x' \\ y' \\ z' \\ 1 \end{bmatrix} = T \cdot \begin{bmatrix} x \\ y \\ z \\ 1 \end{bmatrix} \end{split}\]

Dimana:

• \(x' = x + tx\)

• \(y' = y + ty\)

• \(z' = z + tz\)

---

✅ Aplikasi Matriks Translasi:

• Grafika komputer: Untuk menggeser objek atau gambar di layar.

• Robotika: Untuk memindahkan posisi lengan robot.

• Geometri: Untuk memindahkan titik atau bentuk dalam ruang tanpa merubah ukuran atau orientasi.

---

import numpy as np
import matplotlib.pyplot as plt

# Titik-titik objek (misalnya segitiga)
x = np.array([1, 2, 3])  # Koordinat X
y = np.array([1, 3, 2])  # Koordinat Y

# Matriks translasi (misalnya translasi 2 unit ke kanan dan 1 unit ke atas)
tx, ty = 2, 1
translation_matrix = np.array([[1, 0, tx],
                               [0, 1, ty],
                               [0, 0, 1]])

# Menambahkan baris 1 untuk koordinat homogen (x, y, 1)
coordinates = np.vstack((x, y, np.ones_like(x)))

# Menghitung hasil translasi
translated_coordinates = translation_matrix @ coordinates

# Titik-titik hasil translasi
x_translated = translated_coordinates[0, :]
y_translated = translated_coordinates[1, :]

# Plot objek asli dan hasil translasi
plt.figure(figsize=(6, 6))
plt.plot(x, y, 'bo-', label='Objek Asli')  # Titik objek asli (biru)
plt.plot(x_translated, y_translated, 'ro-', label='Objek Setelah Translasi')  # Titik objek setelah translasi (merah)

# Menambahkan label dan judul
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Matriks Translasi pada Objek 2D')
plt.axhline(0, color='black',linewidth=1)
plt.axvline(0, color='black',linewidth=1)
plt.grid(True)
plt.legend()
plt.axis('equal')  # Agar skala X dan Y sama

plt.show()