feat: all features

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -9,4 +9,5 @@ __pycache__/
 
 outputs/
 videos/
-images/
+images/
+testing/

app.py

@@ -1,7 +1,103 @@
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from ultralytics import YOLO
 
-app = FastAPI()
+from typing import Dict
 
+from core.defect_detection import *
+from utils import *
+
+import uvicorn, asyncio
+
+# ============================================================
+# APP SETUP
+# ============================================================
+app = FastAPI(
+    title="AI Engine Dummy",
+    version="1.0.0",
+    description="""
+    ## 🧠 AI Engine Dummy API
+
+    API simulasi integrasi **AI Engine** untuk deteksi defect pada sistem monitoring.
+
+    ---
+    ### 🔹 Endpoint Utama
+    - `/start-detection` → Memulai simulasi deteksi untuk beberapa kamera.
+    
+    ### 🔹 Webhook
+    - Gunakan https://webhook.site/ untuk menerima hasil deteksi.
+    - Pastikan mengisi `webhook_url` pada payload request.
+    
+    ### 🔹 Simulasi
+    - Tiap kamera akan melakukan deteksi selama max 5 (Sesuai Waktu Timeout) detik.
+    - Jika ditemukan defect, hasil langsung dikirim ke webhook dan semua kamera berhenti.
+    - Jika semua kamera tidak menemukan defect setelah 5 (Sesuai Waktu Timeout) detik → status "OK" dikirim satu kali.
+    """,
+)
+
+# ============================================================
+# CORS CONFIG (Hanya port 8899)
+# ============================================================
+allowed_origins = [
+    "http://localhost:8899",
+    "http://127.0.0.1:8899",
+    "http://0.0.0.0:8899",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ============================================================
+# ROUTES
+# ============================================================
 @app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+def read_root():
+    return {"message": "Defect Detection API is running."}
+
+
+@app.post("/start-detection")
+async def start_detection(data: Dict):
+    station_id  = data.get("station_id")
+    parts       = data.get("parts")
+    webhook_url = data.get("webhook_url")
+    cameras     = data.get("cameras", [])
+
+    if not station_id or not parts or not webhook_url or not cameras:
+        return {"status": "error", "message": "Missing required fields"}
+
+    logger.info(f"[INFO] Get metadata parts")
+    model_path = model_by_id_metadata(parts['id'])
+
+    logger.info(f"[INFO] Checking model_path")
+    if isinstance(model_path, str):
+        if not os.path.exists(model_path):
+            logger.info(f"[INFO] Model file not found")
+            return {"status": "error", "message": f"Model file not found: {model_path}"}
+        model = YOLO(model_path)
+    else:
+        model = model_path
+
+    logger.info(f"[START] Station {station_id} → {len(cameras)} kamera diproses")
+
+    # running background
+    asyncio.create_task(run_detection_group(station_id, cameras, webhook_url, model, parts))
+
+    return {
+        "status": "started",
+        "station_id": station_id,
+        "camera_count": len(cameras),
+        "message": "Detection is running in background."
+    }
+
+
+# ============================================================
+# ENTRY POINT
+# ============================================================
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

core/defect_detection.py

@@ -0,0 +1,187 @@
+import os, cv2, time, base64, asyncio, httpx
+
+from datetime import datetime
+from dotenv import load_dotenv
+from typing import Dict, List
+from utils import *
+
+load_dotenv()
+
+MODEL_VERSION   = os.getenv("MODEL_VERSION")
+WEBHOOK_URL     = os.getenv("WEBHOOK_URL")
+
+MAX_RUNTIME_SEC     = float(os.getenv("MAX_RUNTIME_SEC"))
+FRAME_FAIL_SLEEP    = float(os.getenv("FRAME_FAIL_SLEEP"))
+DEFAULT_FPS         = float(os.getenv("DEFAULT_FPS"))
+WEBHOOK_TIMEOUT     = float(os.getenv("WEBHOOK_TIMEOUT"))
+
+# ============================================================
+# DEFECT DETECTION FROM VIDEO URL
+# ============================================================
+def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, model=None):
+    """
+    Detect defects sequentially from a video URL.
+    - Reads frames in order.
+    - Returns immediately when a defect is found.
+    - Returns OK if timeout or no detection.
+    - Always saves last processed image (OK or NG) to outputs/images/
+    """
+
+    cap = cv2.VideoCapture(video_url)
+    if not cap.isOpened():
+        logger.error(f"[ERROR] Cannot open video URL: {video_url}")
+        return {
+            "station_id": station_id,
+            "camera_id": camera_id,
+            "status": "error",
+            "detections": [],
+            "message": f"Cannot open video URL: {video_url}"
+        }
+
+    fps = DEFAULT_FPS
+    if fps == 0 or fps != fps:  # handle NaN
+        fps = DEFAULT_FPS
+
+    start_time = time.time()
+    frame_index = 0
+    last_frame = None
+
+    while True:
+        elapsed = time.time() - start_time
+        if elapsed > MAX_RUNTIME_SEC:
+            logger.info(f"[OK] {camera_id} → Timeout reached ({MAX_RUNTIME_SEC}s), no defect detected.")
+            break
+
+        ret, frame = cap.read()
+        if not ret:
+            time.sleep(FRAME_FAIL_SLEEP)
+            continue
+
+        frame_index += 1
+        time.sleep(1 / fps)
+        last_frame = frame.copy()
+
+        # YOLO DETECTION
+        if model:
+            results = model.predict(source=frame, conf=0.4, imgsz=640, verbose=False)
+            boxes = results[0].boxes
+
+            if len(boxes) > 0:
+                for box in boxes:
+                    cls = int(box.cls[0])
+                    conf = float(box.conf[0])
+                    xyxy = [int(x) for x in box.xyxy[0].tolist()]
+                    defect_name = model.names.get(cls, f"class_{cls}").lower()
+
+                    x1, y1, x2, y2 = xyxy
+
+                    # Ambil warna berdasarkan defect
+                    try :
+                        color = color_defect(defect_name)
+                    except Exception as e:
+                        color = color_defect('other')
+
+                    # Draw bounding box
+                    cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+
+                    # Label
+                    label = f"{defect_name.upper()} {conf:.2f}"
+                    (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+                    cv2.rectangle(frame, (x1, y1 - 20), (x1 + w, y1), color, -1)
+                    cv2.putText(frame, label, (x1, y1 - 5),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+
+                    # Convert frame to Base64
+                    _, buffer = cv2.imencode(".jpg", frame)
+                    frame_base64 = base64.b64encode(buffer).decode("utf-8")
+
+                    # Save annotated image
+                    output_dir = "outputs/images"
+                    os.makedirs(output_dir, exist_ok=True)
+                    filename = f"{station_id}_{camera_id}_NG_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+                    filepath = os.path.join(output_dir, filename)
+                    cv2.imwrite(filepath, frame)
+                    logger.info(f"[SAVED] NG image saved to {filepath}")
+
+                    cap.release()
+                    logger.info(f"[DETECTED] Camera {camera_id} → {defect_name} ({conf:.2f})")
+
+                    return {
+                        "station_id": station_id,
+                        "camera_id": camera_id,
+                        "status_defect": "NG",
+                        "image_base64": frame_base64,
+                        "image_path": filepath,
+                        "detections": [{
+                            "class": defect_name,
+                            "confidence": conf,
+                            "bbox": xyxy
+                        }]
+                    }
+
+    # --- no defect detected ---
+    cap.release()
+
+    if last_frame is not None:
+        _, buffer = cv2.imencode(".jpg", last_frame)
+        frame_base64 = base64.b64encode(buffer).decode("utf-8")
+
+        # Save OK image (no bbox)
+        output_dir = "outputs/images"
+        os.makedirs(output_dir, exist_ok=True)
+        filename = f"{station_id}_{camera_id}_OK_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        filepath = os.path.join(output_dir, filename)
+        cv2.imwrite(filepath, last_frame)
+        logger.info(f"[SAVED] OK image saved to {filepath}")
+    else:
+        frame_base64 = ""
+        filepath = None
+
+    return {
+        "station_id": station_id,
+        "camera_id": camera_id,
+        "status_defect": "OK",
+        "image_base64": frame_base64,
+        "image_path": filepath,
+        "detections": []
+    }
+
+
+# ============================================================
+# ASYNC WRAPPERS
+# ============================================================
+async def _detect_camera_video(station_id: str, camera: Dict, stop_flag: Dict, model=None):
+    """Run detection in thread (for async parallel)."""
+    return await asyncio.to_thread(detect_defect_from_video_url, station_id, camera["camera_id"], camera["rtsp_url"], model)
+
+
+async def run_detection_group(station_id: str, cameras: List[Dict], webhook_url: str, model=None, parts=str):
+    """
+    Run detection for all cameras in parallel.
+    Send webhook with NG/OK status.
+    """
+    stop_flag = {"stop": False}
+    logger.info(f"[START] Station {station_id} → {len(cameras)} camera(s)")
+
+    results = await asyncio.gather(*[
+        _detect_camera_video(station_id, cam, stop_flag, model)
+        for cam in cameras
+    ])
+
+    payload = {
+        "status": "success",
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "model_version": MODEL_VERSION,
+        "parts" : parts,
+        "data": results,
+    }
+
+    # Send webhook
+    try:
+        async with httpx.AsyncClient(timeout=WEBHOOK_TIMEOUT) as client:
+            await client.post(webhook_url, json=payload)
+            logger.info(f"[DONE] Station {station_id}")
+    except Exception as e:
+        logger.error(f"[ERROR] Webhook failed: {e}")
+
+    # return payload

metadata/defect.json

@@ -0,0 +1,24 @@
+[
+    { "class": "short_shoot",     "color": "#FF0000" },
+    { "class": "scratch",         "color": "#00B050" },
+    { "class": "burry",           "color": "#FFFF00" },
+    { "class": "crack",           "color": "#3282F6" },
+    { "class": "silver",          "color": "#0023F5" },
+    { "class": "weldline",        "color": "#7030A0" },
+    { "class": "ejectormark",     "color": "#FFC000" },
+    { "class": "bubble",          "color": "#EF88BE" },
+    { "class": "kontaminasi",     "color": "#7EB5F7" },
+    { "class": "jetting",         "color": "#B5E61D" },
+    { "class": "ng_collar",       "color": "#C0C0C0" },
+    { "class": "minyak",          "color": "#B97A57" },
+    { "class": "bending",         "color": "#EFE4B0" },
+    { "class": "overcut",         "color": "#99D9EA" },
+    { "class": "sinmark",         "color": "#817F26" },
+    { "class": "flowmark",        "color": "#C00000" },
+    { "class": "burnmark",        "color": "#F08784" },
+    { "class": "gloss",           "color": "#7092BE" },
+    { "class": "mutih",           "color": "#C8BFE7" },
+    { "class": "blackspot",       "color": "#75163F" },
+    { "class": "bintik",          "color": "#FFFE91" },
+    { "class": "other",           "color": "#FFFFFF" }
+]

metadata/product.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "4", 
+    "pin_api": "JI4ACL-GCSBYHBK03",
+    "name": "CASE BLOWER LHD_SFG - LH", 
+    "sku": "002928",
+    "model_path": "models/short shot_case lhd.pt"
+  },
+  {
+    "id": "6", 
+    "pin_api": "JI4ACL-GCB5Y4BK00",
+    "name": "CASE BLOWER JK017470-4150", 
+    "sku": "005581",
+    "model_path": "models/short shot_case blower jk 2.pt"
+  }
+]		

