Computer Vision untuk Pemula: Dari Piksel Sampai Bikin API-nya Sendiri (OpenCV + FastAPI)

🧠 TL;DR — Gambar digital cuma kumpulan angka dalam bentuk matriks. Begitu kamu paham itu, semua konsep di Computer Vision — dari grayscale, convolution, sampai CNN — jadi jauh lebih masuk akal. Di post ini kita bongkar konsepnya pelan-pelan, sambil coding bareng pakai OpenCV, terus kita bungkus jadi API pakai FastAPI.

Pernah kepikiran nggak, gimana caranya HP kamu bisa tahu ada wajah di foto? Atau gimana caranya CCTV bisa "curiga" kalau ada orang masuk area terlarang? Semua itu berawal dari satu ide sederhana yang sering diremehkan orang: komputer sebenarnya nggak "melihat" gambar seperti kita — dia cuma melihat angka.

Begitu kamu paham cara komputer "melihat" angka ini, pintu masuk ke dunia Computer Vision jadi jauh lebih terang. Yuk kita bongkar satu-satu, plus ada beberapa titik di mana kamu bisa berhenti sejenak buat nge-test pemahaman kamu sendiri. 👇

📋 Yang Akan Kamu Pelajari

• Apa Itu Computer Vision, Sebenarnya?

• Anatomi Sebuah Gambar Digital

• Image Processing vs Computer Vision — Bedanya Apa?

• Di Mana Computer Vision Dipakai?

• Praktik: 5 Operasi Dasar dengan OpenCV

• Bonus: Edge Detection Lanjutan (Sobel, Laplacian, Canny+Blur)

• Dari Kernel Manual ke CNN

• Bungkus Jadi API dengan FastAPI

• Bonus: Endpoint Versi Gambar Langsung & Bukti Deploy Nyata

• Cheat Sheet & Kuis Mini

💡 Kalau kamu publish di Hashnode, aktifkan toggle "Table of Contents" di pengaturan artikel (bagian Post Settings saat publish) — Hashnode otomatis bikin navigasi loncat-ke-section yang beneran jalan, dari heading yang ada di artikel ini.

---

Apa Itu Computer Vision, Sebenarnya?

Definisi klasik AI: sistem yang bisa berpikir dan bertindak layaknya manusia. Nah, kalau kecerdasan itu diarahkan ke bahasa, itu namanya NLP. Kalau diarahkan ke penglihatan, itu namanya Computer Vision.

💡 Computer Vision adalah cabang AI yang membuat komputer bisa memahami dan menafsirkan informasi visual dari gambar atau video — mendeteksi objek, mengenali wajah, bahkan mengambil keputusan dari apa yang "dilihatnya".

Tapi sebelum komputer bisa "mikir" soal gambar, dia butuh fondasi yang lebih dasar dulu: Image Processing. Ibarat belajar bahasa, kamu nggak bisa langsung nulis puisi sebelum kenal huruf. Image processing itu "huruf"-nya.

🧩 Quick check #1: Kalau NLP itu kecerdasan linguistik, Computer Vision itu kecerdasan apa?

(coba jawab dulu di kepala kamu sebelum baca baris berikutnya 👇)

✅ Jawaban: Kecerdasan visual — kemampuan memahami informasi dari gambar/video, bukan teks.

Anatomi Sebuah Gambar Digital

Ini bagian paling penting yang sering dilewatkan orang: gambar digital itu matriks angka.

Setiap gambar tersusun dari piksel — satuan terkecil sebuah gambar — dan tiap piksel punya nilai yang menyatakan intensitas cahaya di titik itu. Makin gelap, nilainya makin mendekati 0. Makin terang, nilainya makin tinggi.

Grayscale vs RGB

	Grayscale	RGB (Berwarna)
Jumlah channel	1	3 (Red, Green, Blue)
Rentang nilai per piksel	0 (hitam) – 255 (putih)	3 nilai per piksel (R, G, B)
Bentuk representasi	Matriks 2D	Matriks 3D (ditumpuk 3 layer)

Warna itu sebenarnya cuma hasil kombinasi tiga angka. Contoh:

• R=255, G=0, B=0 → merah menyala 🔴

• R=G=125, B=0 → kekuningan 🟡

