Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,30 @@ 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
+examples/Fold_1.png filter=lfs diff=lfs merge=lfs -text
+examples/Fold_2.png filter=lfs diff=lfs merge=lfs -text
+examples/Fold_3.png filter=lfs diff=lfs merge=lfs -text
+examples/Holes_1.png filter=lfs diff=lfs merge=lfs -text
+examples/Holes_2.png filter=lfs diff=lfs merge=lfs -text
+examples/Holes_3.png filter=lfs diff=lfs merge=lfs -text
+examples/Holes_4.png filter=lfs diff=lfs merge=lfs -text
+examples/Spots_1.png filter=lfs diff=lfs merge=lfs -text
+examples/Spots_2.png filter=lfs diff=lfs merge=lfs -text
+examples/Spots_3.png filter=lfs diff=lfs merge=lfs -text
+examples/Spots_4.png filter=lfs diff=lfs merge=lfs -text
+examples/Spots_5.png filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_cuff_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_cuff_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_cuff_3.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_cuff_4.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_cuff_5.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_foreign_object_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_foreign_object_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_foreign_object_3.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_foreign_object_4.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_foreign_object_5.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_hole_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_hole_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_hole_3.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_hole_4.jpg filter=lfs diff=lfs merge=lfs -text
+examples/vinyl_hole_5.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,48 @@
 ---
 title: Glove Defect Detection
-emoji: 🦀
-colorFrom: indigo
-colorTo: yellow
+emoji: 🧤
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.12.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧤 Glove Defect Detection System
+
+An image processing app that automatically **classifies safety glove types** and **detects surface defects** — no deep learning required, purely classical computer vision (HSV segmentation + morphological operations).
+
+## How it works
+
+1. **Upload** a photo of a glove (rubber, cloth, nitrile, or vinyl).
+2. The app **classifies the glove type** by analysing dominant HSV colour features.
+3. It then runs the **type-specific defect detector** and returns an annotated image.
+
+## Supported glove types & defects
+
+| Glove Type    | Detected Defects                            |
+|---------------|---------------------------------------------|
+| Rubber        | Holes · Discoloration · Folds               |
+| Cloth         | Missing Fingers · Holes · Stains            |
+| Nitrile       | Spots · Holes · Tears                       |
+| Vinyl         | Palm Holes · Cuff Tears · Foreign Objects   |
+
+## Technical stack
+
+- **OpenCV** — image preprocessing, morphological operations, contour drawing
+- **scikit-image** — connected-component region properties (area, eccentricity, etc.)
+- **Gradio** — web interface
+
+## Project
+
+IPPR (Image Processing & Pattern Recognition) Assignment  
+Asia Pacific University of Technology & Innovation (APU)
+
+| Contributor                              | Module                                     |
+|------------------------------------------|--------------------------------------------|
+| Chiew Wen Qian (TP084377)                | Rubber detector · Code & GUI integration   |
+| Farouk Elouzzani (TP075438)              | Glove type classifier · Vinyl detector     |
+| Puteri Hannah binti Mohamed Daud Ibrahim (TP077710) | Nitrile detector              |
+| Wendy Koh Xin Hui (TP077721)             | Cloth detector                             |

app.py

