Upload 11 files

annotation_format_checker.py

@@ -0,0 +1,57 @@
+import cv2
+import matplotlib.pyplot as plt
+import os
+
+def check_yolo_annotations(image_dir, label_dir):
+    """
+    Checks if the conversion from VOC to YOLO format is correct by plotting bounding boxes on the images.
+
+    Parameters:
+    image_dir (str): Directory path to the images.
+    label_dir (str): Directory path to the YOLO format annotations.
+    """
+    # Get the first image file
+    image_files = sorted(os.listdir(image_dir))
+    first_image_file = image_files[0]
+
+    # Construct paths for the image and its corresponding label
+    image_path = os.path.join(image_dir, first_image_file)
+    label_path = os.path.join(label_dir, os.path.splitext(first_image_file)[0] + '.txt')
+
+    # Load the image using OpenCV
+    image = cv2.imread(image_path)
+    # Convert the image from BGR (OpenCV default) to RGB (matplotlib default)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Read the label file to get bounding box information
+    with open(label_path, 'r') as f:
+        lines = f.readlines()
+
+    # Plot the bounding box on the image
+    for line in lines:
+        # Parse the label file line to extract bounding box information
+        class_id, x_center, y_center, width, height = map(float, line.strip().split())
+        img_height, img_width, _ = image.shape
+
+        # Convert YOLO format to bounding box format
+        x_center *= img_width
+        y_center *= img_height
+        width *= img_width
+        height *= img_height
+
+        # Calculate the top-left and bottom-right coordinates of the bounding box
+        x1 = int(x_center - width / 2)
+        y1 = int(y_center - height / 2)
+        x2 = int(x_center + width / 2)
+        y2 = int(y_center + height / 2)
+
+        # Draw the bounding box on the image using a green rectangle
+        cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+
+    # Display the image with bounding box using matplotlib
+    plt.imshow(image)
+    plt.axis('off')  # Hide the axis
+    plt.show()  # Display the image
+
+if __name__ == "__main__":
+    check_yolo_annotations('Dataset/images', 'Dataset/yolo_annotations')

app.py

