Computer Vision dengan OpenCV

# Instal OpenCV dan NumPy
pip install opencv-python numpy

# Untuk fitur GUI (imshow, waitKey)
pip install opencv-python-headless
# Atau jika butuh GUI penuh:
pip install opencv-python

# Verifikasi instalasi
python -c "import cv2; print(cv2.__version__)"
# Output: 4.10.0 (atau versi terbaru)

import cv2
import numpy as np

# Membaca gambar dari file
img = cv2.imread('foto.jpg')

# Mengecek dimensi gambar (tinggi, lebar, channel)
print(f"Dimensi: {img.shape}")  # Contoh: (480, 640, 3)
print(f"Ukuran: {img.size}")    # Total pixel: 480 * 640 * 3
print(f"Tipe data: {img.dtype}") # uint8 (0-255)

# Menampilkan gambar di jendela
cv2.imshow('Gambar Asli', img)
cv2.waitKey(0)         # Tunggu tombol ditekan
cv2.destroyAllWindows() # Tutup semua jendela

# Menyimpan gambar ke file
cv2.imwrite('output.jpg', img)

# Membaca gambar sebagai grayscale
gray = cv2.imread('foto.jpg', cv2.IMREAD_GRAYSCALE)
cv2.imshow('Grayscale', gray)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Membaca video dari file
cap = cv2.VideoCapture('video.mp4')

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    cv2.imshow('Video', frame)
    
    # Tekan 'q' untuk keluar
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# Membaca dari webcam (ganti 0 dengan index kamera)
cap = cv2.VideoCapture(0)
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow('Webcam', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

img = cv2.imread('foto.jpg')

# ===== RESIZE =====
# Resize ke ukuran tertentu
resized = cv2.resize(img, (400, 300))  # (lebar, tinggi)

# Resize dengan faktor skala
resized_half = cv2.resize(img, None, fx=0.5, fy=0.5)

# Resize dengan interpolasi yang tepat
# INTER_AREA untuk mengecilkan, INTER_CUBIC/INTER_LINEAR untuk memperbesar
resized_down = cv2.resize(img, (200, 150), interpolation=cv2.INTER_AREA)
resized_up = cv2.resize(img, (1280, 960), interpolation=cv2.INTER_CUBIC)

# ===== CROP =====
# Crop menggunakan array slicing [y1:y2, x1:x2]
cropped = img[100:400, 150:500]  # Potong area tertentu

# ===== ROTASI =====
(h, w) = img.shape[:2]
center = (w // 2, h // 2)

# Rotasi 45 derajat
M = cv2.getRotationMatrix2D(center, 45, 1.0)
rotated = cv2.warpAffine(img, M, (w, h))

# Rotasi 90 derajat (lebih mudah dengan flip)
rotated_90 = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
rotated_180 = cv2.rotate(img, cv2.ROTATE_180)

# ===== FLIP =====
flip_horizontal = cv2.flip(img, 1)  # Mirror horizontal
flip_vertical = cv2.flip(img, 0)    # Mirror vertical
flip_both = cv2.flip(img, -1)       # Kedua arah

# ===== KONVERSI WARNA =====
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# ===== MENGGABUNG GAMBAR =====
# Horizontal stacking
combined_h = np.hstack([img, cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)])

# Vertical stacking
combined_v = np.vstack([img, img])

cv2.imshow('Hasil', combined_h)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

gray = cv2.imread('dokumen.jpg', cv2.IMREAD_GRAYSCALE)

# Simple Thresholding
# THRESH_BINARY: pixel > 127 → 255, else → 0
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# THRESH_BINARY_INV: kebalikan dari binary
_, binary_inv = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)

# THRESH_TRUNC: pixel > 127 → 127, else tetap
_, trunc = cv2.threshold(gray, 127, 255, cv2.THRESH_TRUNC)

# Adaptive Thresholding — cocok untuk pencahayaan tidak rata
adaptive_mean = cv2.adaptiveThreshold(
    gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
    cv2.THRESH_BINARY, 11, 2
)

adaptive_gauss = cv2.adaptiveThreshold(
    gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    cv2.THRESH_BINARY, 11, 2
)

# Otsu's Thresholding — otomatis mencari threshold terbaik
_, otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

print(f"Threshold Otsu: {_}")  # Nilai threshold yang dipilih otomatis

# Tampilkan semua hasil
titles = ['Asli', 'Binary', 'Adaptive Mean', 'Otsu']
images = [gray, binary, adaptive_mean, otsu]

for i in range(4):
    cv2.imshow(titles[i], images[i])
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

img = cv2.imread('foto.jpg')

# ===== BLURRING =====
# Averaging Blur — rata-rata dari kernel neighborhood
blur_avg = cv2.blur(img, (5, 5))

# Gaussian Blur — pembobotan Gaussian (lebih natural)
blur_gauss = cv2.GaussianBlur(img, (7, 7), 0)

# Median Blur — bagus untuk menghilangkan noise "salt & pepper"
blur_median = cv2.medianBlur(img, 5)

