Convert to Gradio and add complete ALPR OCR system

.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv/
+.env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.temp

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 8501
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV STREAMLIT_SERVER_PORT=8501
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Run the application
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Japhari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,39 @@
+.PHONY: help install test clean build run docker-build docker-run deploy
+
+help: ## Show this help message
+	@echo 'Usage: make [target]'
+	@echo ''
+	@echo 'Targets:'
+	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  %-15s %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+
+install: ## Install dependencies
+	pip install -r requirements.txt
+
+test: ## Run tests
+	python -m pytest tests/ -v
+
+clean: ## Clean up build artifacts
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	find . -type d -name __pycache__ -delete
+	find . -type f -name "*.pyc" -delete
+
+build: ## Build the package
+	python setup.py sdist bdist_wheel
+
+run: ## Run the Gradio app locally
+	python app.py
+
+docker-build: ## Build Docker image
+	docker build -t alpr-ocr .
+
+docker-run: ## Run Docker container
+	docker run -p 7860:7860 alpr-ocr
+
+deploy: ## Deploy to Hugging Face Spaces
+	@echo "Deploying to Hugging Face Spaces..."
+	@echo "1. Make sure you have git-lfs installed"
+	@echo "2. Run: git add . && git commit -m 'Update ALPR OCR system'"
+	@echo "3. Run: git push origin main"
+	@echo "4. Your Space will be automatically updated at: https://huggingface.co/spaces/Japhari/alpr-ocr"

README.md

@@ -1,13 +1,59 @@
 ---
-title: Alpr Ocr
-emoji: 🌖
-colorFrom: gray
+title: Automatic License Plate Recognition
+emoji: 🔍
+colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 5.44.1
+sdk_version: 4.44.0
 app_file: app.py
-pinned: false
-short_description: Automatic License Number Recognition
+tags:
+  - computer-vision
+  - license-plate
+  - alpr
+  - license-plate-recognition
+  - object-detection
+  - license-plate-detection
+  - gradio
+  - ocr
+  - yolo
+  - onnx
+  - real-time
+pinned: true
+license: mit
+short_description: Automatic License Plate Recognition
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Automatic License Plate Recognition (ALPR)
+
+An automatic license plate recognition (ALPR) system with customizable detector and OCR models. This system uses the FastALPR library to detect and recognize license plates in images.
+
+## Features
+
+- **Multiple Detector Models**: Choose from various plate detection models
+- **Customizable OCR Models**: Select different OCR models for text recognition
+- **Real-time Processing**: Upload images and get instant results
+- **Visual Annotations**: See detected plates highlighted on the image
+- **Confidence Scores**: Get confidence levels for each detection
+
+## Usage
+
+1. Upload an image containing a vehicle with a license plate
+2. Select your preferred detector and OCR models from the sidebar
+3. View the processed results with annotations
+4. See detailed OCR text and confidence scores
+
+## Models
+
+The system supports multiple detector and OCR models from the FastALPR library, including:
+
+- Various YOLO-based detection models
+- CCT OCR models for text recognition
+- Global and specialized models for different use cases
+
+## Requirements
+
+- Python 3.8+
+- FastALPR library
+- Streamlit
+- OpenCV
+- PIL/Pillow

app.py

