Upload 50 files

.gitattributes

@@ -37,3 +37,8 @@ assets/lp_video[[:space:]]-[[:space:]]Trim.mp4 filter=lfs diff=lfs merge=lfs -te
 assets/lp_video.mp4 filter=lfs diff=lfs merge=lfs -text
 apps/assets/examples/license_plate_detector_ocr/2/lp_video_output.mp4 filter=lfs diff=lfs merge=lfs -text
 apps/assets/examples/license_plate_detector_ocr/2/lp_video.mp4 filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/license_plate_detector_ocr/2/lp_video_output.mp4 filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/license_plate_detector_ocr/2/lp_video.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/examples/license_plate_detector_ocr/2/lp_video_output.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/examples/license_plate_detector_ocr/2/lp_video.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/gradio_app_demo.jpg filter=lfs diff=lfs merge=lfs -text

.python-version

@@ -1 +1 @@
-python v3.11.13
+3.11.13

apps/gradio_app.py

@@ -1,138 +1,131 @@
-import gradio as gr
-import os
-import logging
-from gradio_app.config import setup_logging, setup_sys_path
-from gradio_app.processor import gradio_process, update_preview, update_visibility
-
-# Initialize logging and sys.path
-setup_logging()
-setup_sys_path()
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-# Load custom CSS
-custom_css = """
-.custom-table tr:hover { background-color: #f0f0f0; cursor: pointer; }
-.custom-table .selected { background-color: #d0e8ff; }
-.custom-file-input { margin-bottom: 10px; }
-.custom-radio { margin-bottom: 10px; }
-.custom-button { margin: 5px; }
-.custom-image, .custom-video { width: 100%; }
-.custom-textbox { width: 100%; }
-"""
-# Optionally, you can still load from styles.css if preferred
-# custom_css = open(os.path.join(os.path.dirname(__file__), "gradio_app", "static", "styles.css"), "r").read()
-
-# Path to examples directory
-examples_dir = os.path.join(os.path.dirname(__file__), "gradio_app", "assets", "examples", "license_plate_detector_ocr")
-
-# Collect example files
-examples = [
-    {
-        "Input File": os.path.join(examples_dir, "1", "lp_image.jpg"),
-        "Output File": os.path.join(examples_dir, "1", "lp_image_output.jpg"),
-        "Input Type": "Image"
-    },
-    {
-        "Input File": os.path.join(examples_dir, "2", "lp_video.mp4"),
-        "Output File": os.path.join(examples_dir, "2", "lp_video_output.mp4"),
-        "Input Type": "Video"
-    }
-]
-
-# Validate example file paths
-for ex in examples:
-    if not os.path.exists(ex["Input File"]):
-        logger.error(f"Input file not found: {ex['Input File']}")
-    if not os.path.exists(ex["Output File"]):
-        logger.error(f"Output file not found: {ex['Output File']}")
-
-# Function to handle example selection
-def select_example(selected_row, examples_data):
-    logger.info(f"Selected row: {selected_row}")
-    if selected_row is not None:
-        try:
-            row_index = int(selected_row[0]) if isinstance(selected_row, list) else int(selected_row)
-            if 0 <= row_index < len(examples):
-                selected_example = examples[row_index]
-                input_file_path = selected_example["Input File"]
-                logger.info(f"Loading file: {input_file_path}")
-                return input_file_path, selected_example["Input Type"], None, None, None
-        except (IndexError, ValueError, TypeError) as e:
-            logger.error(f"Error selecting example: {e}")
-    return None, "Image", None, None, None  # Default return if selection fails
-
-# Gradio Interface
-with gr.Blocks(css=custom_css) as iface:
-    gr.Markdown(
-        """
-        # License Plate Detection and OCR
-        Detect license plates from images or videos and read their text using 
-        advanced computer vision and OCR for accurate identification.
-        """,
-        elem_classes="markdown-title"
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_file = gr.File(label="Upload Image or Video", file_types=["image", "video"], elem_classes="custom-file-input")
-            input_type = gr.Radio(choices=["Image", "Video"], label="Input Type", value="Image", elem_classes="custom-radio")
-            with gr.Blocks():
-                input_preview_image = gr.Image(label="Input Preview", visible=True, elem_classes="custom-image")
-                input_preview_video = gr.Video(label="Input Preview", visible=False, elem_classes="custom-video")
-            with gr.Row():
-                clear_button = gr.Button("Clear", variant="secondary", elem_classes="custom-button secondary")
-                submit_button = gr.Button("Submit", variant="primary", elem_classes="custom-button primary")
-            
-            # Examples table
-            gr.Markdown("### Examples")
-            examples_table = gr.Dataframe(
-                value=[[os.path.basename(ex["Input File"]), os.path.basename(ex["Output File"]), ex["Input Type"]] for ex in examples],
-                headers=["Input File", "Output File", "Input Type"],
-                interactive=True,  # Allow row selection
-                elem_classes="custom-table"
-            )
-
-        with gr.Column(scale=2):
-            with gr.Blocks():
-                output_image = gr.Image(label="Processed Output (Image)", type="numpy", visible=True, elem_classes="custom-image")
-                output_video = gr.Video(label="Processed Output (Video)", visible=False, elem_classes="custom-video")
-            output_text = gr.Textbox(label="Detected License Plates", lines=10, elem_classes="custom-textbox")
-
-    # Bind example selection after all components are defined
-    examples_table.change(
-        fn=select_example,
-        inputs=[examples_table, examples_table],
-        outputs=[input_file, input_type, output_image, output_video, output_text]
-    )
-
-    # Update preview and output visibility when input type changes
-    input_type.change(
-        fn=update_visibility,
-        inputs=input_type,
-        outputs=[input_preview_image, input_preview_video, output_image, output_video]
-    )
-
-    # Update preview when file is uploaded
-    input_file.change(
-        fn=update_preview,
-        inputs=[input_file, input_type],
-        outputs=[input_preview_image, input_preview_video]
-    )
-
-    # Bind the processing function
-    submit_button.click(
-        fn=gradio_process,
-        inputs=[input_file, input_type],
-        outputs=[output_image, output_video, output_text, input_preview_image, input_preview_video]
-    )
-
-    # Clear button functionality
-    clear_button.click(
-        fn=lambda: (None, None, None, "Image", None, None, None, None),
-        outputs=[input_file, output_image, output_video, input_type, input_preview_image, input_preview_video, output_image, output_video]
-    )
-
-if __name__ == "__main__":
-    iface.launch()
+import gradio as gr
+import os
+from gradio_app.config import setup_logging, setup_sys_path
+from gradio_app.processor import gradio_process, update_preview, update_visibility, clear_preview_data
+
+# Initialize logging and sys.path
+setup_logging()
+setup_sys_path()
+
+# Load custom CSS
+custom_css = open(os.path.join(os.path.dirname(__file__), "gradio_app", "static", "styles.css"), "r").read()
+
+# Define example files
+examples = [
+    {
+        "input_file": os.path.join(os.path.dirname(__file__), "gradio_app", "assets", "examples", "license_plate_detector_ocr", "1", "lp_image.jpg"),
+        "output_file": os.path.join(os.path.dirname(__file__), "gradio_app", "assets", "examples", "license_plate_detector_ocr", "1", "lp_image_output.jpg"),
+        "input_type": "Image"
+    },
+    {
+        "input_file": os.path.join(os.path.dirname(__file__), "gradio_app", "assets", "examples", "license_plate_detector_ocr", "2", "lp_video.mp4"),
+        "output_file": os.path.join(os.path.dirname(__file__), "gradio_app", "assets", "examples", "license_plate_detector_ocr", "2", "lp_video_output.mp4"),
+        "input_type": "Video"
+    }
+]
+
+# Function to handle example selection
+def load_example(evt: gr.SelectData):
+    index = evt.index[0] if evt.index else 0
+    example = examples[index]
+    input_file = example["input_file"]
+    output_file = example["output_file"]
+    input_type = example["input_type"]
+    
+    # Update visibility based on input type
+    input_preview_image, input_preview_video, output_image, output_video = update_visibility(input_type)
+    
+    # Update preview based on input file and type
+    input_preview_image, input_preview_video = update_preview(input_file, input_type)
+    
+    return (
+        input_file,
+        input_type,
+        input_preview_image,
+        input_preview_video,
+        output_file if input_type == "Image" else None,
+        output_file if input_type == "Video" else None,
+        "Example loaded - click Submit to process"
+    )
+
+# Gradio Interface
+with gr.Blocks(css=custom_css) as iface:
+    gr.Markdown(
+        """
+        # License Plate Detection and OCR
+        Detect license plates from images or videos and read their text using 
+        advanced computer vision and OCR for accurate identification.
+        """,
+        elem_classes="markdown-title"
+    )
+
+        
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_file = gr.File(label="Upload Image or Video", elem_classes="custom-file-input")
+            input_type = gr.Radio(choices=["Image", "Video"], label="Input Type", value="Image", elem_classes="custom-radio")
+            with gr.Blocks():
+                input_preview_image = gr.Image(label="Input Preview", visible=True, elem_classes="custom-image")
+                input_preview_video = gr.Video(label="Input Preview", visible=False, elem_classes="custom-video")
+            with gr.Row():
+                clear_button = gr.Button("Clear", variant="secondary", elem_classes="custom-button secondary")
+                submit_button = gr.Button("Submit", variant="primary", elem_classes="custom-button primary")
+        with gr.Column(scale=1):
+            with gr.Blocks():
+                output_image = gr.Image(label="Processed Output (Image)", type="numpy", visible=True, elem_classes="custom-image")
+                output_video = gr.Video(label="Processed Output (Video)", visible=False, elem_classes="custom-video")
+            output_text = gr.Textbox(label="Detected License Plates", lines=10, elem_classes="custom-textbox")
+
+    # Update preview and output visibility when input type changes
+    input_type.change(
+        fn=update_visibility,
+        inputs=input_type,
+        outputs=[input_preview_image, input_preview_video, output_image, output_video]
+    )
+
+    # Update preview when file is uploaded
+    input_file.change(
+        fn=update_preview,
+        inputs=[input_file, input_type],
+        outputs=[input_preview_image, input_preview_video]
+    )
+    
+    # Bind the processing function
+    submit_button.click(
+        fn=gradio_process,
+        inputs=[input_file, input_type],
+        outputs=[output_image, output_video, output_text, input_preview_image, input_preview_video]
+    )
+    
+    # Clear button functionality
+    clear_button.click(
+        fn=lambda: (None, None, None, "Image", None, None, None, None),
+        outputs=[input_file, output_image, output_video, input_type, input_preview_image, input_preview_video, output_image, output_video]
+    ).then(
+        fn=clear_preview_data,
+        inputs=None,
+        outputs=None
+    )
+
+    # Examples table
+    with gr.Row():
+        gr.Markdown("### Examples")
+
+    with gr.Row():
+        example_table = gr.Dataframe(
+            value=[[i, ex["input_type"], os.path.basename(ex["input_file"])] for i, ex in enumerate(examples)],
+            headers=["Index", "Type", "File"],
+            datatype=["number", "str", "str"],
+            interactive=True,
+            elem_classes="custom-table"
+        )
+
+    # Example table click handler
+    example_table.select(
+        fn=load_example,
+        inputs=None,
+        outputs=[input_file, input_type, input_preview_image, input_preview_video, output_image, output_video, output_text]
+    )
+
+if __name__ == "__main__":
+    iface.launch(share=True)

apps/gradio_app/assets/examples/license_plate_detector_ocr/2/lp_video.mp4

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

apps/gradio_app/assets/examples/license_plate_detector_ocr/2/lp_video_output.mp4

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

apps/gradio_app/processor.py

@@ -4,7 +4,9 @@ import shutil
 import traceback
 import logging
 import gradio as gr
-import uuid  # Import uuid module
+import uuid
+import cv2
+import time
 from gradio_app.utils import convert_to_supported_format
 
 # Adjust sys.path to include the src directory
@@ -13,60 +15,125 @@ from infer import infer, is_image_file
 
 def gradio_process(input_file, input_type):
     """Process the input file (image or video) for license plate detection and OCR."""
+    unique_id = str(uuid.uuid4())[:8]
+    temp_input_dir = os.path.abspath(os.path.join("apps/gradio_app/temp_data", unique_id))
+    preview_dir = os.path.abspath(os.path.join("apps/gradio_app/preview_data", unique_id))
     try:
-        logging.debug(f"Input file path: {input_file.name}")
-        print(f"Input file path: {input_file.name}")
+        file_path = input_file.name if hasattr(input_file, 'name') else input_file
+        logging.debug(f"Input file path: {file_path}")
+        print(f"Input file path: {file_path}")
         
-        # Copy input file to temp_data directory to ensure stability
-        temp_input_dir = "apps/gradio_app/temp_data"
-        os.makedirs(temp_input_dir, exist_ok=True)
-        temp_input_path = os.path.join(temp_input_dir, os.path.basename(input_file.name))
-        shutil.copy(input_file.name, temp_input_path)
-        logging.debug(f"Copied input file to: {temp_input_path}")
-        
-        # Verify input file exists
-        if not os.path.exists(temp_input_path):
-            error_msg = f"Error: Input file {temp_input_path} does not exist."
+        # Verify source file exists and is readable
+        if not os.path.exists(file_path):
+            error_msg = f"Error: Source file {file_path} does not exist."
+            logging.error(error_msg)
+            return None, None, error_msg, None, None
+        if not os.access(file_path, os.R_OK):
+            error_msg = f"Error: Source file {file_path} is not readable."
             logging.error(error_msg)
             return None, None, error_msg, None, None
         
-        # Set output path with UUID
-        output_dir = "apps/gradio_app/temp_data"
+        # Create unique temp and preview directories
+        os.makedirs(temp_input_dir, exist_ok=True)
+        os.makedirs(preview_dir, exist_ok=True)
+        temp_input_path = os.path.join(temp_input_dir, os.path.basename(file_path))
+        preview_input_path = os.path.join(preview_dir, os.path.basename(file_path))
+        
+        # Copy input file to temp and preview directories with retry
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                shutil.copy2(file_path, temp_input_path)  # Copy to temp for processing
+                shutil.copy2(file_path, preview_input_path)  # Copy to preview for display
+                os.chmod(temp_input_path, 0o644)
+                os.chmod(preview_input_path, 0o644)
+                logging.debug(f"Copied input file to: {temp_input_path} and {preview_input_path}")
+                break
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    error_msg = f"Error copying file {file_path} to {temp_input_path} or {preview_input_path} after {max_retries} attempts: {str(e)}"
+                    logging.error(error_msg)
+                    return None, None, error_msg, None, None
+                time.sleep(0.5)  # Brief delay before retry
+        
+        # Verify copied files
+        for path in [temp_input_path, preview_input_path]:
+            if not os.path.exists(path):
+                error_msg = f"Error: Copied file {path} does not exist."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+            if not os.access(path, os.R_OK):
+                error_msg = f"Error: Copied file {path} is not readable."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+            if os.path.getsize(path) == 0:
+                error_msg = f"Error: Copied file {path} is empty."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+        
+        # Validate image or video
+        if is_image_file(temp_input_path):
+            img = cv2.imread(temp_input_path)
+            if img is None:
+                error_msg = f"Error: Could not load image from {temp_input_path}."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+            # Check image properties
+            height, width, channels = img.shape
+            logging.debug(f"Image properties: {width}x{height}, {channels} channels")
+            if channels not in (1, 3, 4):
+                error_msg = f"Error: Unsupported number of channels ({channels}) in {temp_input_path}. Expected 1, 3, or 4."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+            if width == 0 or height == 0:
+                error_msg = f"Error: Invalid image dimensions ({width}x{height}) in {temp_input_path}."
+                logging.error(error_msg)
+                return None, None, error_msg, None, None
+        else:
+            cap = cv2.VideoCapture(temp_input_path)
+            if not cap.isOpened():
+                error_msg = f"Error: Could not open video at {temp_input_path}."
+                logging.error(error_msg)
+                cap.release()
+                return None, None, error_msg, None, None
+            cap.release()
+        
+        # Set output path
+        output_dir = os.path.abspath(os.path.join("apps/gradio_app/temp_data", str(uuid.uuid4())[:8]))
         os.makedirs(output_dir, exist_ok=True)
-        # Modified line with UUID
-        unique_id = str(uuid.uuid4())[:8]  # Use first 8 characters of UUID for brevity
         output_filename = f"{os.path.splitext(os.path.basename(temp_input_path))[0]}_{unique_id}_output{'_output.jpg' if is_image_file(temp_input_path) else '_output.mp4'}"
         output_path = os.path.join(output_dir, output_filename)
         logging.debug(f"Output path: {output_path}")
         
         # Call the infer function
+        logging.debug(f"Calling infer with input: {temp_input_path}, output: {output_path}")
         result_array, plate_texts = infer(temp_input_path, output_path)
         
         if result_array is None and is_image_file(temp_input_path):
-            error_msg = f"Error: Processing failed for {temp_input_path}. 'infer' returned None."
+            error_msg = f"Error: Processing failed for {temp_input_path}. 'infer' returned None. Check infer.py logs for details."
             logging.error(error_msg)
-            return None, None, error_msg, None, None
+            return None, None, error_msg, preview_input_path if is_image_file(temp_input_path) else None, preview_input_path if not is_image_file(temp_input_path) else None
         
         # Validate output file for videos
         if not is_image_file(temp_input_path):
             if not os.path.exists(output_path):
                 error_msg = f"Error: Output video file {output_path} was not created."
                 logging.error(error_msg)
-                return None, None, error_msg, None, None
+                return None, None, error_msg, None, preview_input_path
             # Convert output video to supported format
             converted_output_path = os.path.join(output_dir, f"converted_{os.path.basename(output_path)}")
             converted_path = convert_to_supported_format(output_path, converted_output_path)
             if converted_path is None:
                 error_msg = f"Error: Failed to convert output video {output_path} to supported format."
                 logging.error(error_msg)
-                return None, None, error_msg, None, None
+                return None, None, error_msg, None, preview_input_path
             output_path = converted_path
         
         # Format plate texts
         if is_image_file(temp_input_path):
             formatted_texts = "\n".join(plate_texts) if plate_texts else "No plates detected"
             logging.debug(f"Image processed successfully. Plate texts: {formatted_texts}")
-            return result_array, None, formatted_texts, temp_input_path, None
+            return result_array, None, formatted_texts, preview_input_path, None
         else:
             formatted_texts = []
             for i, texts in enumerate(plate_texts):
@@ -74,28 +141,52 @@ def gradio_process(input_file, input_type):
                     formatted_texts.append(f"Frame {i+1}: {', '.join(texts)}")
             formatted_texts = "\n".join(formatted_texts) if formatted_texts else "No plates detected"
             logging.debug(f"Video processed successfully. Plate texts: {formatted_texts}")
-            return None, output_path, formatted_texts, None, temp_input_path
+            return None, output_path, formatted_texts, None, preview_input_path
     except Exception as e:
-        error_message = f"Error processing {input_file.name}: {str(e)}\n{traceback.format_exc()}"
+        error_message = f"Error processing {file_path}: {str(e)}\n{traceback.format_exc()}"
         logging.error(error_message)
         print(error_message)
-        return None, None, error_message, None, None
+        return None, None, error_message, preview_input_path if is_image_file(file_path) else None, preview_input_path if not is_image_file(file_path) else None
+    finally:
+        # Clean up temp directory after processing, but keep preview directory
+        if os.path.exists(temp_input_dir):
+            shutil.rmtree(temp_input_dir, ignore_errors=True)
+            logging.debug(f"Cleaned up temporary directory: {temp_input_dir}")
 
 def update_preview(file, input_type):
     """Return file path for the appropriate preview component based on input type."""
     if not file:
         logging.debug("No file provided for preview.")
         return None, None
-    logging.debug(f"Updating preview for {input_type}: {file.name}")
+    
+    # Handle both file objects and string paths
+    file_path = file.name if hasattr(file, 'name') else file
+    logging.debug(f"Updating preview for {input_type}: {file_path}")
+    
     # Verify file exists
-    if not os.path.exists(file.name):
-        logging.error(f"Input file {file.name} does not exist.")
+    if not os.path.exists(file_path):
+        logging.error(f"Input file {file_path} does not exist.")
         return None, None
+    
     # Check if video format is supported
-    if input_type == "Video" and not file.name.lower().endswith(('.mp4', '.webm')):
-        logging.error(f"Unsupported video format for {file.name}. Use MP4 or WebM.")
+    if input_type == "Video" and not file_path.lower().endswith(('.mp4', '.webm')):
+        logging.error(f"Unsupported video format for {file_path}. Use MP4 or WebM.")
         return None, None
-    return file.name if input_type == "Image" else None, file.name if input_type == "Video" else None
+    
+    # Copy to preview directory for persistent display
+    unique_id = str(uuid.uuid4())[:8]
+    preview_dir = os.path.abspath(os.path.join("apps/gradio_app/preview_data", unique_id))
+    os.makedirs(preview_dir, exist_ok=True)
+    preview_input_path = os.path.join(preview_dir, os.path.basename(file_path))
+    try:
+        shutil.copy2(file_path, preview_input_path)
+        os.chmod(preview_input_path, 0o644)
+        logging.debug(f"Copied preview file to: {preview_input_path}")
+    except Exception as e:
+        logging.error(f"Error copying preview file to {preview_input_path}: {str(e)}")
+        return None, None
+    
+    return preview_input_path if input_type == "Image" else None, preview_input_path if input_type == "Video" else None
 
 def update_visibility(input_type):
     """Update visibility of input/output components based on input type."""
@@ -107,4 +198,12 @@ def update_visibility(input_type):
         gr.update(visible=is_video),
         gr.update(visible=is_image),
         gr.update(visible=is_video)
-    )
+    )
+
+def clear_preview_data():
+    """Clear all files in the preview_data directory."""
+    preview_data_dir = os.path.abspath("apps/gradio_app/preview_data")
+    if os.path.exists(preview_data_dir):
+        shutil.rmtree(preview_data_dir, ignore_errors=True)
+        logging.debug(f"Cleared preview_data directory: {preview_data_dir}")
+    os.makedirs(preview_data_dir, exist_ok=True)

