Setelah memahami dasar-dasar kanvas, sistem koordinat, dan interaksi mouse pada artikel sebelumnya, kini saatnya melangkah lebih jauh ke dunia yang paling memikat dari Processing: Seni Generatif (*Generative Art*) dan Simulasi Partikel Berbasis Fisika.

Alih-alih menggambar bentuk manual satu per satu, kita akan menulis aturan matematika sederhana dan membiarkan komputer menghasilkan pola visual yang rumit, dinamis, dan bernilai estetika tinggi.

Artikel ini adalah Bagian 2 dari seri panduan Processing di Python:

• Bagian 1: Mengenal Processing di Python: Menggambar Interaktif dan Animasi (Kanvas, setup/draw, mouse, pantulan bola).
• Bagian 2 (Sedang Dibaca): Seni Generatif dan Sistem Partikel di Python Processing (Perlin noise, trigonometri, pohon fraktal, dan gravitasi partikel).
• Bagian 3: Processing Modern di Python 3 Menggunakan py5: Seni Kreatif di VS Code dan Integrasi NumPy (Transisi ke Python 3, VS Code, dan komputasi NumPy).

1. Perlin Noise vs Random: Menghasilkan Gerakan Organik

Dalam seni generatif, fungsi acak random() biasa seringkali menghasilkan lompatan angka yang patah-patah dan tidak alami. Untuk meniru fenomena alam seperti hembusan angin, riak air, atau kontur awan, kita menggunakan Perlin Noise melalui fungsi bawaan noise().

Fungsi noise(x, y) menghasilkan urutan bilangan acak yang saling terhubung mulus (gradual) bernilai antara 0.0 hingga 1.0. Berikut adalah cara menciptakan 3 lapisan gelombang air yang mengalir alami:

# 01-gelombang-perlin-noise.py
waktu = 0.0

def setup():
    size(600, 400)
    smooth()

def draw():
    global waktu
    background(15, 23, 42)  # Latar biru dongker malam
    
    noFill()
    strokeWeight(3)
    
    # Menggambar 3 lapisan gelombang dengan variasi kecepatan dan warna
    lapisan = [
        {"warna": (56, 189, 248, 150), "offset": 0.0, "skala": 80},   # Biru muda
        {"warna": (129, 140, 248, 180), "offset": 10.0, "skala": 100}, # Indigo
        {"warna": (244, 114, 182, 220), "offset": 20.0, "skala": 120}  # Merah muda
    ]
    
    for l in lapisan:
        stroke(*l["warna"])
        beginShape()
        x_offset = l["offset"]
        
        # Hitung tinggi kurva di setiap titik horizontal x
        for x in range(0, width + 10, 10):
            # noise() menghasilkan angka lembut antara 0.0 dan 1.0
            y = map(noise(x_offset, waktu), 0, 1, 150 - l["skala"], 250 + l["skala"])
            vertex(x, y)
            x_offset += 0.05
            
        endShape()
    
    # Jalankan waktu ke depan agar gelombang mengalir
    waktu += 0.02

Perhatikan penggunaan beginShape() dan vertex(x, y). Kedua fungsi ini memungkinkan kita menghubungkan titik-titik koordinat menjadi satu pita kurva vektor yang bersambung tanpa putus.

2. Geometri Harmonik: Bunga Mandala dengan Trigonometri

Matematika adalah kuas terbaik dalam seni generatif. Menggunakan fungsi trigonometri lingkaran dan rotasi kanvas (rotate()), kita bisa membuat pola geometri mandala bercahaya yang berputar:

# 02-bunga-trigonometri.py
sudut_rotasi = 0.0

def setup():
    size(600, 400)
    rectMode(CENTER)

def draw():
    global sudut_rotasi
    background(10, 15, 30)
    
    # Pindahkan titik pusat koordinat (0, 0) ke tengah kanvas
    translate(width / 2, height / 2)
    rotate(sudut_rotasi)
    
    jumlah_kelopak = 12
    noFill()
    strokeWeight(2)
    
    for i in range(jumlah_kelopak):
        pushMatrix()
        # Putar kanvas per kelopak
        rotate(TWO_PI / jumlah_kelopak * i)
        
        # Gambar kelopak elips dan ornamen kotak
        stroke(56, 189, 248, 160)
        ellipse(60, 0, 120, 40)
        
        stroke(168, 85, 247, 180)
        ellipse(100, 0, 80, 25)
        
        stroke(244, 114, 182, 220)
        rect(40, 0, 30, 30)
        popMatrix()
        
    # Titik inti tengah bercahaya
    fill(250, 204, 21)
    noStroke()
    ellipse(0, 0, 20, 20)
    
    # Putar kanvas secara bertahap
    sudut_rotasi += 0.015

Kunci dari teknik ini adalah fungsi pasangan pushMatrix() dan popMatrix(). pushMatrix() mencatat kondisi koordinat saat ini, dan popMatrix() mengembalikannya seperti semula, sehingga perputaran satu kelopak tidak mengganggu orientasi kelopak berikutnya.

3. Fraktal Rekursif: Menumbuhkan Pohon Alami Interaktif

Fraktal adalah pola geometris di mana bagian kecil dari suatu objek memiliki bentuk serupa dengan keseluruhan objek tersebut (*self-similarity*). Struktur ranting pohon di alam adalah contoh nyata dari fraktal rekursif.

Di bawah ini, kita membuat fungsi rekursif tumbuhkan_ranting() yang memanggil dirinya sendiri sebanyak 2 kali (kiri dan kanan), dengan sudut yang dikontrol oleh posisi kursor mouse:

# 03-pohon-fraktal-rekursif.py
def setup():
    size(600, 400)

def draw():
    background(15, 23, 42)
    
    # Sudut percabangan ditentukan oleh posisi horizontal kursor mouse
    sudut = map(mouseX, 0, width, 0, PI / 2)
    
    # Mulai pertumbuhan pohon dari bawah tengah kanvas
    translate(width / 2, height)
    stroke(56, 189, 248)
    strokeWeight(3)
    
    # Gambar batang utama dan mulai rekursi
    line(0, 0, 0, -100)
    translate(0, -100)
    tumbuhkan_ranting(70, sudut)

def tumbuhkan_ranting(panjang, sudut):
    # Setiap ranting diperkecil menjadi 67% dari ranting induknya
    panjang *= 0.67
    
    # Batas rekursi: berhenti jika panjang ranting sudah lebih kecil dari 4 piksel
    if panjang > 4:
        # Cabang Kanan
        pushMatrix()
        rotate(sudut)
        stroke(168, 85, 247, 200)
        strokeWeight(max(1, panjang / 15))
        line(0, 0, 0, -panjang)
        translate(0, -panjang)
        tumbuhkan_ranting(panjang, sudut)
        popMatrix()
        
        # Cabang Kiri
        pushMatrix()
        rotate(-sudut)
        stroke(244, 114, 182, 200)
        strokeWeight(max(1, panjang / 15))
        line(0, 0, 0, -panjang)
        translate(0, -panjang)
        tumbuhkan_ranting(panjang, sudut)
        popMatrix()

Penting: Selalu tentukan kondisi batas berhenti rekursi (dalam kode ini: if panjang > 4:) agar komputer tidak mengalami *infinite recursion* yang menyebabkan program macet (*stack overflow*).

4. Simulasi Fisika: Sistem Partikel Air Mancur (OOP)

Ketika kamu melihat efek sihir, ledakan api, atau semburan air di video game, hampir semuanya dibuat menggunakan Sistem Partikel (*Particle System*). Menggunakan Pemrograman Berorientasi Objek (OOP) di Python, kita bisa memodelkan setiap butir partikel sebagai objek yang memiliki posisi, kecepatan, gaya gravitasi, dan umur hidup (*lifespan*):

# 04-sistem-partikel-air-mancur.py
import random

class Partikel:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        # Kecepatan semburan awal ke atas dan sedikit acak ke samping
        self.vx = random.uniform(-2.5, 2.5)
        self.vy = random.uniform(-8.0, -4.0)
        self.gravitasi = 0.2
        self.masa_hidup = 255.0  # Transparansi alpha berkurang tiap frame
        self.warna = random.choice([
            (56, 189, 248),   # Cyan
            (168, 85, 247),   # Ungu
            (244, 114, 182),  # Pink
            (250, 204, 21)    # Emas
        ])

    def update(self):
        self.vy += self.gravitasi   # Menambah efek gravitasi ke bawah
        self.x += self.vx
        self.y += self.vy
        self.masa_hidup -= 4.0      # Partikel perlahan memudar

    def display(self):
        noStroke()
        fill(self.warna[0], self.warna[1], self.warna[2], max(0, self.masa_hidup))
        ellipse(self.x, self.y, 8, 8)

    def is_mati(self):
        return self.masa_hidup <= 0

# Wadah penyimpan partikel
daftar_partikel = []

def setup():
    size(600, 400)

def draw():
    background(15, 23, 42)
    
    # Pancarkan 3 partikel baru di setiap frame dari titik tengah bawah
    for _ in range(3):
        daftar_partikel.append(Partikel(width / 2, height - 40))
        
    # Perbarui dan gambar setiap partikel
    # Kita iterasi terbalik agar aman saat menghapus partikel yang mati
    for i in range(len(daftar_partikel) - 1, -1, -1):
        p = daftar_partikel[i]
        p.update()
        p.display()
        if p.is_mati():
            daftar_partikel.pop(i)

Mengapa loop menggunakan iterasi terbalik range(len(daftar_partikel) - 1, -1, -1)?

Ketika menghapus elemen dari sebuah daftar Python yang sedang diulang (*iterated*), menghapus dari belakang ke depan memastikan nomor indeks elemen-elemen sebelumnya tidak bergeser secara keliru.

Ringkasan Materi

• Perlin Noise (noise()) memberikan transisi angka acak yang halus dan terhubung, sempurna untuk membuat ombak, kabut, dan lanskap alam.
• Kombinasi pushMatrix() dan popMatrix() memungkinkan kita mengisolasi transformasi geometri tanpa mengubah sistem koordinat kanvas global.
• Fraktal Rekursif meniru keindahan arsitektur alam seperti ranting, kepingan salju, dan paku-pakuan melalui pemanggilan fungsi berulang dengan skala menurun.
• Sistem Partikel Berorientasi Objek menjadi fondasi utama untuk memprogram efek visual dinamis seperti kembang api, asap, dan semburan air.

Langkah Selanjutnya: Menuju Python 3 & py5

Pada artikel penutup serial ini, kita akan mengeksplorasi cara membawa Processing ke lingkungan Python 3 modern (CPython) menggunakan pustaka py5, menjalankan sketsa langsung di VS Code, dan memanfaatkan kecepatan NumPy untuk mengolah puluhan ribu partikel secara instan!

👉 Lanjut membaca artikel penutup serial ini: Bagian 3: Processing Modern di Python 3 Menggunakan py5: Seni Kreatif di VS Code dan Integrasi NumPy