Grafik

BAB 46: Canvas

Menggambar grafik 2D di browser menggunakan elemen canvas dan JavaScript.

Seluruh bab tentang form yang baru kita selesaikan membahas cara HTML mengumpulkan data dari pengguna, teks, pilihan, file. Tapi HTML juga bisa melakukan sesuatu yang berlawanan arah: menampilkan grafik yang dihasilkan secara dinamis oleh kode, langsung di dalam halaman web. Tidak membutuhkan gambar eksternal, tidak membutuhkan plugin. Itulah yang dilakukan elemen <canvas>.

<canvas> adalah sebuah area kosong di halaman yang bisa kamu gambar sesuka hati menggunakan JavaScript. Garis, kotak, lingkaran, teks, gradien, bahkan animasi, semua bisa dibuat di atas satu elemen ini.

Apa Itu Canvas

Elemen <canvas> adalah sebuah "kanvas" bitmap yang dapat digambar menggunakan JavaScript melalui Canvas API. Ia tidak menampilkan apapun secara default: hanya menyediakan ruang menggambar. Semua gambar dibuat oleh kode JavaScript, bukan konten HTML.

Ini berbeda dari elemen <img> yang menampilkan file gambar yang sudah jadi. Canvas bersifat prosedural: kamu memberikan instruksi menggambar satu per satu, dan browser menjalankannya.

HTMLHTML
<!-- portofolio.html -->
<canvas id="papan-gambar" width="400" height="200">
  Browser Anda tidak mendukung canvas. Gunakan browser modern.
</canvas>

Teks di antara tag <canvas> adalah fallback content: hanya ditampilkan jika browser tidak mendukung canvas. Browser modern sudah mendukungnya, tapi selalu baik untuk menyediakan teks alternatif.

Atur dimensi canvas dengan atribut width dan height di HTML, bukan lewat CSS. Jika kamu mengatur ukuran canvas via CSS, area gambar internal tidak ikut berubah, akibatnya gambar bisa terlihat terdistorsi atau buram.

Mendapatkan Context Menggambar

Sebelum bisa menggambar apapun, kamu perlu mengambil rendering context dari elemen canvas. Context inilah yang menyediakan semua method untuk menggambar.

HTMLHTML
<!-- portofolio.html -->
<canvas id="papan-gambar" width="400" height="200"></canvas>

<script src="js/grafik.js"></script>
JavaScriptJAVASCRIPT
// js/grafik.js
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

Method getContext("2d") mengembalikan objek CanvasRenderingContext2D yang akan kita gunakan sepanjang bab ini. Nilai "2d" menentukan bahwa kita menggunakan Canvas 2D API, ada juga "webgl" untuk grafik 3D, tapi itu topik yang jauh lebih luas.

Menggambar Bentuk Dasar

Persegi panjang

Canvas 2D menyediakan tiga method bawaan untuk menggambar persegi panjang:

  • fillRect(x, y, lebar, tinggi), menggambar persegi panjang berisi warna
  • strokeRect(x, y, lebar, tinggi), menggambar garis tepi persegi panjang
  • clearRect(x, y, lebar, tinggi), menghapus area menjadi transparan

Koordinat (x, y) mengacu pada pojok kiri atas persegi panjang, diukur dari pojok kiri atas canvas.

JavaScriptJAVASCRIPT
// js/grafik.js
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

// kotak hijau terisi
ctx.fillStyle = "#2ecc71";
ctx.fillRect(20, 20, 150, 80);

// kotak dengan garis tepi biru
ctx.strokeStyle = "#2980b9";
ctx.lineWidth = 3;
ctx.strokeRect(200, 20, 150, 80);

// hapus bagian tengah kotak hijau
ctx.clearRect(60, 40, 70, 40);

Diagram sistem koordinat canvas dengan fillRect pada posisi (20,20)

Gambar 1: Sistem koordinat canvas dan parameter fillRect

Properti fillStyle dan strokeStyle menerima semua format warna CSS: nama warna, hex, rgb(), hsl(), atau bahkan gradien.

Path dan Garis

Untuk bentuk yang lebih kompleks (segitiga, poligon, garis bebas) canvas menggunakan konsep path. Path adalah rangkaian titik-titik yang dihubungkan, dan kamu menggambarnya dalam tiga langkah:

  1. Mulai path baru dengan beginPath()
  2. Tentukan bentuk menggunakan method moveTo(), lineTo(), dll.
  3. Akhiri dengan stroke() (gambar garis) atau fill() (isi dengan warna)
JavaScriptJAVASCRIPT
// js/grafik.js: dikembangkan dari contoh sebelumnya
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

// gambar segitiga
ctx.beginPath();
ctx.moveTo(200, 150);   // pindah ke titik awal tanpa menggambar
ctx.lineTo(300, 50);    // garis ke atas-kanan
ctx.lineTo(100, 50);    // garis ke kiri
ctx.closePath();        // tutup path kembali ke titik awal
ctx.fillStyle = "#e74c3c";
ctx.fill();

// gambar garis zigzag
ctx.beginPath();
ctx.moveTo(20, 130);
ctx.lineTo(80, 80);
ctx.lineTo(140, 130);
ctx.lineTo(200, 80);
ctx.strokeStyle = "#8e44ad";
ctx.lineWidth = 2;
ctx.stroke();

closePath() menggambar garis otomatis dari titik terakhir kembali ke titik awal path. Ini berguna untuk menutup bentuk poligon tanpa harus mengulangi koordinat titik pertama.

Lingkaran dan Busur

Untuk menggambar lingkaran, gunakan method arc():