@@ -0,0 +1,93 @@
+import gradio as gr
+import cv2
+import matplotlib.pyplot as plt
+from ultralytics import YOLO
+import pytesseract
+
+def load_model(model_path):
+    """
+    Loads the YOLO model from the specified path.
+
+    Parameters:
+    model_path (str): Path to the YOLO model file.
+
+    Returns:
+    YOLO: Loaded YOLO model.
+    """
+    return YOLO(model_path)
+
+def predict_and_plot(image, model):
+    """
+    Predicts and plots the bounding boxes on the given image using the trained YOLO model.
+    Also performs OCR on the detected bounding boxes to extract text.
+
+    Parameters:
+    image (numpy.ndarray): Input image.
+    model (YOLO): The trained YOLO model.
+
+    Returns:
+    numpy.ndarray: Image with bounding boxes drawn.
+    str: Detected text from the bounding boxes.
+    """
+    # Perform prediction on the input image using the model
+    results = model.predict(image, device='cpu')
+
+    # Convert the image from BGR (OpenCV default) to RGB (matplotlib default)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    detected_texts = []
+
+    # Extract the bounding boxes and labels from the results
+    for result in results:
+        for box in result.boxes:
+            # Get the coordinates of the bounding box
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            # Get the confidence score of the prediction
+            confidence = box.conf[0]
+
+            # Draw the bounding box on the image
+            cv2.rectangle(image_rgb, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            # Draw the confidence score near the bounding box
+            cv2.putText(image_rgb, f'{confidence*100:.2f}%', (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
+
+            # Crop the bounding box from the image for OCR
+            roi = image[y1:y2, x1:x2]
+
+            # Perform OCR on the cropped image
+            text = pytesseract.image_to_string(roi, config='--psm 6')
+            detected_texts.append(text.strip())
+
+    detected_text = "\n".join(detected_texts)
+    return image_rgb, detected_text
+
+def main(image):
+    """
+    Main function to handle the prediction and plotting.
+
+    Parameters:
+    image (numpy.ndarray): Input image.
+
+    Returns:
+    numpy.ndarray: Image with bounding boxes drawn.
+    str: Detected text from the bounding boxes.
+    """
+    # Load the model (ensure 'best.pt' is in the correct path)
+    model = load_model('best.pt')
+    return predict_and_plot(image, model)
+
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=main,
+    inputs=gr.Image(type="numpy", label="Upload an Image"),
+    outputs=[
+        gr.Image(type="numpy", label="Output Image with Bounding Boxes"),
+        gr.Textbox(label="Detected Text")
+    ],
+    title="License Plate Detection and OCR",
+    description="Upload an image to detect license plates and extract text using YOLO and Tesseract OCR."
+)
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    iface.launch()

best.pt

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

data_preparation.py

@@ -0,0 +1,54 @@
+import os
+import shutil
+from sklearn.model_selection import train_test_split
+
+def prepare_data(dataset_path):
+    """
+    Prepares the dataset by splitting it into training, validation, and test sets.
+
+    Parameters:
+    dataset_path (str): Path to the dataset.
+    """
+    images_path = os.path.join(dataset_path, 'images')
+    yolo_annotations_path = os.path.join(dataset_path, 'yolo_annotations')
+
+    # Paths to split datasets
+    train_images_path = os.path.join(dataset_path, 'YOLO', 'train', 'images')
+    val_images_path = os.path.join(dataset_path, 'YOLO', 'val', 'images')
+    test_images_path = os.path.join(dataset_path, 'YOLO', 'test', 'images')
+
+    train_annotations_path = os.path.join(dataset_path, 'YOLO', 'train', 'labels')
+    val_annotations_path = os.path.join(dataset_path, 'YOLO', 'val', 'labels')
+    test_annotations_path = os.path.join(dataset_path, 'YOLO', 'test', 'labels')
+
+    # Create directories
+    os.makedirs(train_images_path, exist_ok=True)
+    os.makedirs(val_images_path, exist_ok=True)
+    os.makedirs(test_images_path, exist_ok=True)
+    os.makedirs(train_annotations_path, exist_ok=True)
+    os.makedirs(val_annotations_path, exist_ok=True)
+    os.makedirs(test_annotations_path, exist_ok=True)
+
+    # Get list of all images
+    all_images = [f for f in os.listdir(images_path) if f.endswith('.png')]
+    train_images, val_test_images = train_test_split(all_images, test_size=0.3, random_state=42)
+    val_images, test_images = train_test_split(val_test_images, test_size=0.33, random_state=42)
+
+    # Function to copy images and annotations
+    def copy_files(image_list, dest_image_path, dest_label_path):
+        for image in image_list:
+            image_path = os.path.join(images_path, image)
+            label_path = os.path.join(yolo_annotations_path, image.replace('.png', '.txt'))
+
+            shutil.copy(image_path, dest_image_path)
+            shutil.copy(label_path, dest_label_path)
+
+    # Copy files to respective directories
+    copy_files(train_images, train_images_path, train_annotations_path)
+    copy_files(val_images, val_images_path, val_annotations_path)
+    copy_files(test_images, test_images_path, test_annotations_path)
+
+    print("Dataset split into training, validation, and test sets.")
+
+if __name__ == "__main__":
+    prepare_data('Dataset')

label_format_converter_to_yolo.py

@@ -0,0 +1,61 @@
+import os
+import xml.etree.ElementTree as ET
+
+def convert_to_yolo(annotation_path, yolo_annotation_path):
+    """
+    Converts PASCAL VOC annotations to YOLO format.
+
+    Parameters:
+    annotation_path (str): Path to the PASCAL VOC annotation file.
+    yolo_annotation_path (str): Path to save the YOLO format annotation file.
+    """
+    tree = ET.parse(annotation_path)
+    root = tree.getroot()
+
+    # Get image dimensions
+    size = root.find('size')
+    width = int(size.find('width').text)
+    height = int(size.find('height').text)
+
+    # Open corresponding YOLO annotation file
+    yolo_annotation = open(yolo_annotation_path, 'w')
+
+    for obj in root.findall('object'):
+        class_id = 0  # Since all objects are 'license_plate', class_id is 0
+        bndbox = obj.find('bndbox')
+
+        xmin = int(bndbox.find('xmin').text)
+        ymin = int(bndbox.find('ymin').text)
+        xmax = int(bndbox.find('xmax').text)
+        ymax = int(bndbox.find('ymax').text)
+
+        # Convert to YOLO format
+        x_center = (xmin + xmax) / 2.0 / width
+        y_center = (ymin + ymax) / 2.0 / height
+        bbox_width = (xmax - xmin) / width
+        bbox_height = (ymax - ymin) / height
+
+        yolo_annotation.write(f"{class_id} {x_center} {y_center} {bbox_width} {bbox_height}\n")
+
+    yolo_annotation.close()
+
+def convert_all_annotations(annotations_path, yolo_annotations_path):
+    """
+    Converts all PASCAL VOC annotations in a directory to YOLO format.
+
+    Parameters:
+    annotations_path (str): Directory path to the PASCAL VOC annotations.
+    yolo_annotations_path (str): Directory path to save the YOLO format annotations.
+    """
+    os.makedirs(yolo_annotations_path, exist_ok=True)
+
+    for xml_file in os.listdir(annotations_path):
+        if xml_file.endswith('.xml'):
+            xml_path = os.path.join(annotations_path, xml_file)
+            yolo_annotation_path = os.path.join(yolo_annotations_path, xml_file.replace('.xml', '.txt'))
+            convert_to_yolo(xml_path, yolo_annotation_path)
+
+    print("Conversion to YOLO format completed.")
+
+if __name__ == "__main__":
+    convert_all_annotations('Dataset', 'Dataset/yolo_annotations')

predict.py

@@ -0,0 +1,52 @@
+import cv2
+import matplotlib.pyplot as plt
+from ultralytics import YOLO
+import pytesseract
+from pytesseract import Output
+
+def predict_and_plot(model, path_test_car):
+    """
+    Predicts and plots the bounding boxes on the given test image using the trained YOLO model.
+    Also performs OCR on the detected bounding boxes to extract text.
+
+    Parameters:
+    model (YOLO): The trained YOLO model.
+    path_test_car (str): Path to the test image file.
+    """
+    # Perform prediction on the test image using the model
+    results = model.predict(path_test_car, device='CPU')
+
+    # Load the image using OpenCV
+    image = cv2.imread(path_test_car)
+    # Convert the image from BGR (OpenCV default) to RGB (matplotlib default)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Extract the bounding boxes and labels from the results
+    for result in results:
+        for box in result.boxes:
+            # Get the coordinates of the bounding box
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            # Get the confidence score of the prediction
+            confidence = box.conf[0]
+
+            # Draw the bounding box on the image
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            # Draw the confidence score near the bounding box
+            cv2.putText(image, f'{confidence*100:.2f}%', (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
+
+            # Crop the bounding box from the image for OCR
+            roi = image[y1:y2, x1:x2]
+
+            # Perform OCR on the cropped image
+            text = pytesseract.image_to_string(roi, config='--psm 6')
+            print(f"Detected text: {text}")
+
+    # Plot the image with bounding boxes
+    plt.imshow(image)
+    plt.axis('off')  # Hide the axis
+    plt.show()  # Display the image
+
+if __name__ == "__main__":
+    model = YOLO('best.pt')
+    predict_and_plot(model, "Dataset/images/Cars9.png")

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow 
+opencv-python-headless 
+tesseract 
+pytesseract 
+ultralytics

train.py

@@ -0,0 +1,36 @@
+from ultralytics import YOLO
+
+def train_model(model_path, data_path, epochs, batch_size, device, img_size, save_dir):
+    """
+    Trains the YOLO model on the specified dataset.
+
+    Parameters:
+    model_path (str): Path to the YOLO model.
+    data_path (str): Path to the dataset configuration file.
+    epochs (int): Number of training epochs.
+    batch_size (int): Batch size for training.
+    device (str): Device to use for training ('cpu' or 'cuda').
+    img_size (int): Image size for training.
+    save_dir (str): Directory to save the trained model.
+    """
+    model = YOLO('yolov8n.pt')
+    model.train(
+        data=data_path,
+        epochs=epochs,
+        batch=batch_size,
+        device=device,
+        imgsz=img_size,
+        cache=True,
+        save_dir=save_dir
+    )
+
+if __name__ == "__main__":
+    train_model(
+        model_path='yolov8n.pt',
+        data_path='Dataset/datasets.yaml',
+        epochs=100,
+        batch_size=16,
+        device='cuda',
+        img_size=320,
+        save_dir='Dataset/model'
+    )

training_epoch_accuracy_visulizer.py

@@ -0,0 +1,32 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+def plot_training_results(csv_path):
+    """
+    Plots the training accuracy over epochs from the training results CSV file.
+
+    Parameters:
+    csv_path (str): Path to the training results CSV file.
+    """
+    # Load the training results from the CSV file
+    results = pd.read_csv(csv_path)
+    results.columns = results.columns.str.strip()  # Remove any leading/trailing whitespace from column names
+
+    # Extract epochs and accuracy metrics
+    epochs = results.index + 1  # Epochs are zero-indexed, so add 1
+    mAP_0_5 = results['metrics/mAP50(B)']  # Mean Average Precision at IoU=0.5
+    mAP_0_5_0_95 = results['metrics/mAP50-95(B)']  # Mean Average Precision at IoU=0.5:0.95
+
+    # Plot the accuracy over epochs
+    plt.figure(figsize=(10, 5))
+    plt.plot(epochs, mAP_0_5, label='mAP@0.5')
+    plt.plot(epochs, mAP_0_5_0_95, label='mAP@0.5:0.95')
+    plt.xlabel('Epoch')
+    plt.ylabel('Accuracy')
+    plt.title('Accuracy Over Epochs')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+if __name__ == "__main__":
+    plot_training_results('runs/detect/train/results.csv')

yaml_creator.py

@@ -0,0 +1,29 @@
+def create_yaml_file(dataset_path):
+    """
+    Creates a dataset configuration YAML file for YOLO training.
+
+    Parameters:
+    dataset_path (str): Path to the dataset.
+    """
+    datasets_yaml = '''
+    path: /Dataset/YOLO
+
+    train: train/images
+    val: val/images
+    test: test/images
+
+    # number of classes
+    nc: 1
+
+    # class names
+    names: ['license_plate']
+    '''
+
+    # Write the content to the datasets.yaml file
+    with open(os.path.join(dataset_path,'datasets.yaml'), 'w') as file:
+        file.write(datasets_yaml)
+    
+    print("datasets.yaml file created.")
+
+if __name__ == "__main__":
+    create_yaml_file('Dataset')