• R=0, G=0, B=0 → hitam pekat ⚫

Ini juga alasan kenapa color picker di software desain selalu nunjukkin tiga slider RGB — itu literally angka-angka piksel yang lagi kamu atur.

Resolusi & Color Depth

Resolusi 1920 × 1080 artinya ada 1920 piksel di lebar dan 1080 di tinggi. Kalau gambarnya berwarna, total angka yang harus disimpan komputer adalah:

1920 × 1080 × 3 channel = 6.220.800 angka

...hanya untuk satu gambar. Ini kenapa gambar resolusi tinggi lebih "berat" diproses — makin detail, makin banyak angka yang harus dihitung.

Sementara color depth menentukan berapa banyak level warna yang mungkin: 8-bit = 256 level (0–255), 24-bit RGB = sekitar 16 juta warna kombinasi.

🧮 Coba hitung sendiri: Berapa total angka yang direpresentasikan gambar grayscale 640×480?

(pause dulu, hitung manual, baru scroll)

✅ Jawaban: 640 × 480 × 1 channel = 307.200 angka. Bandingkan dengan versi berwarnanya yang butuh 3× lebih banyak — 921.600 angka! Itu sebabnya konversi ke grayscale sering dipakai buat mempercepat pemrosesan.

Dimensi Gambar: 2D vs 3D

Satu karakteristik lagi yang sering disebut belakangan: gambar juga punya "dimensi" representasi.

• Gambar 2D — gray scale, cuma satu lapisan matriks piksel.

• Gambar 3D — gambar berwarna, di mana channel-channel RGB ditumpuk jadi satu struktur data (contoh bentuknya: array 224 × 224 × 3).

Istilah ini bakal sering muncul lagi pas kamu belajar deep learning — terutama waktu ngomongin "input shape" di sebuah model.

Image Processing vs Computer Vision — Bedanya Apa?

Dua istilah ini sering dianggap sama padahal beda — meski saling terkait erat.

	Image Processing	Computer Vision
Input	Gambar	Gambar / video
Output	Gambar (sudah dimanipulasi)	Interpretasi (label, koordinat, deskripsi)
Level operasi	Low-level, per piksel	Lebih kompleks & menyeluruh
Contoh	Blur, crop, edge detection	Deteksi objek, klasifikasi, face recognition

Gampangnya: image processing mengubah gambar jadi gambar lain, computer vision mengubah gambar jadi pemahaman. Dan biasanya, computer vision butuh image processing sebagai langkah awal sebelum bisa "mengerti" apa yang ada di gambar.

Operasi image processing sendiri macam-macam bentuknya — filtering, penghalusan gambar, peningkatan kontras, segmentasi, sampai transformasi warna — dan dipakai luas di banyak bidang: dunia medis, fotografi, pengawasan (surveillance), sampai jadi fondasi hampir semua aplikasi AI yang berurusan sama visual.

Di Mana Computer Vision Dipakai?

Ini bukan teori kosong — computer vision udah dipakai di banyak industri, sering tanpa kamu sadari:

🎓 Education

• Pengawasan ujian — mendeteksi kecurangan lewat webcam: siswa ngobrol sama orang lain, sering menoleh, atau keluar dari frame kamera dalam waktu lama otomatis kena flag sebagai peringatan.

• Pengenalan tulisan tangan — menilai jawaban ujian atau tugas tulisan tangan siswa secara otomatis.

🏦 Banking / Administratif

• Verifikasi tanda tangan dan tulisan tangan pada dokumen untuk keperluan validasi keaslian.

🏥 Healthcare

• Deteksi penyakit pada citra medis — memindai MRI, CT scan, atau X-ray untuk mendeteksi kanker, kelainan jantung, atau tumor secara otomatis dengan akurasi tinggi.

• Analisis citra mikroskopis — memeriksa sel/jaringan untuk menemukan abnormalitas seperti infeksi atau perubahan patologis.

🏭 Manufaktur

• Inspeksi kualitas otomatis (visual inspection) — mendeteksi cacat, retak, atau ketidaksesuaian ukuran di lini produksi (contoh klasik: cek cacat pada layar HP) dengan kecepatan dan ketelitian yang jauh di atas mata manusia.