@@ -0,0 +1,217 @@
+"""
+Glove Defect Detection — Gradio app entry point.
+
+Upload a glove image → automatic type classification → defect analysis.
+"""
+
+import numpy as np
+import gradio as gr
+
+from detectors.glove_type_detector import detect_glove_type
+from detectors.rubber_detection    import detect_rubber
+from detectors.cloth_detection     import detect_cloth
+from detectors.nitrile_detection   import detect_nitrile
+from detectors.vinyl_detection     import detect_vinyl
+
+DETECTORS = {
+    "Rubber Glove":  detect_rubber,
+    "Cloth Glove":   detect_cloth,
+    "Nitrile Glove": detect_nitrile,
+    "Vinyl Glove":   detect_vinyl,
+}
+
+
+def analyse(image: np.ndarray):
+    if image is None:
+        return None, "—", "—"
+    img = image.astype(np.uint8)
+    _, glove_type   = detect_glove_type(img)
+    detector        = DETECTORS.get(glove_type, detect_rubber)
+    result_img, raw_status = detector(img)
+    label = "✅ Passed" if raw_status == "Passed" else "⚠️ Defective"
+    return result_img, glove_type, label
+
+
+def load_from_gallery(evt: gr.SelectData):
+    """Pass the clicked gallery image into the input component."""
+    val = evt.value
+    # Gradio 4+ returns {"image": {"path": ...}, "caption": ...} for (path, caption) tuples
+    if isinstance(val, dict):
+        img = val.get("image", val)
+        if isinstance(img, dict):
+            return img.get("path") or img.get("url")
+        return img
+    return val
+
+
+# ── Sample image lists — (file_path, caption) ────────────────────────────────
+# Corrected groupings per dataset naming convention:
+#   DC_*          → Rubber  + Discoloration
+#   Fold_*        → Rubber  + Fold
+#   Original_*    → Rubber  + Normal
+#   PH_*          → Rubber  + Hole (Palm)
+#   H(*)          → Cloth   + Hole
+#   MF(*)         → Cloth   + Missing Finger
+#   S(*)          → Cloth   + Stain
+#   Holes_*       → Nitrile + Hole
+#   Normal_*      → Nitrile + Normal
+#   Spots_*       → Nitrile + Spot
+#   Tear_*        → Nitrile + Tear
+#   vinyl_hole_*  → Vinyl   + Palm Hole
+#   vinyl_cuff_*  → Vinyl   + Cuff Tear
+#   vinyl_foreign_* → Vinyl + Foreign Object
+
+RUBBER = [
+    ("examples/Original_1.jpeg",  "Normal"),
+    ("examples/Original_2.jpeg",  "Normal"),
+    ("examples/Original_3.jpeg",  "Normal"),
+    ("examples/PH_1.jpeg",        "Hole"),
+    ("examples/PH_2.jpeg",        "Hole"),
+    ("examples/PH_3.jpeg",        "Hole"),
+    ("examples/DC_1.jpeg",        "Discoloration"),
+    ("examples/DC_2.jpeg",        "Discoloration"),
+    ("examples/Fold_1.png",       "Fold"),
+    ("examples/Fold_2.png",       "Fold"),
+    ("examples/Fold_3.png",       "Fold"),
+]
+
+CLOTH = [
+    ("examples/H(2).jpeg",  "Hole"),
+    ("examples/H(3).jpeg",  "Hole"),
+    ("examples/H(5).jpeg",  "Hole"),
+    ("examples/H(6).jpeg",  "Hole"),
+    ("examples/H(7).jpeg",  "Hole"),
+    ("examples/MF(2).jpeg", "Missing Finger"),
+    ("examples/MF(3).jpeg", "Missing Finger"),
+    ("examples/MF(4).jpeg", "Missing Finger"),
+    ("examples/MF(5).jpeg", "Missing Finger"),
+    ("examples/MF(6).jpeg", "Missing Finger"),
+    ("examples/MF(7).jpeg", "Missing Finger"),
+    ("examples/S(1).jpeg",  "Stain"),
+    ("examples/S(7).jpeg",  "Stain"),
+    ("examples/S(8).jpeg",  "Stain"),
+    ("examples/S(9).jpeg",  "Stain"),
+    ("examples/S(10).jpeg", "Stain"),
+]
+
+NITRILE = [
+    ("examples/Normal_1.jpg",  "Normal"),
+    ("examples/Normal_2.jpg",  "Normal"),
+    ("examples/Holes_1.png",   "Hole"),
+    ("examples/Holes_2.png",   "Hole"),
+    ("examples/Holes_3.png",   "Hole"),
+    ("examples/Holes_4.png",   "Hole"),
+    ("examples/Spots_1.png",   "Spot"),
+    ("examples/Spots_2.png",   "Spot"),
+    ("examples/Spots_3.png",   "Spot"),
+    ("examples/Spots_4.png",   "Spot"),
+    ("examples/Spots_5.png",   "Spot"),
+    ("examples/Tear_1.jpg",    "Tear"),
+    ("examples/Tear_2.jpg",    "Tear"),
+    ("examples/Tear_3.jpg",    "Tear"),
+]
+
+VINYL = [
+    ("examples/vinyl_hole_1.jpg",           "Palm Hole"),
+    ("examples/vinyl_hole_2.jpg",           "Palm Hole"),
+    ("examples/vinyl_hole_3.jpg",           "Palm Hole"),
+    ("examples/vinyl_hole_4.jpg",           "Palm Hole"),
+    ("examples/vinyl_hole_5.jpg",           "Palm Hole"),
+    ("examples/vinyl_cuff_1.jpg",           "Cuff Tear"),
+    ("examples/vinyl_cuff_2.jpg",           "Cuff Tear"),
+    ("examples/vinyl_cuff_3.jpg",           "Cuff Tear"),
+    ("examples/vinyl_cuff_4.jpg",           "Cuff Tear"),
+    ("examples/vinyl_cuff_5.jpg",           "Cuff Tear"),
+    ("examples/vinyl_foreign_object_1.jpg", "Foreign Object"),
+    ("examples/vinyl_foreign_object_2.jpg", "Foreign Object"),
+    ("examples/vinyl_foreign_object_3.jpg", "Foreign Object"),
+    ("examples/vinyl_foreign_object_4.jpg", "Foreign Object"),
+    ("examples/vinyl_foreign_object_5.jpg", "Foreign Object"),
+]
+
+
+# ── UI ──────────────────────────────��─────────────────────────────────────────
+
+with gr.Blocks(
+    title="Glove Defect Inspector",
+    theme=gr.themes.Soft(primary_hue="blue"),
+) as demo:
+
+    gr.Markdown(
+        """
+        # 🧤 Glove Defect Detection System
+        Upload a photo of a safety glove OR pick one from the sample gallery below.
+        The system will automatically identify the **glove type** and scan for **defects**.
+
+        | Glove Type | Detectable Defects                            |
+        |------------|-----------------------------------------------|
+        | Rubber     | Holes · Discoloration · Folds                 |
+        | Cloth      | Missing Fingers · Holes · Stains              |
+        | Nitrile    | Spots · Holes · Tears                         |
+        | Vinyl      | Palm Holes · Cuff Tears · Foreign Objects     |
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            inp = gr.Image(
+                type="numpy",
+                label="Input Image",
+                sources=["upload", "webcam"],
+                height=340,
+            )
+
+        with gr.Column(scale=1):
+            out_img = gr.Image(
+                type="numpy",
+                label="Annotated Result",
+                height=340,
+            )
+
+    with gr.Row():
+        out_type   = gr.Textbox(label="Detected Glove Type", interactive=False)
+        out_status = gr.Textbox(label="Defect Status",        interactive=False)
+
+    inp.change(fn=analyse, inputs=inp, outputs=[out_img, out_type, out_status])
+
+    # ── Sample gallery ────────────────────────────────────────────────────────
+    gr.Markdown("### 🖼️ Sample Images | Click any thumbnail to load & analyse it")
+
+    with gr.Accordion("🟢 Rubber Glove  (11 samples)", open=False):
+        rubber_gallery = gr.Gallery(
+            value=RUBBER, columns=6, height=200,
+            show_label=False, allow_preview=False, object_fit="cover",
+        )
+
+    with gr.Accordion("⚪ Cloth Glove  (16 samples)", open=False):
+        cloth_gallery = gr.Gallery(
+            value=CLOTH, columns=6, height=200,
+            show_label=False, allow_preview=False, object_fit="cover",
+        )
+
+    with gr.Accordion("🟣 Nitrile Glove  (14 samples)", open=False):
+        nitrile_gallery = gr.Gallery(
+            value=NITRILE, columns=6, height=200,
+            show_label=False, allow_preview=False, object_fit="cover",
+        )
+
+    with gr.Accordion("⚫ Vinyl Glove  (15 samples)", open=False):
+        vinyl_gallery = gr.Gallery(
+            value=VINYL, columns=6, height=200,
+            show_label=False, allow_preview=False, object_fit="cover",
+        )
+
+    # Clicking any gallery thumbnail → loads image into inp → auto-analyses
+    for gal in [rubber_gallery, cloth_gallery, nitrile_gallery, vinyl_gallery]:
+        gal.select(fn=load_from_gallery, outputs=inp)
+
+    gr.Markdown(
+        """
+        ---
+        **Project**: IPPR Assignment — Asia Pacific University (APU)  
+        **Team**: Chiew Wen Qian · Farouk Elouzzani · Puteri Hannah · Wendy Koh Xin Hui
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch()

detectors/__init__.py

@@ -0,0 +1 @@
+# detectors package

detectors/cloth_detection.py

@@ -0,0 +1,116 @@
+"""
+Cloth glove defect detector — ported from Cloth_Detection.m (Wendy Koh Xin Hui).
+
+Detects:
+  MISSING FINGER — long, eccentric skin-coloured region (torn/missing finger)
+  HOLE           — smaller skin-coloured spot inside the glove
+  STAIN          — orange-yellow patch with low eccentricity
+"""
+
+import cv2
+import numpy as np
+from skimage.measure import regionprops, label as sk_label
+from .utils import fill_holes, remove_small_blobs, get_hsv, disk_kernel, rect_kernel
+
+
+def detect_cloth(img_rgb: np.ndarray):
+    """
+    Parameters
+    ----------
+    img_rgb : np.ndarray  (H, W, 3) uint8 RGB
+
+    Returns
+    -------
+    result  : np.ndarray  — annotated RGB image
+    status  : str         — 'Passed' or 'Defective'
+    """
+    rows, cols = img_rgb.shape[:2]
+    defect_status = "Passed"
+
+    # ── Glove mask via Otsu ───────────────────────────────────────────────────
+    gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+    _, glove_mask = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    glove_mask = fill_holes(glove_mask)
+
+    H, S, V = get_hsv(img_rgb)
+
+    # ── Pipeline A: stain detection (orange-yellow H ∈ [0.07, 0.17]) ─────────
+    stain_raw = (
+        (H >= 0.07) & (H <= 0.17) & (S >= 0.40) & (V >= 0.30)
+    ).astype(np.uint8) * 255
+    stain_raw  = stain_raw & glove_mask
+    se_stain   = disk_kernel(2)
+    stain_mask = cv2.dilate(cv2.erode(stain_raw, se_stain), se_stain)
+    stain_mask = remove_small_blobs(stain_mask, 60)
+
+    # ── Pipeline B: skin / hole detection (pink-red H ∈ [0.0, 0.06]) ─────────
+    skin_raw   = (
+        (H >= 0.0) & (H <= 0.06) & (S >= 0.25) & (S <= 0.70) & (V >= 0.15)
+    ).astype(np.uint8) * 255
+    se_clean      = disk_kernel(3)
+    cleaned       = cv2.dilate(cv2.erode(skin_raw & glove_mask, se_clean), se_clean)
+    # Close with a tall rectangle to bridge finger-width gaps
+    se_finger     = rect_kernel(150, 20)
+    finger_mask   = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, se_finger)
+    finger_mask   = finger_mask & ~stain_mask   # stains must not bleed into finger mask
+
+    # ── Annotate ──────────────────────────────────────────────────────────────
+    result = img_rgb.copy()
+
+    # Finger / hole regions
+    n_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+        finger_mask, connectivity=8
+    )
+    for i in range(1, n_labels):
+        bx = stats[i, cv2.CC_STAT_LEFT]
+        by = stats[i, cv2.CC_STAT_TOP]
+        bw = stats[i, cv2.CC_STAT_WIDTH]
+        bh = stats[i, cv2.CC_STAT_HEIGHT]
+        area = stats[i, cv2.CC_STAT_AREA]
+
+        comp  = (labels == i).astype(np.uint8) * 255
+        lf    = sk_label(comp > 0)
+        props = regionprops(lf)
+        if not props:
+            continue
+        ecc   = props[0].eccentricity
+        ratio = bh / max(bw, 1)
+
+        if (bh > 80 or ratio > 1.6) and ecc > 0.85:
+            cv2.rectangle(result, (bx, by), (bx + bw, by + bh), (255, 0, 0), 4)
+            cv2.putText(
+                result, "MISSING FINGER", (bx, max(by - 25, 12)),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2, cv2.LINE_AA,
+            )
+            defect_status = "Defective"
+        elif area > 80:
+            cv2.rectangle(result, (bx, by), (bx + bw, by + bh), (255, 255, 0), 2)
+            cv2.putText(
+                result, "HOLE", (bx, max(by - 20, 12)),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2, cv2.LINE_AA,
+            )
+            defect_status = "Defective"
+
+    # Stain regions
+    n_s, labs_s, stats_s, _ = cv2.connectedComponentsWithStats(
+        stain_mask, connectivity=8
+    )
+    for j in range(1, n_s):
+        comp  = (labs_s == j).astype(np.uint8) * 255
+        lf    = sk_label(comp > 0)
+        props = regionprops(lf)
+        if not props:
+            continue
+        if props[0].eccentricity < 0.85:
+            bx = stats_s[j, cv2.CC_STAT_LEFT]
+            by = stats_s[j, cv2.CC_STAT_TOP]
+            bw = stats_s[j, cv2.CC_STAT_WIDTH]
+            bh = stats_s[j, cv2.CC_STAT_HEIGHT]
+            cv2.rectangle(result, (bx, by), (bx + bw, by + bh), (255, 128, 0), 3)
+            cv2.putText(
+                result, "STAIN", (bx, by + bh + 20),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 128, 0), 2, cv2.LINE_AA,
+            )
+            defect_status = "Defective"
+
+    return result, defect_status