apps/old3-gradio_app.py

@@ -0,0 +1,68 @@
+import gradio as gr
+import os
+from gradio_app.config import setup_logging, setup_sys_path
+from gradio_app.processor import gradio_process, update_preview, update_visibility
+
+# Initialize logging and sys.path
+setup_logging()
+setup_sys_path()
+
+# Load custom CSS
+custom_css = open(os.path.join(os.path.dirname(__file__), "gradio_app", "static", "styles.css"), "r").read()
+
+# Gradio Interface
+with gr.Blocks(css=custom_css) as iface:
+    gr.Markdown(
+        """
+        # License Plate Detection and OCR
+        Detect license plates from images or videos and read their text using 
+        advanced computer vision and OCR for accurate identification.
+        """,
+        elem_classes="markdown-title"
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_file = gr.File(label="Upload Image or Video", elem_classes="custom-file-input")
+            input_type = gr.Radio(choices=["Image", "Video"], label="Input Type", value="Image", elem_classes="custom-radio")
+            with gr.Blocks():
+                input_preview_image = gr.Image(label="Input Preview", visible=True, elem_classes="custom-image")
+                input_preview_video = gr.Video(label="Input Preview", visible=False, elem_classes="custom-video")
+            with gr.Row():
+                clear_button = gr.Button("Clear", variant="secondary", elem_classes="custom-button secondary")
+                submit_button = gr.Button("Submit", variant="primary", elem_classes="custom-button primary")
+        with gr.Column(scale=2):
+            with gr.Blocks():
+                output_image = gr.Image(label="Processed Output (Image)", type="numpy", visible=True, elem_classes="custom-image")
+                output_video = gr.Video(label="Processed Output (Video)", visible=False, elem_classes="custom-video")
+            output_text = gr.Textbox(label="Detected License Plates", lines=10, elem_classes="custom-textbox")
+
+    # Update preview and output visibility when input type changes
+    input_type.change(
+        fn=update_visibility,
+        inputs=input_type,
+        outputs=[input_preview_image, input_preview_video, output_image, output_video]
+    )
+
+    # Update preview when file is uploaded
+    input_file.change(
+        fn=update_preview,
+        inputs=[input_file, input_type],
+        outputs=[input_preview_image, input_preview_video]
+    )
+    
+    # Bind the processing function
+    submit_button.click(
+        fn=gradio_process,
+        inputs=[input_file, input_type],
+        outputs=[output_image, output_video, output_text, input_preview_image, input_preview_video]
+    )
+    
+    # Clear button functionality
+    clear_button.click(
+        fn=lambda: (None, None, None, "Image", None, None, None, None),
+        outputs=[input_file, output_image, output_video, input_type, input_preview_image, input_preview_video, output_image, output_video]
+    )
+
+if __name__ == "__main__":
+    iface.launch(share=True)

assets/examples/license_plate_detector_ocr/2/lp_video.mp4

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

assets/examples/license_plate_detector_ocr/2/lp_video_output.mp4

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

requirements/requirements.txt

@@ -1,8 +1,9 @@
-opencv-python
-ultralytics
-roboflow
+opencv-python>=4.11.0.86
+ultralytics>=8.3.162
+roboflow>=1.1.66
 wget
+albumentations==2.0.8
 ffmpeg-python
-paddleocr
-paddlepaddle-gpu
-paddlepaddle
+paddleocr==2.9.0 
+paddlepaddle-gpu==2.6.2 
+paddlepaddle==2.6.2

requirements/requirements_compatible.txt

@@ -2,6 +2,7 @@ opencv-python==4.11.0.86
 ultralytics==8.3.162
 roboflow==1.1.66
 wget==3.2
+albumentations==2.0.8
 ffmpeg-python==0.2.0
 paddleocr==2.9.0 
 paddlepaddle-gpu==2.6.2 

src/license_plate_detector_ocr/infer.py

@@ -1,168 +1,54 @@
 import os
 import sys
-import cv2
-import numpy as np
-from ultralytics import YOLO
-from inference.paddleocr_infer import process_ocr
+import logging
+import traceback
+from inference.image_video_processor import process_image, process_video
 
 # Append the current directory to sys.path
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
 
 def is_image_file(file_path):
     """Check if the file is an image based on its extension."""
     image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}
     return os.path.splitext(file_path)[1].lower() in image_extensions
 