🔒 Security / Surveillance

• Pengawasan keamanan — sistem CCTV pintar (termasuk di kota pintar atau area tambang) mendeteksi aktivitas atau perilaku mencurigakan, misalnya orang yang masuk ke area terlarang.

• Pengecekan kelengkapan APD pekerja — otomatis mengenali apakah pekerja sudah pakai helm, masker, sarung tangan, dan perlengkapan wajib lainnya.

📄 Lainnya

• OCR untuk pemrosesan dokumen, dan face recognition yang sekarang udah jadi standar di banyak aplikasi sehari-hari.

Hampir semua use case di atas dimulai dari hal yang sama: memproses piksel gambar sampai komputer bisa "membaca" polanya.

Praktik: 5 Operasi Dasar dengan OpenCV

Cukup teori — sekarang kita coding. Kita akan pakai OpenCV, salah satu library Python paling populer untuk image processing, biar nggak perlu implementasi algoritma dari nol.

⚠️ Gotcha yang wajib diingat: OpenCV membaca gambar dalam format BGR, bukan RGB! Titik (0,0) juga ada di pojok kiri atas, bukan di tengah seperti koordinat kartesius biasa.

1️⃣ Image Cropping

Cropping itu sebenarnya cuma slicing NumPy array — karena gambar yang dibaca OpenCV memang berbentuk array 2D.

import cv2

image = cv2.imread('input_image.jpg')

# [y_start:y_end, x_start:x_end] — baris dulu, baru kolom
cropped_image = image[50:200, 100:300]

cv2.imwrite('cropped_image.jpg', cropped_image)

2️⃣ Grayscale

import cv2

image = cv2.imread('input_image.jpg')
grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imwrite('grayscale_image.jpg', grayscale_image)

Hasil nyata dari kode di atas — asli berwarna diubah jadi hitam-putih, cuma nyimpen intensitas cahaya.

3️⃣ Channel Split

Berguna banget saat masuk ke semantic segmentation — tiap channel bisa merepresentasikan mask kelas objek yang berbeda.

import cv2

image = cv2.imread('input_image.jpg')
blue_channel, green_channel, red_channel = cv2.split(image)

cv2.imwrite('red_channel.jpg', red_channel)
cv2.imwrite('green_channel.jpg', green_channel)
cv2.imwrite('blue_channel.jpg', blue_channel)

4️⃣ Convolution — Jantungnya Image Processing

Ini konsep paling penting di seluruh artikel ini. Bayangkan sebuah kernel (matriks kecil, misal 5×5) yang digeser pelan-pelan di atas gambar. Di setiap posisi, nilai kernel dikalikan dengan piksel di bawahnya, lalu dijumlahkan jadi satu nilai output.

Kernel yang berbeda = efek yang berbeda:

• Kernel isi rata-rata → blur 🌫️

• Kernel [[0,-1,0],[-1,4,-1],[0,-1,0]] → edge detection ✏️

• Kernel identitas → gambar nggak berubah

import cv2
import numpy as np

image = cv2.imread('input_image.jpg')

kernel = np.ones((5, 5), np.float32) / 25  # kernel blur
convolved_image = cv2.filter2D(image, -1, kernel)

cv2.imwrite('convolved_image.jpg', convolved_image)

🧪 Coba sendiri: Ganti kernel di atas dengan kernel edge detection [[0,-1,0],[-1,4,-1],[0,-1,0]]. Apa yang terjadi?

✅ Jawaban: Gambar hasilnya akan menampilkan garis-garis tepi (edge) dari objek di foto, bukan lagi gambar utuh yang blur. Ini karena kernel tersebut "menonjolkan" perbedaan intensitas antar piksel bertetangga — persis di mana tepi objek berada.

Ini bukan simulasi — ini hasil beneran dari kernel edge detection di atas, diterapkan ke gambar Spider-Man. Lihat gimana kernelnya "menonjolkan" garis-garis kostumnya.

5️⃣ Line Detection (Canny + Hough Transform)

import cv2
import numpy as np

