Upload 6 files

README.md

@@ -1,13 +1,85 @@
+
 ---
-title: License Plate V 2
-emoji: 🚀
-colorFrom: gray
-colorTo: purple
+title: Thai License Plate Detection V1.2
+emoji: 🚗
+colorFrom: blue
+colorTo: green
 sdk: streamlit
-sdk_version: 1.42.0
+sdk_version: "1.29.0"
 app_file: app.py
 pinned: false
-short_description: License plate detection
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Thai License Plate Recognition App
+
+This Streamlit application performs Thai license plate detection and recognition using deep learning models.
+
+## Features
+
+- License plate detection using YOLO
+- Character recognition for Thai license plates
+- Province name detection and recognition
+- Real-time processing with visual feedback
+- User-friendly web interface
+
+## Setup
+
+1. Install the required dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Download the required model files and place them in the `models` directory:
+   - `best.pt` - YOLO model for license plate detection
+   - `read_char.pt` - YOLO model for character recognition
+
+3. Ensure the configuration file `config/data.yaml` is present with character mappings.
+
+## Running the Application
+
+To run the application:
+
+```bash
+streamlit run app.py
+```
+
+The application will be available at `http://localhost:8501` by default.
+
+## Usage
+
+1. Open the application in your web browser
+2. Click the "Choose an image..." button to upload an image containing a Thai license plate
+3. Wait for the processing to complete
+4. View the results:
+   - Detected license plate number
+   - Detected province name
+   - Visual detection results
+
+## Models
+
+The application uses three main models:
+1. YOLO model for license plate detection
+2. YOLO model for character recognition
+3. TrOCR model for province text recognition (automatically downloaded)
+
+## Directory Structure
+
+```
+streamlitapp/
+├── app.py
+├── requirements.txt
+├── README.md
+├── models/
+│   ├── best.pt
+│   └── read_char.pt
+└── config/
+    └── data.yaml
+```
+
+## Notes
+
+- The application requires an internet connection for the first run to download the TrOCR model
+- Supported image formats: JPG, JPEG, PNG
+- For optimal results, ensure the license plate is clearly visible in the image 

app.py