detectors/glove_type_detector.py

@@ -0,0 +1,83 @@
+"""
+Glove type classifier — ported from GloveTypeDetector.m (Farouk Elouzzani).
+
+Pipeline:
+  1. Otsu threshold on grayscale → binary foreground mask
+  2. Invert mask if the border is mostly foreground (background/foreground swap)
+  3. Fill holes + keep largest blob
+  4. Extract HSV from foreground pixels, classify by dominant hue/saturation/value
+     Green  → Rubber Glove
+     White  → Cloth Glove
+     Purple → Nitrile Glove
+     Black  → Vinyl Glove
+"""
+
+import cv2
+import numpy as np
+from .utils import fill_holes, keep_largest_blob, get_hsv
+
+GLOVE_TYPES = {
+    1: "Rubber Glove",
+    2: "Cloth Glove",
+    3: "Nitrile Glove",
+    4: "Vinyl Glove",
+}
+
+
+def detect_glove_type(img_rgb: np.ndarray):
+    """
+    Classify the glove type in img_rgb.
+
+    Parameters
+    ----------
+    img_rgb : np.ndarray  (H, W, 3) uint8 RGB
+
+    Returns
+    -------
+    masked_glove : np.ndarray  — input image with background zeroed out
+    glove_type   : str         — one of the GLOVE_TYPES values
+    """
+    if img_rgb.ndim == 2:
+        img_rgb = cv2.cvtColor(img_rgb, cv2.COLOR_GRAY2RGB)
+
+    # --- Foreground / background separation via Otsu ---
+    gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+    _, mask = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+    # If the border pixels are mostly bright, the glove is the dark object → invert
+    border = np.concatenate(
+        [mask[0, :], mask[-1, :], mask[:, 0], mask[:, -1]]
+    )
+    if np.sum(border > 0) > len(border) / 2:
+        mask = cv2.bitwise_not(mask)
+
+    mask = fill_holes(mask)
+    mask = keep_largest_blob(mask, n=1)
+
+    # --- HSV feature extraction from foreground ---
+    H, S, V = get_hsv(img_rgb)
+    fg = mask > 0
+    if not np.any(fg):
+        fg = np.ones_like(mask, dtype=bool)
+
+    fH, fS, fV = H[fg], S[fg], V[fg]
+
+    is_black  = fV < 0.25
+    is_white  = (fS < 0.10) & ~is_black
+    is_purple = (fH > 0.60) & (fH < 0.90) & ~is_white & ~is_black
+    is_green  = (fH > 0.20) & (fH < 0.55) & ~is_white & ~is_black
+
+    # Default class = 2 (Cloth / white)
+    classes = np.full(len(fH), 2, dtype=np.int32)
+    classes[is_green]  = 1
+    classes[is_white]  = 2
+    classes[is_purple] = 3
+    classes[is_black]  = 4
+
+    counts  = {k: int(np.sum(classes == k)) for k in [1, 2, 3, 4]}
+    dominant = max(counts, key=counts.get)
+
+    masked = img_rgb.copy()
+    masked[~fg] = 0
+
+    return masked, GLOVE_TYPES[dominant]

