Computer Vision: Object Detection — YOLO, R-CNN, SSD

import numpy as np

def compute_iou(box1, box2):
    """Hitung IoU antara dua bounding box [x1, y1, x2, y2]"""
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])
    
    intersection = max(0, x2 - x1) * max(0, y2 - y1)
    
    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
    
    union = area1 + area2 - intersection
    
    return intersection / union if union > 0 else 0


def non_max_suppression(boxes, scores, iou_threshold=0.5):
    """
    NMS dari scratch
    
    Args:
        boxes: Array shape (N, 4) — [x1, y1, x2, y2]
        scores: Array shape (N,) — confidence scores
        iou_threshold: IoU threshold untuk suppression
    
    Returns:
        List indices dari boxes yang dipertahankan
    """
    # Sort berdasarkan score (descending)
    sorted_indices = np.argsort(scores)[::-1]
    
    keep = []
    
    while len(sorted_indices) > 0:
        # Ambil box dengan score tertinggi
        current = sorted_indices[0]
        keep.append(current)
        
        if len(sorted_indices) == 1:
            break
        
        # Hitung IoU dengan semua box lain
        remaining = sorted_indices[1:]
        ious = np.array([compute_iou(boxes[current], boxes[i]) for i in remaining])
        
        # Hapus box yang IoU >= threshold (terlalu tumpang tindih)
        mask = ious < iou_threshold
        sorted_indices = remaining[mask]
    
    return keep


# === CONTOH PENGGUNAAN ===
boxes = np.array([
    [100, 100, 200, 200],   # Box A
    [110, 110, 210, 210],   # Box B (tumpang tindih dengan A)
    [105, 105, 205, 205],   # Box C (tumpang tindih dengan A)
    [300, 300, 400, 400],   # Box D (objek berbeda)
    [305, 305, 405, 405],   # Box E (tumpang tindih dengan D)
])

scores = np.array([0.92, 0.89, 0.85, 0.95, 0.88])

print("=== Sebelum NMS ===")
for i, (box, score) in enumerate(zip(boxes, scores)):
    print(f"  Box {i}: {box} | Score: {score:.2f}")

# Jalankan NMS
kept_indices = non_max_suppression(boxes, scores, iou_threshold=0.5)

print(f"\n=== Setelah NMS (threshold=0.5) ===")
for idx in kept_indices:
    print(f"  Box {idx}: {boxes[idx]} | Score: {scores[idx]:.2f}")

# Menggunakan PyTorch NMS (lebih cepat)
import torch
from torchvision.ops import nms as torch_nms

boxes_tensor = torch.FloatTensor(boxes)
scores_tensor = torch.FloatTensor(scores)
kept_torch = torch_nms(boxes_tensor, scores_tensor, iou_threshold=0.5)
print(f"\nPyTorch NMS result: {kept_torch.numpy()}")

import numpy as np

def compute_ap(recalls, precisions):
    """Hitung Average Precision menggunakan interpolation 11-point"""
    # 11-point interpolation (PASCAL VOC style)
    ap = 0.0
    for t in np.arange(0, 1.1, 0.1):
        precisions_at_recall = precisions[recalls >= t]
        if len(precisions_at_recall) > 0:
            ap += np.max(precisions_at_recall)
    return ap / 11.0


def compute_precision_recall(detections, ground_truths, iou_threshold=0.5):
    """
    Hitung precision-recall curve
    
    detections: list of (confidence, bbox, class)
    ground_truths: list of (bbox, class)
    """
    # Sort detections berdasarkan confidence (descending)
    detections = sorted(detections, key=lambda x: x[0], reverse=True)
    
    tp = np.zeros(len(detections))
    fp = np.zeros(len(detections))
    matched_gt = set()
    
    for i, (conf, det_box, det_class) in enumerate(detections):
        best_iou = 0
        best_gt_idx = -1
        
        for j, (gt_box, gt_class) in enumerate(ground_truths):
            if j in matched_gt or det_class != gt_class:
                continue
            iou = compute_iou(det_box, gt_box)
            if iou > best_iou:
                best_iou = iou
                best_gt_idx = j
        
        if best_iou >= iou_threshold:
            tp[i] = 1
            matched_gt.add(best_gt_idx)
        else:
            fp[i] = 1
    
    # Cumulative TP and FP
    tp_cumsum = np.cumsum(tp)
    fp_cumsum = np.cumsum(fp)
    
    precisions = tp_cumsum / (tp_cumsum + fp_cumsum)
    recalls = tp_cumsum / len(ground_truths)
    
    return recalls, precisions