models/crack_duct.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db9bd066179cb368c2300ffeb772b8a3616043801c5ee75fd16dbb9e16804a9a
+size 6245539

models/short shot_case blower jk 2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d00c7c978e73e7752933920d617b72c9bb5e1f234dc84816f55b91338fbbe72c
+size 6299811

models/short shot_case blower jk.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc3bad050ab2dcc8fda6b45802373c508f4da4066fb41e0e1ce582fa0bafb0ff
+size 6301987

models/short shot_case lhd.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94cb1c2bd2753fc9313afd02cb44bf4eb29fca14a49e9a49c7afcdd3ae9367a2
+size 6245539

utils.py

@@ -0,0 +1,86 @@
+import logging, sys, asyncio, random, json
+from pathlib import Path
+
+# ============================================================
+# LOGGER SETUP
+# ============================================================
+logger = logging.getLogger("ai_engine_dummy")
+logger.setLevel(logging.INFO)
+
+# Handler untuk tampil di console
+handler = logging.StreamHandler(sys.stdout)
+formatter = logging.Formatter("[%(asctime)s] %(levelname)s → %(message)s", "%H:%M:%S")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+# ============================================================
+# HELPER FUNCTION (opsional untuk simulasi delay)
+# ============================================================
+async def async_sleep_random(min_s=0.2, max_s=0.8):
+    """
+    Helper untuk simulasi waktu inferensi secara acak.
+    """
+    durasi = random.uniform(min_s, max_s)
+    await asyncio.sleep(durasi)
+
+# ============================================================
+# HELPER
+# ============================================================
+def _metadata():
+    """
+    load file metadata.json into json data
+    """
+    path = Path("metadata/product.json")
+    if not path.exists():
+        return {"status": "error", "message": "metadata.json not found"}
+
+    with open(path, "r") as f:
+        data = json.load(f)
+    return data
+
+def _color_map():
+    path = Path("metadata/defect.json")
+    if not path.exists():
+        return []
+
+    with open(path, "r") as f:
+        return json.load(f)
+
+def model_by_id_metadata(part_id):
+    """
+    part_id = "4" # id part / product
+    get model_path from metadata by part_id
+    """
+    metadata = _metadata()
+    id_part = part_id
+    item = next((x for x in metadata if x["id"] == id_part), None)
+    model_path = item['model_path']
+    return model_path
+
+def model_by_pin_metadata(pin_api):
+    """
+    pin_api = "JI4ACL-GCSBYHBK03" # PIN API from part / product
+    get model_path from metadata by pin_api
+    """
+    metadata = _metadata()
+    pin_api = pin_api
+    item = next((x for x in metadata if x["pin_api"] == pin_api), None)
+    model_path = item['model_path']
+    return model_path
+
+def color_defect(defect_name):
+    """
+    Return BGR tuple color for OpenCV bounding box.
+    """
+    defect_name = defect_name.lower()
+    data = _color_map()
+
+    item = next((x for x in data if x["class"].lower() == defect_name), None)
+    if item is None:
+        return (0, 255, 0)  # Default GREEN jika tidak ditemukan
+
+    hex_color = item["color"].lstrip('#')
+    r = int(hex_color[0:2], 16)
+    g = int(hex_color[2:4], 16)
+    b = int(hex_color[4:6], 16)
+    return (b, g, r)  # Convert to BGR