image = cv2.imread('input_image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

edges = cv2.Canny(gray, 50, 150, apertureSize=3)
lines = cv2.HoughLines(edges, 1, np.pi / 180, 200)

if lines is not None:
    for rho, theta in lines[:, 0]:
        a, b = np.cos(theta), np.sin(theta)
        x0, y0 = a * rho, b * rho
        x1, y1 = int(x0 + 1000 * (-b)), int(y0 + 1000 * (a))
        x2, y2 = int(x0 - 1000 * (-b)), int(y0 - 1000 * (a))
        cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line_detected_image.jpg', image)

Garis-garis merah adalah hasil Hough Transform — mendeteksi pola garis lurus dari tepi-tepi yang ditemukan Canny sebelumnya.

Cara kerjanya: Canny dulu cari tepi-tepinya, lalu Hough Transform mencari pola garis dari titik-titik tepi tersebut — mirip cara kamu menghubungkan titik-titik jadi garis lurus.

💡 Catatan praktik: kalau garis hasil deteksi kelihatan terlalu pendek/aneh di gambar resolusi besar, panjang garis (1000 di kode atas) bisa dibuat dinamis mengikuti dimensi gambar: line_length = max(img_height, img_width). Threshold Hough Transform juga bisa diturunkan (mis. dari 200 ke 80) kalau garis yang kedeteksi kurang banyak.

Bonus: Edge Detection Lanjutan — Sobel, Laplacian & Canny + Gaussian Blur

Canny bukan satu-satunya cara deteksi tepi. Beberapa variasi lain yang sering dipakai:

Canny langsung dari grayscale

import cv2

img = cv2.imread('input_image.jpg', cv2.IMREAD_GRAYSCALE)
edges = cv2.Canny(img, 100, 200)
cv2.imwrite('canny_edge_detection.jpg', edges)

Sobel Operator — gradien intensitas dihitung terpisah di sumbu horizontal & vertikal, lalu digabung jadi satu magnitude.

sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)

gradient_magnitude = cv2.magnitude(sobelx, sobely)
gradient_magnitude = cv2.convertScaleAbs(gradient_magnitude)
cv2.imwrite('sobel_edge_detection.jpg', gradient_magnitude)

Laplacian Operator — pakai turunan kedua, sensitif ke perubahan intensitas di segala arah sekaligus (bukan cuma horizontal/vertikal kayak Sobel).

laplacian = cv2.Laplacian(img, cv2.CV_64F)
laplacian_abs = cv2.convertScaleAbs(laplacian)
cv2.imwrite('laplacian_detection.jpg', laplacian_abs)

Gaussian Blur + Canny — smoothing dulu sebelum Canny, biar nggak nangkep tepi-tepi palsu akibat noise.

blur = cv2.GaussianBlur(img, (5, 5), 1.4)
edges = cv2.Canny(blur, threshold1=100, threshold2=200)
cv2.imwrite('canny_edge_detection_blurred.jpg', edges)

Operator	Karakteristik	Kapan dipakai
Canny	Multi-tahap, hasil tepi tipis & bersih	Deteksi tepi umum, dasar Line Detection
Sobel	Gradien terpisah horizontal & vertikal	Butuh tahu arah tepi
Laplacian	Turunan kedua, sensitif segala arah	Cepat, tapi rentan noise
Gaussian Blur + Canny	Canny + pre-processing smoothing	Gambar noise tinggi

Dari Kernel Manual ke CNN: Lompatan yang Mengubah Segalanya

Sekarang pertanyaan pentingnya: gimana kita tahu nilai kernel yang "benar" untuk tugas tertentu?

Jawabannya: kita nggak perlu menentukannya secara manual. Di sinilah Convolutional Neural Network (CNN) masuk — alih-alih kernel yang nilainya tetap (fixed), CNN mempelajari nilai kernel terbaik lewat proses training, menyesuaikan dengan data yang diberikan.

🚀 Inilah kenapa CNN jauh lebih powerful dibanding operasi convolution manual: kernelnya adaptif, bukan hardcoded.

Dari sisi arsitektur, basic-nya CNN tetap neural network biasa — cuma ditambah serangkaian convolutional layer yang tugasnya nyari nilai-nilai terbaik buat mengisi filter, supaya ekstraksi fitur dari gambar jadi maksimal.