# === CONTOH PERHITUNGAN mAP ===
# Simulated detections: (confidence, [x1,y1,x2,y2], class)
detections = [
    (0.95, [100, 100, 200, 200], 'cat'),
    (0.88, [300, 300, 400, 400], 'dog'),
    (0.82, [110, 105, 205, 210], 'cat'),  # Duplicate detection
    (0.75, [50, 50, 150, 150], 'cat'),    # False positive
    (0.70, [310, 310, 410, 410], 'dog'),
]

# Ground truth: ([x1,y1,x2,y2], class)
ground_truths = [
    ([105, 105, 205, 205], 'cat'),
    ([305, 305, 405, 405], 'dog'),
    ([500, 500, 600, 600], 'dog'),  # Tidak terdeteksi (FN)
]

# Hitung PR curve
recalls, precisions = compute_precision_recall(detections, ground_truths)

print("=== Precision-Recall Analysis ===")
for i, (r, p) in enumerate(zip(recalls, precisions)):
    print(f"  Deteksi {i+1}: P={p:.3f}, R={r:.3f}")

# Hitung AP
ap = compute_ap(recalls, precisions)
print(f"\nAverage Precision (AP): {ap:.3f}")

# mAP = rata-rata AP semua kelas (di sini hanya 1 kelas contoh)
print(f"mAP@0.5: {ap:.3f}")
print("\nDi konteks nyata, hitung AP untuk setiap kelas, lalu rata-rata = mAP")

# pip install ultralytics
from ultralytics import YOLO
import cv2
import numpy as np

# === 1. INFERENCE DENGAN PRE-TRAINED MODEL ===
# Load model pre-trained di COCO dataset (80 kelas)
model = YOLO('yolov8n.pt')  # 'n'=nano, 's'=small, 'm'=medium, 'l'=large, 'x'=extra-large

# Inference pada gambar
results = model('https://ultralytics.com/images/bus.jpg')

# Parse results
for result in results:
    boxes = result.boxes          # Bounding boxes
    masks = result.masks          # Segmentation masks (jika ada)
    probs = result.probs          # Classification probabilities
    
    print(f"\n=== Deteksi pada gambar ===")
    print(f"Jumlah objek terdeteksi: {len(boxes)}")
    
    for box in boxes:
        # Koordinat bounding box
        x1, y1, x2, y2 = box.xyxy[0].tolist()    # Format (x1, y1, x2, y2)
        confidence = box.conf[0].item()             # Confidence score
        class_id = int(box.cls[0].item())           # Class ID
        class_name = model.names[class_id]          # Class name
        
        print(f"  {class_name}: {confidence:.2f} "
              f"→ [{x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}]")

# Simpan hasil dengan bounding box
result_plot = results[0].plot()  # Gambar dengan annotated boxes
cv2.imwrite('detection_result.jpg', result_plot)
print("\n✓ Hasil disimpan: detection_result.jpg")

# === 2. VIDEO DETECTION ===
def detect_video(model, video_path, output_path='output.mp4'):
    """Object detection pada video"""
    cap = cv2.VideoCapture(video_path)
    fps = int(cap.get(cv2.CAP_PROP_FPS))
    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
    
    frame_count = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        # Run YOLOv8 inference
        results = model(frame, verbose=False)
        
        # Draw boxes on frame
        annotated = results[0].plot()
        out.write(annotated)
        
        frame_count += 1
        if frame_count % 30 == 0:
            print(f"  Processed {frame_count} frames...")
    
    cap.release()
    out.release()
    print(f"✓ Video saved: {output_path} ({frame_count} frames)")

# Uncomment untuk proses video:
# detect_video(model, 'input_video.mp4')

