Implement initial project structure and setup

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -0,0 +1,194 @@
+import gradio as gr
+from ultralytics import YOLO
+import cv2
+import numpy as np
+from PIL import Image
+from sklearn.cluster import DBSCAN
+
+# Load the YOLO model
+model = YOLO('models/rugai_m_v2.pt')
+
+def remove_overlapping_boxes(boxes, iou_threshold=0.3):
+    """Remove overlapping boxes using IoU threshold."""
+    if not boxes:
+        return []
+    
+    # Convert boxes to numpy array
+    boxes = np.array(boxes)
+    
+    # Calculate areas
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    
+    # Sort by area (largest first)
+    indices = np.argsort(areas)[::-1]
+    
+    keep = []
+    while indices.size > 0:
+        i = indices[0]
+        keep.append(i)
+        
+        # Calculate IoU with remaining boxes
+        xx1 = np.maximum(boxes[i, 0], boxes[indices[1:], 0])
+        yy1 = np.maximum(boxes[i, 1], boxes[indices[1:], 1])
+        xx2 = np.minimum(boxes[i, 2], boxes[indices[1:], 2])
+        yy2 = np.minimum(boxes[i, 3], boxes[indices[1:], 3])
+        
+        w = np.maximum(0, xx2 - xx1)
+        h = np.maximum(0, yy2 - yy1)
+        overlap = (w * h) / areas[indices[1:]]
+        
+        # Keep boxes with IoU less than threshold
+        indices = indices[1:][overlap < iou_threshold]
+    
+    return keep
+
+def process_image(image, show_boxes=True):
+    # Convert PIL Image to numpy array if needed
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Run inference with specific parameters
+    results = model.predict(image, imgsz=320, conf=0.25, iou=0.9)[0]
+    
+    # Lists to store center points of knots
+    centers_x = []
+    centers_y = []
+    
+    # Process each result and extract boxes
+    boxes = []  # Store all boxes and their centers
+    height, width = image.shape[:2]
+    
+    for box in results.boxes:
+        x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+        x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
+        
+        # Calculate box center
+        center_x = (x1 + x2) // 2
+        center_y = (y1 + y2) // 2
+        boxes.append({
+            'coords': (x1, y1, x2, y2),
+            'center': (center_x, center_y)
+        })
+        centers_x.append(center_x)
+        centers_y.append(center_y)
+    
+    # Remove overlapping boxes
+    if boxes:
+        box_coords = [box['coords'] for box in boxes]
+        keep_indices = remove_overlapping_boxes(box_coords, iou_threshold=0.3)
+        boxes = [boxes[i] for i in keep_indices]
+        centers_x = [centers_x[i] for i in keep_indices]
+        centers_y = [centers_y[i] for i in keep_indices]
+    
+    # Sort centers
+    centers_y.sort()
+    centers_x.sort()
+    
+    # Set tolerances based on average knot size
+    if len(boxes) > 0:
+        avg_width = sum((b['coords'][2] - b['coords'][0]) for b in boxes) / len(boxes)
+        avg_height = sum((b['coords'][3] - b['coords'][1]) for b in boxes) / len(boxes)
+        x_tolerance = int(avg_width * 0.22)
+        y_tolerance = int(avg_height * 0.22)
+    else:
+        x_tolerance = y_tolerance = 5
+    
+    # Find representative points for rows and columns using DBSCAN
+    rows = []
+    cols = []
+    
+    # Cluster y-coordinates into rows
+    if centers_y:
+        y_centers = np.array(centers_y).reshape(-1, 1)
+        y_clustering = DBSCAN(eps=y_tolerance, min_samples=2, metric='euclidean').fit(y_centers)
+        unique_labels = np.unique(y_clustering.labels_)
+        for label in unique_labels:
+            if label != -1:  # Skip noise points
+                cluster_points = y_centers[y_clustering.labels_ == label]
+                rows.append(int(np.mean(cluster_points)))
+    
+    # Cluster x-coordinates into columns
+    if centers_x:
+        x_centers = np.array(centers_x).reshape(-1, 1)
+        x_clustering = DBSCAN(eps=x_tolerance, min_samples=2, metric='euclidean').fit(x_centers)
+        unique_labels = np.unique(x_clustering.labels_)
+        for label in unique_labels:
+            if label != -1:  # Skip noise points
+                cluster_points = x_centers[x_clustering.labels_ == label]
+                cols.append(int(np.mean(cluster_points)))
+    
+    # Sort rows and columns
+    rows.sort()
+    cols.sort()
+    
+    # Calculate total knots
+    total_knots = len(rows) * len(cols)
+    
+    # Add padding for measurements
+    padding = 100
+    padded_img = np.full((height + 2*padding, width + 2*padding, 3), 255, dtype=np.uint8)
+    padded_img[padding:padding+height, padding:padding+width] = image
+    
+    # Draw boxes if requested
+    if show_boxes:
+        for box in boxes:
+            x1, y1, x2, y2 = box['coords']
+            cv2.rectangle(padded_img, 
+                        (x1 + padding, y1 + padding),
+                        (x2 + padding, y2 + padding),
+                        (0, 255, 0), 2)
+    
+    # Draw measurement lines and labels
+    cv2.line(padded_img, (padding, padding//2), (width+padding, padding//2), (0, 0, 0), 2)
+    cv2.putText(padded_img, f"{len(cols)} knots",
+                (padding + width//2 - 100, padding//2 - 10),
+                cv2.FONT_HERSHEY_DUPLEX, 0.7, (0, 0, 0), 2)
+    
+    cv2.line(padded_img, (width+padding+padding//2, padding), (width+padding+padding//2, height+padding), (0, 0, 0), 2)
+    cv2.putText(padded_img, f"{len(rows)} knots",
+                (width+padding+padding//2 + 10, padding + height//2),
+                cv2.FONT_HERSHEY_DUPLEX, 0.7, (0, 0, 0), 2)
+    
+    # Add total knot count and density
+    cv2.putText(padded_img, f"{int(total_knots)} Total Knots",
+                (padding + width//2 - 100, height + padding + padding//2),
+                cv2.FONT_HERSHEY_DUPLEX, 0.7, (0, 0, 0), 2)
+    
+    # Calculate area in cm² (assuming 1 pixel = 0.0264 cm)
+    area_cm2 = (width * height * 0.0264 * 0.0264)
+    density = total_knots / area_cm2 if area_cm2 > 0 else 0
+    
+    cv2.putText(padded_img, f"{int(total_knots)} knots/sqcm",
+                (padding + width//2 - 100, height + padding + padding//2 + 30),
+                cv2.FONT_HERSHEY_DUPLEX, 0.7, (0, 0, 0), 2)
+    
+    # Prepare detection information
+    detection_info += f"Rows: {len(rows)}\n"
+    detection_info += f"Columns: {len(cols)}\n"
+    detection_info += f"Density: {int(total_knots)} knots/cm²"
+    
+    return padded_img, detection_info
+
+# Create Gradio interface
+with gr.Blocks(title="Rug Knot Detector") as demo:
+    gr.Markdown("# 🧶 Rug Knot Detector")
+    gr.Markdown("Upload an image of a rug to detect and analyze knots using our custom YOLO model.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="Upload Rug Image")
+            show_boxes = gr.Checkbox(label="Show Detection Boxes", value=True)
+            detect_btn = gr.Button("Detect Knots")
+        
+        with gr.Column():
+            output_image = gr.Image(label="Detection Results")
+            output_text = gr.Textbox(label="Detection Information", lines=5)
+    
+    detect_btn.click(
+        fn=process_image,
+        inputs=[input_image, show_boxes],
+        outputs=[output_image, output_text]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

models/rugai_m_v2.pt

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

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+ultralytics==8.3.72
+ultralytics-thop==2.0.14
+Pillow
+numpy
+scikit-learn