CNN sendiri adalah turunan dari deep learning yang khusus dipakai untuk data gambar — beda "keluarga" dengan RNN, Transformer, atau LSTM yang biasa dipakai buat data sekuensial seperti teks. Kalau kamu sudah kenal arsitektur-arsitektur itu dari sisi NLP, CNN adalah versi "sepupunya" yang didesain khusus buat data visual.

CNN adalah topik besar tersendiri yang akan kita bahas lebih dalam nanti — tapi sekarang kamu udah tahu fondasinya: convolution, yang barusan kita praktikkan sendiri di atas.

Bungkus Jadi API dengan FastAPI

Terakhir, kelima operasi di atas bisa langsung "dijual" sebagai layanan lewat API. Idenya: terima gambar → proses di memori (tanpa simpan ke disk) → kembalikan hasilnya dalam format base64 — karena endpoint API nggak bisa langsung ngembaliin file gambar mentah.

Instalasi

pip install fastapi uvicorn pillow opencv-python

Setup & Helper Function

from fastapi import FastAPI, UploadFile, File
from PIL import Image, ImageOps
import io, base64, cv2
import numpy as np

app = FastAPI()

def pil_image_to_base64(image: Image.Image):
    buffered = io.BytesIO()
    image.save(buffered, format="JPEG")
    return base64.b64encode(buffered.getvalue()).decode("utf-8")

def cv2_image_to_base64(image):
    _, buffer = cv2.imencode('.jpg', image)
    return base64.b64encode(buffer).decode("utf-8")

Dari dua helper function itu, tinggal bikin satu endpoint per operasi:

/crop/ — potong gambar sesuai koordinat

@app.post("/crop/")
async def crop_image(file: UploadFile = File(...), x: int = 0,
                      y: int = 0, width: int = 100, height: int = 100):
    image = Image.open(io.BytesIO(await file.read()))
    cropped_image = image.crop((x, y, x + width, y + height))
    return {"image_base64": pil_image_to_base64(cropped_image)}

/grayscale/ — konversi ke grayscale

@app.post("/grayscale/")
async def grayscale_image(file: UploadFile = File(...)):
    image = Image.open(io.BytesIO(await file.read()))
    grayscale_image = ImageOps.grayscale(image)
    return {"image_base64": pil_image_to_base64(grayscale_image)}

/channel_split/ — ambil salah satu channel warna

@app.post("/channel_split/")
async def channel_split(file: UploadFile = File(...), channel: str = "red"):
    image = cv2.imdecode(np.frombuffer(await file.read(), np.uint8),
                          cv2.IMREAD_COLOR)
    (blue, green, red) = cv2.split(image)
    if channel == "red":
        return {"image_base64": cv2_image_to_base64(red)}
    elif channel == "green":
        return {"image_base64": cv2_image_to_base64(green)}
    else:
        return {"image_base64": cv2_image_to_base64(blue)}

/convolution/ — terapkan filter blur

@app.post("/convolution/")
async def convolution(file: UploadFile = File(...)):
    image = cv2.imdecode(np.frombuffer(await file.read(),
                          np.uint8), cv2.IMREAD_COLOR)
    kernel = np.ones((5, 5), np.float32) / 25
    convolved_image = cv2.filter2D(image, -1, kernel)
    return {"image_base64": cv2_image_to_base64(convolved_image)}

/line_detection/ — deteksi garis via Canny + Hough Transform

@app.post("/line_detection/")
async def line_detection(file: UploadFile = File(...)):
    image = cv2.imdecode(np.frombuffer(await file.read(),
                          np.uint8), cv2.IMREAD_COLOR)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
    lines = cv2.HoughLines(edges, 1, np.pi / 180, 200)

    if lines is not None:
        for rho, theta in lines[:, 0]:
            a, b = np.cos(theta), np.sin(theta)
            x0, y0 = a * rho, b * rho
            x1, y1 = int(x0 + 1000 * (-b)), int(y0 + 1000 * (a))
            x2, y2 = int(x0 - 1000 * (-b)), int(y0 - 1000 * (a))
            cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)

    return {"image_base64": cv2_image_to_base64(image)}

Lima endpoint, lima operasi image processing yang udah kamu pelajari dari awal — dan sekarang siap dipanggil orang lain lewat HTTP request. 🎉