@@ -0,0 +1,167 @@
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+from typing import get_args
+
+from fast_alpr import ALPR
+from fast_alpr.default_detector import PlateDetectorModel
+from fast_alpr.default_ocr import OcrModel
+
+# Default models
+DETECTOR_MODELS = list(get_args(PlateDetectorModel))
+OCR_MODELS = list(get_args(OcrModel))
+# Put global OCR first
+OCR_MODELS.remove("cct-s-v1-global-model")
+OCR_MODELS.insert(0, "cct-s-v1-global-model")
+
+def process_image(image, detector_model, ocr_model):
+    """
+    Process an image with ALPR system
+    
+    Args:
+        image: PIL Image or numpy array
+        detector_model: Selected detector model
+        ocr_model: Selected OCR model
+    
+    Returns:
+        tuple: (annotated_image, results_text)
+    """
+    if image is None:
+        return None, "Please upload an image to continue."
+    
+    try:
+        # Convert image to numpy array if it's a PIL Image
+        if isinstance(image, Image.Image):
+            img_array = np.array(image.convert("RGB"))
+        else:
+            img_array = image
+        
+        # Initialize ALPR with selected models
+        alpr = ALPR(detector_model=detector_model, ocr_model=ocr_model)
+        
+        # Run ALPR on the image
+        results = alpr.predict(img_array)
+        
+        # Draw predictions on the image
+        annotated_img_array = alpr.draw_predictions(img_array)
+        
+        # Convert back to PIL Image for Gradio
+        annotated_img = Image.fromarray(annotated_img_array)
+        
+        # Format results text
+        if results:
+            results_text = "**OCR Results:**\n"
+            for i, result in enumerate(results):
+                plate_text = result.ocr.text if result.ocr else "N/A"
+                plate_confidence = result.ocr.confidence if result.ocr else 0.0
+                results_text += f"{i+1}. Detected Plate: `{plate_text}` with confidence `{plate_confidence:.2f}`\n"
+        else:
+            results_text = "No license plate detected 😔."
+        
+        return annotated_img, results_text
+        
+    except Exception as e:
+        return None, f"Error processing image: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Automatic License Plate Recognition (ALPR)",
+    theme=gr.themes.Soft(
+        primary_hue="green",
+        secondary_hue="blue",
+        neutral_hue="slate"
+    )
+) as demo:
+    
+    gr.Markdown("""
+    # 🔍 Automatic License Plate Recognition (ALPR)
+    
+    An automatic license plate recognition (ALPR) system with customizable detector and OCR models.
+    
+    This system uses the FastALPR library to detect and recognize license plates in images.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Model Selection")
+            detector_dropdown = gr.Dropdown(
+                choices=DETECTOR_MODELS,
+                value=DETECTOR_MODELS[0],
+                label="Choose Detector Model",
+                info="Select the model for license plate detection"
+            )
+            
+            ocr_dropdown = gr.Dropdown(
+                choices=OCR_MODELS,
+                value=OCR_MODELS[0],
+                label="Choose OCR Model",
+                info="Select the model for text recognition"
+            )
+            
+            gr.Markdown("### Upload Image")
+            image_input = gr.Image(
+                label="Upload an image of a vehicle with a license plate",
+                type="pil",
+                height=300
+            )
+            
+            process_btn = gr.Button(
+                "🚀 Process Image",
+                variant="primary",
+                size="lg"
+            )
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Results")
+            image_output = gr.Image(
+                label="Annotated Image with OCR Results",
+                height=300
+            )
+            
+            text_output = gr.Markdown(
+                label="OCR Results",
+                value="Upload an image and click 'Process Image' to see results."
+            )
+    
+    # Add some examples
+    gr.Markdown("### 📸 Example Images")
+    gr.Examples(
+        examples=[],
+        inputs=image_input,
+        label="Try with these examples (if available)"
+    )
+    
+    # Connect the interface
+    process_btn.click(
+        fn=process_image,
+        inputs=[image_input, detector_dropdown, ocr_dropdown],
+        outputs=[image_output, text_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 🚀 How to Use
+    
+    1. **Select Models**: Choose your preferred detector and OCR models from the dropdowns
+    2. **Upload Image**: Upload an image containing a vehicle with a license plate
+    3. **Process**: Click the "Process Image" button to run ALPR
+    4. **View Results**: See the annotated image and OCR text results
+    
+    ### 🔧 Supported Models
+    
+    - **Detector Models**: Various YOLO-based detection models
+    - **OCR Models**: CCT OCR models for text recognition including global and specialized models
+    
+    ### 📊 Features
+    
+    - Real-time license plate detection
+    - Customizable model selection
+    - Visual annotations with bounding boxes
+    - Confidence scores for OCR results
+    - Support for multiple image formats
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=False)

deploy.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+# Deploy script for Hugging Face Spaces
+# This script helps deploy the ALPR OCR system to Hugging Face
+
+set -e
+
+echo "🚀 Starting deployment to Hugging Face Spaces..."
+
+# Check if git is initialized
+if [ ! -d ".git" ]; then
+    echo "📁 Initializing git repository..."
+    git init
+    git remote add origin https://huggingface.co/spaces/Japhari/alpr-ocr
+fi
+
+# Check if git-lfs is installed
+if ! command -v git-lfs &> /dev/null; then
+    echo "⚠️  git-lfs is not installed. Please install it first:"
+    echo "   macOS: brew install git-lfs"
+    echo "   Ubuntu: sudo apt-get install git-lfs"
+    echo "   Windows: https://git-lfs.github.com/"
+    exit 1
+fi
+
+# Setup git-lfs
+echo "🔧 Setting up git-lfs..."
+git lfs install
+git lfs track "*.py"
+git lfs track "*.md"
+git lfs track "*.txt"
+git lfs track "*.toml"
+git lfs track "*.yml"
+git lfs track "*.yaml"
+git lfs track "*.sh"
+
+# Add all files
+echo "📝 Adding files to git..."
+git add .
+
+# Commit changes
+echo "💾 Committing changes..."
+git commit -m "Update ALPR OCR system - $(date)"
+
+# Push to Hugging Face
+echo "🚀 Pushing to Hugging Face Spaces..."
+git push origin main
+
+echo "✅ Deployment completed successfully!"
+echo "🌐 Your Space is available at: https://huggingface.co/spaces/Japhari/alpr-ocr"
+echo "⏳ It may take a few minutes for the changes to appear."

docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+  alpr-app:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - .:/app
+    environment:
+      - PYTHONPATH=/app
+    restart: unless-stopped

packages.txt

@@ -0,0 +1,6 @@
+libgl1-mesa-glx
+libglib2.0-0
+libsm6
+libxext6
+libxrender-dev
+libgomp1

pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "alpr-ocr"
+dynamic = ["version"]
+description = "Automatic License Plate Recognition (ALPR) system with customizable detector and OCR models"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Japhari", email = ""}
+]
+maintainers = [
+    {name = "Japhari", email = ""}
+]
+keywords = ["alpr", "ocr", "license-plate", "computer-vision", "gradio"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "fast-alpr[onnx]>=0.2.0",
+    "gradio>=4.44.0",
+    "opencv-python-headless",
+    "pillow",
+    "numpy",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "flake8",
+    "mypy",
+    "pre-commit",
+]
+
+[project.urls]
+Homepage = "https://huggingface.co/spaces/Japhari/alpr-ocr"
+Repository = "https://huggingface.co/spaces/Japhari/alpr-ocr"
+Documentation = "https://huggingface.co/spaces/Japhari/alpr-ocr"
+Issues = "https://huggingface.co/spaces/Japhari/alpr-ocr"
+
+[project.scripts]
+alpr-ocr = "app:main"
+
+[tool.setuptools]
+packages = ["app"]
+
+[tool.setuptools.package-data]
+"*" = ["*.md", "*.txt", "*.toml"]
+
+[tool.black]
+line-length = 88
+target-version = ['py39']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"

requirements.txt

@@ -0,0 +1,5 @@
+fast-alpr[onnx]>=0.2.0
+gradio>=4.44.0
+opencv-python-headless
+pillow
+numpy

runtime.txt

@@ -0,0 +1 @@
+python-3.9

setup.py

@@ -0,0 +1,45 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="alpr-ocr",
+    version="0.1.0",
+    author="Japhari",
+    author_email="",
+    description="Automatic License Plate Recognition (ALPR) system with customizable detector and OCR models",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://huggingface.co/spaces/Japhari/alpr-ocr",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Scientific/Engineering :: Image Recognition",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    python_requires=">=3.9",
+    install_requires=requirements,
+    extras_require={
+        "dev": [
+            "pytest",
+            "black",
+            "flake8",
+            "mypy",
+        ],
+    },
+    include_package_data=True,
+    zip_safe=False,
+)

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package for ALPR OCR system

tests/test_app.py

@@ -0,0 +1,35 @@
+import pytest
+import numpy as np
+from PIL import Image
+import gradio as gr
+
+# Mock test for the ALPR system
+def test_requirements_import():
+    """Test that all required packages can be imported"""
+    try:
+        import cv2
+        import numpy as np
+        import gradio as gr
+        from PIL import Image
+        from fast_alpr import ALPR
+        assert True
+    except ImportError as e:
+        pytest.fail(f"Failed to import required package: {e}")
+
+def test_image_processing():
+    """Test basic image processing functionality"""
+    # Create a dummy image
+    dummy_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    
+    # Test PIL conversion
+    pil_img = Image.fromarray(dummy_img)
+    assert pil_img.size == (100, 100)
+    
+    # Test numpy conversion back
+    img_array = np.array(pil_img)
+    assert img_array.shape == (100, 100, 3)
+
+def test_streamlit_components():
+    """Test that Streamlit components can be created"""
+    # This is a basic test to ensure the app structure is valid
+    assert True