detectors/nitrile_detection.py

@@ -0,0 +1,112 @@
+"""
+Nitrile glove defect detector — ported from Nitrile_Detection.m
+(Puteri Hannah binti Mohamed Daud Ibrahim).
+
+Detects:
+  SPOT  — dark enclosed region (brightness < 0.25)
+  HOLE  — bright enclosed gap away from the palm edge
+  TEAR  — bright gap that touches the glove edge AND lies within the palm ROI
+"""
+
+import cv2
+import numpy as np
+from .utils import (
+    fill_holes, keep_largest_blob, remove_small_blobs,
+    im_dilate, get_hsv, resize_to_height, disk_kernel,
+)
+
+
+def detect_nitrile(img_rgb: np.ndarray):
+    """
+    Parameters
+    ----------
+    img_rgb : np.ndarray  (H, W, 3) uint8 RGB
+
+    Returns
+    -------
+    result  : np.ndarray  — annotated RGB image
+    status  : str         — 'Passed' or 'Defective'
+    """
+    img    = resize_to_height(img_rgb, 800)
+    rows, cols = img.shape[:2]
+
+    blurred = cv2.GaussianBlur(img, (0, 0), 1.5)
+    H, S, V = get_hsv(blurred)
+
+    # ── Glove segmentation (purple H ∈ [0.55, 0.95]) ─────────────────────────
+    raw_mask = (
+        (H > 0.55) & (H < 0.95) & (S > 0.10) & (V > 0.15)
+    ).astype(np.uint8) * 255
+    raw_mask = remove_small_blobs(raw_mask, 500)
+
+    solid     = fill_holes(raw_mask)
+    silhouette = keep_largest_blob(solid, n=1)
+
+    # ── Palm ROI: circle centred on the glove, radius = 23 % of image width ──
+    palm_roi = np.zeros((rows, cols), dtype=bool)
+    n_lbl, lbl, stats, centroids = cv2.connectedComponentsWithStats(
+        silhouette, connectivity=8
+    )
+    if n_lbl > 1:
+        cx = float(centroids[1, 0])
+        cy = float(centroids[1, 1])
+        Y, X = np.mgrid[0:rows, 0:cols]
+        palm_roi = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2) < (cols * 0.23)
+
+    # ── Defect masks ──────────────────────────────────────────────────────────
+    # Internal gaps: fully enclosed holes within the silhouette
+    internal = (silhouette > 0) & ~(raw_mask > 0)
+
+    # Edge tears: skin-tone pixels in a 15-px halo around the glove, inside palm ROI
+    skin_mask = ((H < 0.1) | (H > 0.90)) & (S > 0.15) & (V > 0.15)
+    halo      = im_dilate(silhouette, 15) & ~(silhouette > 0)
+    edge_tears = skin_mask & (halo > 0) & palm_roi
+
+    all_defects = (internal | edge_tears).astype(np.uint8) * 255
+    all_defects = remove_small_blobs(all_defects, 40)
+
+    # ── Classification & annotation ───────────────────────────────────────────
+    glove_boundary = cv2.Canny(silhouette, 100, 200)
+    thick_boundary = im_dilate(glove_boundary, 12)
+
+    n_lbl, labels, stats, _ = cv2.connectedComponentsWithStats(
+        all_defects, connectivity=8
+    )
+
+    result          = img.copy()
+    any_defect      = False
+
+    for k in range(1, n_lbl):
+        idx = np.where(labels == k)
+        bb  = stats[k]
+        bx, by = bb[cv2.CC_STAT_LEFT], bb[cv2.CC_STAT_TOP]
+        bw, bh = bb[cv2.CC_STAT_WIDTH], bb[cv2.CC_STAT_HEIGHT]
+
+        # Centroid bounds-check
+        cx_d = int(np.mean(idx[1]))
+        cy_d = int(np.mean(idx[0]))
+        cx_d = min(max(cx_d, 0), cols - 1)
+        cy_d = min(max(cy_d, 0), rows - 1)
+
+        brightness = float(np.median(V[idx]))
+
+        if brightness < 0.25:
+            label, color = "SPOT", (255, 255, 0)
+        else:
+            touches_edge = bool(
+                np.any(thick_boundary[idx]) or np.any(edge_tears[idx])
+            )
+            in_palm = bool(palm_roi[cy_d, cx_d])
+            if touches_edge and in_palm:
+                label, color = "TEAR", (255, 50, 50)
+            else:
+                label, color = "HOLE", (255, 0, 255)
+
+        any_defect = True
+        cv2.rectangle(result, (bx, by), (bx + bw, by + bh), color, 3)
+        cv2.putText(
+            result, label, (bx, max(by - 8, 12)),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.65, color, 2, cv2.LINE_AA,
+        )
+
+    return result, "Defective" if any_defect else "Passed"

