Update app.py

app.py

@@ -1,226 +1,145 @@
-import os
 import cv2
 import numpy as np
-import tempfile
-import gradio as gr
 
 
 # ============================================================
-# SETTINGS
+# ID CARD DETECTOR
 # ============================================================
 
-MAX_PROCESS_SIZE = 1800
-
-# Egyptian ID cards are normally wider than tall.
-MIN_ASPECT = 1.20
-MAX_ASPECT = 2.40
-
-# Don't accept extremely tiny contours.
-MIN_CARD_AREA = 0.04
-
-# Padding around detected card.
-PADDING = 3
-
-
-# ============================================================
-# IMAGE HELPERS
-# ============================================================
-
-def resize_for_processing(image):
-    """
-    Resize only for processing.
-    The final crop is taken from the ORIGINAL image.
-    """
-
-    h, w = image.shape[:2]
-
-    scale = min(1.0, MAX_PROCESS_SIZE / max(h, w))
-
-    if scale == 1.0:
-        return image.copy(), 1.0
-
-    new_w = int(w * scale)
-    new_h = int(h * scale)
-
-    small = cv2.resize(
-        image,
-        (new_w, new_h),
-        interpolation=cv2.INTER_AREA
-    )
-
-    return small, scale
-
-
-def order_points(points):
+def order_points(pts):
     """
     Return points in:
-        top-left
-        top-right
-        bottom-right
-        bottom-left
+    top-left, top-right, bottom-right, bottom-left
     """
-
-    pts = np.array(points, dtype=np.float32)
+    pts = np.array(pts, dtype=np.float32)
 
     s = pts.sum(axis=1)
     d = np.diff(pts, axis=1).reshape(-1)
 
-    ordered = np.zeros((4, 2), dtype=np.float32)
-
-    ordered[0] = pts[np.argmin(s)]
-    ordered[2] = pts[np.argmax(s)]
-
-    ordered[1] = pts[np.argmin(d)]
-    ordered[3] = pts[np.argmax(d)]
+    tl = pts[np.argmin(s)]
+    br = pts[np.argmax(s)]
+    tr = pts[np.argmin(d)]
+    bl = pts[np.argmax(d)]
 
-    return ordered
+    return np.array([tl, tr, br, bl], dtype=np.float32)
 
 
-def polygon_angle(a, b, c):
+def four_point_crop(image, pts, padding=0):
     """
-    Angle ABC.
-    """
-
-    ba = a - b
-    bc = c - b
-
-    denom = (
-        np.linalg.norm(ba) *
-        np.linalg.norm(bc)
-    )
-
-    if denom == 0:
-        return 0
-
-    cos_angle = np.dot(ba, bc) / denom
-    cos_angle = np.clip(cos_angle, -1.0, 1.0)
-
-    return np.degrees(np.arccos(cos_angle))
-
+    Perspective-correct the ID card.
 
-def valid_rectangle(points, image_shape):
-    """
-    Check whether four points look like a card.
+    IMPORTANT:
+    This does NOT stretch the entire original image.
+    Only the detected quadrilateral is transformed.
     """
 
-    h, w = image_shape[:2]
-
-    pts = order_points(points)
-
-    area = cv2.contourArea(pts.astype(np.float32))
-
-    if area < h * w * MIN_CARD_AREA:
-        return False, 0
+    rect = order_points(pts)
 
-    width_top = np.linalg.norm(pts[1] - pts[0])
-    width_bottom = np.linalg.norm(pts[2] - pts[3])
+    tl, tr, br, bl = rect
 
-    height_left = np.linalg.norm(pts[3] - pts[0])
-    height_right = np.linalg.norm(pts[2] - pts[1])
+    width_a = np.linalg.norm(br - bl)
+    width_b = np.linalg.norm(tr - tl)
 
-    width = (width_top + width_bottom) / 2
-    height = (height_left + height_right) / 2
+    height_a = np.linalg.norm(tr - br)
+    height_b = np.linalg.norm(tl - bl)
 