@@ -0,0 +1,260 @@
+import streamlit as st
+from PIL import Image
+import cv2
+import numpy as np
+from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+from ultralytics import YOLO
+import Levenshtein
+import yaml
+import os
+import io
+import tempfile
+import torchvision
+
+
+class LicensePlateProcessor:
+    def __init__(self):
+        # Load models for plate detection
+        self.yolo_detector = YOLO('models/best.pt')  # For plate detection
+        self.char_reader = YOLO('models/read_char.pt')  # For character reading
+        
+        # Load TrOCR for province detection
+        self.processor_plate = TrOCRProcessor.from_pretrained('openthaigpt/thai-trocr')
+        self.model_plate = VisionEncoderDecoderModel.from_pretrained('openthaigpt/thai-trocr')
+        
+        # Load character mapping from yaml
+        with open('config/data.yaml', 'r', encoding='utf-8') as f:
+            data_config = yaml.safe_load(f)
+            self.char_mapping = data_config.get('char_mapping', {})
+            self.names = data_config['names']
+        
+        # Load province list
+        self.thai_provinces = [
+            "กรุงเทพมหานคร", "กระบี่", "กาญจนบุรี", "กาฬสินธุ์", "กำแพงเพชร", "ขอนแก่น", 
+            "จันทบุรี", "ฉะเชิงเทรา", "ชลบุรี", "ชัยนาท", "ชัยภูมิ", "ชุมพร", "เชียงราย", 
+            "เชียงใหม่", "ตรัง", "ตราด", "ตาก", "นครนายก", "นครปฐม", "นครพนม", "นครราชสีมา", 
+            "นครศรีธรรมราช", "นครสวรรค์", "นราธิวาส", "น่าน", "บึงกาฬ", "บุรีรัมย์", "ปทุมธานี", 
+            "ประจวบคีรีขันธ์", "ปราจีนบุรี", "ปัตตานี", "พะเยา", "พังงา", "พัทลุง", "พิจิตร", 
+            "พิษณุโลก", "เพชรบูรณ์", "เพชรบุรี", "แพร่", "ภูเก็ต", "มหาสารคาม", "มุกดาหาร", 
+            "แม่ฮ่องสอน", "ยโสธร", "ยะลา", "ร้อยเอ็ด", "ระนอง", "ระยอง", "ราชบุรี", "ลพบุรี", 
+            "ลำปาง", "ลำพูน", "เลย", "ศรีสะเกษ", "สกลนคร", "สงขลา", "สมุทรปราการ", "สมุทรสงคราม", 
+            "สมุทรสาคร", "สระแก้ว", "สระบุรี", "สิงห์บุรี", "สุโขทัย", "สุพรรณบุรี", "สุราษฎร์ธานี", 
+            "สุรินทร์", "หนองคาย", "หนองบัวลำภู", "อำนาจเจริญ", "อุดรธานี", "อุทัยธานี", 
+            "อุบลราชธานี", "อ่างทอง"
+        ]
+        
+        self.CONF_THRESHOLD = 0.3
+
+    def _map_class_to_char(self, class_name):
+        """Map class to character using yaml mapping"""
+        if str(class_name) in self.char_mapping:
+            return self.char_mapping[str(class_name)]
+        return str(class_name)
+
+    def get_closest_province(self, input_text):
+        """Find closest matching province"""
+        min_distance = float('inf')
+        closest_province = None
+
+        for province in self.thai_provinces:
+            distance = Levenshtein.distance(input_text, province)
+            if distance < min_distance:
+                min_distance = distance
+                closest_province = province
+
+        return closest_province, min_distance
+
+    def read_plate_characters(self, plate_image):
+        """Read characters from plate image"""
+        results = self.char_reader.predict(plate_image, conf=0.3)
+        
+        detections = []
+        for r in results:
+            boxes = r.boxes
+            for box in boxes:
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                confidence = float(box.conf[0])
+                class_id = int(box.cls[0])
+                
+                mapped_char = self._map_class_to_char(self.names[class_id])
+                
+                detections.append({
+                    'char': mapped_char,
+                    'confidence': confidence,
+                    'bbox': (x1, y1, x2, y2)
+                })
+        
+        # Sort detections left to right
+        detections.sort(key=lambda x: x['bbox'][0])
+        
+        # Combine characters
+        plate_text = ''.join(det['char'] for det in detections)
+        return plate_text
+
+    def process_image(self, image_path: str):
+        try:
+            # Read image
+            image = cv2.imread(image_path)
+            if image is None:
+                print(f"Error: Could not read image from {image_path}")
+                return None
+
+            # Detect license plate location
+            results = self.yolo_detector(image)
+            
+            data = {"plate_number": "", "province": "", "raw_province": ""}
+            
+            # Save visualization
+            output_image = image.copy()
+            
+            for result in results:
+                for box in result.boxes:
+                    confidence = float(box.conf)
+                    if confidence < self.CONF_THRESHOLD:
+                        continue
+
+                    x1, y1, x2, y2 = map(int, box.xyxy.flatten())
+                    cropped_image = image[y1:y2, x1:x2]
+
+                    # Draw rectangle on output image
+                    color = (0, 255, 0) if int(box.cls.item()) == 0 else (255, 0, 0)
+                    cv2.rectangle(output_image, (x1, y1), (x2, y2), color, 2)
+
+                    if int(box.cls.item()) == 0:  # License plate number
+                        # Read characters using YOLO character reader
+                        data["plate_number"] = self.read_plate_characters(cropped_image)
+                        
+                    elif int(box.cls.item()) == 1:  # Province
+                        # Process province using TrOCR
+                        cropped_image_gray = cv2.cvtColor(cropped_image, cv2.COLOR_BGR2GRAY)
+                        equalized_image = cv2.equalizeHist(cropped_image_gray)
+                        _, thresh_image = cv2.threshold(equalized_image, 65, 255, cv2.THRESH_BINARY_INV)
+                        cropped_image_3d = cv2.cvtColor(thresh_image, cv2.COLOR_GRAY2RGB)
+                        resized_image = cv2.resize(cropped_image_3d, (128, 32))
+                        
+                        pixel_values = self.processor_plate(resized_image, return_tensors="pt").pixel_values
+                        generated_ids = self.model_plate.generate(pixel_values)
+                        generated_text = self.processor_plate.batch_decode(generated_ids, skip_special_tokens=True)[0]
+                        
+                        generated_province, _ = self.get_closest_province(generated_text)
+                        data["raw_province"] = generated_text
+                        data["province"] = generated_province
+
+            # Save the output image
+            cv2.imwrite('output_detection.jpg', output_image)
+            return data
+
+        except Exception as e:
+            print(f"Error processing image: {str(e)}")
+            return None
+
+def main():
+    st.set_page_config(
+        page_title="Thai License Plate Recognition",
+        layout="wide"
+    )
+
+    st.title("Thai License Plate Recognition")
+    st.write("Upload an image to detect and read Thai license plates")
+
+    # Initialize processor
+    @st.cache_resource
+    def load_processor():
+        return LicensePlateProcessor()
+
+    processor = load_processor()
+
+    # File uploader
+    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+    if uploaded_file is not None:
+        # Create columns for side-by-side display
+        col1, col2 = st.columns(2)
+
+        # Display original image
+        with col1:
+            st.subheader("Original Image")
+            image = Image.open(uploaded_file)
+            st.image(image, use_column_width=True)
+
+            # Convert PIL Image to OpenCV format for processing
+            image_array = np.array(image)
+            if len(image_array.shape) == 3 and image_array.shape[2] == 4:
+                # Convert RGBA to RGB if needed
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_RGBA2RGB)
+            image_cv = cv2.cvtColor(image_array, cv2.COLOR_RGB2BGR)
+
+        # Process image
+        with st.spinner("Processing image..."):
+            try:
+                # Save the OpenCV image for processing
+                temp_path = 'temp_input.jpg'
+                cv2.imwrite(temp_path, image_cv)
+                
+                # Process the image using the processor
+                results = processor.process_image(temp_path)
+
+                # Clean up temporary input file
+                os.remove(temp_path)
+
+                if results:
+                    # Display results
+                    st.subheader("Detection Results")
+                    
+                    # Create a styled container for results
+                    results_container = st.container()
+                    with results_container:
+                        st.markdown(f"""
+                        <div style='background-color: #f0f2f6; padding: 20px; border-radius: 10px;'>
+                            <h3>License Plate: {results['plate_number']}</h3>
+                            <h3>Province: {results['province']}</h3>
+                            <p>Raw Province Text: {results['raw_province']}</p>
+                        </div>
+                        """, unsafe_allow_html=True)
+
+                    # Display detection visualization
+                    with col2:
+                        st.subheader("Detection Visualization")
+                        if os.path.exists('output_detection.jpg'):
+                            # Read and convert the output image from BGR to RGB
+                            output_image = cv2.imread('output_detection.jpg')
+                            output_image_rgb = cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB)
+                            st.image(output_image_rgb, use_column_width=True)
+                            # Clean up output image
+                            os.remove('output_detection.jpg')
+                else:
+                    st.error("No license plate detected in the image.")
+
+            except Exception as e:
+                st.error(f"Error processing image: {str(e)}")
+                # Clean up any temporary files in case of error
+                if os.path.exists('temp_input.jpg'):
+                    os.remove('temp_input.jpg')
+                if os.path.exists('output_detection.jpg'):
+                    os.remove('output_detection.jpg')
+
+    # Add information about the application
+    with st.expander("About This Application"):
+        st.markdown("""
+        ### Thai License Plate Recognition System
+
+        This application uses advanced computer vision and deep learning to:
+        - Detect license plates in images using YOLO
+        - Read Thai license plate numbers using character recognition
+        - Identify province names using TrOCR
+        - Provide visual detection results
+
+        #### How to Use:
+        1. Click the 'Browse files' button above
+        2. Select an image containing a Thai license plate
+        3. Wait for the processing to complete
+        4. View the results and detection visualization
+
+        #### Technologies Used:
+        - YOLO for license plate detection
+        - Custom YOLO model for character recognition
+        - TrOCR for province text recognition
+        """)
+
+if __name__ == "__main__":
+    main() 