detectors/rubber_detection.py

@@ -0,0 +1,119 @@
+"""
+Rubber glove defect detector — ported from Rubber_Detection.m (Chiew Wen Qian).
+
+Detects:
+  HOLE          — enclosed regions whose colour does not match the glove
+  DISCOLORATION — abnormally vivid or dark patches inside the glove
+  FOLD          — elongated dark valleys with a sharp brightness gradient
+"""
+
+import cv2
+import numpy as np
+from skimage.measure import regionprops, label as sk_label
+from .utils import (
+    fill_holes, keep_largest_blob, remove_small_blobs,
+    im_close, im_erode, clean_mask, get_hsv,
+    resize_to_max, draw_labeled_regions,
+)
+
+
+def detect_rubber(img_rgb: np.ndarray):
+    """
+    Parameters
+    ----------
+    img_rgb : np.ndarray  (H, W, 3) uint8 RGB
+
+    Returns
+    -------
+    result  : np.ndarray  — annotated RGB image
+    status  : str         — 'Passed' or 'Defective'
+    """
+    img    = resize_to_max(img_rgb, 800)
+    rows, cols = img.shape[:2]
+
+    # ── 1. HSV segmentation ───────────────────────────────────────────────────
+    blurred   = cv2.GaussianBlur(img, (0, 0), 1.5)
+    H, S, V   = get_hsv(blurred)
+
+    raw_glove = (
+        (H > 0.40) & (H < 0.68) & (S > 0.08) & (V > 0.20) & (V < 0.92)
+    ).astype(np.uint8) * 255
+    raw_glove = remove_small_blobs(raw_glove, 800)
+
+    glove_mask = im_close(raw_glove, 6)
+    glove_mask = keep_largest_blob(glove_mask)
+    glove_mask = fill_holes(glove_mask)
+    safe_zone  = im_erode(glove_mask, 8)
+
+    sz    = safe_zone > 0
+    Vs, Ss = V[sz], S[sz]
+    medV  = float(np.median(Vs)) if Vs.size else 0.5
+    medS  = float(np.median(Ss)) if Ss.size else 0.2
+    stdV  = float(np.std(Vs))    if Vs.size else 0.05
+
+    # ── 2. Hole detection ─────────────────────────────────────────────────────
+    # Enclosed regions = filled glove minus raw glove (dark interior gaps)
+    enclosed = (fill_holes(raw_glove) > 0) & ~(raw_glove > 0)
+    enclosed = enclosed & (im_erode(glove_mask, 8) > 0)
+    enclosed = remove_small_blobs(enclosed.astype(np.uint8) * 255, 30)
+
+    labeled = sk_label(enclosed > 0)
+    props   = regionprops(labeled)
+
+    holes_bool = np.zeros((rows, cols), dtype=bool)
+    for p in props:
+        if p.area < 80 or p.eccentricity >= 0.98:
+            continue
+        r_idx, c_idx = p.coords[:, 0], p.coords[:, 1]
+        rH = float(H[r_idx, c_idx].mean())
+        rS = float(S[r_idx, c_idx].mean())
+        rV = float(V[r_idx, c_idx].mean())
+
+        is_glove_color = (0.40 < rH < 0.68) and rS > 0.08 and (0.20 < rV < 0.92)
+        is_dark_stain  = (rV < medV - 0.12) and (rS < medS)
+        if is_glove_color or is_dark_stain:
+            continue
+        holes_bool[r_idx, c_idx] = True
+
+    holes_mask = clean_mask(holes_bool.astype(np.uint8) * 255, 6, 80)
+
+    # ── 3. Discoloration detection ────────────────────────────────────────────
+    vivid      = (S > medS + 0.18) & sz
+    dark_mark  = (V < medV - max(3.5 * stdV, 0.15)) & (S < medS) & sz
+    dcol_bool  = (vivid | dark_mark) & ~(holes_mask > 0)
+    dcol_mask  = clean_mask(dcol_bool.astype(np.uint8) * 255, 4, 120)
+
+    # ── 4. Fold detection ─────────────────────────────────────────────────────
+    interior   = im_erode(glove_mask, 20) > 0
+    Vs_smooth  = cv2.GaussianBlur(V.astype(np.float32), (0, 0), 1.5)
+    neigh_avg  = cv2.blur(Vs_smooth, (25, 25))
+    valley     = (Vs_smooth < neigh_avg - 0.04) & interior
+
+    gx = cv2.Sobel(Vs_smooth, cv2.CV_32F, 1, 0, ksize=3)
+    gy = cv2.Sobel(Vs_smooth, cv2.CV_32F, 0, 1, ksize=3)
+    grad = np.sqrt(gx ** 2 + gy ** 2)
+    g_max = grad.max()
+    grad_norm  = grad / g_max if g_max > 0 else grad
+    sharp_edge = grad_norm > 0.18
+
+    fold_cand  = (
+        valley & sharp_edge & interior
+        & ~(holes_mask > 0) & ~(dcol_mask > 0)
+    )
+    fold_cand  = clean_mask(fold_cand.astype(np.uint8) * 255, 14, 500)
+
+    lf = sk_label(fold_cand > 0)
+    fp = regionprops(lf)
+    folds_bool = np.zeros((rows, cols), dtype=bool)
+    for p in fp:
+        if p.eccentricity > 0.80 and p.area > 500:
+            folds_bool[p.coords[:, 0], p.coords[:, 1]] = True
+
+    # ── 5. Annotate ───────────────────────────────────────────────────────────
+    result = img.copy()
+    found  = False
+    found  = draw_labeled_regions(result, holes_mask,               (255,  50,  50), "HOLE",          40)  or found
+    found  = draw_labeled_regions(result, dcol_mask,                (255, 255,   0), "DISCOLORATION", 100) or found
+    found  = draw_labeled_regions(result, folds_bool.astype(np.uint8)*255, (0, 255, 255), "FOLD",  400) or found
+
+    return result, "Defective" if found else "Passed"