-    if height <= 1:
-        return False, 0
+    width = int(max(width_a, width_b))
+    height = int(max(height_a, height_b))
 
-    aspect = width / height
-
-    # Card should be wider than tall.
-    if aspect < MIN_ASPECT or aspect > MAX_ASPECT:
-        return False, 0
-
-    # Check angles.
-    angles = []
-
-    for i in range(4):
-        a = pts[(i - 1) % 4]
-        b = pts[i]
-        c = pts[(i + 1) % 4]
-
-        angles.append(
-            polygon_angle(a, b, c)
-        )
-
-    # A real card should have reasonably rectangular corners.
-    angle_score = 0
-
-    for angle in angles:
-        difference = abs(angle - 90)
-
-        if difference < 10:
-            angle_score += 1.0
-        elif difference < 20:
-            angle_score += 0.7
-        elif difference < 30:
-            angle_score += 0.3
-
-    angle_score /= 4
+    if width < 100 or height < 60:
+        return None
 
-    # Opposite sides should have similar lengths.
-    width_ratio = min(width_top, width_bottom) / max(
-        width_top,
-        width_bottom
+    # ID cards are normally wider than tall.
+    # If detector returned the opposite orientation,
+    # rotate the result.
+    if height > width:
+        width, height = height, width
+
+    dst = np.array([
+        [0, 0],
+        [width - 1, 0],
+        [width - 1, height - 1],
+        [0, height - 1]
+    ], dtype=np.float32)
+
+    # Use original dimensions from the ordered points
+    real_width = int(max(width_a, width_b))
+    real_height = int(max(height_a, height_b))
+
+    dst = np.array([
+        [0, 0],
+        [real_width - 1, 0],
+        [real_width - 1, real_height - 1],
+        [0, real_height - 1]
+    ], dtype=np.float32)
+
+    matrix = cv2.getPerspectiveTransform(rect, dst)
+
+    warped = cv2.warpPerspective(
+        image,
+        matrix,
+        (real_width, real_height),
+        flags=cv2.INTER_CUBIC,
+        borderMode=cv2.BORDER_REPLICATE
     )
 
-    height_ratio = min(height_left, height_right) / max(
-        height_left,
-        height_right
-    )
+    if warped is None or warped.size == 0:
+        return None
 
-    rectangularity = (
-        0.5 * angle_score +
-        0.25 * width_ratio +
-        0.25 * height_ratio
-    )
+    # Always make ID horizontal.
+    if warped.shape[0] > warped.shape[1]:
+        warped = cv2.rotate(
+            warped,
+            cv2.ROTATE_90_CLOCKWISE
+        )
 
-    return True, rectangularity
+    return warped
 
 
 # ============================================================
-# FIND CARD
+# METHOD 1
+# STRONG RECTANGLE / EDGE DETECTION
 # ============================================================
 
-def find_card_contour(image):
-    """
-    Search for the ID card using several different edge/threshold
-    methods.
+def detect_by_edges(image):
+    h, w = image.shape[:2]
 
-    IMPORTANT:
-    We only detect the card.
-    We do NOT perspective-transform it.
-    """
+    # Work on a smaller image for detection only.
+    scale = 1.0
 
-    small, scale = resize_for_processing(image)
+    max_dimension = 1400
 
-    h, w = small.shape[:2]
+    if max(h, w) > max_dimension:
+        scale = max_dimension / max(h, w)
 
-    gray = cv2.cvtColor(
-        small,
-        cv2.COLOR_BGR2GRAY
-    )
+        small = cv2.resize(
+            image,
+            None,
+            fx=scale,
+            fy=scale,
+            interpolation=cv2.INTER_AREA
+        )
+    else:
+        small = image.copy()
 
-    # --------------------------------------------------------
-    # Slight blur
-    # --------------------------------------------------------
+    gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)
 
+    # Remove small texture from cloth/background.
     blur = cv2.GaussianBlur(
         gray,
         (5, 5),
         0
     )
 