JavaScriptJAVASCRIPT
ctx.arc(cx, cy, radius, sudutMulai, sudutAkhir, berlawananJarum)

Sudut diukur dalam radian, bukan derajat. Satu putaran penuh = 2 * Math.PI. Untuk mengonversi derajat ke radian: derajat * Math.PI / 180.

JavaScriptJAVASCRIPT
// js/grafik.js: melanjutkan contoh di atas
// lingkaran penuh
ctx.beginPath();
ctx.arc(320, 130, 40, 0, 2 * Math.PI);
ctx.fillStyle = "#f39c12";
ctx.fill();

// setengah lingkaran
ctx.beginPath();
ctx.arc(80, 170, 30, 0, Math.PI); // 0 hingga PI = setengah ke bawah
ctx.strokeStyle = "#1abc9c";
ctx.lineWidth = 3;
ctx.stroke();

Menggambar Teks

Canvas bisa menampilkan teks menggunakan fillText() untuk teks berisi warna, atau strokeText() untuk teks garis tepi saja.

JavaScriptJAVASCRIPT
// js/grafik.js
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

ctx.font = "bold 24px Arial";
ctx.fillStyle = "#2c3e50";
ctx.fillText("Portofolio Budi", 20, 40);

ctx.font = "16px Georgia";
ctx.strokeStyle = "#e74c3c";
ctx.strokeText("Web Developer", 20, 70);

Properti font menerima nilai yang sama persis dengan CSS font shorthand: ukuran, keluarga font, tebal, dll. Koordinat (x, y) pada fillText() menentukan posisi baseline teks, titik bawah dari sebagian besar huruf.

Gunakan ctx.textAlign = "center" untuk memusatkan teks secara horizontal relatif terhadap koordinat x yang diberikan. Nilai lain: "left" (default), "right", "start", "end".

Warna dan Transparansi

Selain warna solid, fillStyle dan strokeStyle juga menerima nilai dengan transparansi:

JavaScriptJAVASCRIPT
// js/grafik.js
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

// menggunakan rgba untuk transparansi
ctx.fillStyle = "rgba(52, 152, 219, 0.8)";  // biru 80% opak
ctx.fillRect(30, 30, 200, 100);

ctx.fillStyle = "rgba(231, 76, 60, 0.6)";   // merah 60% opak
ctx.fillRect(100, 70, 200, 100);             // tumpang tindih

Cara lain mengatur transparansi adalah lewat properti globalAlpha yang mempengaruhi semua gambar setelahnya:

JavaScriptJAVASCRIPT
ctx.globalAlpha = 0.5;  // semua gambar selanjutnya 50% transparan
ctx.fillStyle = "#3498db";
ctx.fillRect(50, 50, 100, 100);
ctx.globalAlpha = 1.0;  // kembalikan ke penuh

Menyimpan dan Memulihkan State

Ketika kamu mengubah fillStyle, strokeStyle, lineWidth, dan properti lainnya, perubahan itu berlaku permanen di context tersebut. Jika kamu menggambar banyak elemen dengan gaya berbeda, ini bisa merepotkan.

Canvas menyediakan save() dan restore() untuk menyimpan dan memulihkan seluruh "state" context sekaligus:

JavaScriptJAVASCRIPT
// js/grafik.js
const papan = document.getElementById("papan-gambar");
const ctx = papan.getContext("2d");

// state awal
ctx.fillStyle = "#2c3e50";
ctx.fillRect(10, 10, 80, 80);

ctx.save();  // simpan state saat ini

// ubah state untuk elemen berikutnya
ctx.fillStyle = "#e74c3c";
ctx.globalAlpha = 0.7;
ctx.fillRect(60, 60, 80, 80);

ctx.restore();  // pulihkan state ke sebelum save()

// kembali ke fillStyle "#2c3e50", globalAlpha 1
ctx.fillRect(150, 10, 80, 80);

save() dan restore() bekerja seperti stack, setiap save() mendorong state ke tumpukan, setiap restore() mengambil state teratas. Ini sangat berguna ketika menggambar komponen yang kompleks.

Latihan

Gunakan canvas untuk menambahkan elemen visual ke portofolio Budi:

  1. Buat file grafik.html dengan sebuah <canvas> berukuran 500×300 piksel. Gambar di atasnya: sebuah persegi panjang berwarna gelap sebagai "kartu", teks nama Budi di dalamnya, dan sebuah lingkaran sebagai "avatar placeholder" di pojok kiri kartu.

  2. Kembangkan contoh tersebut dengan menggambar tiga kotak berwarna berbeda yang sedikit tumpang tindih menggunakan rgba(), sehingga area tumpang tindih terlihat transparansi warnanya.

  3. Coba gambar sebuah bintang lima sudut menggunakan path dengan moveTo() dan lineTo(). Petunjuk: titik-titik bintang bisa dihitung dengan fungsi trigonometri Math.cos() dan Math.sin().

Canvas menyimpan banyak kemungkinan (animasi, chart, efek visual, bahkan game sederhana. Semua berawal dari pemahaman dasar yang baru saja kita bangun. Tapi canvas bukan satu-satunya cara HTML menampilkan grafik. Ada pendekatan yang berbeda mendasar: alih-alih menggambar piksel demi piksel, kamu mendefinisikan bentuk sebagai elemen XML yang bisa diubah ukurannya tanpa kehilangan kualitas. Itulah SVG) dan kita akan menjelajahinya di bab selanjutnya.

Referensi

  1. 1 MDN Web Docs: <canvas>: The Graphics Canvas element
  2. 2 MDN Web Docs: Canvas API Tutorial
  3. 3 MDN Web Docs: CanvasRenderingContext2D