-def process_image(model, image_path, output_path=None):
-    """Process a single image for license plate detection and OCR."""
-    image = cv2.imread(image_path)
-    if image is None:
-        print(f"Error: Could not load image from {image_path}")
-        return None, None
-    
-    try:
-        results = model(image_path)
-    except Exception as e:
-        print(f"Error during image inference: {e}")
-        return None, None
-    
-    plate_texts = []
-    for result in results:
-        for box in result.boxes:
-            x1, y1, x2, y2 = map(int, box.xyxy[0])
-            confidence = box.conf[0]
-            
-            # Crop the license plate region
-            plate_region = image[y1:y2, x1:x2]
-            # Run OCR on the cropped region
-            ocr_results = process_ocr(plate_region)
-            plate_text = ocr_results[0] if ocr_results else "No text detected"
-            plate_texts.append(plate_text)
-            
-            # Draw bounding box and OCR text on the image
-            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
-            label = f"{plate_text} ({confidence:.2f})"
-            cv2.putText(image, label, (x1, y1 - 10),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-    
-    # Set default output path if not provided
-    if output_path is None:
-        output_path = os.path.splitext(image_path)[0] + '_output.jpg'
-    
-    # Ensure output directory exists
-    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
-    cv2.imwrite(output_path, image)
-    print(f"Saved processed image to {output_path}")
-    
-    return image, plate_texts
-
-def process_video(model, video_path, output_path=None):
-    """Process a video for license plate detection and OCR, writing text on detected boxes."""
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        print(f"Error: Could not open video at {video_path}")
-        return None, None
-    
-    # Get video properties
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    
-    # Set default output path if not provided
-    if output_path is None:
-        output_path = os.path.splitext(video_path)[0] + '_output.mp4'
-    
-    # Ensure output directory exists
-    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
-    
-    # Prepare output video
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-    
-    frames = []
-    all_plate_texts = []
-    
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            print("End of video or error reading frame.")
-            break
-        
-        try:
-            results = model(frame)
-        except Exception as e:
-            print(f"Error during video inference: {e}")
-            break
-        
-        frame_plate_texts = []
-        boxes_detected = False
-        
-        for result in results:
-            for box in result.boxes:
-                boxes_detected = True
-                x1, y1, x2, y2 = map(int, box.xyxy[0])
-                confidence = box.conf[0]
-                
-                # Crop the license plate region
-                plate_region = frame[y1:y2, x1:x2]
-                
-                # Run OCR on the cropped region
-                ocr_results = process_ocr(plate_region)
-                plate_text = ocr_results[0] if ocr_results else "No text detected"
-                frame_plate_texts.append(plate_text)
-                
-                # Draw bounding box and OCR text on the frame
-                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-                label = f"{plate_text} ({confidence:.2f})"
-                cv2.putText(frame, label, (x1, y1 - 10),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-        
-        if boxes_detected:
-            frames.append(frame)
-            all_plate_texts.append(frame_plate_texts)
-        else:
-            # Append frame even if no boxes detected to maintain video continuity
-            frames.append(frame)
-            all_plate_texts.append([])
-        
-        out.write(frame)
-    
-    cap.release()
-    out.release()
-    print(f"Saved processed video to {output_path}")
-    
-    if not frames:
-        print("No frames processed.")
-        return None, None
-    
-    # Convert list of frames to 4D NumPy array
-    video_array = np.stack(frames, axis=0)
-    return video_array, all_plate_texts
-
 def infer(input_path, output_path=None):
-    """Main function to process either an image or video for license plate detection and OCR."""
+    """Process an image or video for license plate detection and OCR."""
     model_path = "ckpts/yolo/finetune/runs/license_plate_detector/weights/best.pt"
     
+    logging.debug(f"Starting inference for {input_path} with output {output_path}")
+    
     if not os.path.exists(model_path):
-        print(f"Error: Model file not found at {model_path}")
+        error_msg = f"Error: Model file not found at {model_path}"
+        logging.error(error_msg)
+        print(error_msg)
         return None, None
     
     if not os.path.exists(input_path):
-        print(f"Error: Input file not found at {input_path}")
+        error_msg = f"Error: Input file not found at {input_path}"
+        logging.error(error_msg)
+        print(error_msg)
         return None, None
     
     try:
-        model = YOLO(model_path)
+        if is_image_file(input_path):
+            result_array, plate_texts = process_image(model_path, input_path, output_path)
+        else:
+            result_array, plate_texts = process_video(model_path, input_path, output_path)
+        
+        if result_array is None:
+            error_msg = f"Error: Processing failed in {'process_image' if is_image_file(input_path) else 'process_video'} for {input_path}"
+            logging.error(error_msg)
+            print(error_msg)
+            return None, None
+        
+        logging.debug(f"Inference successful: {len(plate_texts)} plates detected")
+        return result_array, plate_texts
     except Exception as e:
-        print(f"Error loading model: {e}")
+        error_msg = f"Error during inference for {input_path}: {str(e)}\n{traceback.format_exc()}"
+        logging.error(error_msg)
+        print(error_msg)
         return None, None
-    
-    if is_image_file(input_path):
-        result_array, plate_texts = process_image(model, input_path, output_path)
-    else:
-        result_array, plate_texts = process_video(model, video_path=input_path, output_path=output_path)
-    
-    return result_array, plate_texts
 
 if __name__ == "__main__":
     import argparse

src/license_plate_detector_ocr/inference/image_video_processor.py

@@ -0,0 +1,134 @@
+import os
+import cv2
+import numpy as np
+from uuid import uuid4
+from inference.yolo_infer import yolo_infer
+from inference.paddleocr_infer import process_ocr
+
+def process_image(model_path, image_path, output_path=None):
+    """Process a single image for license plate detection and OCR."""
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Error: Could not load image from {image_path}")
+        return None, None
+    
+    try:
+        results = yolo_infer(model_path, image_path)
+    except Exception as e:
+        print(f"Error during image inference: {e}")
+        return None, None
+    
+    plate_texts = []
+    for result in results:
+        for box in result.boxes:
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            confidence = box.conf[0]
+            
+            # Crop the license plate region
+            plate_region = image[y1:y2, x1:x2]
+            # Run OCR on the cropped region
+            ocr_results = process_ocr(plate_region)
+            plate_text = ocr_results[0] if ocr_results else "No text detected"
+            plate_texts.append(plate_text)
+            
+            # Draw bounding box and OCR text on the image
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            label = f"{plate_text} ({confidence:.2f})"
+            cv2.putText(image, label, (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+    
+    # Set default output path with UUID if not provided
+    if output_path is None:
+        output_dir = "apps/gradio_app/temp_data"
+        output_path = os.path.join(output_dir, f"output_{uuid4()}.jpg")
+    
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
+    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(output_path, image)
+    print(f"Saved processed image to {output_path}")
+    
+    return image, plate_texts
+
+def process_video(model_path, video_path, output_path=None):
+    """Process a video for license plate detection and OCR."""
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"Error: Could not open video at {video_path}")
+        return None, None
+    
+    # Get video properties
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    
+    # Set default output path with UUID if not provided
+    if output_path is None:
+        output_dir = "apps/gradio_app/temp_data"
+        output_path = os.path.join(output_dir, f"output_{uuid4()}.mp4")
+    
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
+    
+    # Prepare output video
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    frames = []
+    all_plate_texts = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            print("End of video or error reading frame.")
+            break
+        
+        try:
+            results = yolo_infer(model_path, frame)
+        except Exception as e:
+            print(f"Error during video inference: {e}")
+            break
+        
+        frame_plate_texts = []
+        boxes_detected = False
+        
+        for result in results:
+            for box in result.boxes:
+                boxes_detected = True
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                confidence = box.conf[0]
+                
+                # Crop the license plate region
+                plate_region = frame[y1:y2, x1:x2]
+                
+                # Run OCR on the cropped region
+                ocr_results = process_ocr(plate_region)
+                plate_text = ocr_results[0] if ocr_results else "No text detected"
+                frame_plate_texts.append(plate_text)
+                
+                # Draw bounding box and OCR text on the frame
+                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                label = f"{plate_text} ({confidence:.2f})"
+                cv2.putText(frame, label, (x1, y1 - 10),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        if boxes_detected:
+            frames.append(frame)
+            all_plate_texts.append(frame_plate_texts)
+        else:
+            frames.append(frame)
+            all_plate_texts.append([])
+        
+        out.write(frame)
+    
+    cap.release()
+    out.release()
+    print(f"Saved processed video to {output_path}")
+    
+    if not frames:
+        print("No frames processed.")
+        return None, None
+    
+    # Convert list of frames to 4D NumPy array
+    video_array = np.stack(frames, axis=0)
+    return video_array, all_plate_texts

src/license_plate_detector_ocr/inference/yolo_infer.py

@@ -0,0 +1,26 @@
+from ultralytics import YOLO
+
+_model_cache = None
+
+def load_yolo_model(model_path):
+    """Load and cache the YOLO model from the specified path."""
+    global _model_cache
+    if _model_cache is None:
+        try:
+            _model_cache = YOLO(model_path, verbose=False)
+        except Exception as e:
+            raise Exception(f"Error loading YOLO model: {e}")
+    return _model_cache
+
+def yolo_infer(model_path, input_data):
+    """Perform YOLO inference on input data using the cached model."""
+    try:
+        model = load_yolo_model(model_path)
+        results = model(input_data, verbose=False)
+        return results
+    except Exception as e:
+        print(f"Error during YOLO inference: {e}")
+        return []
+
+if __name__ == "__main__":
+    print("This module is intended for import, not direct execution.")

src/license_plate_detector_ocr/old2-infer.py

@@ -0,0 +1,173 @@
+import os
+import sys
+import cv2
+import numpy as np
+from ultralytics import YOLO
+from inference.paddleocr_infer import process_ocr
+
+# Append the current directory to sys.path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
+
+def is_image_file(file_path):
+    """Check if the file is an image based on its extension."""
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}
+    return os.path.splitext(file_path)[1].lower() in image_extensions
+
+def process_image(model, image_path, output_path=None):
+    """Process a single image for license plate detection and OCR."""
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Error: Could not load image from {image_path}")
+        return None, None
+    
+    try:
+        results = model(image_path)
+    except Exception as e:
+        print(f"Error during image inference: {e}")
+        return None, None
+    
+    plate_texts = []
+    for result in results:
+        for box in result.boxes:
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            confidence = box.conf[0]
+            
+            # Crop the license plate region
+            plate_region = image[y1:y2, x1:x2]
+            # Run OCR on the cropped region
+            ocr_results = process_ocr(plate_region)
+            plate_text = ocr_results[0] if ocr_results else "No text detected"
+            plate_texts.append(plate_text)
+            
+            # Draw bounding box and OCR text on the image
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            label = f"{plate_text} ({confidence:.2f})"
+            cv2.putText(image, label, (x1, y1 - 10),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+    
+    # Set default output path if not provided
+    if output_path is None:
+        output_path = os.path.splitext(image_path)[0] + '_output.jpg'
+    
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
+    cv2.imwrite(output_path, image)
+    print(f"Saved processed image to {output_path}")
+    
+    return image, plate_texts
+
+def process_video(model, video_path, output_path=None):
+    """Process a video for license plate detection and OCR, writing text on detected boxes."""
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"Error: Could not open video at {video_path}")
+        return None, None
+    
+    # Get video properties
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    
+    # Set default output path if not provided
+    if output_path is None:
+        output_path = os.path.splitext(video_path)[0] + '_output.mp4'
+    
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(output_path) or '.', exist_ok=True)
+    
+    # Prepare output video
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    frames = []
+    all_plate_texts = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            print("End of video or error reading frame.")
+            break
+        
+        try:
+            results = model(frame)
+        except Exception as e:
+            print(f"Error during video inference: {e}")
+            break
+        
+        frame_plate_texts = []
+        boxes_detected = False
+        
+        for result in results:
+            for box in result.boxes:
+                boxes_detected = True
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                confidence = box.conf[0]
+                
+                # Crop the license plate region
+                plate_region = frame[y1:y2, x1:x2]
+                
+                # Run OCR on the cropped region
+                ocr_results = process_ocr(plate_region)
+                plate_text = ocr_results[0] if ocr_results else "No text detected"
+                frame_plate_texts.append(plate_text)
+                
+                # Draw bounding box and OCR text on the frame
+                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                label = f"{plate_text} ({confidence:.2f})"
+                cv2.putText(frame, label, (x1, y1 - 10),
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        if boxes_detected:
+            frames.append(frame)
+            all_plate_texts.append(frame_plate_texts)
+        else:
+            # Append frame even if no boxes detected to maintain video continuity
+            frames.append(frame)
+            all_plate_texts.append([])
+        
+        out.write(frame)
+    
+    cap.release()
+    out.release()
+    print(f"Saved processed video to {output_path}")
+    
+    if not frames:
+        print("No frames processed.")
+        return None, None
+    
+    # Convert list of frames to 4D NumPy array
+    video_array = np.stack(frames, axis=0)
+    return video_array, all_plate_texts
+
+def infer(input_path, output_path=None):
+    """Main function to process either an image or video for license plate detection and OCR."""
+    model_path = "ckpts/yolo/finetune/runs/license_plate_detector/weights/best.pt"
+    
+    if not os.path.exists(model_path):
+        print(f"Error: Model file not found at {model_path}")
+        return None, None
+    
+    if not os.path.exists(input_path):
+        print(f"Error: Input file not found at {input_path}")
+        return None, None
+    
+    try:
+        model = YOLO(model_path)
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return None, None
+    
+    if is_image_file(input_path):
+        result_array, plate_texts = process_image(model, input_path, output_path)
+    else:
+        result_array, plate_texts = process_video(model, video_path=input_path, output_path=output_path)
+    
+    return result_array, plate_texts
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Detect and read license plates in an image or video.")
+    parser.add_argument("--input_path", type=str, required=True, help="Path to the input image or video file")
+    parser.add_argument("--output_path", type=str, default=None, help="Path to save the output file (optional)")
+    args = parser.parse_args()
+    result_array, plate_texts = infer(args.input_path, args.output_path)

src/license_plate_detector_ocr/old3-infer.py

@@ -0,0 +1,56 @@
+import os
+import sys
+import shutil
+from inference.image_video_processor import process_image, process_video
+
+# Append the current directory to sys.path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
+
+def is_image_file(file_path):
+    """Check if the file is an image based on its extension."""
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}
+    return os.path.splitext(file_path)[1].lower() in image_extensions
+
+def clear_temp_directory(temp_dir="apps/gradio_app/temp_data"):
+    """Remove all files in the specified temporary directory."""
+    if os.path.exists(temp_dir):
+        try:
+            for filename in os.listdir(temp_dir):
+                file_path = os.path.join(temp_dir, filename)
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            print(f"Cleared temporary directory: {temp_dir}")
+        except Exception as e:
+            print(f"Error clearing temporary directory {temp_dir}: {e}")
+
+def infer(input_path, output_path=None):
+    """Process an image or video for license plate detection and OCR."""
+    model_path = "ckpts/yolo/finetune/runs/license_plate_detector/weights/best.pt"
+    
+    if not os.path.exists(model_path):
+        print(f"Error: Model file not found at {model_path}")
+        return None, None
+    
+    if not os.path.exists(input_path):
+        print(f"Error: Input file not found at {input_path}")
+        return None, None
+    
+    # Clear temporary directory before new inference
+    clear_temp_directory()
+    
+    if is_image_file(input_path):
+        result_array, plate_texts = process_image(model_path, input_path, output_path)
+    else:
+        result_array, plate_texts = process_video(model_path, input_path, output_path)
+    
+    return result_array, plate_texts
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Detect and read license plates in an image or video.")
+    parser.add_argument("--input_path", type=str, required=True, help="Path to the input image or video file")
+    parser.add_argument("--output_path", type=str, default=None, help="Path to save the output file (optional)")
+    args = parser.parse_args()
+    result_array, plate_texts = infer(args.input_path, args.output_path)