-    candidates = []
-
-    # ========================================================
-    # METHOD 1 - CANNY
-    # ========================================================
+    # Multiple edge thresholds.
+    edge_images = []
 
     for low, high in [
+        (20, 70),
         (30, 100),
+        (40, 130),
         (50, 150),
-        (70, 180),
-        (100, 200),
+        (70, 180)
     ]:
 
         edges = cv2.Canny(
@@ -241,9 +160,15 @@ def find_card_contour(image):
             iterations=2
         )
 
+        edge_images.append(edges)
+
+    candidates = []
+
+    for edges in edge_images:
+
         contours, _ = cv2.findContours(
             edges,
-            cv2.RETR_LIST,
+            cv2.RETR_EXTERNAL,
             cv2.CHAIN_APPROX_SIMPLE
         )
 
@@ -251,7 +176,14 @@ def find_card_contour(image):
 
             area = cv2.contourArea(contour)
 
-            if area < h * w * MIN_CARD_AREA:
+            image_area = small.shape[0] * small.shape[1]
+
+            # Card should occupy a reasonable amount
+            # of the photograph.
+            if area < image_area * 0.015:
+                continue
+
+            if area > image_area * 0.95:
                 continue
 
             perimeter = cv2.arcLength(
@@ -259,685 +191,561 @@ def find_card_contour(image):
                 True
             )
 
-            if perimeter == 0:
+            if perimeter <= 0:
                 continue
 
-            for epsilon_factor in [
-                0.015,
-                0.02,
-                0.025,
-                0.03,
-                0.04,
-            ]:
-
-                approx = cv2.approxPolyDP(
-                    contour,
-                    epsilon_factor * perimeter,
-                    True
-                )
-
-                if len(approx) != 4:
-                    continue
-
-                pts = approx.reshape(4, 2)
+            approx = cv2.approxPolyDP(
+                contour,
+                0.025 * perimeter,
+                True
+            )
 
-                valid, score = valid_rectangle(
-                    pts,
-                    small.shape
-                )
+            # ------------------------------------------------
+            # NORMAL 4-CORNER DETECTION
+            # ------------------------------------------------
 
-                if not valid:
-                    continue
+            if len(approx) == 4:
 