detectors/utils.py

@@ -0,0 +1,170 @@
+"""
+Shared image-processing helpers used across all glove detectors.
+All functions accept and return uint8 binary masks (0 / 255) unless noted.
+HSV values are normalised to [0, 1] throughout.
+"""
+
+import cv2
+import numpy as np
+
+
+# ── Structuring elements ──────────────────────────────────────────────────────
+
+def disk_kernel(r: int) -> np.ndarray:
+    """Disk-shaped SE — equivalent to MATLAB strel('disk', r)."""
+    return cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * r + 1, 2 * r + 1))
+
+
+def rect_kernel(rows: int, cols: int) -> np.ndarray:
+    """Rectangular SE — equivalent to MATLAB strel('rectangle', [rows, cols])."""
+    return cv2.getStructuringElement(cv2.MORPH_RECT, (cols, rows))
+
+
+# ── Morphological wrappers ────────────────────────────────────────────────────
+
+def im_close(mask: np.ndarray, r: int) -> np.ndarray:
+    return cv2.morphologyEx(mask, cv2.MORPH_CLOSE, disk_kernel(r))
+
+
+def im_open(mask: np.ndarray, r: int) -> np.ndarray:
+    return cv2.morphologyEx(mask, cv2.MORPH_OPEN, disk_kernel(r))
+
+
+def im_erode(mask: np.ndarray, r: int) -> np.ndarray:
+    return cv2.erode(mask, disk_kernel(r))
+
+
+def im_dilate(mask: np.ndarray, r: int) -> np.ndarray:
+    return cv2.dilate(mask, disk_kernel(r))
+
+
+# ── Binary mask helpers ───────────────────────────────────────────────────────
+
+def fill_holes(binary_mask: np.ndarray) -> np.ndarray:
+    """Fill enclosed holes — equivalent to MATLAB imfill(mask, 'holes')."""
+    h, w = binary_mask.shape
+    flood = binary_mask.copy()
+    flood_mask = np.zeros((h + 2, w + 2), np.uint8)
+    cv2.floodFill(flood, flood_mask, (0, 0), 255)
+    return binary_mask | cv2.bitwise_not(flood)
+
+
+def keep_largest_blob(binary_mask: np.ndarray, n: int = 1) -> np.ndarray:
+    """Keep the n largest connected components — equivalent to bwareafilt(mask, n)."""
+    n_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+        binary_mask, connectivity=8
+    )
+    if n_labels <= 1:
+        return binary_mask
+    areas = stats[1:, cv2.CC_STAT_AREA]
+    top_labels = np.argsort(areas)[::-1][:n] + 1
+    result = np.zeros_like(binary_mask)
+    for lbl in top_labels:
+        result[labels == lbl] = 255
+    return result
+
+
+def remove_small_blobs(binary_mask: np.ndarray, min_area: int) -> np.ndarray:
+    """Remove components smaller than min_area — equivalent to bwareaopen."""
+    n_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+        binary_mask, connectivity=8
+    )
+    result = np.zeros_like(binary_mask)
+    for i in range(1, n_labels):
+        if stats[i, cv2.CC_STAT_AREA] >= min_area:
+            result[labels == i] = 255
+    return result
+
+
+def imclearborder(binary_mask: np.ndarray) -> np.ndarray:
+    """Remove blobs touching the image border — equivalent to MATLAB imclearborder."""
+    n_labels, labels, _, _ = cv2.connectedComponentsWithStats(
+        binary_mask, connectivity=8
+    )
+    border_labels = set()
+    for edge in (labels[0, :], labels[-1, :], labels[:, 0], labels[:, -1]):
+        border_labels.update(np.unique(edge).tolist())
+    border_labels.discard(0)
+    result = binary_mask.copy()
+    for lbl in border_labels:
+        result[labels == lbl] = 0
+    return result
+
+
+def clean_mask(mask: np.ndarray, disk_r: int, min_area: int) -> np.ndarray:
+    """im_close then remove_small_blobs — matches MATLAB cleanMask helper."""
+    return remove_small_blobs(im_close(mask, disk_r), min_area)
+
+
+# ── Colour / resize helpers ───────────────────────────────────────────────────
+
+def get_hsv(img_rgb: np.ndarray):
+    """
+    Convert RGB image to HSV and return H, S, V as float32 arrays in [0, 1].
+    OpenCV uses H∈[0,179], S∈[0,255], V∈[0,255] — we normalise here.
+    """
+    hsv = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2HSV).astype(np.float32)
+    return hsv[:, :, 0] / 179.0, hsv[:, :, 1] / 255.0, hsv[:, :, 2] / 255.0
+
+
+def resize_to_max(img: np.ndarray, max_px: int = 800) -> np.ndarray:
+    """Resize so that the longer side equals max_px (preserves aspect ratio)."""
+    h, w = img.shape[:2]
+    if h >= w:
+        new_h, new_w = max_px, max(1, int(w * max_px / h))
+    else:
+        new_h, new_w = max(1, int(h * max_px / w)), max_px
+    return cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+
+
+def resize_to_height(img: np.ndarray, target_h: int = 800) -> np.ndarray:
+    """Resize so height == target_h — matches imresize(img, [800, NaN])."""
+    h, w = img.shape[:2]
+    new_w = max(1, int(w * target_h / h))
+    return cv2.resize(img, (new_w, target_h), interpolation=cv2.INTER_LINEAR)
+
+
+def resize_to_width(img: np.ndarray, target_w: int = 800) -> np.ndarray:
+    """Resize so width == target_w — matches imresize(img, scale) by width."""
+    h, w = img.shape[:2]
+    new_h = max(1, int(h * target_w / w))
+    return cv2.resize(img, (target_w, new_h), interpolation=cv2.INTER_LINEAR)
+
+
+# ── Drawing helper ────────────────────────────────────────────────────────────
+
+def draw_labeled_regions(
+    img: np.ndarray,
+    mask: np.ndarray,
+    color: tuple,
+    label: str,
+    min_area: int,
+) -> bool:
+    """
+    Draw a coloured outline + text label for every region in mask that is
+    larger than min_area.  img is modified in place (RGB uint8).
+    Returns True if at least one region was drawn.
+    """
+    if mask is None or not np.any(mask > 0):
+        return False
+    if mask.dtype != np.uint8:
+        mask = (mask > 0).astype(np.uint8) * 255
+
+    n_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+        mask, connectivity=8
+    )
+    found = False
+    for i in range(1, n_labels):
+        if stats[i, cv2.CC_STAT_AREA] < min_area:
+            continue
+        found = True
+        comp = ((labels == i).astype(np.uint8) * 255)
+        perim = im_dilate(comp, 3) - comp
+        img[perim > 0] = color
+        x = stats[i, cv2.CC_STAT_LEFT]
+        y = max(stats[i, cv2.CC_STAT_TOP] - 8, 12)
+        cv2.putText(
+            img, label, (x, y),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.65, color, 2, cv2.LINE_AA,
+        )
+    return found