# Bilateral Filter — blur sambil menjaga tepi tetap tajam
blur_bilateral = cv2.bilateralFilter(img, 9, 75, 75)

# ===== EDGE DETECTION =====
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Sobel Operator — deteksi tepi arah X dan Y
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
sobel_combined = cv2.magnitude(sobel_x, sobel_y)

# Laplacian — deteksi tepi semua arah
laplacian = cv2.Laplacian(gray, cv2.CV_64F)

# Canny Edge Detection — yang paling populer
edges = cv2.Canny(gray, 50, 150)  # (gambar, threshold1, threshold2)

# ===== SHARPENING =====
kernel_sharpen = np.array([
    [0, -1, 0],
    [-1, 5, -1],
    [0, -1, 0]
])
sharpened = cv2.filter2D(img, -1, kernel_sharpen)

# ===== MORPHOLOGICAL OPERATIONS =====
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
kernel = np.ones((5, 5), np.uint8)

# Erosion — mengikis tepi objek
erosion = cv2.erode(binary, kernel, iterations=1)

# Dilation — memperbesar tepi objek
dilation = cv2.dilate(binary, kernel, iterations=1)

# Opening — erosion diikuti dilation (hilangkan noise)
opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)

# Closing — dilation diikuti erosion (tutup lubang kecil)
closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)

cv2.imshow('Canny Edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

# Muat classifier Haar Cascade
# File XML sudah disertakan saat instalasi OpenCV
face_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
)
eye_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_eye.xml'
)
smile_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_smile.xml'
)