# === 3. WEBCAM REAL-TIME DETECTION ===
def detect_webcam(model):
    """Real-time object detection dari webcam"""
    cap = cv2.VideoCapture(0)  # Camera index 0
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        results = model(frame, verbose=False)
        annotated = results[0].plot()
        
        cv2.imshow('YOLOv8 Real-Time Detection', annotated)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

# Uncomment untuk webcam:
# detect_webcam(model)

from ultralytics import YOLO

# === FINE-TUNE YOLOv8 PADA CUSTOM DATASET ===

# 1. Load pre-trained model (transfer learning)
model = YOLO('yolov8m.pt')  # Start dari pre-trained medium model

# 2. Training dengan custom dataset
# Dataset harus dalam format YOLO:
#   dataset/
#     ├── train/
#     │   ├── images/ (gambar .jpg/.png)
#     │   └── labels/ (label .txt, format: class x_center y_center w h)
#     ├── val/
#     │   ├── images/
#     │   └── labels/
#     └── data.yaml
#
# data.yaml contoh:
#   train: dataset/train/images
#   val: dataset/val/images
#   nc: 3  # jumlah kelas
#   names: ['cat', 'dog', 'bird']  # nama kelas

results = model.train(
    data='dataset/data.yaml',   # Path ke data config
    epochs=100,                 # Jumlah epoch
    imgsz=640,                  # Ukuran gambar input
    batch=16,                   # Batch size
    lr0=0.01,                   # Initial learning rate
    lrf=0.01,                   # Final learning rate (lr0 * lrf)
    warmup_epochs=3,            # Warmup epochs
    optimizer='AdamW',          # Optimizer
    augment=True,               # Data augmentation
    mosaic=1.0,                 # Mosaic augmentation probability
    mixup=0.0,                  # Mixup augmentation
    copy_paste=0.0,             # Copy-paste augmentation
    device=0,                   # GPU device (0, 1, 'cpu')
    project='runs/detect',      # Output directory
    name='custom_model',        # Experiment name
    exist_ok=False,
    pretrained=True,
    verbose=True,
)

# 3. Evaluasi model
metrics = model.val()
print(f"\n=== Hasil Evaluasi ===")
print(f"mAP@50:    {metrics.box.map50:.4f}")
print(f"mAP@50-95: {metrics.box.map:.4f}")
print(f"Precision: {metrics.box.mp:.4f}")
print(f"Recall:    {metrics.box.mr:.4f}")

# 4. Export ke berbagai format
model.export(format='onnx')     # ONNX
model.export(format='torchscript')  # TorchScript
# model.export(format='tflite')  # TensorFlow Lite
# model.export(format='coreml')  # CoreML (iOS)

print("\n✓ Model exported!")
print("  - ONNX: best.onnx")
print("  - TorchScript: best.torchscript")

from ultralytics import YOLO

# === YOLOv8 UNTUK BERBAGAI TUGAS ===

# 1. OBJECT DETECTION
model_det = YOLO('yolov8n.pt')
results = model_det('image.jpg')

# 2. INSTANCE SEGMENTATION
model_seg = YOLO('yolov8n-seg.pt')
results = model_seg('image.jpg')

# 3. IMAGE CLASSIFICATION
model_cls = YOLO('yolov8n-cls.pt')
results = model_cls('image.jpg')

# 4. POSE ESTIMATION
model_pose = YOLO('yolov8n-pose.pt')
results = model_pose('image.jpg')

# 5. OBB (ORIENTED BOUNDING BOX)
model_obb = YOLO('yolov8n-obb.pt')
results = model_obb('image.jpg')

# === CONTOH: POSE ESTIMATION ===
model_pose = YOLO('yolov8n-pose.pt')
results = model_pose('person.jpg')

for result in results:
    keypoints = result.keypoints
    if keypoints is not None:
        for person_kp in keypoints:
            # 17 COCO keypoints
            # 0=nose, 1=left_eye, 2=right_eye, ...
            # 5=left_shoulder, 6=right_shoulder
            # 11=left_hip, 12=right_hip
            kp_data = person_kp.data[0]  # (17, 3): x, y, confidence
            print(f"Pose keypoints: {kp_data.shape}")
            print(f"  Nose: ({kp_data[0][0]:.0f}, {kp_data[0][1]:.0f})")

print("\n✓ Semua model YOLOv8 siap digunakan!")