detectors/vinyl_detection.py

@@ -0,0 +1,111 @@
+"""
+Vinyl glove defect detector — ported from Vinyl_Detection.m (Farouk Elouzzani).
+
+Detects (blobs with area > 800 px after morphological cleaning):
+  PALM HOLE    — skin-coloured, circular (circularity > 0.8)
+  CUFF TEAR    — skin-coloured, elongated (circularity ≤ 0.8)
+  FOREIGN OBJ  — non-skin-coloured anomaly
+"""
+
+import math
+import cv2
+import numpy as np
+from skimage.measure import regionprops, label as sk_label
+from .utils import imclearborder, get_hsv, resize_to_width, im_open, im_close
+
+
+def detect_vinyl(img_rgb: np.ndarray):
+    """
+    Parameters
+    ----------
+    img_rgb : np.ndarray  (H, W, 3) uint8 RGB
+
+    Returns
+    -------
+    result  : np.ndarray  — annotated RGB image
+    status  : str         — 'Passed' or 'Defective'
+    """
+    img    = resize_to_width(img_rgb, 800)
+    rows, cols = img.shape[:2]
+
+    gray   = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    H, S, V = get_hsv(img)
+
+    # ── Masks ─────────────────────────────────────────────────────────────────
+    # Foreground: non-white pixels; Glove: dark (V < 0.35 = black vinyl body)
+    fg_mask    = (gray < 210).astype(np.uint8) * 255
+    glove_mask = (V < 0.35).astype(np.uint8) * 255
+
+    # Defects are foreground pixels that are NOT the dark glove but have colour
+    defect_mask = fg_mask & ~glove_mask & ((S > 0.15).astype(np.uint8) * 255)
+
+    # ── Morphological refinement ──────────────────────────────────────────────
+    defect_mask = im_open(defect_mask, 3)
+    defect_mask = im_close(defect_mask, 3)
+    defect_mask = imclearborder(defect_mask)
+
+    # ── Blob analysis ─────────────────────────────────────────────────────────
+    lf    = sk_label(defect_mask > 0)
+    props = regionprops(lf)
+
+    result        = img.copy()
+    defect_status = "Passed"
+
+    for p in props:
+        if p.area <= 800:
+            continue
+
+        defect_status = "Defective"
+        bx, by, bx2, by2 = (
+            p.bbox[1], p.bbox[0], p.bbox[3], p.bbox[2]
+        )
+        bw, bh = bx2 - bx, by2 - by
+        label_x = bx + bw // 2
+        label_y = max(by - 40, 15)
+
+        # Per-blob colour sampling
+        r_idx, c_idx = p.coords[:, 0], p.coords[:, 1]
+        meanH = float(H[r_idx, c_idx].mean())
+        meanS = float(S[r_idx, c_idx].mean())
+        meanV = float(V[r_idx, c_idx].mean())
+
+        is_skin = (
+            0.0 <= meanH <= 0.12
+            and 0.20 <= meanS <= 0.70
+            and 0.30 <= meanV <= 1.00
+        )
+        circularity = (
+            (4 * math.pi * p.area) / (p.perimeter ** 2)
+            if p.perimeter > 0 else 0.0
+        )
+
+        if is_skin:
+            if circularity > 0.8:
+                label, outline, bg = "PALM HOLE", (255, 255, 0), (0, 0, 0)
+            else:
+                label, outline, bg = "CUFF TEAR", (255, 50, 50), (255, 255, 255)
+        else:
+            label, outline, bg = "FOREIGN OBJ", (50, 255, 50), (0, 0, 0)
+
+        # Draw boundary contour
+        comp = (lf == p.label).astype(np.uint8) * 255
+        contours, _ = cv2.findContours(comp, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(result, contours, -1, outline, 3)
+
+        # Draw label with background box
+        font       = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 0.6
+        thickness  = 2
+        (tw, th), _ = cv2.getTextSize(label, font, font_scale, thickness)
+        tx = label_x - tw // 2
+        ty = label_y
+        cv2.rectangle(result, (tx - 2, ty - th - 2), (tx + tw + 2, ty + 2), bg, -1)
+        cv2.putText(result, label, (tx, ty), font, font_scale, outline, thickness, cv2.LINE_AA)
+
+    if defect_status == "Passed":
+        cv2.putText(
+            result, "NO DEFECTS DETECTED", (20, 40),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2, cv2.LINE_AA,
+        )
+
+    return result, defect_status