-                candidates.append(
-                    (
-                        score,
-                        area,
-                        pts
-                    )
+                pts = approx.reshape(4, 2).astype(
+                    np.float32
                 )
 
-    # ========================================================
-    # METHOD 2 - ADAPTIVE THRESHOLD
-    # ========================================================
-
-    adaptive = cv2.adaptiveThreshold(
-        blur,
-        255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-        cv2.THRESH_BINARY,
-        31,
-        7
-    )
-
-    kernel = cv2.getStructuringElement(
-        cv2.MORPH_RECT,
-        (11, 11)
-    )
-
-    adaptive = cv2.morphologyEx(
-        adaptive,
-        cv2.MORPH_CLOSE,
-        kernel,
-        iterations=2
-    )
-
-    contours, _ = cv2.findContours(
-        adaptive,
-        cv2.RETR_LIST,
-        cv2.CHAIN_APPROX_SIMPLE
-    )
-
-    for contour in contours:
-
-        area = cv2.contourArea(contour)
+            else:
 
-        if area < h * w * MIN_CARD_AREA:
-            continue
+                # ------------------------------------------------
+                # ROTATED RECTANGLE FALLBACK
+                # ------------------------------------------------
 
-        perimeter = cv2.arcLength(
-            contour,
-            True
-        )
+                rect = cv2.minAreaRect(contour)
 
-        if perimeter == 0:
-            continue
+                box = cv2.boxPoints(rect)
 
-        approx = cv2.approxPolyDP(
-            contour,
-            0.025 * perimeter,
-            True
-        )
-
-        if len(approx) != 4:
-            continue
-
-        pts = approx.reshape(4, 2)
-
-        valid, score = valid_rectangle(
-            pts,
-            small.shape
-        )
-
-        if valid:
-            candidates.append(
-                (
-                    score,
-                    area,
-                    pts
+                pts = np.array(
+                    box,
+                    dtype=np.float32
                 )
-            )
 
-    # ========================================================
-    # METHOD 3 - THRESHOLD
-    # ========================================================
-
-    for threshold_value in [80, 100, 120, 140, 160, 180, 200]:
-
-        _, binary = cv2.threshold(
-            blur,
-            threshold_value,
-            255,
-            cv2.THRESH_BINARY
-        )
-
-        binary = cv2.morphologyEx(
-            binary,
-            cv2.MORPH_CLOSE,
-            kernel,
-            iterations=2
-        )
+            rect = cv2.minAreaRect(
+                pts.astype(np.float32)
+            )
 
-        contours, _ = cv2.findContours(
-            binary,
-            cv2.RETR_LIST,
-            cv2.CHAIN_APPROX_SIMPLE
-        )
+            rw, rh = rect[1]
 
-        for contour in contours:
+            if rw <= 0 or rh <= 0:
+                continue
 
-            area = cv2.contourArea(contour)
+            ratio = max(rw, rh) / min(rw, rh)
 
-            if area < h * w * MIN_CARD_AREA:
+            # Egyptian ID card is approximately 1.58:1.
+            # Allow considerable perspective / rotation.
+            if ratio < 1.25 or ratio > 2.25:
                 continue
 
-            perimeter = cv2.arcLength(
-                contour,
-                True
+            rect_area = rw * rh
+
+            rectangularity = area / max(
+                rect_area,
+                1
             )
 
-            if perimeter == 0:
+            if rectangularity < 0.45:
                 continue
 
-            approx = cv2.approxPolyDP(
-                contour,
-                0.025 * perimeter,
-                True
-            )
+            # Score:
+            # - large area
+            # - good rectangle
+            # - ratio near ID-card ratio
+            target_ratio = 1.58
 
-            if len(approx) != 4:
-                continue
+            ratio_score = 1.0 - min(
+                abs(ratio - target_ratio) / 1.0,
+                1.0
+            )
 
-            pts = approx.reshape(4, 2)
+            area_score = min(
+                area / image_area / 0.35,
+                1.0
+            )
 
-            valid, score = valid_rectangle(
-                pts,
-                small.shape
+            score = (
+                ratio_score * 0.40 +
+                rectangularity * 0.35 +
+                area_score * 0.25
             )
 
-            if valid:
-                candidates.append(
-                    (
-                        score,
-                        area,
-                        pts
-                    )
+            candidates.append(
+                (
+                    score,
+                    pts / scale
                 )
-
-    # ========================================================
-    # NO CANDIDATE
-    # ========================================================
+            )
 
     if not candidates:
         return None
 
-    # ========================================================
-    # SCORE CANDIDATES
-    # ========================================================
-
-    # Prefer:
-    # - rectangular shapes
-    # - larger cards
-    #
-    # But don't blindly choose the largest contour.
-
     candidates.sort(
-        key=lambda x: (
-            x[0] * 0.7 +
-            min(
-                x[1] / (h * w),
-                1.0
-            ) * 0.3
-        ),
+        key=lambda x: x[0],
         reverse=True
     )
 
-    best_score, best_area, best_pts = candidates[0]
-
-    # Convert coordinates back to original image.
-    best_pts = best_pts.astype(np.float32)
+    # Only accept a reasonably strong detection.
+    best_score, best_pts = candidates[0]
 
-    if scale != 1.0:
-        best_pts /= scale
+    if best_score < 0.42:
+        return None
 
-    return order_points(best_pts)
+    return best_pts
 
 
 # ============================================================
-# CREATE MASKED CARD
+# METHOD 2
+# COLOR / LIGHT CARD DETECTION
 # ============================================================
 
-def make_card_mask(image, points):
-    """
-    Create a mask around the actual card.
-
-    IMPORTANT:
-    We DO NOT warp the card.
-
-    The original pixels stay exactly where they were.
-    """
+def detect_by_brightness(image):
 
     h, w = image.shape[:2]
 
-    mask = np.zeros(
-        (h, w),
-        dtype=np.uint8
-    )
-
-    polygon = np.round(points).astype(
-        np.int32
-    )
-
-    cv2.fillPoly(
-        mask,
-        [polygon],
-        255
-    )
-
-    # Slightly close small gaps.
-    kernel = cv2.getStructuringElement(
-        cv2.MORPH_ELLIPSE,
-        (5, 5)
-    )
-
-    mask = cv2.morphologyEx(
-        mask,
-        cv2.MORPH_CLOSE,
-        kernel
-    )
-
-    return mask
+    max_dimension = 1400
 
+    if max(h, w) > max_dimension:
 
-# ============================================================
-# SAFE RECTANGULAR FALLBACK
-# ============================================================
+        scale = max_dimension / max(h, w)
 
-def fallback_card_detection(image):
-    """
-    If the four corners cannot be found, try to find a large
-    horizontal rectangular region.
+        small = cv2.resize(
+            image,
+            None,
+            fx=scale,
+            fy=scale,
+            interpolation=cv2.INTER_AREA
+        )
 
-    This NEVER stretches the image.
-    """
+    else:
 
-    h, w = image.shape[:2]
+        scale = 1.0
+        small = image.copy()
 
-    small, scale = resize_for_processing(image)
+    hsv = cv2.cvtColor(
+        small,
+        cv2.COLOR_BGR2HSV
+    )
 
-    sh, sw = small.shape[:2]
+    # ID card is generally relatively bright
+    # and low/medium saturation.
+    sat = hsv[:, :, 1]
+    val = hsv[:, :, 2]
 
-    gray = cv2.cvtColor(
-        small,
-        cv2.COLOR_BGR2GRAY
+    mask1 = cv2.inRange(
+        val,
+        135,
+        255
     )
 
-    blur = cv2.GaussianBlur(
-        gray,
-        (7, 7),
-        0
+    mask2 = cv2.inRange(
+        sat,
+        0,
+        145
     )
 
-    edges = cv2.Canny(
-        blur,
-        40,
-        150
+    mask = cv2.bitwise_and(
+        mask1,
+        mask2
     )
 
+    # Clean the mask.
     kernel = cv2.getStructuringElement(
         cv2.MORPH_RECT,
         (15, 15)
     )
 
-    edges = cv2.morphologyEx(
-        edges,
+    mask = cv2.morphologyEx(
+        mask,
         cv2.MORPH_CLOSE,
         kernel,
         iterations=2
     )
 
+    mask = cv2.morphologyEx(
+        mask,
+        cv2.MORPH_OPEN,
+        kernel,
+        iterations=1
+    )
+
     contours, _ = cv2.findContours(
-        edges,
+        mask,
         cv2.RETR_EXTERNAL,
         cv2.CHAIN_APPROX_SIMPLE
     )
 
-    best = None
-    best_score = 0
+    image_area = small.shape[0] * small.shape[1]
+
+    candidates = []
 
     for contour in contours:
 
         area = cv2.contourArea(contour)
 
-        if area < sh * sw * 0.05:
+        if area < image_area * 0.02:
             continue
 
-        x, y, cw, ch = cv2.boundingRect(
-            contour
-        )
+        if area > image_area * 0.80:
+            continue
 
-        if ch == 0:
+        rect = cv2.minAreaRect(contour)
+
+        rw, rh = rect[1]
+
+        if rw <= 0 or rh <= 0:
             continue
 
-        aspect = cw / ch
+        ratio = max(rw, rh) / min(rw, rh)
 
-        if aspect < 1.15 or aspect > 2.8:
+        if ratio < 1.25 or ratio > 2.25:
             continue
 
-        area_ratio = area / (sh * sw)
+        box = cv2.boxPoints(rect)
 
-        # Prefer wider rectangles with reasonable area.
-        score = (
-            min(area_ratio, 0.8) * 0.6 +
-            min(aspect / 1.6, 1.0) * 0.4
+        box = np.array(
+            box,
+            dtype=np.float32
         )
 
-        if score > best_score:
+        rect_area = rw * rh
 
-            best_score = score
+        rectangularity = area / max(
+            rect_area,
+            1
+        )
 
-            best = (
-                x,
-                y,
-                cw,
-                ch
-            )
+        if rectangularity < 0.40:
+            continue
 
-    if best is None:
-        return None
+        ratio_score = 1.0 - min(
+            abs(ratio - 1.58) / 1.0,
+            1.0
+        )
 
-    x, y, cw, ch = best
+        area_score = min(
+            area / image_area / 0.35,
+            1.0
+        )
 
-    if scale != 1.0:
-        x = int(x / scale)
-        y = int(y / scale)
-        cw = int(cw / scale)
-        ch = int(ch / scale)
+        score = (
+            ratio_score * 0.50 +
+            rectangularity * 0.30 +
+            area_score * 0.20
+        )
 
-    x2 = min(
-        w,
-        x + cw
-    )
+        candidates.append(
+            (
+                score,
+                box / scale
+            )
+        )
 
-    y2 = min(
-        h,
-        y + ch
-    )
+    if not candidates:
+        return None
 
-    return (
-        x,
-        y,
-        x2,
-        y2
+    candidates.sort(
+        key=lambda x: x[0],
+        reverse=True
     )
 
+    score, pts = candidates[0]
 
-# ============================================================
-# MAIN CARD EXTRACTION
-# ============================================================
+    if score < 0.40:
+        return None
 
-def extract_id_card(input_image):
-    """
-    Main processing function.
+    return pts
 
-    Output:
-        PNG with transparent background around the ID card.
 
-    NO perspective correction.
-    NO stretching.
-    NO resizing.
-    """
+# ============================================================
+# METHOD 3
+# OCR-REGION FALLBACK
+#
+# This is particularly useful when the card and background
+# have almost the same color.
+# ============================================================
+
+def detect_from_text_boxes(image, ocr=None):
 
-    if input_image is None:
+    if ocr is None:
         return None
 
-    # Gradio may give RGB.
-    if len(input_image.shape) == 3:
+    try:
 
-        if input_image.shape[2] == 4:
-            image = cv2.cvtColor(
-                input_image,
-                cv2.COLOR_RGBA2BGR
-            )
-        else:
-            image = cv2.cvtColor(
-                input_image,
-                cv2.COLOR_RGB2BGR
-            )
+        result = ocr.predict(image)
 
-    else:
-        image = cv2.cvtColor(
-            input_image,
-            cv2.COLOR_GRAY2BGR
-        )
+        if result is None:
+            return None
 
-    original = image.copy()
+        boxes = []
 
-    h, w = original.shape[:2]
+        # PaddleOCR versions can return different structures.
+        for item in result:
 
-    # ========================================================
-    # TRY REAL CARD QUADRILATERAL
-    # ========================================================
+            if item is None:
+                continue
 
-    points = find_card_contour(
-        original
-    )
+            data = None
 
-    if points is not None:
+            if isinstance(item, dict):
+                data = item
 
-        mask = make_card_mask(
-            original,
-            points
-        )
+            elif hasattr(item, "json"):
+                try:
+                    data = item.json
+                except:
+                    data = None
 
-        # ----------------------------------------------------
-        # Bounding box of the card
-        # ----------------------------------------------------
+            if not data:
+                continue
 
-        xs = points[:, 0]
-        ys = points[:, 1]
+            # Try common PaddleOCR structures.
+            for key in [
+                "rec_polys",
+                "dt_polys",
+                "rec_boxes"
+            ]:
 
-        x1 = max(
-            0,
-            int(np.floor(xs.min())) - PADDING
-        )
+                if key in data:
 
-        y1 = max(
-            0,
-            int(np.floor(ys.min())) - PADDING
-        )
+                    arr = np.asarray(
+                        data[key]
+                    )
 
-        x2 = min(
-            w,
-            int(np.ceil(xs.max())) + PADDING
-        )
+                    if arr.ndim == 2 and arr.shape[1] == 4:
 
-        y2 = min(
-            h,
-            int(np.ceil(ys.max())) + PADDING
-        )
+                        arr = arr.reshape(
+                            -1,
+                            2,
+                            2
+                        )
 
-        if x2 > x1 and y2 > y1:
+                    if arr.ndim == 3:
 
-            crop = original[
-                y1:y2,
-                x1:x2
-            ]
+                        for b in arr:
 
-            crop_mask = mask[
-                y1:y2,
-                x1:x2
-            ]
+                            if b.shape[0] >= 4:
 
-            # ------------------------------------------------
-            # Create RGBA
-            # ------------------------------------------------
+                                boxes.append(
+                                    np.array(
+                                        b,
+                                        dtype=np.float32
+                                    )
+                                )
 
-            rgba = cv2.cvtColor(
-                crop,
-                cv2.COLOR_BGR2RGBA
-            )
+        if len(boxes) < 2:
+            return None
 
-            # Transparent outside the card.
-            rgba[:, :, 3] = crop_mask
+        all_points = np.vstack(
+            boxes
+        )
 
-            return save_result(
-                rgba,
-                "id_card_detected"
-            )
+        # Remove tiny / isolated OCR detections.
+        x_min = np.min(
+            all_points[:, 0]
+        )
 
-    # ========================================================
-    # FALLBACK
-    # ========================================================
+        y_min = np.min(
+            all_points[:, 1]
+        )
 
-    fallback = fallback_card_detection(
-        original
-    )
+        x_max = np.max(
+            all_points[:, 0]
+        )
 
-    if fallback is not None:
+        y_max = np.max(
+            all_points[:, 1]
+        )
 
-        x1, y1, x2, y2 = fallback
+        width = x_max - x_min
+        height = y_max - y_min
 
-        crop = original[
-            y1:y2,
-            x1:x2
-        ]
+        if width <= 0 or height <= 0:
+            return None
 
-        if crop.size > 0:
+        ratio = max(width, height) / min(
+            width,
+            height
+        )
 
-            # Create a soft rectangular mask.
-            rgba = cv2.cvtColor(
-                crop,
-                cv2.COLOR_BGR2RGBA
-            )
+        # The collection of ID text should have
+        # a wide overall shape.
+        if ratio < 1.15 or ratio > 3.5:
+            return None
 
-            return save_result(
-                rgba,
-                "id_card_fallback"
-            )
+        # Expand around OCR text.
+        pad_x = width * 0.35
+        pad_y = height * 0.55
 
-    # ========================================================
-    # LAST RESORT
-    # ========================================================
-    #
-    # Do NOT resize/stretch the original.
-    #
-    # Instead return None so the user knows detection failed.
-    #
+        x_min -= pad_x
+        x_max += pad_x
 
-    return None
+        y_min -= pad_y
+        y_max += pad_y
 
+        x_min = max(0, int(x_min))
+        y_min = max(0, int(y_min))
 
-# ============================================================
-# SAVE RESULT
-# ============================================================
+        x_max = min(
+            image.shape[1] - 1,
+            int(x_max)
+        )
 
-def save_result(rgba, prefix):
+        y_max = min(
+            image.shape[0] - 1,
+            int(y_max)
+        )
 
-    fd, path = tempfile.mkstemp(
-        suffix=".png",
-        prefix=prefix + "_"
-    )
+        if x_max <= x_min or y_max <= y_min:
+            return None
+
+        return np.array(
+            [
+                [x_min, y_min],
+                [x_max, y_min],
+                [x_max, y_max],
+                [x_min, y_max]
+            ],
+            dtype=np.float32
+        )
 
-    os.close(fd)
+    except Exception as e:
 
-    cv2.imwrite(
-        path,
-        cv2.cvtColor(
-            rgba,
-            cv2.COLOR_RGBA2BGRA
+        print(
+            "OCR fallback failed:",
+            e
         )
-    )
 
-    return path
+        return None
 
 
 # ============================================================
-# GRADIO UI
+# MAIN DETECTOR
 # ============================================================
 
-DESCRIPTION = """
-### Egyptian ID Card Extractor
+def detect_id_card(image, ocr=None):
 
-Upload an image containing an Egyptian ID card.
+    if image is None:
+        return None
 
-The detector will:
+    # Gradio may provide RGB.
+    # Convert to OpenCV BGR.
+    if len(image.shape) == 3:
 
-- Detect the ID card boundaries
-- Remove the surrounding background
-- Keep the man's photo and all card information
-- Crop around the card
-- Preserve the original pixels
-- NOT perspective-stretch the card
-- NOT resize the card
-- Output a transparent PNG outside the card
+        if image.shape[2] == 3:
 
-If the card is tilted, it remains tilted rather than being artificially
-stretched into a rectangle.
-"""
+            cv_image = cv2.cvtColor(
+                image,
+                cv2.COLOR_RGB2BGR
+            )
 
+        else:
 
-with gr.Blocks(
-    title="ID Card Extractor"
-) as demo:
+            cv_image = image.copy()
 
-    gr.Markdown(
-        "# 🪪 Egyptian ID Card Extractor"
-    )
+    else:
 
-    gr.Markdown(
-        DESCRIPTION
+        cv_image = cv2.cvtColor(
+            image,
+            cv2.COLOR_GRAY2BGR
+        )
+
+    original = cv_image.copy()
+
+    print(
+        "Input:",
+        original.shape
     )
 
-    with gr.Row():
+    # ========================================================
+    # TRY 1 - EDGE
+    # ========================================================
 
-        with gr.Column():
+    pts = detect_by_edges(
+        original
+    )
 
-            input_image = gr.Image(
-                label="Upload ID Image",
-                type="numpy"
-            )
+    if pts is not None:
 
-            process_button = gr.Button(
-                "✂️ Detect & Remove Background",
-                variant="primary"
-            )
+        print(
+            "ID detected using EDGE method"
+        )
+
+        result = four_point_crop(
+            original,
+            pts
+        )
 
-        with gr.Column():
+        if result is not None:
 
-            output_image = gr.Image(
-                label="Cropped ID Card",
-                type="filepath",
-                format="png"
+            return cv2.cvtColor(
+                result,
+                cv2.COLOR_BGR2RGB
             )
 
-    status = gr.Markdown(
-        ""
+    # ========================================================
+    # TRY 2 - BRIGHTNESS / COLOR
+    # ========================================================
+
+    pts = detect_by_brightness(
+        original
     )
 
-    def process(image):
+    if pts is not None:
 
-        if image is None:
-            return None, " Please upload an image."
+        print(
+            "ID detected using BRIGHTNESS method"
+        )
 
-        result = extract_id_card(
-            image
+        result = four_point_crop(
+            original,
+            pts
         )
 
-        if result is None:
-            return (
-                None,
-                " I could not confidently detect the ID card. "
-                "The original image was NOT stretched or returned."
+        if result is not None:
+
+            return cv2.cvtColor(
+                result,
+                cv2.COLOR_BGR2RGB
             )
 
-        return (
-            result,
-            "✅ ID card detected. Background removed without perspective stretching."
-        )
+    # ========================================================
+    # TRY 3 - OCR
+    # ========================================================
 
-    process_button.click(
-        fn=process,
-        inputs=input_image,
-        outputs=[
-            output_image,
-            status
-        ]
+    pts = detect_from_text_boxes(
+        original,
+        ocr
     )
 
-    input_image.change(
-        fn=process,
-        inputs=input_image,
-        outputs=[
-            output_image,
-            status
-        ]
-    )
+    if pts is not None:
 
+        print(
+            "ID detected using OCR fallback"
+        )
 
-# ============================================================
-# START
-# ============================================================
+        result = four_point_crop(
+            original,
+            pts
+        )
 
-if __name__ == "__main__":
+        if result is not None:
 
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(
-            os.environ.get(
-                "PORT",
-                7860
+            return cv2.cvtColor(
+                result,
+                cv2.COLOR_BGR2RGB
             )
-        ),
-        show_error=True
-    )
+
+    # ========================================================
+    # IMPORTANT:
+    # DO NOT RESIZE / STRETCH THE ORIGINAL IMAGE
+    # ========================================================
+
+    print(
+        "No reliable ID card detected."
+    )
+
+    return None