Clean deployment for HF Spaces - code only

.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+documents/
+
+# Output directories
+outputs/
+output/
+labelled/
+pipeline_outputs/
+
+# Model files (except stamp model which we'll handle separately)
+# *.pt
+*.pth
+*.onnx
+*.h5
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+venv/
+env/
+ENV/
+

Dockerfile

@@ -0,0 +1,38 @@
+# Dockerfile for Hugging Face Spaces
+FROM python:3.10-slim
+
+# Install system dependencies for OpenCV and PyMuPDF
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create user
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --user --upgrade -r requirements.txt
+
+# Copy all application code
+COPY --chown=user . .
+
+# Create directories for models if needed
+RUN mkdir -p stamp_detector signature qr
+
+# Note: stamp_model.pt should be uploaded via HF Hub web interface or upload_model.py script
+# The model will be available at stamp_detector/stamp_model.pt after upload
+
+# Expose port (HF Spaces uses port 7860)
+EXPOSE 7860
+
+# Run FastAPI on port 7860
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -0,0 +1,52 @@
+---
+title: Document Processing Pipeline API
+emoji: 📄
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Document Processing Pipeline API
+
+FastAPI service for detecting QR codes, signatures, and stamps in PDF documents.
+
+## Features
+
+- **QR Code Detection**: Detects and decodes QR codes in documents
+- **Signature Detection**: Uses YOLOv8s to detect signatures
+- **Stamp Detection**: Uses YOLOv8 to detect stamps/seals
+- **PDF Support**: Processes multi-page PDF documents
+
+## API Endpoints
+
+- `POST /process-pdf` - Upload and process PDF file
+- `POST /process-pdf-from-url` - Process PDF from URL (S3 or HTTP/HTTPS)
+- `GET /docs` - Interactive API documentation
+- `GET /health` - Health check
+
+Visit `/docs` for interactive API documentation.
+
+## Usage
+
+### Process PDF via API
+
+```bash
+curl -X POST "https://bekzhanK1-armeta-hackaton.hf.space/process-pdf" \
+  -F "file=@document.pdf" \
+  -F "dpi=200" \
+  -F "stamp_conf=0.25"
+```
+
+### Process PDF from URL
+
+```bash
+curl -X POST "https://bekzhanK1-armeta-hackaton.hf.space/process-pdf-from-url?pdf_url=https://example.com/document.pdf"
+```
+
+## Model Requirements
+
+- Signature model: Automatically downloaded from Hugging Face
+- Stamp model: Must be uploaded to `stamp_detector/stamp_model.pt` in this repository
+