# Baca gambar
img = cv2.imread('grup_foto.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Deteksi wajah
# detectMultiScale(gambar, scaleFactor, minNeighbors, minSize)
faces = face_cascade.detectMultiScale(
    gray,
    scaleFactor=1.1,
    minNeighbors=5,
    minSize=(30, 30)
)

print(f"Terdeteksi {len(faces)} wajah")

# Gambar kotak di sekitar wajah yang terdeteksi
for (x, y, w, h) in faces:
    # Kotak wajah (warna hijau)
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
    
    # Label teks
    cv2.putText(img, 'Wajah', (x, y - 10),
                cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    
    # ROI (Region of Interest) untuk deteksi mata di dalam wajah
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = img[y:y+h, x:x+w]
    
    # Deteksi mata di area wajah
    eyes = eye_cascade.detectMultiScale(roi_gray, 1.1, 10)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (255, 0, 0), 2)

cv2.imshow('Face Detection', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Simpan hasil
cv2.imwrite('hasil_face_detection.jpg', img)

import cv2
import numpy as np

face_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
)

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Deteksi wajah dengan parameter yang dioptimalkan
    faces = face_cascade.detectMultiScale(
        gray,
        scaleFactor=1.3,
        minNeighbors=5,
        minSize=(50, 50)
    )
    
    # Gambar kotak pada setiap wajah
    for (x, y, w, h) in faces:
        # Kotak dengan warna biru
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 200, 0), 2)
        
        # Tampilkan jumlah wajah
        cv2.putText(frame, f'Wajah Terdeteksi: {len(faces)}',
                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
                    0.8, (0, 255, 0), 2)
    
    cv2.imshow('Webcam Face Detection', frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# Baca gambar dan konversi
img = cv2.imread('objek.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Preprocessing: blur + threshold
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
_, thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)

# Temukan contour
# RETR_EXTERNAL: hanya contour terluar
# RETR_TREE: semua contour dengan hierarchy
# CHAIN_APPROX_SIMPLE: kompres titik contour
contours, hierarchy = cv2.findContours(
    thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
)

print(f"Jumlah contour ditemukan: {len(contours)}")

# Gambar semua contour
img_contour = img.copy()
cv2.drawContours(img_contour, contours, -1, (0, 255, 0), 2)

# Analisis setiap contour
for i, cnt in enumerate(contours):
    # Hitung luas area
    area = cv2.contourArea(cnt)
    
    # Filter contour kecil (noise)
    if area < 100:
        continue
    
    # Hitung keliling
    perimeter = cv2.arcLength(cnt, closed=True)
    
    # Aproksimasi bentuk polygon
    epsilon = 0.02 * perimeter
    approx = cv2.approxPolyDP(cnt, epsilon, True)
    
    # Tentukan bentuk berdasarkan jumlah sudut
    vertices = len(approx)
    if vertices == 3:
        bentuk = "Segitiga"
    elif vertices == 4:
        # Cek apakah persegi atau persegi panjang
        (x, y, w, h) = cv2.boundingRect(approx)
        aspect_ratio = w / float(h)
        bentuk = "Persegi" if 0.95 <= aspect_ratio <= 1.05 else "Persegi Panjang"
    elif vertices == 5:
        bentuk = "Pentagon"
    elif vertices > 5:
        bentuk = "Lingkaran"
    else:
        bentuk = f"Polygon-{vertices}"
    
    # Gambar bounding box
    (x, y, w, h) = cv2.boundingRect(cnt)
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.putText(img, f'{bentuk}', (x, y-10),
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    print(f"Contour {i}: Bentuk={bentuk}, Area={area:.0f}, "
          f"Keliling={perimeter:.0f}, Sudut={vertices}")

cv2.imshow('Contour Detection', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

# Tracking objek berdasarkan warna menggunakan HSV
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Konversi ke HSV color space
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    # Range warna biru dalam HSV
    lower_blue = np.array([100, 50, 50])
    upper_blue = np.array([130, 255, 255])
    
    # Buat mask
    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    
    # Hilangkan noise dengan morphological operations
    kernel = np.ones((5, 5), np.uint8)
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
    
    # Temukan contour dari mask
    contours, _ = cv2.findContours(mask, cv2.RETR_TREE,
                                    cv2.CHAIN_APPROX_SIMPLE)
    
    if contours:
        # Ambil contour terbesar
        largest = max(contours, key=cv2.contourArea)
        area = cv2.contourArea(largest)
        
        if area > 500:
            # Hitung centroid (pusat massa)
            M = cv2.moments(largest)
            if M["m00"] != 0:
                cx = int(M["m10"] / M["m00"])
                cy = int(M["m01"] / M["m00"])
                
                # Gambar lingkaran di centroid
                cv2.circle(frame, (cx, cy), 10, (0, 255, 0), -1)
                cv2.putText(frame, f'Posisi: ({cx}, {cy})',
                           (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
                           0.8, (0, 255, 0), 2)
            
            # Gambar bounding box
            x, y, w, h = cv2.boundingRect(largest)
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
    cv2.imshow('Object Tracking', frame)
    cv2.imshow('Mask', mask)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# OpenCV Built-in Trackers
# KCS: Kurnia Continuation Sensitivity (paling akurat)
# CSRT: Discriminative Correlation Filter with Channel and Spatial Reliability
# MOSSE: Minimum Output Sum of Squared Error (paling cepat)

cap = cv2.VideoCapture('video.mp4')

# Baca frame pertama
ret, frame = cap.read()
if not ret:
    print("Gagal membaca video")
    exit()

# Pilih ROI (Region of Interest) secara interaktif
roi = cv2.selectROI("Pilih Objek", frame, showCrosshair=True)
cv2.destroyWindow("Pilih Objek")

# Buat tracker CSRT
tracker = cv2.TrackerCSRT.create()
tracker.init(frame, roi)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Update tracker
    success, bbox = tracker.update(frame)
    
    if success:
        # Tracking berhasil
        x, y, w, h = [int(v) for v in bbox]
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
        cv2.putText(frame, "Tracking", (x, y-10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
    else:
        # Tracking gagal
        cv2.putText(frame, "Tracking Gagal!", (50, 50),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    
    cv2.imshow('Multi Tracker', frame)
    
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# Fungsi untuk mendeteksi beberapa warna sekaligus
def detect_colors(frame):
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    # Definisi rentang warna dalam HSV
    color_ranges = {
        'Merah 1': (np.array([0, 70, 50]), np.array([10, 255, 255])),
        'Merah 2': (np.array([170, 70, 50]), np.array([180, 255, 255])),
        'Hijau':   (np.array([36, 50, 70]), np.array([89, 255, 255])),
        'Biru':    (np.array([100, 50, 50]), np.array([130, 255, 255])),
        'Kuning':  (np.array([20, 100, 100]), np.array([35, 255, 255])),
        'Orange':  (np.array([10, 100, 20]), np.array([20, 255, 255])),
    }
    
    results = {}
    
    for nama, (lower, upper) in color_ranges.items():
        mask = cv2.inRange(hsv, lower, upper)
        
        # Morphological operations untuk menghilangkan noise
        kernel = np.ones((5, 5), np.uint8)
        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
        
        contours, _ = cv2.findContours(mask, cv2.RETR_TREE,
                                        cv2.CHAIN_APPROX_SIMPLE)
        
        for cnt in contours:
            area = cv2.contourArea(cnt)
            if area > 1000:
                x, y, w, h = cv2.boundingRect(cnt)
                
                # Warna kotak berbeda untuk setiap warna terdeteksi
                colors_map = {
                    'Merah 1': (0, 0, 255), 'Merah 2': (0, 0, 255),
                    'Hijau': (0, 255, 0), 'Biru': (255, 0, 0),
                    'Kuning': (0, 255, 255), 'Orange': (0, 165, 255),
                }
                
                color = colors_map.get(nama, (255, 255, 255))
                label = nama.replace(' 1', '').replace(' 2', '')
                
                cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
                cv2.putText(frame, label, (x, y-10),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
                results[label] = (x, y, w, h)
    
    return frame, results

# Jalankan dari webcam
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    result_frame, detections = detect_colors(frame)
    
    # Tampilkan jumlah objek terdeteksi
    cv2.putText(result_frame, f'Objek: {len(detections)}',
                (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
                0.8, (255, 255, 255), 2)
    
    cv2.imshow('Color Detection', result_frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()