Added files

Dockerfile

@@ -0,0 +1,31 @@
+# Use a base Python image
+FROM python:3.9-slim
+
+# Set the working directory
+WORKDIR /app
+
+# Copy requirements first to leverage Docker caching
+COPY requirements.txt requirements.txt
+
+# Install system dependencies needed by OpenCV and potentially others
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    # Add any other system libs if needed during build
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+# Use --no-cache-dir to reduce image size
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the port Flask runs on (default is 5000)
+EXPOSE 5000
+
+# Command to run the application
+# Use gunicorn for a more robust server than Flask's default debug server
+# Install gunicorn first
+RUN pip install --no-cache-dir gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

app.py

@@ -0,0 +1,274 @@
+import os
+import time
+import cv2  # OpenCV for image handling
+import easyocr  # For OCR
+import torch  # PyTorch (dependency for YOLO/EasyOCR)
+import numpy as np  # For numerical operations
+from ultralytics import YOLO  # YOLO model from ultralytics
+from flask import Flask, request, render_template, redirect, url_for, flash
+from werkzeug.utils import secure_filename
+import traceback # To print full error tracebacks
+import re # Import regular expressions for post-processing
+
+# --- Configuration ---
+UPLOAD_FOLDER = os.path.join('static', 'uploads')
+RESULT_FOLDER = os.path.join('static', 'results')
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
+
+weights_path = 'best.pt' # Assumes best.pt is in the same folder as app.py
+PLATE_CLASS_NAME = 'license_plate'
+
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['RESULT_FOLDER'] = RESULT_FOLDER
+app.secret_key = 'super secret key' # Needed for flashing messages
+
+# --- Create Folders if they don't exist ---
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(RESULT_FOLDER, exist_ok=True)
+
+# --- Load Models (Load only once when the app starts) ---
+reader = None
+model = None
+model_class_names = {} # Initialize empty
+
+print("Loading EasyOCR Reader...")
+try:
+    # Use gpu=True if you have a CUDA-enabled GPU and compatible PyTorch/CUDA
+    model_dir = os.path.join('.', 'easyocr_models')
+    os.makedirs(model_dir, exist_ok=True)
+    reader = easyocr.Reader(['en'], gpu=torch.cuda.is_available(), model_storage_directory=model_dir)
+    print("EasyOCR Reader loaded successfully.")
+except Exception as e:
+    print(f"Error loading EasyOCR Reader: {e}. OCR will not work.")
+    print(traceback.format_exc()) # Print full traceback
+
+print("Loading YOLO Model...")
+try:
+    if not os.path.exists(weights_path):
+        raise FileNotFoundError(f"YOLO weights file not found at {weights_path}. Please make sure 'best.pt' is in the same directory as app.py or update the path.")
+    model = YOLO(weights_path)
+    print("YOLO Model loaded successfully.")
+    # Store class names if model loaded
+    if model:
+        model_class_names = model.names
+        print("Class names:", model_class_names) # Print class names {index: 'name'}
+except Exception as e:
+    print(f"Error loading YOLO model from {weights_path}: {e}. Detection will not work.")
+    print(traceback.format_exc()) # Print full traceback
+
+# --- Helper Functions ---
+def allowed_file(filename):
+    """Checks if the filename has an allowed extension."""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def perform_ocr_on_image(img_crop, allowlist='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
+    """Performs OCR on a given image crop (NumPy array)."""
+    if reader is None:
+        print("EasyOCR Reader not loaded. Cannot perform OCR.")
+        return "OCR Error"
+
+    try:
+        # Convert to grayscale
+        gray_img = cv2.cvtColor(img_crop, cv2.COLOR_BGR2GRAY)
+
+        # Resize for consistent input size
+        target_height = 64  # You can adjust this value
+        scale_ratio = target_height / gray_img.shape[0]
+        target_width = int(gray_img.shape[1] * scale_ratio)
+        resized_img = cv2.resize(gray_img, (target_width, target_height))
+
+        # Basic preprocessing
+        resized_img = cv2.equalizeHist(resized_img)  # Enhance contrast
+        
+        # Perform OCR
+        results = reader.readtext(resized_img, allowlist=allowlist)
+        
+        # Process results
+        if not results:
+            return "No text found"
+            
+        # Take the result with highest confidence
+        text = results[0][1]  # Get the text part
+        
+        # Convert to uppercase and remove any non-alphanumeric characters
+        text = text.upper()
+        text = re.sub(r'[^A-Z0-9]', '', text)
+        
+        return text if text else "No text found"
+
+
+        print(f"Final combined text after post-processing: '{plate_text}'")
+
+        return plate_text if plate_text else "No text found"
+
+    except Exception as e:
+        print(f"Error during OCR processing in perform_ocr_on_image: {e}")
+        print(traceback.format_exc())
+        return "OCR Processing Error"
+
+# ... (rest of run_detection_ocr, Flask routes, and __main__ remain the same) ...
+
+def run_detection_ocr(image_path, result_filename):
+    """Runs YOLO detection and EasyOCR on the image."""
+    if model is None or reader is None:
+        print("Models not loaded. Cannot process image.")
+        return None, ["Model Loading Error"]
+
+    detected_texts = []
+    result_image_path = None
+
+    try:
+        # Read the image
+        img = cv2.imread(image_path)
+        if img is None:
+            print(f"Error: Could not read image at {image_path}")
+            return None, ["Image Reading Error"]
+
+        img_copy = img.copy() # Make a copy for drawing
+
+        # Run YOLO detection with original confidence threshold
+        print(f"Running YOLO prediction on {image_path}...")
+        results = model.predict(img, conf=0.25) # Restore original confidence for detection
+        print("YOLO prediction complete.")
+
+        # Process detections
+        for result in results:
+            boxes = result.boxes
+            if boxes is None or len(boxes) == 0:
+                print("No boxes detected in this result.")
+                continue
+
+            for box in boxes:
+                try:
+                    # Get class index and name using the loaded names
+                    class_id = int(box.cls[0])
+                    class_name = model_class_names.get(class_id, 'Unknown')
+                    confidence = float(box.conf[0])
+                    x1_temp, y1_temp, x2_temp, y2_temp = map(int, box.xyxy[0])
+                    print(f"Detected '{class_name}' (Conf: {confidence:.2f}) at [{x1_temp}, {y1_temp}, {x2_temp}, {y2_temp}]")
+
+                    # Check with the CORRECTED class name
+                    if class_name.lower() == PLATE_CLASS_NAME.lower(): # Comparison should now work
+                        x1, y1, x2, y2 = map(int, box.xyxy[0])
+                        padding = 10
+                        crop_y1 = max(0, y1 - padding)
+                        crop_y2 = min(img.shape[0], y2 + padding)
+                        crop_x1 = max(0, x1 - padding)
+                        crop_x2 = min(img.shape[1], x2 + padding)
+
+                        if crop_y2 > crop_y1 and crop_x2 > crop_x1:
+                            plate_crop = img[crop_y1:crop_y2, crop_x1:crop_x2]
+
+                            # Added print before calling OCR
+                            print(f"--- Cropped {PLATE_CLASS_NAME} at [{crop_x1}, {crop_y1}, {crop_x2}, {crop_y2}], attempting OCR ---")
+                            plate_text = perform_ocr_on_image(plate_crop) # Function updated with preprocessing/postprocessing
+                            print(f"-> OCR Result returned for {PLATE_CLASS_NAME}: {plate_text}")
+                            detected_texts.append(plate_text)
+
+                            # Drawing logic
+                            label = f"{class_name}: {plate_text}" # Label uses result from OCR call
+                            cv2.rectangle(img_copy, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                            text_pos = (x1, y1 - 10) if y1 > 20 else (x1, y2 + 20)
+                            cv2.putText(img_copy, label, text_pos,
+                                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                        else:
+                            print(f"Skipping invalid crop dimensions for {PLATE_CLASS_NAME}: y1={crop_y1}, y2={crop_y2}, x1={crop_x1}, x2={crop_x2}")
+                    else:
+                       # Draw blue boxes for other detected objects (optional)
+                       cv2.rectangle(img_copy, (x1_temp, y1_temp), (x2_temp, y2_temp), (255, 0, 0), 1) # Blue box, thinner
+                       cv2.putText(img_copy, f"{class_name} {confidence:.2f}", (x1_temp, y1_temp - 5),
+                                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+
+
+                except Exception as e_inner:
+                    print(f"Error processing a specific detection: {e_inner}")
+                    print(traceback.format_exc())
+                    detected_texts.append("Detection Proc. Error")
+
+        # Save the result image
+        result_image_path = os.path.join(app.config['RESULT_FOLDER'], result_filename)
+        cv2.imwrite(result_image_path, img_copy)
+        print(f"Result image saved to: {result_image_path}")
+
+        return result_image_path, detected_texts
+
+    except Exception as e:
+        print(f"Error during detection/OCR: {e}")
+        print(traceback.format_exc())
+        return None, ["Overall Processing Error"]
+
+# --- Flask Routes ---
+@app.route('/', methods=['GET', 'POST'])
+def upload_file():
+    error_message = None
+    if request.method == 'POST':
+        if 'file' not in request.files:
+            flash('No file part')
+            return redirect(request.url)
+        file = request.files['file']
+        if file.filename == '':
+            flash('No selected file')
+            return redirect(request.url)
+
+        if file and allowed_file(file.filename):
+            try:
+                original_filename = secure_filename(file.filename)
+                timestamp = time.strftime("%Y%m%d-%H%M%S")
+                unique_filename = f"{timestamp}_{original_filename}"
+                upload_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
+                file.save(upload_path)
+                print(f"File saved to: {upload_path}")
+
+                # --- Call Processing Logic ---
+                if model is None or reader is None:
+                    return render_template('result.html',
+                                           original_image_url=url_for('static', filename=f'uploads/{unique_filename}'),
+                                           result_image_url=None,
+                                           detected_texts=None,
+                                           error_message="AI models failed to load. Cannot process image.")
+
+                result_filename = f"result_{unique_filename}"
+                result_image_path, detected_texts = run_detection_ocr(upload_path, result_filename)
+
+                # Generate URLs for the templates
+                original_url = url_for('static', filename=f'uploads/{unique_filename}')
+                result_url = url_for('static', filename=f'results/{result_filename}') if result_image_path else None
+
+                # *** Filter out error messages before displaying ***
+                display_texts = [text for text in detected_texts if "Error" not in text and text != "No text found" and text != "Crop too small" and text != "Invalid Crop"]
+                if not display_texts and detected_texts: # If only errors or 'no text', show generic message
+                    display_texts = ["No text recognized"]
+                elif not detected_texts and not display_texts: # If detection worked but OCR returned nothing valid
+                    display_texts = ["No text recognized"]
+                elif not detected_texts: # Fallback if processing completely failed
+                     display_texts = ["Processing Error"]
+
+
+                return render_template('result.html',
+                                       original_image_url=original_url,
+                                       result_image_url=result_url,
+                                       detected_texts=display_texts, # Use filtered list
+                                       error_message=None if result_image_path else "An error occurred during image processing.")
+
+            except Exception as e:
+                error_message = f"An error occurred during file upload or processing: {e}"
+                print(f"Error in upload_file route: {e}")
+                print(traceback.format_exc())
+                # Render index again, show the error
+                return render_template('index.html', error_message=error_message)
+
+        else:
+            error_message = "Invalid file type. Please upload a PNG, JPG, or JPEG image."
+            return render_template('index.html', error_message=error_message)
+
+    # For GET requests
+    return render_template('index.html', error_message=None)
+
+
+# --- Run the App ---
+if __name__ == "__main__":
+    app.run(debug=True)
+

best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d95861825bb4184404344c9cf809f40fd31dba785fe54e8ba5b9a3583789822
+size 6248291

easyocr_models/craft_mlt_25k.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a5efbfb48b4081100544e75e1e2b57f8de3d84f213004b14b85fd4b3748db17
+size 83152330

easyocr_models/english_g2.pth

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

readme copy.md

@@ -0,0 +1,60 @@
+---
+title: Automatic Number Plate Recognition
+emoji: 🚗
+colorFrom: blue
+colorTo: green
+sdk: docker # Using Docker for more control with OpenCV/PyTorch
+pinned: false
+app_file: app.py # Tells Spaces which file to run
+---
+
+# 🚗 Automatic Number Plate Recognition (ANPR)
+
+This **Hugging Face Space** demonstrates an **Automatic Number Plate Recognition (ANPR)** system built using **Flask**, **YOLOv9**, and **EasyOCR**.
+
+---
+
+## 🔍 Features
+
+- **Detection:** [YOLOv9](https://github.com/ultralytics/ultralytics) via the Ultralytics library, trained specifically on license plates.  
+- **OCR:** [EasyOCR](https://github.com/JaidedAI/EasyOCR) to extract text from detected plates.  
+- **Framework:** Flask-based web application for easy upload and visualization.  
+
+---
+
+## 🧠 How It Works
+
+1. **Upload an Image:**  
+   Click **“Choose File”** to select a `.png`, `.jpg`, or `.jpeg` image containing a vehicle.
+
+2. **Process the Image:**  
+   Click **“Upload and Process”**.
+
+3. **View Results:**  
+   - Original image  
+   - Processed image with the detected plate **boxed and labeled**  
+   - Extracted **plate text** displayed below  
+
+---
+
+## ⚙️ Architecture Overview
+
+| Component | Technology | Purpose |
+|------------|-------------|----------|
+| **Detection Model** | YOLOv9 | Detects license plate region |
+| **OCR Engine** | EasyOCR | Extracts alphanumeric text |
+| **Framework** | Flask | Provides web interface |
+| **Containerization** | Docker | Ensures reproducible environment |
+
+---
+
+## 📦 Installation & Setup
+
+```bash
+# Clone this repository
+git clone https://huggingface.co/spaces/your-username/anpr
+cd anpr
+
+# Build and run using Docker
+docker build -t anpr .
+docker run -p 7860:7860 anpr

requirements.txt

@@ -0,0 +1,6 @@
+Flask>=2.0
+opencv-python-headless
+easyocr
+ultralytics
+torch
+torchvision

templates/index.html

@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ANPR Image Upload</title>
+    <!-- Load Tailwind CSS from CDN -->
+    <script src="https://www.google.com/search?q=https://cdn.tailwindcss.com"></script>
+    <style>
+        /* Optional: Add custom styles or use a font like Inter */
+        body {
+            font-family: 'Inter', sans-serif;
+        }
+    </style>
+</head>
+
+<body class="bg-gray-100 flex items-center justify-center min-h-screen">
+    <div class="bg-white p-8 rounded-lg shadow-xl w-full max-w-lg">
+        <h1 class="text-3xl font-bold mb-6 text-center text-gray-800">Number Plate Detector</h1>
+        <p class="text-center text-gray-600 mb-6">Upload an image containing a vehicle's number plate.</p>
+
+        <!-- The form sends data to our '/' route using the POST method -->
+        <!-- enctype="multipart/form-data" is essential for file uploads -->
+        <form method="post" enctype="multipart/form-data" class="space-y-6">
+            <div>
+                <label for="file" class="block text-sm font-medium text-gray-700 mb-2">Choose an image file:</label>
+                <input type="file" name="file" id="file" required accept="image/png, image/jpeg, image/jpg"
+                    class="block w-full text-sm text-gray-500 rounded-md border border-gray-300 cursor-pointer
+                        file:mr-4 file:py-2 file:px-4
+                        file:rounded-md file:border-0
+                        file:text-sm file:font-semibold
+                        file:bg-indigo-50 file:text-indigo-700
+                        hover:file:bg-indigo-100 focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500">
+                <p class="text-xs text-gray-500 mt-1">Accepted formats: PNG, JPG, JPEG.</p>
+            </div>
+
+            <div>
+                <button type="submit"
+                    class="w-full flex justify-center py-2 px-4 border border-transparent rounded-md shadow-sm text-sm font-medium text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition duration-150 ease-in-out">
+                    Upload and Detect
+                </button>
+            </div>
+        </form>
+
+        <!-- We can add messages here later (e.g., upload errors) -->
+        {% if error_message %}
+        <p class="mt-4 text-center text-red-600">{{ error_message }}</p>
+        {% endif %}
+    </div>
+</body>
+
+</html>

templates/result.html

@@ -0,0 +1,74 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ANPR Result</title>
+    <script src="https://www.google.com/search?q=https://cdn.tailwindcss.com"></script>
+    <link href="https://www.google.com/search?q=https://fonts.googleapis.com/css2%3Ffamily%3DInter:wght%40400%3B500%3B600%3B700%26display%3Dswap" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Inter', sans-serif;
+        }
+
+        .result-image {
+            max-width: 100%;
+            height: auto;
+            max-height: 70vh;
+            margin: 10px auto;
+            display: block;
+        }
+    </style>
+</head>
+
+<body class="bg-gray-100 p-8">
+    <div class="max-w-4xl mx-auto bg-white p-6 rounded-lg shadow-md">
+        <h1 class="text-2xl font-semibold mb-6 text-center text-gray-700">ANPR Processing Result</h1>
+
+        {% if error_message %}
+        <div class="bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded relative mb-4" role="alert">
+            <strong class="font-bold">Error:</strong>
+            <span class="block sm:inline">{{ error_message }}</span>
+        </div>
+        {% else %}
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-6 mb-6">
+            <div>
+                <h2 class="text-xl font-medium mb-2 text-gray-600">Original Image</h2>
+                {% if original_image_url %}
+                <img src="{{ original_image_url }}" alt="Original Uploaded Image" class="result-image rounded-md border border-gray-300">
+                {% else %}
+                <p class="text-gray-500">Original image not available.</p>
+                {% endif %}
+            </div>
+            <div>
+                <h2 class="text-xl font-medium mb-2 text-gray-600">Processed Image</h2>
+                {% if result_image_url %}
+                <img src="{{ result_image_url }}" alt="Processed Image with Detections" class="result-image rounded-md border border-gray-300">
+                {% else %}
+                <p class="text-gray-500">Processed image not available.</p>
+                {% endif %}
+            </div>
+        </div>
+
+        <div class="mb-6">
+            <h2 class="text-xl font-medium mb-2 text-gray-600">Detected Plate Texts:</h2>
+            {% if detected_texts %}
+            <ul class="list-disc list-inside bg-gray-50 p-4 rounded-md border border-gray-200">
+                {% for text in detected_texts %}
+                <li class="text-lg text-gray-800 mb-1 font-mono">{{ text }}</li>
+                {% endfor %}
+            </ul>
+            {% else %}
+            <p class="text-gray-500 bg-gray-50 p-4 rounded-md border border-gray-200">No license plates detected or text recognized.</p>
+            {% endif %}
+        </div>
+        {% endif %}
+
+        <div class="text-center mt-6">
+            <a href="{{ url_for('upload_file') }}" class="inline-block bg-blue-500 hover:bg-blue-600 text-white font-semibold py-2 px-4 rounded-md transition duration-300">Upload Another Image</a>
+        </div>
+    </div>
+</body>
+
+</html>

yolov8n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31e20dde3def09e2cf938c7be6fe23d9150bbbe503982af13345706515f2ef95
+size 6534387