api.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+"""
+FastAPI application for document processing pipeline.
+Accepts PDF files and returns detection results in JSON format.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Query
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import httpx
+
+from pipeline import process_pdf_pipeline, PDF_SUPPORT
+
+app = FastAPI(
+    title="Document Processing Pipeline API",
+    description="API for QR code, signature, and stamp detection in PDF documents",
+    version="1.0.0"
+)
+
+# Enable CORS for all origins (adjust in production)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    """Health check endpoint."""
+    return {
+        "status": "ok",
+        "message": "Document Processing Pipeline API",
+        "pdf_support": PDF_SUPPORT
+    }
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {"status": "healthy", "pdf_support": PDF_SUPPORT}
+
+
+@app.post("/process-pdf")
+async def process_pdf(
+    file: UploadFile = File(..., description="PDF file to process"),
+    dpi: int = 200,
+    stamp_conf: float = 0.25
+):
+    """
+    Process a PDF file and return detection results.
+
+    Args:
+        file: PDF file to upload
+        dpi: DPI for PDF to image conversion (default: 200)
+        stamp_conf: Confidence threshold for stamp detection (default: 0.25)
+
+    Returns:
+        JSON response with detection results
+    """
+    # Check if PDF support is available
+    if not PDF_SUPPORT:
+        raise HTTPException(
+            status_code=503,
+            detail="PDF processing is not available. Please install PyMuPDF: pip install PyMuPDF"
+        )
+
+    # Validate file type
+    if not file.filename.lower().endswith('.pdf'):
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid file type. Only PDF files are supported."
+        )
+
+    # Create temporary file for uploaded PDF
+    temp_pdf = None
+    try:
+        # Save uploaded file to temporary location
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_pdf:
+            content = await file.read()
+            temp_pdf.write(content)
+            temp_pdf_path = temp_pdf.name
+
+        # Process the PDF
+        try:
+            result = process_pdf_pipeline(
+                pdf_path=temp_pdf_path,
+                output_dir=tempfile.gettempdir(),  # Use temp directory
+                stamp_model_path="stamp_detector/stamp_model.pt",
+                stamp_conf=stamp_conf,
+                dpi=dpi,
+                save_intermediate=False
+            )
+
+            # Return the result as JSON
+            return JSONResponse(content=result)
+
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error processing PDF: {str(e)}"
+            )
+
+    finally:
+        # Clean up temporary file
+        if temp_pdf and os.path.exists(temp_pdf_path):
+            try:
+                os.unlink(temp_pdf_path)
+            except Exception:
+                pass
+
+
+@app.post("/process-pdf-advanced")
+async def process_pdf_advanced(
+    file: UploadFile = File(..., description="PDF file to process"),
+    dpi: int = 200,
+    stamp_conf: float = 0.25,
+    stamp_model: Optional[str] = None
+):
+    """
+    Process a PDF file with advanced options.
+
+    Args:
+        file: PDF file to upload
+        dpi: DPI for PDF to image conversion (default: 200)
+        stamp_conf: Confidence threshold for stamp detection (default: 0.25)
+        stamp_model: Path to custom stamp model (optional)
+
+    Returns:
+        JSON response with detection results
+    """
+    # Check if PDF support is available
+    if not PDF_SUPPORT:
+        raise HTTPException(
+            status_code=503,
+            detail="PDF processing is not available. Please install PyMuPDF: pip install PyMuPDF"
+        )
+
+    # Validate file type
+    if not file.filename.lower().endswith('.pdf'):
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid file type. Only PDF files are supported."
+        )
+
+    # Use default stamp model if not provided
+    stamp_model_path = stamp_model or "stamp_detector/stamp_model.pt"
+
+    # Validate stamp model exists
+    if not Path(stamp_model_path).exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"Stamp model not found: {stamp_model_path}"
+        )
+
+    # Create temporary file for uploaded PDF
+    temp_pdf = None
+    try:
+        # Save uploaded file to temporary location
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_pdf:
+            content = await file.read()
+            temp_pdf.write(content)
+            temp_pdf_path = temp_pdf.name
+
+        # Process the PDF
+        try:
+            result = process_pdf_pipeline(
+                pdf_path=temp_pdf_path,
+                output_dir=tempfile.gettempdir(),  # Use temp directory
+                stamp_model_path=stamp_model_path,
+                stamp_conf=stamp_conf,
+                dpi=dpi,
+                save_intermediate=False
+            )
+
+            # Return the result as JSON
+            return JSONResponse(content=result)
+
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error processing PDF: {str(e)}"
+            )
+
+    finally:
+        # Clean up temporary file
+        if temp_pdf and os.path.exists(temp_pdf_path):
+            try:
+                os.unlink(temp_pdf_path)
+            except Exception:
+                pass
+
+
+@app.post("/process-pdf-from-url")
+async def process_pdf_from_url(
+    pdf_url: str = Query(...,
+                         description="URL to PDF file (S3 or HTTP/HTTPS)"),
+    dpi: int = Query(200, description="DPI for PDF to image conversion"),
+    stamp_conf: float = Query(
+        0.25, description="Confidence threshold for stamp detection"),
+    stamp_model: Optional[str] = Query(
+        None, description="Path to custom stamp model")
+):
+    """
+    Process a PDF file from a URL (S3 or HTTP/HTTPS) and return detection results.
+
+    Args:
+        pdf_url: URL to the PDF file (e.g., s3://bucket/key or https://example.com/file.pdf)
+        dpi: DPI for PDF to image conversion (default: 200)
+        stamp_conf: Confidence threshold for stamp detection (default: 0.25)
+        stamp_model: Path to custom stamp model (optional)
+
+    Returns:
+        JSON response with detection results
+    """
+    # Check if PDF support is available
+    if not PDF_SUPPORT:
+        raise HTTPException(
+            status_code=503,
+            detail="PDF processing is not available. Please install PyMuPDF: pip install PyMuPDF"
+        )
+
+    # Validate URL
+    parsed_url = urlparse(pdf_url)
+    if not parsed_url.scheme:
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid URL format. Must include scheme (http://, https://, or s3://)"
+        )
+
+    # Use default stamp model if not provided
+    stamp_model_path = stamp_model or "stamp_detector/stamp_model.pt"
+
+    # Validate stamp model exists
+    if not Path(stamp_model_path).exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"Stamp model not found: {stamp_model_path}"
+        )
+
+    temp_pdf_path = None
+    try:
+        # Download PDF from URL
+        print(f"Downloading PDF from: {pdf_url}")
+
+        if parsed_url.scheme == 's3':
+            # Handle S3 URLs
+            # For S3, we'll use boto3 if available, otherwise try presigned URL
+            try:
+                import boto3
+                from botocore.exceptions import ClientError
+
+                # Parse S3 URL: s3://bucket/key
+                bucket = parsed_url.netloc
+                key = parsed_url.path.lstrip('/')
+
+                # Download from S3
+                s3_client = boto3.client('s3')
+                temp_pdf_path = tempfile.mktemp(suffix='.pdf')
+
+                try:
+                    s3_client.download_file(bucket, key, temp_pdf_path)
+                    print(f"✓ Downloaded PDF from S3: s3://{bucket}/{key}")
+                except ClientError as e:
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Failed to download from S3: {str(e)}"
+                    )
+
+            except ImportError:
+                # If boto3 is not available, try treating S3 URL as presigned URL
+                # Convert s3:// to https:// (assuming it's a presigned URL)
+                if pdf_url.startswith('s3://'):
+                    raise HTTPException(
+                        status_code=400,
+                        detail="S3 URLs require boto3. Install with: pip install boto3, or use a presigned HTTPS URL"
+                    )
+                # Fall through to HTTP handling
+                pdf_url = pdf_url.replace('s3://', 'https://', 1)
+
+        # Handle HTTP/HTTPS URLs (including presigned S3 URLs)
+        if parsed_url.scheme in ('http', 'https') or temp_pdf_path is None:
+            if temp_pdf_path is None:
+                temp_pdf_path = tempfile.mktemp(suffix='.pdf')
+
+            # 5 minute timeout
+            async with httpx.AsyncClient(timeout=300.0) as client:
+                try:
+                    response = await client.get(pdf_url)
+                    response.raise_for_status()
+
+                    # Validate content type
+                    content_type = response.headers.get(
+                        'content-type', '').lower()
+                    if 'pdf' not in content_type and not pdf_url.lower().endswith('.pdf'):
+                        raise HTTPException(
+                            status_code=400,
+                            detail=f"URL does not point to a PDF file. Content-Type: {content_type}"
+                        )
+
+                    # Save to temporary file
+                    with open(temp_pdf_path, 'wb') as f:
+                        f.write(response.content)
+                    print(f"✓ Downloaded PDF from URL: {pdf_url}")
+
+                except httpx.HTTPStatusError as e:
+                    raise HTTPException(
+                        status_code=e.response.status_code,
+                        detail=f"Failed to download PDF from URL: {str(e)}"
+                    )
+                except httpx.RequestError as e:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Error fetching PDF from URL: {str(e)}"
+                    )
+
+        # Process the PDF
+        try:
+            result = process_pdf_pipeline(
+                pdf_path=temp_pdf_path,
+                output_dir=tempfile.gettempdir(),
+                stamp_model_path=stamp_model_path,
+                stamp_conf=stamp_conf,
+                dpi=dpi,
+                save_intermediate=False
+            )
+
+            # Return the result as JSON
+            return JSONResponse(content=result)
+
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error processing PDF: {str(e)}"
+            )
+
+    finally:
+        # Clean up temporary file
+        if temp_pdf_path and os.path.exists(temp_pdf_path):
+            try:
+                os.unlink(temp_pdf_path)
+            except Exception:
+                pass
+
+
+if __name__ == "__main__":
+    import os
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(
+        "api:app",
+        host="0.0.0.0",
+        port=port,
+        reload=False
+    )

pipeline.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python3
+"""
+Unified Pipeline for Document Processing
+Runs QR code detection, signature detection, and stamp detection in sequence
+and combines all results into a single JSON file.
+"""
+
+import sys
+import json
+import argparse
+import cv2
+import numpy as np
+import tempfile
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+# Try to import PyMuPDF for PDF processing
+try:
+    import fitz  # PyMuPDF
+    PDF_SUPPORT = True
+except ImportError:
+    PDF_SUPPORT = False
+    print("Warning: PyMuPDF not installed. PDF support disabled.")
+    print("Install with: pip install PyMuPDF")
+
+# Add subdirectories to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import detection functions
+from qr.qr_extraction import process_image_no_save as process_qr
+from signature.inference import detect_signatures
+from stamp_detector.detect import detect_stamps_no_save
+
+
+def pdf_to_images(pdf_path: str, dpi: int = 200) -> List[np.ndarray]:
+    """
+    Convert PDF pages to images.
+    
+    Args:
+        pdf_path: Path to PDF file
+        dpi: Resolution for conversion (default: 200)
+        
+    Returns:
+        List of images as numpy arrays (BGR format for OpenCV)
+    """
+    if not PDF_SUPPORT:
+        raise ImportError("PyMuPDF is required for PDF processing. Install with: pip install PyMuPDF")
+    
+    doc = fitz.open(pdf_path)
+    images = []
+    
+    for page_num in range(len(doc)):
+        page = doc[page_num]
+        # Convert to image with specified DPI
+        mat = fitz.Matrix(dpi / 72, dpi / 72)  # 72 is default DPI
+        pix = page.get_pixmap(matrix=mat)
+        
+        # Convert to numpy array
+        img_data = pix.tobytes("ppm")
+        # Use cv2 to decode PPM
+        nparr = np.frombuffer(img_data, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        if img is not None:
+            images.append(img)
+    
+    doc.close()
+    return images
+
+
+def process_pdf_pipeline(
+    pdf_path: str,
+    output_dir: str = "pipeline_outputs",
+    stamp_model_path: str = "stamp_detector/stamp_model.pt",
+    stamp_conf: float = 0.25,
+    dpi: int = 200,
+    save_intermediate: bool = False
+) -> Dict[str, Any]:
+    """
+    Process a PDF file by converting each page to an image and running the pipeline.
+    
+    Args:
+        pdf_path: Path to PDF file
+        output_dir: Directory for output files
+        stamp_model_path: Path to stamp model
+        stamp_conf: Confidence threshold for stamp detection
+        dpi: DPI for PDF to image conversion
+        save_intermediate: Whether to save intermediate results
+        
+    Returns:
+        Combined results dictionary for all pages
+    """
+    pdf_path = Path(pdf_path)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(exist_ok=True)
+    
+    if not pdf_path.exists():
+        raise FileNotFoundError(f"PDF not found: {pdf_path}")
+    
+    if not PDF_SUPPORT:
+        raise ImportError("PyMuPDF is required for PDF processing. Install with: pip install PyMuPDF")
+    
+    print(f"\n{'='*70}")
+    print(f"Processing PDF: {pdf_path.name}")
+    print(f"{'='*70}\n")
+    
+    # Convert PDF to images
+    print(f"📄 Converting PDF pages to images (DPI: {dpi})...")
+    try:
+        page_images = pdf_to_images(str(pdf_path), dpi=dpi)
+        print(f"✓ Converted {len(page_images)} page(s) to images\n")
+    except Exception as e:
+        raise RuntimeError(f"Failed to convert PDF to images: {e}")
+    
+    # Process each page
+    all_pages = []
+    temp_dir = Path(tempfile.mkdtemp())
+    
+    try:
+        for page_num, img in enumerate(page_images, 1):
+            print(f"\n{'='*70}")
+            print(f"Processing Page {page_num}/{len(page_images)}")
+            print(f"{'='*70}\n")
+            
+            # Save temporary image for processing
+            temp_img_path = temp_dir / f"page_{page_num}.jpg"
+            cv2.imwrite(str(temp_img_path), img)
+            
+            # Process the page
+            try:
+                page_result = process_image_pipeline(
+                    str(temp_img_path),
+                    output_dir=output_dir,
+                    stamp_model_path=stamp_model_path,
+                    stamp_conf=stamp_conf,
+                    save_intermediate=save_intermediate
+                )
+                
+                # Add page number to result
+                page_result["page_number"] = page_num
+                page_result["image"] = f"{pdf_path.stem}_page_{page_num}.jpg"
+                all_pages.append(page_result)
+                
+            except Exception as e:
+                print(f"✗ Error processing page {page_num}: {str(e)}")
+                all_pages.append({
+                    "page_number": page_num,
+                    "image": f"{pdf_path.stem}_page_{page_num}.jpg",
+                    "error": str(e)
+                })
+    finally:
+        # Clean up temporary directory
+        import shutil
+        shutil.rmtree(temp_dir, ignore_errors=True)
+    
+    # Create combined summary
+    summary = {
+        "total_pages": len(all_pages),
+        "total_qr_codes": sum(p.get("summary", {}).get("qr_codes", 0) for p in all_pages),
+        "total_signatures": sum(p.get("summary", {}).get("signatures", 0) for p in all_pages),
+        "total_stamps": sum(p.get("summary", {}).get("stamps", 0) for p in all_pages),
+        "total_detections": sum(p.get("summary", {}).get("total", 0) for p in all_pages)
+    }
+    
+    result = {
+        "pdf": pdf_path.name,
+        "pdf_path": str(pdf_path),
+        "summary": summary,
+        "pages": all_pages
+    }
+    
+    print(f"\n{'='*70}")
+    print("PDF PROCESSING COMPLETE")
+    print(f"{'='*70}")
+    print(f"Total Pages:   {summary['total_pages']}")
+    print(f"QR Codes:      {summary['total_qr_codes']}")
+    print(f"Signatures:    {summary['total_signatures']}")
+    print(f"Stamps:        {summary['total_stamps']}")
+    print(f"Total:         {summary['total_detections']}")
+    print(f"{'='*70}\n")
+    
+    return result
+
+
+def process_image_pipeline(
+    image_path: str,
+    output_dir: str = "pipeline_outputs",
+    qr_model_path: Optional[str] = None,
+    signature_model_path: Optional[str] = None,
+    stamp_model_path: str = "stamp_detector/stamp_model.pt",
+    stamp_conf: float = 0.25,
+    save_intermediate: bool = False
+) -> Dict[str, Any]:
+    """
+    Process a single image through all three detection models.
+    
+    Args:
+        image_path: Path to input image
+        output_dir: Directory for output files
+        qr_model_path: Path to QR model (not used, kept for compatibility)
+        signature_model_path: Path to signature model (optional)
+        stamp_model_path: Path to stamp model
+        stamp_conf: Confidence threshold for stamp detection
+        save_intermediate: Whether to save intermediate results
+        
+    Returns:
+        Combined results dictionary
+    """
+    image_path = Path(image_path)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(exist_ok=True)
+    
+    if not image_path.exists():
+        raise FileNotFoundError(f"Image not found: {image_path}")
+    
+    print(f"\n{'='*70}")
+    print(f"Processing: {image_path.name}")
+    print(f"{'='*70}\n")
+    
+    # Get image dimensions once (will be used to consolidate)
+    img_sample = cv2.imread(str(image_path))
+    if img_sample is None:
+        raise ValueError(f"Could not read image: {image_path}")
+    img_height, img_width = img_sample.shape[:2]
+    
+    # Initialize result structure with consolidated image info
+    result = {
+        "image": image_path.name,
+        "image_dimensions": {
+            "width": img_width,
+            "height": img_height
+        },
+        "qr_codes": [],
+        "signatures": [],
+        "stamps": []
+    }
+    
+    # Step 1: QR Code Detection
+    print("🔷 Step 1/3: QR Code Detection")
+    print("-" * 70)
+    try:
+        qr_result = process_qr(str(image_path))
+        
+        if qr_result and qr_result.get("qr_codes", {}).get("items"):
+            result["qr_codes"] = qr_result["qr_codes"]["items"]
+            print(f"✓ Found {len(result['qr_codes'])} QR code(s)")
+        else:
+            print("✓ No QR codes detected")
+    except Exception as e:
+        print(f"✗ Error in QR detection: {str(e)}")
+        result["qr_error"] = str(e)
+    
+    # Step 2: Signature Detection
+    print(f"\n🔷 Step 2/3: Signature Detection")
+    print("-" * 70)
+    try:
+        sig_result = detect_signatures(
+            str(image_path),
+            model=None,  # Will auto-load
+            output_dir=None,  # Don't save
+            signatures_dir=None,  # Don't save
+            save_crops=False  # Don't save crops
+        )
+        
+        if sig_result and sig_result.get("signatures"):
+            # Clean up signature items (remove cropped_path if present, keep only essential data)
+            cleaned_signatures = []
+            for sig in sig_result["signatures"]:
+                cleaned_sig = {
+                    "id": sig.get("signature_id"),
+                    "confidence": sig.get("confidence"),
+                    "bbox": sig.get("bbox")
+                }
+                cleaned_signatures.append(cleaned_sig)
+            result["signatures"] = cleaned_signatures
+            print(f"✓ Found {len(result['signatures'])} signature(s)")
+        else:
+            print("✓ No signatures detected")
+    except Exception as e:
+        print(f"✗ Error in signature detection: {str(e)}")
+        result["signature_error"] = str(e)
+    
+    # Step 3: Stamp Detection
+    print(f"\n🔷 Step 3/3: Stamp Detection")
+    print("-" * 70)
+    try:
+        if not Path(stamp_model_path).exists():
+            raise FileNotFoundError(f"Stamp model not found: {stamp_model_path}")
+        
+        stamp_result = detect_stamps_no_save(
+            str(image_path),
+            model_path=stamp_model_path,
+            conf=stamp_conf
+        )
+        
+        if stamp_result and stamp_result.get("detections"):
+            # Clean up stamp items (keep only essential data, remove normalized bbox)
+            cleaned_stamps = []
+            for stamp in stamp_result["detections"]:
+                cleaned_stamp = {
+                    "confidence": stamp.get("confidence"),
+                    "bbox": stamp.get("bbox")
+                }
+                cleaned_stamps.append(cleaned_stamp)
+            result["stamps"] = cleaned_stamps
+            print(f"✓ Found {len(result['stamps'])} stamp(s)")
+        else:
+            print("✓ No stamps detected")
+    except Exception as e:
+        print(f"✗ Error in stamp detection: {str(e)}")
+        result["stamp_error"] = str(e)
+    
+    # Create summary
+    result["summary"] = {
+        "qr_codes": len(result.get("qr_codes", [])),
+        "signatures": len(result.get("signatures", [])),
+        "stamps": len(result.get("stamps", [])),
+        "total": len(result.get("qr_codes", [])) + len(result.get("signatures", [])) + len(result.get("stamps", []))
+    }
+    
+    print(f"\n{'='*70}")
+    print("SUMMARY")
+    print(f"{'='*70}")
+    print(f"QR Codes:      {result['summary']['qr_codes']}")
+    print(f"Signatures:    {result['summary']['signatures']}")
+    print(f"Stamps:        {result['summary']['stamps']}")
+    print(f"Total:         {result['summary']['total']}")
+    print(f"{'='*70}\n")
+    
+    return result
+
+
+def process_folder_pipeline(
+    input_folder: str,
+    output_dir: str = "pipeline_outputs",
+    stamp_model_path: str = "stamp_detector/stamp_model.pt",
+    stamp_conf: float = 0.25,
+    save_intermediate: bool = False
+) -> Dict[str, Any]:
+    """
+    Process all images in a folder through the pipeline.
+    
+    Args:
+        input_folder: Folder containing input images
+        output_dir: Directory for output files
+        stamp_model_path: Path to stamp model
+        stamp_conf: Confidence threshold for stamp detection
+        save_intermediate: Whether to save intermediate results
+        
+    Returns:
+        Combined results for all images
+    """
+    input_folder = Path(input_folder)
+    if not input_folder.exists():
+        raise FileNotFoundError(f"Input folder not found: {input_folder}")
+    
+    # Supported image formats
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif', '.webp'}
+    image_files = [f for f in input_folder.iterdir()
+                   if f.is_file() and f.suffix.lower() in image_extensions]
+    
+    if not image_files:
+        print(f"No image files found in '{input_folder}'")
+        return {"images": [], "summary": {}}
+    
+    print(f"\n{'='*70}")
+    print(f"Found {len(image_files)} image(s) to process")
+    print(f"{'='*70}\n")
+    
+    all_results = []
+    for i, image_file in enumerate(image_files, 1):
+        print(f"\n[{i}/{len(image_files)}]")
+        try:
+            result = process_image_pipeline(
+                str(image_file),
+                output_dir=output_dir,
+                stamp_model_path=stamp_model_path,
+                stamp_conf=stamp_conf,
+                save_intermediate=save_intermediate
+            )
+            all_results.append(result)
+        except Exception as e:
+            print(f"✗ Error processing {image_file.name}: {str(e)}")
+            all_results.append({
+                "image": image_file.name,
+                "image_path": str(image_file),
+                "error": str(e)
+            })
+    
+    # Create summary
+    summary = {
+        "total_images": len(all_results),
+        "total_qr_codes": sum(r.get("summary", {}).get("qr_codes", 0) for r in all_results),
+        "total_signatures": sum(r.get("summary", {}).get("signatures", 0) for r in all_results),
+        "total_stamps": sum(r.get("summary", {}).get("stamps", 0) for r in all_results),
+        "total_detections": sum(r.get("summary", {}).get("total", 0) for r in all_results)
+    }
+    
+    final_result = {
+        "summary": summary,
+        "images": all_results
+    }
+    
+    # Save combined JSON
+    output_dir = Path(output_dir)
+    output_dir.mkdir(exist_ok=True)
+    json_path = output_dir / "pipeline_results.json"
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(final_result, f, indent=2, ensure_ascii=False)
+    
+    print(f"\n{'='*70}")
+    print("PIPELINE COMPLETE")
+    print(f"{'='*70}")
+    print(f"Processed:     {summary['total_images']} image(s)")
+    print(f"QR Codes:      {summary['total_qr_codes']}")
+    print(f"Signatures:    {summary['total_signatures']}")
+    print(f"Stamps:        {summary['total_stamps']}")
+    print(f"Total:         {summary['total_detections']}")
+    print(f"\nResults saved to: {json_path}")
+    print(f"{'='*70}\n")
+    
+    return final_result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Unified pipeline for QR code, signature, and stamp detection"
+    )
+    parser.add_argument(
+        "input",
+        help="Input image file, PDF file, or folder containing images"
+    )
+    parser.add_argument(
+        "--output",
+        default="pipeline_outputs",
+        help="Output directory (default: pipeline_outputs)"
+    )
+    parser.add_argument(
+        "--stamp-model",
+        default="stamp_detector/stamp_model.pt",
+        help="Path to stamp model (default: stamp_detector/stamp_model.pt)"
+    )
+    parser.add_argument(
+        "--stamp-conf",
+        type=float,
+        default=0.25,
+        help="Confidence threshold for stamp detection (default: 0.25)"
+    )
+    parser.add_argument(
+        "--save-intermediate",
+        action="store_true",
+        help="Save intermediate results from each detection step"
+    )
+    
+    parser.add_argument(
+        "--dpi",
+        type=int,
+        default=200,
+        help="DPI for PDF to image conversion (default: 200)"
+    )
+    
+    args = parser.parse_args()
+    
+    input_path = Path(args.input)
+    
+    if input_path.is_file():
+        # Check if it's a PDF
+        if input_path.suffix.lower() == '.pdf':
+            if not PDF_SUPPORT:
+                print("Error: PyMuPDF is required for PDF processing.")
+                print("Install with: pip install PyMuPDF")
+                sys.exit(1)
+            
+            # Process PDF
+            result = process_pdf_pipeline(
+                str(input_path),
+                output_dir=args.output,
+                stamp_model_path=args.stamp_model,
+                stamp_conf=args.stamp_conf,
+                dpi=args.dpi,
+                save_intermediate=args.save_intermediate
+            )
+            
+            # Save JSON
+            output_dir = Path(args.output)
+            output_dir.mkdir(exist_ok=True)
+            json_path = output_dir / f"{input_path.stem}_pipeline_result.json"
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+            print(f"Results saved to: {json_path}")
+            
+        else:
+            # Process single image
+            result = process_image_pipeline(
+                str(input_path),
+                output_dir=args.output,
+                stamp_model_path=args.stamp_model,
+                stamp_conf=args.stamp_conf,
+                save_intermediate=args.save_intermediate
+            )
+            
+            # Save JSON
+            output_dir = Path(args.output)
+            output_dir.mkdir(exist_ok=True)
+            json_path = output_dir / f"{input_path.stem}_pipeline_result.json"
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+            print(f"Results saved to: {json_path}")
+        
+    elif input_path.is_dir():
+        # Process folder
+        process_folder_pipeline(
+            str(input_path),
+            output_dir=args.output,
+            stamp_model_path=args.stamp_model,
+            stamp_conf=args.stamp_conf,
+            save_intermediate=args.save_intermediate
+        )
+    else:
+        print(f"Error: '{args.input}' is not a valid file or directory")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+

pipeline_outputs/docs_pipeline_result.json

@@ -1,101 +0,0 @@
-{
-  "pdf": "docs.pdf",
-  "pdf_path": "documents/docs.pdf",
-  "summary": {
-    "total_pages": 3,
-    "total_qr_codes": 0,
-    "total_signatures": 1,
-    "total_stamps": 2,
-    "total_detections": 3
-  },
-  "pages": [
-    {
-      "image": "docs_page_1.jpg",
-      "image_dimensions": {
-        "width": 3306,
-        "height": 4678
-      },
-      "qr_codes": [],
-      "signatures": [
-        {
-          "id": 1,
-          "confidence": 0.5241817831993103,
-          "bbox": {
-            "x1": 1187.189453125,
-            "y1": 2745.45556640625,
-            "x2": 1849.0565185546875,
-            "y2": 3305.53076171875,
-            "width": 661.8670654296875,
-            "height": 560.0751953125
-          }
-        }
-      ],
-      "stamps": [
-        {
-          "confidence": 0.7363,
-          "bbox": {
-            "x1": 1520,
-            "y1": 2700,
-            "x2": 2166,
-            "y2": 3358,
-            "width": 646,
-            "height": 658
-          }
-        }
-      ],
-      "summary": {
-        "qr_codes": 0,
-        "signatures": 1,
-        "stamps": 1,
-        "total": 2
-      },
-      "page_number": 1
-    },
-    {
-      "image": "docs_page_2.jpg",
-      "image_dimensions": {
-        "width": 3306,
-        "height": 4678
-      },
-      "qr_codes": [],
-      "signatures": [],
-      "stamps": [],
-      "summary": {
-        "qr_codes": 0,
-        "signatures": 0,
-        "stamps": 0,
-        "total": 0
-      },
-      "page_number": 2
-    },
-    {
-      "image": "docs_page_3.jpg",
-      "image_dimensions": {
-        "width": 3306,
-        "height": 4678
-      },
-      "qr_codes": [],
-      "signatures": [],
-      "stamps": [
-        {
-          "confidence": 0.7546,
-          "bbox": {
-            "x1": 1889,
-            "y1": 3896,
-            "x2": 2531,
-            "y2": 4540,
-            "width": 642,
-            "height": 644
-          }
-        }
-      ],
-      "summary": {
-        "qr_codes": 0,
-        "signatures": 0,
-        "stamps": 1,
-        "total": 1
-      },
-      "page_number": 3
-    }
-  ]
-}

qr/qr_extraction.py

@@ -0,0 +1,375 @@
+"""Extract QR codes from images and save labeled images and JSON data."""
+# ----------------------------------------------
+# --- Author         : Ahmet Ozlu
+# --- Mail           : ahmetozlu93@gmail.com
+# --- Date           : 17th September 2018
+# --- Modified       : QR code extraction only
+# ----------------------------------------------
+
+import cv2
+import numpy as np
+import json
+import os
+from pathlib import Path
+
+
+def detect_qr_codes(img_original):
+    """
+    Detect QR codes in an image using multiple preprocessing approaches.
+
+    Parameters:
+    -----------
+    img_original : numpy.ndarray
+        Original BGR image
+
+    Returns:
+    --------
+    list
+        List of QR code dictionaries with 'x', 'y', 'width', 'height', 'data', 'points'
+    """
+    qr_detector = cv2.QRCodeDetector()
+    qr_codes = []
+    seen_qr_boxes = set()
+
+    def add_qr_code(qr_points, info, seen_set):
+        """Helper function to add QR code if not already detected"""
+        if qr_points is None or len(qr_points) == 0:
+            return False
+
+        qr_points = qr_points.astype(int)
+        x_coords = qr_points[:, 0]
+        y_coords = qr_points[:, 1]
+        x_min, x_max = int(x_coords.min()), int(x_coords.max())
+        y_min, y_max = int(y_coords.min()), int(y_coords.max())
+
+        # Check if we've already detected this QR code (within 10 pixels tolerance)
+        box_key = (x_min // 10, y_min // 10, x_max // 10, y_max // 10)
+        if box_key in seen_set:
+            return False
+
+        seen_set.add(box_key)
+        qr_codes.append({
+            'x': x_min,
+            'y': y_min,
+            'width': x_max - x_min,
+            'height': y_max - y_min,
+            'data': info if info else '',
+            'points': qr_points.tolist()
+        })
+        return True
+
+    # Try multiple preprocessing approaches for better QR code detection
+    test_images = [("original", img_original)]
+    gray = cv2.cvtColor(img_original, cv2.COLOR_BGR2GRAY)
+    test_images.append(("grayscale", gray))
+
+    # Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    gray_clahe = clahe.apply(gray)
+    test_images.append(("clahe", gray_clahe))
+
+    # Add thresholded versions
+    _, thresh1 = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+    _, thresh2 = cv2.threshold(
+        gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    test_images.append(("binary", thresh1))
+    test_images.append(("otsu", thresh2))
+
+    # Add inverted versions (QR codes might be white on black)
+    test_images.append(("inverted", cv2.bitwise_not(gray)))
+    test_images.append(("inverted_clahe", cv2.bitwise_not(gray_clahe)))
+
+    # Try detection on each preprocessed image
+    for img_name, test_img in test_images:
+        if len(qr_codes) > 0:
+            print(f"  QR code detected using: {img_name}")
+            break  # Stop if we found QR codes
+
+        # Ensure image is in correct format (3-channel for color, 1-channel for grayscale)
+        if len(test_img.shape) == 2:
+            # Grayscale - convert to 3-channel for detection
+            test_img_3ch = cv2.cvtColor(test_img, cv2.COLOR_GRAY2BGR)
+        else:
+            test_img_3ch = test_img
+
+        # Try detectAndDecodeMulti first (for multiple QR codes)
+        try:
+            retval, decoded_info, points, straight_qrcode = qr_detector.detectAndDecodeMulti(
+                test_img_3ch)
+
+            if retval and points is not None:
+                # Handle both single and multiple QR codes
+                if isinstance(decoded_info, str):
+                    decoded_info = [decoded_info]
+                    points = [points]
+
+                for info, qr_points in zip(decoded_info, points):
+                    if add_qr_code(qr_points, info, seen_qr_boxes):
+                        print(f"  QR code detected using: {img_name} (multi)")
+        except Exception as e:
+            pass
+
+        # Try single QR code detection as fallback
+        if len(qr_codes) == 0:
+            try:
+                retval, decoded_info, points, straight_qrcode = qr_detector.detectAndDecode(
+                    test_img_3ch)
+                if retval and points is not None and len(points) > 0:
+                    if add_qr_code(points, decoded_info, seen_qr_boxes):
+                        print(f"  QR code detected using: {img_name} (single)")
+            except Exception as e:
+                pass
+
+    return qr_codes
+
+
+def process_image_no_save(input_path):
+    """
+    Process a single image and detect QR codes without saving images or JSON files.
+
+    Parameters:
+    -----------
+    input_path : str
+        Path to input image
+
+    Returns:
+    --------
+    dict
+        Dictionary with detection results (no files saved)
+    """
+    # Read the input image
+    img_original = cv2.imread(input_path)
+    if img_original is None:
+        print(f"Error: Could not read image {input_path}")
+        return None
+
+    # Detect QR codes
+    qr_codes = detect_qr_codes(img_original)
+
+    # Prepare QR codes for JSON
+    qr_codes_json = []
+    for i, qr in enumerate(qr_codes):
+        qr_json = {
+            "id": i + 1,
+            "x": qr['x'],
+            "y": qr['y'],
+            "width": qr['width'],
+            "height": qr['height'],
+            "data": qr['data']
+        }
+        # Optionally include corner points if needed
+        if 'points' in qr and len(qr['points']) > 0:
+            qr_json['corner_points'] = qr['points']
+        qr_codes_json.append(qr_json)
+
+    # Create output JSON structure
+    output_json = {
+        "image": Path(input_path).name,
+        "image_dimensions": {
+            "width": img_original.shape[1],
+            "height": img_original.shape[0]
+        },
+        "qr_codes": {
+            "count": len(qr_codes_json),
+            "items": qr_codes_json
+        }
+    }
+
+    return output_json
+
+
+def process_image(input_path, output_folder='labelled', json_folder='outputs'):
+    """
+    Process a single image and detect QR codes.
+
+    Parameters:
+    -----------
+    input_path : str
+        Path to input image
+    output_folder : str
+        Folder to save labeled images
+    json_folder : str
+        Folder to save JSON files
+
+    Returns:
+    --------
+    dict
+        Dictionary with detection results
+    """
+    # Get filename without extension
+    filename = Path(input_path).stem
+    file_ext = Path(input_path).suffix
+
+    print(f"\n{'='*60}")
+    print(f"Processing: {Path(input_path).name}")
+    print(f"{'='*60}")
+
+    # Read the input image
+    img_original = cv2.imread(input_path)
+    if img_original is None:
+        print(f"Error: Could not read image {input_path}")
+        return None
+
+    # Detect QR codes
+    qr_codes = detect_qr_codes(img_original)
+
+    print(f"Found {len(qr_codes)} QR code(s)")
+
+    # Create labeled image
+    labeled_img = img_original.copy()
+
+    # Draw QR codes in blue color
+    for i, qr in enumerate(qr_codes):
+        # Draw bounding box
+        cv2.rectangle(labeled_img, (qr['x'], qr['y']),
+                      (qr['x'] + qr['width'], qr['y'] + qr['height']),
+                      (255, 0, 0), 2)  # Blue color (BGR format)
+
+        # Draw QR code points/polygon
+        if len(qr['points']) >= 4:
+            pts = np.array(qr['points'], np.int32)
+            cv2.polylines(labeled_img, [pts], True, (255, 0, 0), 2)
+
+        # Add label
+        cv2.putText(labeled_img, f"QR {i+1}", (qr['x'], qr['y'] - 5),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
+
+        # Add QR data text (if not too long)
+        if qr['data'] and len(qr['data']) < 50:
+            cv2.putText(labeled_img, qr['data'][:30],
+                        (qr['x'], qr['y'] + qr['height'] + 20),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+
+    # Create output folders
+    os.makedirs(output_folder, exist_ok=True)
+    os.makedirs(json_folder, exist_ok=True)
+
+    # Save labeled image
+    output_image_path = os.path.join(
+        output_folder, f'qr_labelled_{filename}{file_ext}')
+    cv2.imwrite(output_image_path, labeled_img)
+
+    # Prepare QR codes for JSON
+    qr_codes_json = []
+    for i, qr in enumerate(qr_codes):
+        qr_json = {
+            "id": i + 1,
+            "x": qr['x'],
+            "y": qr['y'],
+            "width": qr['width'],
+            "height": qr['height'],
+            "data": qr['data']
+        }
+        # Optionally include corner points if needed
+        if 'points' in qr and len(qr['points']) > 0:
+            qr_json['corner_points'] = qr['points']
+        qr_codes_json.append(qr_json)
+
+    # Create output JSON
+    output_json = {
+        "image": Path(input_path).name,
+        "image_dimensions": {
+            "width": img_original.shape[1],
+            "height": img_original.shape[0]
+        },
+        "qr_codes": {
+            "count": len(qr_codes_json),
+            "items": qr_codes_json
+        }
+    }
+
+    # Save JSON
+    output_json_path = os.path.join(
+        json_folder, f'qr_detection_{filename}.json')
+    with open(output_json_path, 'w') as f:
+        json.dump(output_json, f, indent=2)
+
+    # Print summary
+    print(f"✓ Found {len(qr_codes_json)} QR code(s)")
+    print(f"✓ Labeled image saved: {output_image_path}")
+    print(f"✓ Detection data saved: {output_json_path}")
+
+    return output_json
+
+
+def process_folder(input_folder='inputs', output_folder='labelled', json_folder='outputs'):
+    """
+    Process all images in the input folder.
+
+    Parameters:
+    -----------
+    input_folder : str
+        Folder containing input images
+    output_folder : str
+        Folder to save labeled images
+    json_folder : str
+        Folder to save JSON files
+    """
+    # Create output folders
+    os.makedirs(output_folder, exist_ok=True)
+    os.makedirs(json_folder, exist_ok=True)
+
+    # Supported image formats
+    image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif']
+
+    # Get all image files
+    input_path = Path(input_folder)
+    if not input_path.exists():
+        print(f"Error: Input folder '{input_folder}' does not exist!")
+        return
+
+    image_files = [f for f in input_path.iterdir()
+                   if f.is_file() and f.suffix.lower() in image_extensions]
+
+    if not image_files:
+        print(f"No image files found in '{input_folder}'")
+        return
+
+    print(f"\n{'='*60}")
+    print(f"Found {len(image_files)} image(s) to process")
+    print(f"{'='*60}\n")
+
+    # Process each image
+    all_results = []
+    for i, image_file in enumerate(image_files, 1):
+        print(f"\n[{i}/{len(image_files)}] Processing: {image_file.name}")
+        try:
+            result = process_image(
+                str(image_file),
+                output_folder=output_folder,
+                json_folder=json_folder
+            )
+            if result:
+                all_results.append(result)
+        except Exception as e:
+            print(f"✗ Error processing {image_file.name}: {str(e)}")
+            continue
+
+    # Save summary JSON with all results
+    if all_results:
+        summary_path = os.path.join(json_folder, 'qr_detection_summary.json')
+        summary = {
+            "total_images": len(all_results),
+            "total_qr_codes": sum(r['qr_codes']['count'] for r in all_results),
+            "images": all_results
+        }
+        with open(summary_path, 'w') as f:
+            json.dump(summary, f, indent=2)
+
+        print(f"\n{'='*60}")
+        print(f"PROCESSING COMPLETE")
+        print(f"{'='*60}")
+        print(f"✓ Processed {len(all_results)} image(s)")
+        print(f"✓ Total QR codes detected: {summary['total_qr_codes']}")
+        print(f"✓ Summary saved: {summary_path}")
+        print(f"✓ Labeled images saved in: {output_folder}/")
+        print(f"✓ JSON files saved in: {json_folder}/")
+
+
+if __name__ == "__main__":
+    # Process all images in the 'inputs' folder
+    process_folder(
+        input_folder='inputs',
+        output_folder='labelled',
+        json_folder='outputs'
+    )

requirements.txt

@@ -0,0 +1,19 @@
+# Core dependencies
+opencv-python>=4.5.0
+numpy>=1.21.0
+
+# ML/AI models
+ultralytics>=8.0.0
+supervision
+huggingface_hub
+
+# PDF processing
+PyMuPDF>=1.23.0
+
+# API
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+httpx>=0.25.0
+boto3>=1.28.0
+

signature/README.md

@@ -0,0 +1,118 @@
+# YOLOv8 Signature Detector
+
+This repository implements signature detection using the YOLOv8s model from [tech4humans/yolov8s-signature-detector](https://huggingface.co/tech4humans/yolov8s-signature-detector).
+
+## Setup
+
+Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Authentication
+
+The model repository is gated and requires Hugging Face authentication. You need to:
+
+1. **Login via CLI** (recommended):
+   ```bash
+   huggingface-cli login
+   ```
+   Enter your Hugging Face token when prompted. Get your token from [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+
+2. **Or set environment variable**:
+   ```bash
+   export HF_TOKEN=your_token_here
+   ```
+
+3. **Or manually download the model**:
+   ```bash
+   huggingface-cli download tech4humans/yolov8s-signature-detector yolov8s.pt
+   ```
+   Then place `yolov8s.pt` in the project root directory.
+
+## Usage
+
+### Python Script
+
+Process all images in the `inputs/` directory:
+
+```bash
+python inference.py
+```
+
+The script will:
+1. Check for a local `yolov8s.pt` file first
+2. If not found, download the model from Hugging Face (requires authentication)
+3. Process all images in the `inputs/` directory
+4. Save annotated images with detected signatures to the `outputs/` directory
+5. **Save signature coordinates to `outputs/signature_coordinates.json`**
+6. **Crop and save individual signatures to `outputs/signatures/` directory**
+
+### CLI (Alternative)
+
+You can also use the Ultralytics CLI:
+
+```bash
+huggingface-cli download tech4humans/yolov8s-signature-detector yolov8s.pt
+yolo predict model=yolov8s.pt source=inputs/
+```
+
+## Model Formats
+
+The model is available in multiple formats:
+- `yolov8s.pt` (PyTorch format) - used by default
+- `yolov8s.onnx` (ONNX format) - for ONNX Runtime
+- `yolov8s.engine` (TensorRT format) - for TensorRT inference
+
+## Output
+
+The script generates several outputs:
+
+1. **Annotated images**: Images with bounding boxes around detected signatures saved to `outputs/` with the prefix `detected_`
+2. **Signature coordinates JSON**: All detection coordinates saved to `outputs/signature_coordinates.json` with the following structure:
+   ```json
+   [
+     {
+       "image": "image1.jpg",
+       "image_width": 1920,
+       "image_height": 1080,
+       "signatures": [
+         {
+           "signature_id": 1,
+           "confidence": 0.95,
+           "bbox": {
+             "x1": 100.5,
+             "y1": 200.3,
+             "x2": 300.7,
+             "y2": 400.9,
+             "width": 200.2,
+             "height": 200.6
+           },
+           "class_id": 0,
+           "cropped_path": "outputs/signatures/image1_signature_1.jpg"
+         }
+       ]
+     }
+   ]
+   ```
+   
+   The `image_width` and `image_height` fields allow the frontend to properly scale coordinates when displaying images at different sizes. Coordinates are in pixels relative to the original image dimensions.
+3. **Cropped signatures**: Individual signature images saved to `outputs/signatures/` directory
+
+## Extracting Signatures from Coordinates
+
+If you need to re-extract signatures using the saved coordinates, use the helper script:
+
+```bash
+python extract_signatures.py
+```
+
+Or specify a custom JSON file:
+
+```bash
+python extract_signatures.py outputs/signature_coordinates.json
+```
+
+This is useful if you want to extract signatures again without running inference, or if you need to adjust the extraction parameters.
+

signature/extract_signatures.py

@@ -0,0 +1,79 @@
+"""
+Helper script to extract signatures from images using saved coordinates.
+This script can be used to re-extract signatures from the JSON coordinates file.
+"""
+
+import json
+import cv2
+from pathlib import Path
+
+def extract_signatures_from_json(json_path="outputs/signature_coordinates.json", 
+                                  input_dir="inputs",
+                                  output_dir="outputs/extracted_signatures"):
+    """
+    Extract signatures from images using saved coordinates in JSON file.
+    
+    Args:
+        json_path: Path to the JSON file with coordinates
+        input_dir: Directory containing original images
+        output_dir: Directory to save extracted signatures
+    """
+    # Load coordinates
+    with open(json_path, 'r') as f:
+        all_detections = json.load(f)
+    
+    # Create output directory
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    input_path = Path(input_dir)
+    
+    print(f"Loaded coordinates for {len(all_detections)} image(s)")
+    
+    for image_data in all_detections:
+        image_name = image_data["image"]
+        image_file = input_path / image_name
+        
+        if not image_file.exists():
+            print(f"Warning: Image {image_name} not found, skipping...")
+            continue
+        
+        # Read image
+        image = cv2.imread(str(image_file))
+        if image is None:
+            print(f"Error: Could not read {image_name}, skipping...")
+            continue
+        
+        print(f"\nProcessing: {image_name}")
+        print(f"  Found {len(image_data['signatures'])} signature(s)")
+        
+        # Extract each signature
+        for sig_data in image_data["signatures"]:
+            sig_id = sig_data["signature_id"]
+            bbox = sig_data["bbox"]
+            
+            # Get coordinates
+            x1, y1, x2, y2 = int(bbox["x1"]), int(bbox["y1"]), int(bbox["x2"]), int(bbox["y2"])
+            
+            # Ensure coordinates are within image bounds
+            x1 = max(0, x1)
+            y1 = max(0, y1)
+            x2 = min(image.shape[1], x2)
+            y2 = min(image.shape[0], y2)
+            
+            # Crop signature
+            signature_crop = image[y1:y2, x1:x2]
+            
+            # Save cropped signature
+            output_filename = f"{Path(image_name).stem}_signature_{sig_id}.jpg"
+            output_file = output_path / output_filename
+            cv2.imwrite(str(output_file), signature_crop)
+            
+            print(f"    Signature {sig_id}: confidence={sig_data['confidence']:.2f}, saved to {output_file}")
+
+if __name__ == "__main__":
+    import sys
+    
+    json_path = sys.argv[1] if len(sys.argv) > 1 else "outputs/signature_coordinates.json"
+    extract_signatures_from_json(json_path)
+

signature/inference.py

@@ -0,0 +1,247 @@
+import cv2
+import os
+import sys
+import json
+import supervision as sv
+from huggingface_hub import hf_hub_download, login
+from ultralytics import YOLO
+from pathlib import Path
+
+
+def detect_signatures(image_path, model=None, output_dir=None, signatures_dir=None, save_crops=True):
+    """
+    Detect signatures in a single image.
+
+    Args:
+        image_path: Path to the input image
+        model: YOLO model instance (if None, will load/create one)
+        output_dir: Directory for output files (optional)
+        signatures_dir: Directory for cropped signatures (optional)
+        save_crops: Whether to save cropped signature images
+
+    Returns:
+        dict: Detection results with structure:
+            {
+                "image": image_filename,
+                "image_width": int,
+                "image_height": int,
+                "signatures": [...]
+            }
+    """
+    # Load model if not provided
+    if model is None:
+        local_model_path = Path("yolov8s.pt")
+        if local_model_path.exists():
+            model_path = str(local_model_path)
+        else:
+            try:
+                model_path = hf_hub_download(
+                    repo_id="tech4humans/yolov8s-signature-detector",
+                    filename="yolov8s.pt"
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to load signature model: {e}")
+        model = YOLO(model_path)
+
+    # Set up paths (only if we need to save crops)
+    image_file = Path(image_path)
+    if save_crops:
+        if output_dir is None:
+            output_dir = Path("outputs")
+        else:
+            output_dir = Path(output_dir)
+        output_dir.mkdir(exist_ok=True)
+
+        if signatures_dir is None:
+            signatures_dir = output_dir / "signatures"
+        else:
+            signatures_dir = Path(signatures_dir)
+        signatures_dir.mkdir(exist_ok=True)
+    else:
+        # Dummy paths when not saving
+        output_dir = None
+        signatures_dir = None
+
+    # Read image
+    image = cv2.imread(str(image_path))
+    if image is None:
+        raise ValueError(f"Could not read image: {image_path}")
+
+    # Get image dimensions
+    image_height, image_width = image.shape[:2]
+
+    # Run inference
+    results = model(str(image_path))
+    detections = sv.Detections.from_ultralytics(results[0])
+
+    # Store detection data
+    image_detections = {
+        "image": image_file.name,
+        "image_width": int(image_width),
+        "image_height": int(image_height),
+        "signatures": []
+    }
+
+    # Process detections
+    if len(detections) > 0:
+        for i, (xyxy, confidence, class_id) in enumerate(zip(
+            detections.xyxy, detections.confidence, detections.class_id
+        )):
+            x1, y1, x2, y2 = xyxy
+
+            # Store detection data
+            detection_data = {
+                "signature_id": i + 1,
+                "confidence": float(confidence),
+                "bbox": {
+                    "x1": float(x1),
+                    "y1": float(y1),
+                    "x2": float(x2),
+                    "y2": float(y2),
+                    "width": float(x2 - x1),
+                    "height": float(y2 - y1)
+                },
+                "class_id": int(class_id)
+            }
+
+            # Crop and save individual signature if requested
+            if save_crops and signatures_dir is not None:
+                x1_int, y1_int, x2_int, y2_int = int(
+                    x1), int(y1), int(x2), int(y2)
+                x1_int = max(0, x1_int)
+                y1_int = max(0, y1_int)
+                x2_int = min(image.shape[1], x2_int)
+                y2_int = min(image.shape[0], y2_int)
+
+                signature_crop = image[y1_int:y2_int, x1_int:x2_int]
+                signature_filename = f"{image_file.stem}_signature_{i+1}.jpg"
+                signature_path = signatures_dir / signature_filename
+                cv2.imwrite(str(signature_path), signature_crop)
+                detection_data["cropped_path"] = str(signature_path)
+
+            image_detections["signatures"].append(detection_data)
+
+    return image_detections
+
+
+def main():
+    # Check if model file exists locally first
+    local_model_path = Path("yolov8s.pt")
+
+    if local_model_path.exists():
+        print(f"Using local model file: {local_model_path}", flush=True)
+        model_path = str(local_model_path)
+    else:
+        # Try to download model from Hugging Face
+        print("Downloading model from Hugging Face...", flush=True)
+        try:
+            model_path = hf_hub_download(
+                repo_id="tech4humans/yolov8s-signature-detector",
+                filename="yolov8s.pt"
+            )
+        except Exception as e:
+            if "401" in str(e) or "GatedRepoError" in str(type(e).__name__) or "Unauthorized" in str(e):
+                print("\n" + "="*70)
+                print("ERROR: Authentication required to access this model.")
+                print("="*70)
+                print(
+                    "\nThis repository is gated and requires Hugging Face authentication.")
+                print("\nTo authenticate, run one of the following:")
+                print("  1. huggingface-cli login")
+                print("  2. Or set your token: export HF_TOKEN=your_token_here")
+                print("\nAfter authentication, run this script again.")
+                print("="*70)
+                sys.exit(1)
+            else:
+                print(f"\nError downloading model: {e}")
+                print("\nYou can also download the model manually:")
+                print(
+                    "  huggingface-cli download tech4humans/yolov8s-signature-detector yolov8s.pt")
+                print("\nOr place yolov8s.pt in the current directory.")
+                sys.exit(1)
+
+    # Load the model
+    print("Loading model...")
+    model = YOLO(model_path)
+
+    # Set up paths
+    input_dir = Path("inputs")
+    output_dir = Path("outputs")
+    signatures_dir = output_dir / "signatures"  # Directory for cropped signatures
+    output_dir.mkdir(exist_ok=True)
+    signatures_dir.mkdir(exist_ok=True)
+
+    # Store all detections for JSON export
+    all_detections = []
+
+    # Get all image files from inputs directory
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'}
+    image_files = [f for f in input_dir.iterdir()
+                   if f.suffix.lower() in image_extensions]
+
+    if not image_files:
+        print(f"No images found in {input_dir}/")
+        return
+
+    print(f"Found {len(image_files)} image(s) to process")
+
+    # Process each image
+    box_annotator = sv.BoxAnnotator()
+
+    for image_file in image_files:
+        print(f"\nProcessing: {image_file.name}")
+
+        try:
+            # Use the reusable function
+            image_detections = detect_signatures(
+                str(image_file),
+                model=model,
+                output_dir=output_dir,
+                signatures_dir=signatures_dir,
+                save_crops=True
+            )
+
+            # Read image for annotation
+            image = cv2.imread(str(image_file))
+            results = model(str(image_file))
+            detections = sv.Detections.from_ultralytics(results[0])
+
+            if len(detections) > 0:
+                print(f"  Found {len(detections)} signature(s)")
+                for i, sig in enumerate(image_detections["signatures"]):
+                    bbox = sig["bbox"]
+                    print(
+                        f"    Signature {i+1}: confidence={sig['confidence']:.2f}, bbox=[{bbox['x1']:.1f}, {bbox['y1']:.1f}, {bbox['x2']:.1f}, {bbox['y2']:.1f}]")
+                    if "cropped_path" in sig:
+                        print(
+                            f"      Saved cropped signature to: {sig['cropped_path']}")
+            else:
+                print("  No signatures detected")
+
+            all_detections.append(image_detections)
+
+            # Annotate image with bounding boxes
+            annotated_image = box_annotator.annotate(
+                scene=image.copy(),
+                detections=detections
+            )
+
+            # Save annotated image
+            output_path = output_dir / f"detected_{image_file.name}"
+            cv2.imwrite(str(output_path), annotated_image)
+            print(f"  Saved annotated image to: {output_path}")
+        except Exception as e:
+            print(f"  Error processing {image_file.name}: {str(e)}")
+            continue
+
+    # Save all coordinates to JSON file
+    json_path = output_dir / "signature_coordinates.json"
+    with open(json_path, 'w') as f:
+        json.dump(all_detections, f, indent=2)
+    print(f"\n{'='*70}")
+    print(f"Saved all signature coordinates to: {json_path}")
+    print(f"{'='*70}")
+
+
+if __name__ == "__main__":
+    main()

signature/requirements.txt

@@ -0,0 +1,5 @@
+ultralytics
+supervision
+huggingface_hub
+opencv-python
+

stamp_detector/README.md

@@ -0,0 +1,121 @@
+# Stamp Detector
+
+Простой инструмент для детекции печатей (stamp) на изображениях с использованием YOLOv8.
+
+## Установка
+
+```bash
+pip install -r requirements.txt
+```
+
+## Использование
+
+### Базовое использование
+
+```bash
+python detect.py path/to/image.jpg
+```
+
+### С кастомным порогом уверенности
+
+```bash
+python detect.py path/to/image.jpg --conf 0.20
+```
+
+### С указанием пути к модели
+
+```bash
+python detect.py path/to/image.jpg --model stamp_model.pt
+```
+
+### С указанием выходного файла
+
+```bash
+python detect.py path/to/image.jpg --output result.jpg
+```
+
+### Сохранение JSON с координатами
+
+```bash
+# Сохранить JSON в output/{имя_файла}_result.json
+python detect.py path/to/image.jpg --json
+
+# Сохранить JSON в указанный файл
+python detect.py path/to/image.jpg --json-output results.json
+```
+
+## Параметры
+
+- `image_path` (обязательный) - путь к входному изображению
+- `--model` - путь к модели (по умолчанию: `stamp_model.pt`)
+- `--output` - путь для сохранения результата (по умолчанию: `output/{имя_файла}_result.jpg`)
+- `--conf` - порог уверенности (по умолчанию: 0.25)
+- `--json` - сохранить JSON с координатами детекций
+- `--json-output` - путь для сохранения JSON файла
+
+## Структура
+
+```
+stamp_detector/
+├── stamp_model.pt      # Обученная модель YOLOv8
+├── detect.py           # Скрипт детекции
+├── requirements.txt    # Зависимости
+└── README.md          # Документация
+```
+
+## Примеры
+
+```bash
+# Детекция с порогом 0.25
+python detect.py image.jpg
+
+# Более чувствительная детекция (ниже порог)
+python detect.py image.jpg --conf 0.15
+
+# Менее чувствительная детекция (выше порог)
+python detect.py image.jpg --conf 0.35
+
+# Детекция с сохранением JSON координат
+python detect.py image.jpg --json
+```
+
+## Формат JSON
+
+При использовании флага `--json` создается JSON файл со следующей структурой:
+
+```json
+{
+  "image_path": "output/image_result.jpg",
+  "image_size": {
+    "width": 1920,
+    "height": 1080
+  },
+  "detections_count": 2,
+  "detections": [
+    {
+      "class": "stamp",
+      "confidence": 0.8542,
+      "bbox": {
+        "x1": 100,
+        "y1": 200,
+        "x2": 300,
+        "y2": 400,
+        "width": 200,
+        "height": 200
+      },
+      "bbox_normalized": {
+        "x1": 0.052083,
+        "y1": 0.185185,
+        "x2": 0.15625,
+        "y2": 0.37037,
+        "width": 0.104167,
+        "height": 0.185185
+      }
+    }
+  ]
+}
+```
+
+- `bbox` - абсолютные координаты в пикселях
+- `bbox_normalized` - нормализованные координаты (0.0 - 1.0) относительно размера изображения
+

stamp_detector/detect.py

@@ -0,0 +1,315 @@
+"""
+Простой скрипт для детекции печатей (stamp)
+Требуется только: модель и изображение
+"""
+import cv2
+import os
+import sys
+import json
+from ultralytics import YOLO
+
+
+def detect_stamps_no_save(image_path, model_path="stamp_model.pt", conf=0.25):
+    """
+    Detect stamps without saving images.
+    
+    Args:
+        image_path: Path to input image
+        model_path: Path to model (or will download from HF Hub if not found)
+        conf: Confidence threshold
+        
+    Returns:
+        dict: Detection results with detections and image_size
+    """
+    # Load model - try to download from HF Hub if not found locally
+    if not os.path.exists(model_path):
+        # Try to download from Hugging Face Hub
+        try:
+            from huggingface_hub import hf_hub_download
+            print(f"Model not found locally, attempting to download from HF Hub...")
+            # You can upload your model to HF Hub and use it here
+            # For now, try the default path in stamp_detector directory
+            default_path = os.path.join("stamp_detector", "stamp_model.pt")
+            if os.path.exists(default_path):
+                model_path = default_path
+            else:
+                raise FileNotFoundError(f"Stamp model not found: {model_path}. Please upload stamp_model.pt to the Space.")
+        except ImportError:
+            raise FileNotFoundError(f"Stamp model not found: {model_path}")
+    
+    model = YOLO(model_path)
+    
+    # Load image
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"Image not found: {image_path}")
+    
+    image = cv2.imread(image_path)
+    if image is None:
+        raise ValueError(f"Could not load image: {image_path}")
+    
+    # Detection
+    results = model(image, conf=conf, verbose=False)
+    
+    # Collect detections
+    detections = []
+    image_height, image_width = image.shape[:2]
+    
+    for result in results:
+        boxes = result.boxes
+        for box in boxes:
+            class_id = int(box.cls[0])
+            confidence = float(box.conf[0])
+            
+            # Filter only stamp (class_id == 0)
+            if class_id == 0 and confidence >= conf:
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                
+                detection = {
+                    "class": "stamp",
+                    "confidence": round(confidence, 4),
+                    "bbox": {
+                        "x1": int(x1),
+                        "y1": int(y1),
+                        "x2": int(x2),
+                        "y2": int(y2),
+                        "width": int(x2 - x1),
+                        "height": int(y2 - y1)
+                    },
+                    "bbox_normalized": {
+                        "x1": round(x1 / image_width, 6),
+                        "y1": round(y1 / image_height, 6),
+                        "x2": round(x2 / image_width, 6),
+                        "y2": round(y2 / image_height, 6),
+                        "width": round((x2 - x1) / image_width, 6),
+                        "height": round((y2 - y1) / image_height, 6)
+                    }
+                }
+                detections.append(detection)
+    
+    return {
+        "image_size": {
+            "width": image_width,
+            "height": image_height
+        },
+        "detections_count": len(detections),
+        "detections": detections
+    }
+
+
+def detect_stamps(image_path, model_path="stamp_model.pt", output_path=None, conf=0.25, return_json=False):
+    """
+    Детектирует печати на изображении
+
+    Args:
+        image_path: путь к входному изображению
+        model_path: путь к модели (по умолчанию: stamp_model.pt)
+        output_path: путь для сохранения результата (если None, создается автоматически)
+        conf: порог уверенности (по умолчанию: 0.25)
+        return_json: если True, возвращает также JSON с координатами
+
+    Returns:
+        если return_json=False: путь к сохраненному изображению
+        если return_json=True: словарь с 'image_path' и 'detections' (JSON структура)
+    """
+    # Загружаем модель
+    if not os.path.exists(model_path):
+        print(f"❌ Ошибка: модель не найдена: {model_path}")
+        sys.exit(1)
+
+    print(f"📥 Загружаю модель: {model_path}")
+    model = YOLO(model_path)
+    print("✅ Модель загружена")
+
+    # Загружаем изображение
+    if not os.path.exists(image_path):
+        print(f"❌ Ошибка: изображение не найдено: {image_path}")
+        sys.exit(1)
+
+    print(f"📷 Загружаю изображение: {image_path}")
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"❌ Ошибка: не удалось загрузить изображение")
+        sys.exit(1)
+
+    # Детекция
+    print(f"🔍 Выполняю детекцию (порог: {conf})...")
+    results = model(image, conf=conf, verbose=False)
+
+    # Собираем детекции и рисуем рамки
+    result_image = image.copy()
+    detections = []
+    image_height, image_width = image.shape[:2]
+
+    for result in results:
+        boxes = result.boxes
+        for box in boxes:
+            class_id = int(box.cls[0])
+            confidence = float(box.conf[0])
+
+            # Фильтруем только stamp (class_id == 0)
+            if class_id == 0 and confidence >= conf:
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+
+                # Сохраняем детекцию в JSON формате
+                detection = {
+                    "class": "stamp",
+                    "confidence": round(confidence, 4),
+                    "bbox": {
+                        "x1": int(x1),
+                        "y1": int(y1),
+                        "x2": int(x2),
+                        "y2": int(y2),
+                        "width": int(x2 - x1),
+                        "height": int(y2 - y1)
+                    },
+                    "bbox_normalized": {
+                        "x1": round(x1 / image_width, 6),
+                        "y1": round(y1 / image_height, 6),
+                        "x2": round(x2 / image_width, 6),
+                        "y2": round(y2 / image_height, 6),
+                        "width": round((x2 - x1) / image_width, 6),
+                        "height": round((y2 - y1) / image_height, 6)
+                    }
+                }
+                detections.append(detection)
+
+                # Рисуем рамку (красная)
+                cv2.rectangle(result_image, (x1, y1), (x2, y2), (0, 0, 255), 2)
+
+                # Подпись
+                label = f"stamp {confidence:.2f}"
+                (label_width, label_height), _ = cv2.getTextSize(
+                    label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2
+                )
+                cv2.rectangle(
+                    result_image,
+                    (x1, y1 - label_height - 10),
+                    (x1 + label_width, y1),
+                    (0, 0, 255),
+                    -1
+                )
+                cv2.putText(
+                    result_image,
+                    label,
+                    (x1, y1 - 5),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (255, 255, 255),
+                    2
+                )
+
+    # Сохраняем результат
+    if output_path is None:
+        base_name = os.path.splitext(os.path.basename(image_path))[0]
+        output_dir = "output"
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"{base_name}_result.jpg")
+
+    cv2.imwrite(output_path, result_image)
+    print(f"✅ Найдено печатей: {len(detections)}")
+    print(f"📁 Результат сохранен: {output_path}")
+
+    # Возвращаем результат
+    if return_json:
+        result_data = {
+            "image_path": output_path,
+            "image_size": {
+                "width": image_width,
+                "height": image_height
+            },
+            "detections_count": len(detections),
+            "detections": detections
+        }
+        return result_data
+    else:
+        return output_path
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Детекция печатей на изображениях")
+    parser.add_argument("image_path", help="Путь к изображению")
+    parser.add_argument(
+        "--model",
+        default="stamp_model.pt",
+        help="Путь к модели (по умолчанию: stamp_model.pt)"
+    )
+    parser.add_argument(
+        "--output",
+        default=None,
+        help="Путь для сохранения результата (по умолчанию: output/{имя_файла}_result.jpg)"
+    )
+    parser.add_argument(
+        "--conf",
+        type=float,
+        default=0.25,
+        help="Порог уверенности (по умолчанию: 0.25)"
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Сохранить JSON с координатами детекций"
+    )
+    parser.add_argument(
+        "--json-output",
+        default=None,
+        help="Путь для сохранения JSON файла (по умолчанию: output/{имя_файла}_result.json)"
+    )
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("🔍 Детекция печатей (stamp)")
+    print("=" * 60)
+
+    result = detect_stamps(
+        args.image_path,
+        args.model,
+        args.output,
+        args.conf,
+        return_json=args.json or args.json_output is not None
+    )
+
+    # Сохраняем JSON если нужно
+    if args.json or args.json_output is not None:
+        if isinstance(result, dict):
+            json_data = {
+                "image_path": result["image_path"],
+                "image_size": result["image_size"],
+                "detections_count": result["detections_count"],
+                "detections": result["detections"]
+            }
+        else:
+            # Если result - это путь, нужно пересчитать
+            result = detect_stamps(
+                args.image_path,
+                args.model,
+                args.output,
+                args.conf,
+                return_json=True
+            )
+            json_data = {
+                "image_path": result["image_path"],
+                "image_size": result["image_size"],
+                "detections_count": result["detections_count"],
+                "detections": result["detections"]
+            }
+
+        # Определяем путь для JSON
+        if args.json_output:
+            json_path = args.json_output
+        else:
+            base_name = os.path.splitext(os.path.basename(args.image_path))[0]
+            output_dir = "output"
+            os.makedirs(output_dir, exist_ok=True)
+            json_path = os.path.join(output_dir, f"{base_name}_result.json")
+
+        # Сохраняем JSON
+        with open(json_path, "w", encoding="utf-8") as f:
+            json.dump(json_data, f, indent=2, ensure_ascii=False)
+
+        print(f"📄 JSON сохранен: {json_path}")
+
+    print("=" * 60)

stamp_detector/requirements.txt

@@ -0,0 +1,4 @@
+ultralytics>=8.0.0
+opencv-python>=4.5.0
+numpy>=1.21.0
+

upload_model.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""
+Script to upload stamp_model.pt to Hugging Face Space.
+Run this after the Space is created to upload the model file.
+"""
+from huggingface_hub import HfApi, login
+from pathlib import Path
+
+# Login (will prompt for token if not already logged in)
+# Or set HF_TOKEN environment variable
+login()
+
+api = HfApi()
+model_path = Path("stamp_detector/stamp_model.pt")
+
+if not model_path.exists():
+    print(f"Error: {model_path} not found!")
+    exit(1)
+
+print(f"Uploading {model_path} to bekzhanK1/armeta_hackaton...")
+api.upload_file(
+    path_or_fileobj=str(model_path),
+    path_in_repo="stamp_detector/stamp_model.pt",
+    repo_id="bekzhanK1/armeta_hackaton",
+    repo_type="space"
+)
+print("✓ Model uploaded successfully!")
+