Update server.py

server.py

@@ -55,54 +55,92 @@ def map_kaggle_label(raw_label):
     return f"{ft}_{rs}", ft, rs
 
 
-# ─── Feature extraction — exact copy dari Cell 2 notebook ────────────────────
+# ─── Feature extraction — exact copy dari notebook (GrabCut version) ─────────
 def extract_features_from_array(img_array, size=(128, 128)):
     img_resized = cv2.resize(img_array, size)
     gray    = cv2.cvtColor(img_resized, cv2.COLOR_BGR2GRAY)
     blurred = cv2.GaussianBlur(gray, (5, 5), 0)
 
-    _, mask = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # ── Segmentation: GrabCut (matches notebook) ──────────────────────────────
+    h, w = blurred.shape[:2]
+    margin = int(min(h, w) * 0.085)
+    rect = (margin, margin, w - margin * 2, h - margin * 2)
+    mask      = np.zeros(blurred.shape[:2], np.uint8)
+    bgd_model = np.zeros((1, 65), np.float64)
+    fgd_model = np.zeros((1, 65), np.float64)
+    cv2.grabCut(img_resized, mask, rect, bgd_model, fgd_model,
+                iterCount=20, mode=cv2.GC_INIT_WITH_RECT)
+    mask2 = np.where((mask == 2) | (mask == 0), 0, 255).astype('uint8')
+
+    # ── Shape features ────────────────────────────────────────────────────────
+    contours, _ = cv2.findContours(mask2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     aspect_ratio, extent = 0, 0
     if contours:
         c = max(contours, key=cv2.contourArea)
-        x, y, w, h = cv2.boundingRect(c)
-        aspect_ratio = float(w) / h if h != 0 else 0
-        area = cv2.contourArea(c)
-        rect_area = w * h
-        extent = float(area) / rect_area if rect_area != 0 else 0
+        x, y, bw, bh = cv2.boundingRect(c)
+        aspect_ratio = float(bw) / bh if bh != 0 else 0
+        area      = cv2.contourArea(c)
+        rect_area = bw * bh
+        extent    = float(area) / rect_area if rect_area != 0 else 0
 
-    fp = mask > 0
+    fp = mask2 > 0
 
-    # HSV (6)
+    # ── HSV color features (6) ────────────────────────────────────────────────
     hsv = cv2.cvtColor(img_resized, cv2.COLOR_BGR2HSV)
     h_ch, s_ch, v_ch = cv2.split(hsv)
     hsv_feats = [
-        np.mean(h_ch[fp]) if fp.any() else 0, np.mean(s_ch[fp]) if fp.any() else 0,
-        np.mean(v_ch[fp]) if fp.any() else 0, np.std(h_ch[fp])  if fp.any() else 0,
-        np.std(s_ch[fp])  if fp.any() else 0, np.std(v_ch[fp])  if fp.any() else 0,
+        np.mean(h_ch[fp]) if fp.any() else 0,
+        np.mean(s_ch[fp]) if fp.any() else 0,
+        np.mean(v_ch[fp]) if fp.any() else 0,
+        np.std(h_ch[fp])  if fp.any() else 0,
+        np.std(s_ch[fp])  if fp.any() else 0,
+        np.std(v_ch[fp])  if fp.any() else 0,
     ]
 
-    # LAB (5) ← NEW
+    # ── LAB color features (5) ────────────────────────────────────────────────
     lab = cv2.cvtColor(img_resized, cv2.COLOR_BGR2LAB)
     l_ch, a_ch, b_ch = cv2.split(lab)
     lab_feats = [
-        np.mean(l_ch[fp]) if fp.any() else 0, np.mean(a_ch[fp]) if fp.any() else 0,
-        np.mean(b_ch[fp]) if fp.any() else 0, np.std(a_ch[fp])  if fp.any() else 0,
+        np.mean(l_ch[fp]) if fp.any() else 0,
+        np.mean(a_ch[fp]) if fp.any() else 0,
+        np.mean(b_ch[fp]) if fp.any() else 0,
+        np.std(a_ch[fp])  if fp.any() else 0,
         np.std(b_ch[fp])  if fp.any() else 0,
     ]
 
-    # Hue histogram 18 bins (18) ← NEW
-    h_hist = cv2.calcHist([h_ch], [0], mask, [18], [0, 180])
+    # ── Hue histogram 18 bins (18) ────────────────────────────────────────────
+    # NOTE: uses mask2 (uint8 0/255) as the cv2.calcHist mask — matches notebook
+    h_hist = cv2.calcHist([h_ch], [0], mask2, [18], [0, 180])
     h_hist = cv2.normalize(h_hist, h_hist).flatten().tolist()
 
-    # GLCM with distances=[1,3,5], 4 angles, 6 props (6) ← EXPANDED
-    # Quantise to 32 levels: reduces sparsity and speeds up computation.
-    # ⚠️  Must match the notebook — retrain if you change this value.
-    masked_gray = cv2.bitwise_and(gray, gray, mask=mask).astype(np.uint8)
-    masked_gray = (masked_gray // 8).astype(np.uint8)   # 256 → 32 levels
-    glcm = graycomatrix(masked_gray, distances=[1, 3, 5],
+    # ── GLCM texture (6) ──────────────────────────────────────────────────────
+    # Crop to bounding box of mask, inpaint background pixels, then quantise.
+    # This exactly replicates the notebook's GLCM pipeline.
+    x, y, bw, bh = cv2.boundingRect(mask2)
+    if bw > 0 and bh > 0:
+        gray_crop    = gray[y:y + bh, x:x + bw]
+        mask_crop    = mask2[y:y + bh, x:x + bw]
+        masked_gray_raw = np.where(mask_crop > 0, gray_crop, 0).astype(np.uint8)
+        inv_mask_crop   = cv2.bitwise_not(mask_crop)
+        if np.count_nonzero(inv_mask_crop) > 0:
+            inpainted = cv2.inpaint(masked_gray_raw, inv_mask_crop,
+                                    inpaintRadius=1, flags=cv2.INPAINT_TELEA)
+            masked_gray = inpainted if inpainted is not None else masked_gray_raw
+        else:
+            masked_gray = masked_gray_raw
+    else:
+        # GrabCut returned empty mask — fall back to full grayscale
+        masked_gray = gray
+
+    masked_gray_q = (masked_gray // 8).astype(np.uint8)
+    valid_pixels  = masked_gray_q[masked_gray_q > 0]
+    if valid_pixels.size < 100:
+        # Fallback: use full unmasked grayscale
+        glcm_input = (gray // 8).astype(np.uint8)
+    else:
+        glcm_input = masked_gray_q
+
+    glcm = graycomatrix(glcm_input, distances=[1, 3, 5],
                         angles=[0, np.pi/4, np.pi/2, 3*np.pi/4],
                         levels=32, symmetric=True, normed=True)
     glcm_feats = [
@@ -110,23 +148,23 @@ def extract_features_from_array(img_array, size=(128, 128)):
         graycoprops(glcm, 'correlation').mean(),
         graycoprops(glcm, 'energy').mean(),
         graycoprops(glcm, 'homogeneity').mean(),
-        graycoprops(glcm, 'dissimilarity').mean(),  # NEW
-        graycoprops(glcm, 'ASM').mean(),             # NEW
+        graycoprops(glcm, 'dissimilarity').mean(),
+        graycoprops(glcm, 'ASM').mean(),
     ]
 
-    # LBP histogram 10 bins (10) ← NEW
+    # ── LBP texture 10 bins (10) ──────────────────────────────────────────────
     lbp = local_binary_pattern(gray, P=8, R=1, method='uniform')
     lbp_pixels = lbp[fp] if fp.any() else lbp.ravel()
     lbp_hist, _ = np.histogram(lbp_pixels, bins=10, range=(0, 10), density=True)
 
     features = hsv_feats + lab_feats + h_hist + glcm_feats + lbp_hist.tolist() + [aspect_ratio, extent]
-    
-    # raw dict for frontend display (keep the same keys you already use)
+
+    # raw dict for frontend display
     raw = {
         'h_mean': hsv_feats[0], 's_mean': hsv_feats[1], 'v_mean': hsv_feats[2],
         'h_std':  hsv_feats[3], 's_std':  hsv_feats[4], 'v_std':  hsv_feats[5],
         'contrast': glcm_feats[0], 'correlation': glcm_feats[1],
-        'energy': glcm_feats[2], 'homogeneity': glcm_feats[3],
+        'energy': glcm_feats[2],   'homogeneity': glcm_feats[3],
         'aspect_ratio': aspect_ratio, 'extent': extent,
     }
     return features, raw
@@ -245,4 +283,4 @@ if __name__ == '__main__':
     print("RIPE.AI — Flask API Server")
     print("=" * 60)
     print(f"Model loaded: {model_loaded}")
-    app.run(host='0.0.0.0', port=7860, debug=False)
+    app.run(host='0.0.0.0', port=5000, debug=False)