config/data.yaml

@@ -0,0 +1,105 @@
+names:
+  0: '0'
+  1: '1'
+  2: '2'
+  3: '3'
+  4: '4'
+  5: '5'
+  6: '6'
+  7: '7'
+  8: '8'
+  9: '9'
+  10: 'ก'
+  11: 'ข'
+  12: 'ค'
+  13: 'ง'
+  14: 'จ'
+  15: 'ฉ'
+  16: 'ช'
+  17: 'ซ'
+  18: 'ฌ'
+  19: 'ญ'
+  20: 'ฎ'
+  21: 'ฏ'
+  22: 'ฐ'
+  23: 'ฑ'
+  24: 'ฒ'
+  25: 'ณ'
+  26: 'ด'
+  27: 'ต'
+  28: 'ถ'
+  29: 'ท'
+  30: 'ธ'
+  31: 'น'
+  32: 'บ'
+  33: 'ป'
+  34: 'ผ'
+  35: 'ฝ'
+  36: 'พ'
+  37: 'ฟ'
+  38: 'ภ'
+  39: 'ม'
+  40: 'ย'
+  41: 'ร'
+  42: 'ล'
+  43: 'ว'
+  44: 'ศ'
+  45: 'ษ'
+  46: 'ส'
+  47: 'ห'
+  48: 'ฬ'
+  49: 'อ'
+  50: 'ฮ'
+
+char_mapping:
+  '0': '0'
+  '1': '1'
+  '2': '2'
+  '3': '3'
+  '4': '4'
+  '5': '5'
+  '6': '6'
+  '7': '7'
+  '8': '8'
+  '9': '9'
+  '10': 'ก'
+  '11': 'ข'
+  '12': 'ค'
+  '13': 'ง'
+  '14': 'จ'
+  '15': 'ฉ'
+  '16': 'ช'
+  '17': 'ซ'
+  '18': 'ฌ'
+  '19': 'ญ'
+  '20': 'ฎ'
+  '21': 'ฏ'
+  '22': 'ฐ'
+  '23': 'ฑ'
+  '24': 'ฒ'
+  '25': 'ณ'
+  '26': 'ด'
+  '27': 'ต'
+  '28': 'ถ'
+  '29': 'ท'
+  '30': 'ธ'
+  '31': 'น'
+  '32': 'บ'
+  '33': 'ป'
+  '34': 'ผ'
+  '35': 'ฝ'
+  '36': 'พ'
+  '37': 'ฟ'
+  '38': 'ภ'
+  '39': 'ม'
+  '40': 'ย'
+  '41': 'ร'
+  '42': 'ล'
+  '43': 'ว'
+  '44': 'ศ'
+  '45': 'ษ'
+  '46': 'ส'
+  '47': 'ห'
+  '48': 'ฬ'
+  '49': 'อ'
+  '50': 'ฮ' 

models/best.pt

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

models/read_char.pt

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

requirements.txt

@@ -0,0 +1,10 @@
+streamlit==1.31.1
+Pillow==10.0.0
+opencv-python-headless==4.8.0.74
+numpy==1.24.3
+transformers==4.36.2
+ultralytics==8.0.196
+python-Levenshtein==0.23.0
+PyYAML==6.0.1
+torch==2.1.0
+torchvision==0.16.0