Bonus: Endpoint Versi "Gambar Langsung" (Bukan Base64)

Kelima endpoint di atas balikin JSON berisi base64 — format ini paling cocok kalau API-nya dipanggil dari aplikasi lain (web/mobile/backend), tapi kurang enak dilihat langsung di browser atau Swagger UI, karena cuma nongol sebagai teks panjang.

Solusinya gampang: bikin versi endpoint yang response-nya langsung file gambar (media_type="image/jpeg"), bukan JSON. Cukup tambah dua helper function buat convert ke bytes mentah (bukan base64), lalu bungkus pakai Response dari FastAPI:

from fastapi.responses import Response

def pil_image_to_bytes(image: Image.Image) -> bytes:
    buffered = io.BytesIO()
    image.save(buffered, format="JPEG")
    return buffered.getvalue()

def cv2_image_to_bytes(image) -> bytes:
    _, buffer = cv2.imencode('.jpg', image)
    return buffer.tobytes()

Lalu bikin versi "-image" dari tiap endpoint. Contoh buat grayscale:

@app.post("/grayscale-image/")
async def grayscale_image_raw(file: UploadFile = File(...)):
    image = Image.open(io.BytesIO(await file.read()))
    grayscale_image = ImageOps.grayscale(image)
    return Response(content=pil_image_to_bytes(grayscale_image), media_type="image/jpeg")

Pola yang sama tinggal diulang buat /crop-image/, /channel_split-image/, /convolution-image/, dan /line_detection-image/ — logikanya identik dengan versi base64, cuma baris return-nya yang beda.

💡 Sekarang API kamu punya dua "rasa" endpoint: yang JSON+base64 buat dipanggil program lain, dan yang gambar langsung buat testing cepat atau dipakai langsung di <img src="...">.

Bukti Nyata: Deploy & Testing Pakai ngrok

Semua kode di atas sudah divalidasi jalan (dites lewat TestClient FastAPI, request beneran sampai ke fungsi endpoint-nya, bukan cuma dibaca sekilas). Tapi lebih dari itu — dua endpoint di antaranya (/grayscale/ dan /grayscale-image/) sudah dites langsung lewat deployment publik sungguhan: server jalan di Google Colab, di-expose ke internet pakai ngrok, dan diakses dari luar lewat Swagger UI (/docs) yang otomatis dibikin FastAPI. Ini buktinya:

Endpoint /grayscale-image/ dites pakai Spiderman.jpg, hasilnya langsung dirender sebagai gambar di response panel. Perhatikan response header: content-type: image/jpeg, server: uvicorn, dan ngrok-agent-ips — bukti request-nya beneran lewat tunnel ngrok dari internet, bukan simulasi lokal.

Kalau kamu mau coba deploy versi kamu sendiri dari Google Colab (gratis), garis besarnya:

1. Install nest-asyncio dan pyngrok.

2. Daftar akun ngrok gratis, ambil authtoken dari dashboard ngrok.

3. Jalankan uvicorn di dalam asyncio.create_task() (bukan uvicorn.run() biasa — Colab udah punya event loop sendiri yang bakal bentrok kalau dipanggil langsung).

