Upload 7 files

README.md

@@ -1,13 +1,80 @@
+# 🚘 License Plate Detection & Refinement
+
+A **Streamlit-based application** for detecting and refining license plate images using **YOLO for detection** and **OpenCV for image enhancements**.
+
+[![Open in Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](your-streamlit-app-link)
+
 ---
-title: License Plate Detection System
-emoji: 📈
-colorFrom: green
-colorTo: red
-sdk: streamlit
-sdk_version: 1.43.2
-app_file: app.py
-pinned: false
-license: apache-2.0
+
+## 🔧 Features
+
+### **🚘 Real-Time License Plate Detection**
+- Upload an **image** or **video**, or use a **webcam** for real-time detection.
+- Uses **YOLOv11** for accurate license plate detection.
+- Extracts text using **EasyOCR**.
+- Displays detected plates in a structured table.
+
+### **🛠 Refine Image for Detection**
+- Upload an image and apply **pre-processing techniques** to enhance detection.
+- Select from detected license plates to refine specific sections.
+- **Image enhancement options:**
+  - **Noise Reduction** (Bilateral & Non-Local Means Denoising)
+  - **Sharpening** (Enhances edges for better OCR accuracy)
+  - **Grayscale Conversion** (Improves contrast)
+  - **Adaptive Thresholding** (Dynamic brightness adjustment)
+  - **Edge Detection** (Canny filter for better boundary detection)
+  - **Invert Colors** (Helpful for light text on dark backgrounds)
+  - **Auto Enhancement** (Applies recommended adjustments automatically)
+  - **Gamma Correction, CLAHE, Histogram Equalization, Scaling, Blur, Contrast & Brightness adjustments**
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 📌 How to Run Locally
+
+### **1️⃣ Install dependencies**
+```sh
+pip install -r requirements.txt
+```
+
+### **2️⃣ Run the application**
+```sh
+streamlit run app.py
+```
+
+---
+
+## 📁 Project Structure
+```
+📂 License-Plate-Detection
+│── app.py                 # Main navigation & home page
+│── pages/
+│   ├── detect.py          # License plate detection module
+│   ├── refine.py          # Image enhancement module
+│── requirements.txt       # Required Python packages
+│── README.md              # Project documentation
+```
+
+---
+
+## 🚀 Deployment
+You can deploy this app on **Streamlit Cloud** or **Hugging Face Spaces**:
+
+1. **Fork & Push to GitHub**
+2. **Deploy via Streamlit Sharing / Hugging Face Spaces**
+
+[![Deploy on Hugging Face](https://huggingface.co/datasets/huggingface/badges/resolve/main/hf-badge-open.svg)](your-huggingface-link)
+
+---
+
+## 📌 Future Enhancements
+- **Real-time tracking of license plates**.
+- **OCR post-processing to correct errors**.
+- **Additional denoising & image restoration techniques**.
+
+---
+
+## 📝 License
+This project is **open-source** under the **MIT License**. Feel free to modify and improve it!
+
+🌟 If you like this project, don’t forget to **star the repository**!
+

app.py

@@ -0,0 +1,9 @@
+import streamlit as st
+
+pages = [
+    st.Page("home.py", title="Home", icon="🏠"),
+    st.Page("detect.py", title="Real-Time License Plate Detection", icon="🚘"),
+    st.Page("refine.py", title="Refine Image for Detection", icon="🖼️")
+]
+nav = st.navigation(pages, position="sidebar", expanded=False)
+nav.run()

detect.py

@@ -0,0 +1,124 @@
+import streamlit as st
+from ultralytics import YOLO
+import cv2
+import easyocr
+import numpy as np
+import pandas as pd
+from PIL import Image
+import tempfile
+
+@st.cache_resource
+def load_model():
+	model = YOLO('yolo11n-custom.pt')
+	model.fuse()
+	return model
+
+model = load_model()
+
+reader = easyocr.Reader(['en'])
+
+def detect_license_plate(image):
+	results = model.predict(image, conf=0.15, iou=0.3, classes=[0])
+	plate_texts = []
+	img_array = np.array(image)
+	# img = cv2.imread(image_path)
+	img = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+	img_height, img_width, _ = img.shape
+
+	for result in results:
+		for bbox in result.boxes.xyxy:
+			x1, y1, x2, y2 = map(int, bbox.tolist())
+			plate = img[int(y1):int(y2), int(x1):int(x2)]
+			scale=2
+			height, width = plate.shape[:2]
+			plate = cv2.resize(plate, (width * scale, height * scale), interpolation=cv2.INTER_CUBIC)
+			
+			text = reader.readtext(plate, detail=0, allowlist="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-")
+			text = " ".join(text).upper()
+			
+			text_scale = max(1, width / 250)
+			thickness = max(2, width // 200)
+			cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), thickness)
+			(text_width, text_height), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, text_scale, thickness)
+			text_x = x1 + (width - text_width) // 2  # Centered horizontally
+			text_y = y1 - 10 if y1 > 50 else y2 + text_height + 20  # Above unless too high
+			text_box_y1 = text_y - text_height - 5
+			text_box_y2 = text_y + 5
+			cv2.rectangle(img, (text_x - 8, text_box_y1 - 3), (text_x + text_width + 8, text_box_y2 + 3), (0, 0, 0), -1)
+			cv2.rectangle(img, (text_x - 5, text_box_y1), (text_x + text_width + 5, text_box_y2), (255, 255, 255), -1)
+			cv2.putText(img, text, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, text_scale, (0, 0, 0), thickness)
+
+			plate_texts.append(text)
+	image = img
+	return image, plate_texts
+
+st.title("🚘 Real-Time License Plate Detection", anchor=False)
+
+st.write("For better license plate detection, ensure you use high-quality images. If detection is unclear, try enhancing the image first. Use the Refine Image for Detection tool.")
+
+st.write("Upload an image, upload a video, or use your webcam for real-time license plate detection.")
+
+option = st.radio("Choose Input Source:", ("Upload Image", "Upload Video", "Webcam"), horizontal=True )
+
+
+if option == "Upload Image":
+	uploaded_file = st.file_uploader("Upload an image", type=["jpg", "png", "jpeg"])
+	if uploaded_file:
+		img = Image.open(uploaded_file)
+		st.write("Processing...")
+
+		processed_img, plate_texts = detect_license_plate(img)
+
+		st.image(processed_img, caption="Detected Plates Image", use_container_width=True)
+		st.write("**Detected License Plates:**")
+		if plate_texts:
+			plates = pd.DataFrame({"License Plate": plate_texts})
+			plates.index = plates.index + 1
+			st.table(plates)
+		else:
+			st.write("No license plates detected.")
+
+elif option == "Upload Video":
+	uploaded_video = st.file_uploader("Choose a video...", type=["mp4", "avi", "mov"])
+	if uploaded_video is not None:
+		st.write("Processing video...")
+		tfile = tempfile.NamedTemporaryFile(delete=False)
+		tfile.write(uploaded_video.read())
+		cap = cv2.VideoCapture(tfile.name)
+		frame_placeholder = st.empty()
+
+		while cap.isOpened():
+			ret, frame = cap.read()
+			if not ret:
+				break
+			processed_frame, plate_texts = detect_license_plate(frame)
+
+			frame_placeholder.image(processed_frame, caption="Detected Plates Video", use_container_width=True)
+		cap.release()
+
+elif option == "Webcam":
+	if "running" not in st.session_state:
+		st.session_state.running = True
+	if st.button("Stop"):
+		st.session_state.running = False
+
+	st.write("Starting Webcam... Press **Stop** to end.")
+	cap = cv2.VideoCapture(0)
+	frame_placeholder = st.empty()
+
+	while cap.isOpened():
+		ret, frame = cap.read()
+		if not ret:
+			st.warning("Failed to capture webcam feed.")
+			break
+
+		processed_frame, plate_texts = detect_license_plate(frame)
+
+		frame_placeholder.image(processed_frame, channels="BGR", caption="Webcam Feed", use_container_width=True)
+
+		if not st.session_state.running:
+			break
+
+	cap.release()

home.py

@@ -0,0 +1,17 @@
+import streamlit as st
+
+st.title("Welcome to License Plate Detection App", anchor=False)
+st.write("Select a feature below to detect or enhance license plate images.")
+
+# Buttons for navigation
+col1, col2 = st.columns(2)
+
+with col1:
+    if st.button("🚘 Detect License Plates"):
+        st.switch_page("detect.py")  # Navigates to the detection page
+    st.caption("Upload an image, video, or use a webcam for real-time detection.")
+
+with col2:
+    if st.button("🖼️ Enhance Image for Detection"):
+        st.switch_page("refine.py")  # Navigates to the image enhancement page
+    st.caption("Improve image quality for better license plate recognition.")

refine.py

@@ -0,0 +1,163 @@
+import streamlit as st
+from ultralytics import YOLO
+import cv2
+import easyocr
+import numpy as np
+import pandas as pd
+from PIL import Image
+import tempfile
+
+# Upload image
+@st.cache_resource
+def load_model():
+	model = YOLO('yolo11n-custom.pt')
+	model.fuse()
+	return model
+
+model = load_model()
+
+reader = easyocr.Reader(['en'])
+def apply_filters(image, noise, sharpen, grayscale, threshold, edges, invert, auto, blur, contrast, brightness, scale, denoise, hist_eq, gamma, clahe):
+	img = np.array(image)
+	
+	# Auto Enhancement
+	if auto:
+		lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
+		l, a, b = cv2.split(lab)
+		clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+		l = clahe.apply(l)
+		img = cv2.merge((l, a, b))
+		img = cv2.cvtColor(img, cv2.COLOR_LAB2RGB)
+
+
+	# Scaling
+	if scale != 1.0:
+		height, width = img.shape[:2]
+		img = cv2.resize(img, (int(width * scale), int(height * scale)))
+	
+	# Noise Reduction (Bilateral Filtering)
+	if noise:
+		img = cv2.bilateralFilter(img, 9, 75, 75)
+
+	# Noise Reduction (Non-Local Means)
+	if denoise:
+		img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
+	
+	# Sharpening
+	if sharpen:
+		kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
+		img = cv2.filter2D(img, -1, kernel)
+	
+	# Convert to Grayscale
+	if grayscale or threshold or hist_eq or clahe:
+		img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+
+	# Histogram Equalization
+	if hist_eq:
+		img = cv2.equalizeHist(img)
+	
+	# CLAHE (Contrast Limited Adaptive Histogram Equalization)
+	if clahe:
+		clahe_filter = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+		img = clahe_filter.apply(img)
+	
+	# Adaptive Thresholding
+	if threshold:
+		img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
+	
+	# Edge Detection
+	if edges:
+		img = cv2.Canny(img, 100, 200)
+	
+	# Invert Colors
+	if invert:
+		img = cv2.bitwise_not(img)
+	
+	# Blur
+	if gamma != 1.0:
+		inv_gamma = 1.0 / gamma
+		table = np.array([(i / 255.0) ** inv_gamma * 255 for i in np.arange(0, 256)]).astype("uint8")
+		img = cv2.LUT(img, table)
+
+	# Blur
+	if blur:
+		img = cv2.GaussianBlur(img, (2*blur + 1, 2*blur + 1), 0)
+	
+	# Contrast & Brightness
+	if contrast != 1.0 or brightness != 0:
+		img = cv2.convertScaleAbs(img, alpha=contrast, beta=brightness)
+	
+	return img
+
+st.title("🖼️ Refine Image for Detection")
+st.write("Enhance the license plate image for better recognition.")
+
+uploaded_file = st.file_uploader("📤 Upload an image", type=["jpg", "png", "jpeg"])
+
+if uploaded_file:
+	# Read image
+	img = Image.open(uploaded_file)
+	img = np.array(img)
+
+	# Detect license plates
+	st.write("🔍 Detecting license plates...")
+	results = model.predict(img, conf=0.15, iou=0.3, classes=[0])  
+	plates = results[0].boxes.xyxy if len(results) > 0 else []
+
+	if len(plates) == 0:
+		st.error("❌ No license plates detected. Try another image.")
+	else:
+		st.write("📌 **Select a License Plate by Clicking Below**")
+		
+		# Show detected plates in a grid
+		if "selected_plate_index" not in st.session_state:
+			st.session_state.selected_plate_index = 0
+
+		selected_plate_index = st.session_state.get("selected_plate_index", 0)
+		cols = st.columns(len(plates))  # Create dynamic columns
+
+		for i, (x1, y1, x2, y2) in enumerate(plates):
+			plate_img = img[int(y1):int(y2), int(x1):int(x2)]
+			plate_img = Image.fromarray(plate_img)
+
+			with cols[i]:  # Place each image in a column
+				st.image(plate_img, caption=f"Plate {i+1}", use_container_width =True)
+				if st.button(f"Select Plate {i+1}", key=f"plate_{i}"):
+					st.session_state["selected_plate_index"] = i
+
+		# Get the selected plate
+		selected_index = st.session_state["selected_plate_index"]
+		x1, y1, x2, y2 = map(int, plates[selected_index])
+		cropped_plate = img[y1:y2, x1:x2]
+		refined_img = cropped_plate.copy()
+
+		# Sidebar for enhancements
+		st.sidebar.header("🔧 Enhancement Options")
+		blur = st.sidebar.slider("🔹 Blur", 0, 10, 0)
+		contrast = st.sidebar.slider("🔹 Contrast", 0.5, 2.0, 1.0)
+		brightness = st.sidebar.slider("🔹 Brightness", 0.5, 2.0, 1.0)
+		gamma = st.sidebar.slider("Gamma Correction", 0.1, 3.0, 1.0, 0.1)
+		scale = st.sidebar.slider("🔹 Scale", 1.0, 10.0, 5.0)
+		noise = st.sidebar.checkbox("Noise Reduction (Bilateral)")
+		denoise = st.sidebar.checkbox("Denoise (Non-Local Means)")
+		sharpen = st.sidebar.checkbox("Sharpening")
+		hist_eq = st.sidebar.checkbox("Histogram Equalization")
+		clahe = st.sidebar.checkbox("CLAHE (Advanced Contrast)")
+		grayscale = st.sidebar.checkbox("Grayscale Conversion")
+		threshold = st.sidebar.checkbox("Adaptive Thresholding")
+		edges = st.sidebar.checkbox("Edge Detection")
+		invert = st.sidebar.checkbox("Invert Colors")
+		auto = st.sidebar.checkbox("Auto Enhancement")
+
+		refined_img = apply_filters(refined_img, noise, sharpen, grayscale, threshold, edges, invert, auto, blur, contrast, brightness, scale, denoise, hist_eq, gamma, clahe)
+
+		st.image(refined_img, caption="Refined License Plate", use_container_width=True)
+
+		if st.button("📖 Detect License Plate Text"):
+			with st.spinner("🔎 Reading text..."):
+				ocr_result = reader.readtext(np.array(refined_img), detail=0, allowlist="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-")
+				plate_text = " ".join(ocr_result).upper() if ocr_result else "❌ No text detected."
+			
+			# Show detected text
+			st.subheader("📜 Detected License Plate:")
+			st.code(plate_text, language="plaintext")

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+opencv-python
+torch
+torchvision
+easyocr
+numpy
+pandas
+pillow
+ultralytics

yolo11n-custom.pt

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