4. ngrok bakal kasih URL publik (https://xxxx.ngrok-free.dev) yang nge-tunnel ke localhost:8000 di Colab kamu.

(Detail lengkapnya — termasuk beberapa jebakan umum kayak port conflict dan SystemExit yang bisa bikin kernel Colab crash kalau server lama nggak dimatikan dengan benar — mungkin saya bahas terpisah di post lain, karena cukup panjang buat dijelasin di sini.)

Cheat Sheet & Kuis Mini

Sebelum kamu tutup tab ini, yuk konsolidasi semua yang udah dipelajari:

Operasi	Fungsinya	Input → Output	Endpoint
Cropping	Potong area tertentu	Gambar → gambar terpotong	/crop/
Grayscale	Hapus info warna	Gambar berwarna → hitam-putih	/grayscale/
Channel Split	Pisah channel R/G/B	1 gambar → 3 gambar per channel	/channel_split/
Convolution	Terapkan filter via kernel	Gambar → gambar terfilter	/convolution/
Line Detection	Deteksi garis (Canny+Hough)	Gambar → gambar bergaris tertandai	/line_detection/

🎯 Kuis Cepat — Tes Pemahaman Kamu

Coba jawab dulu ketiga pertanyaan ini di kepala kamu sebelum baca jawabannya di bawah masing-masing soal.

1. Kenapa OpenCV kadang bikin warna gambar "aneh" kalau langsung ditampilkan pakai library lain?

✅ Karena OpenCV membaca gambar dalam format BGR, bukan RGB. Kalau kamu tampilkan langsung pakai library yang mengasumsikan RGB (misalnya matplotlib), channel merah dan birunya akan tertukar. Solusinya: konversi dulu pakai cv2.COLOR_BGR2RGB.

2. Apa perbedaan paling mendasar antara image processing dan computer vision?

✅ Image processing: input gambar, output gambar (yang sudah dimanipulasi). Computer vision: input gambar/video, output interpretasi (label, koordinat, deskripsi).

3. Kenapa CNN dianggap "lebih baik" daripada convolution dengan kernel manual (predefined)?

✅ Karena nilai kernel di CNN dipelajari otomatis lewat training dan jadi adaptif terhadap data — sementara kernel manual bersifat tetap (fixed) dan butuh banyak trial-and-error untuk cocok dengan kasus tertentu.

📖 Glosarium Istilah Penting

Simpan bagian ini buat referensi cepat kalau nanti lupa istilah:

• Piksel — satuan terkecil dari gambar digital; nilainya menyatakan intensitas cahaya pada titik tersebut.

• Channel — satu lapisan matriks pada gambar (mis. R, G, atau B); jumlah channel menentukan dimensi warna gambar.

• Resolusi — jumlah piksel lebar × tinggi pada suatu gambar.

• Color Depth — jumlah bit yang dipakai untuk merepresentasikan nilai tiap piksel (menentukan jumlah level/warna yang mungkin).

• Kernel / Filter — matriks kecil yang digeser di atas gambar untuk melakukan operasi convolution.

• Convolution — operasi perkalian & penjumlahan antara kernel dan area gambar yang bertumpukan, digeser ke seluruh gambar.

• Edge Detection — teknik mendeteksi tepi/garis batas objek pada gambar.

• Hough Transform — metode untuk mengekstrak garis dari hasil edge detection berdasarkan pola keterhubungan titik-titik tepi.

• Semantic Segmentation — teknik computer vision untuk memberi label kelas pada setiap piksel gambar.

• CNN (Convolutional Neural Network) — arsitektur deep learning untuk data gambar, di mana nilai kernel/filter dipelajari otomatis lewat training, bukan ditentukan manual.

• Base64 — format encoding untuk merepresentasikan data biner (seperti gambar) sebagai teks, umum dipakai saat mengirim gambar lewat response API/JSON.

• ngrok — layanan tunneling yang bikin server lokal (mis. di Colab) bisa diakses lewat URL publik sementara, tanpa perlu deploy ke cloud beneran.

---

Penutup

Computer Vision kelihatannya rumit dari luar, tapi begitu kamu pegang fondasinya — piksel, matriks, dan convolution — semua topik lanjutan (CNN, object detection, segmentation) jadi bangunan yang berdiri di atas dasar yang sama. Konsep yang sama ini juga yang bakal kamu pakai terus sampai ke deep learning modern sekalipun.

Kalau kamu coba salah satu kode di atas, share hasilnya di kolom komentar ya — penasaran lihat kernel eksperimen kamu! 👇

Kode lengkapnya (notebook, README, semua sudah dites jalan) tersedia terbuka di GitHub: github.com/arielshakaramiro/computer-vision-image-processing

---

Artikel ini bagian dari seri catatan belajar Computer Vision & Image Processing. Follow untuk nggak ketinggalan seri lanjutannya soal Convolutional Neural Network (CNN).

Sumber gambar: Ilustrasi Spider-Man yang dipakai sebagai contoh gambar di sepanjang artikel ini diambil dari Pinterest, dipakai murni untuk keperluan demonstrasi teknik image processing. Karakter Spider-Man adalah hak cipta Marvel/Sony.

Tags: computer-vision opencv python machine-learning fastapi image-processing ai deep-learning