Development of License Plate Recognition System (ANPR/LPR)

Imagine a camera at a shopping mall parking lot capturing an entering vehicle. The system must recognize the plate in milliseconds and decide whether to raise the barrier or add it to a blacklist. If OCR fails, you get a traffic jam at the entrance and negative visitor experience. How do you build an ANPR/LPR system that reliably works in rain, at night, and at speeds up to 60 km/h? We have refined this pipeline over years and share our proven architecture. Our system saves up to 30% budget through open-source models and inference optimization.

How the Two-Stage License Plate Recognition Pipeline Works

Video/Photo → Vehicle Detection → License Plate Detection → OCR → Database 

The two-stage approach (vehicle → plate) is more accurate than one-stage because it handles different plate formats from different countries. The first stage uses YOLO to detect vehicles, the second uses a specialized model to detect the plate within the crop.

from ultralytics import YOLO from paddleocr import PaddleOCR import cv2 import numpy as np import re class ANPRSystem: def __init__(self, vehicle_model: str = 'yolov8l.pt', plate_model: str = 'plate_detector.pt'): self.vehicle_detector = YOLO(vehicle_model) self.plate_detector = YOLO(plate_model) # fine-tuned on license plates self.ocr = PaddleOCR( use_angle_cls=True, lang='en', rec_algorithm='SVTR_LCNet' ) def process(self, frame: np.ndarray) -> list[dict]: # Vehicle detection vehicles = self.vehicle_detector(frame, classes=[2, 3, 5, 7], # car/moto/bus/truck conf=0.5) results = [] for vehicle_box in vehicles[0].boxes.xyxy: x1, y1, x2, y2 = map(int, vehicle_box) vehicle_crop = frame[y1:y2, x1:x2] # License plate detection in vehicle crop plates = self.plate_detector(vehicle_crop, conf=0.5) for plate_box in plates[0].boxes.xyxy: px1, py1, px2, py2 = map(int, plate_box) plate_crop = vehicle_crop[py1:py2, px1:px2] # OCR for plate plate_text = self._recognize_plate(plate_crop) if plate_text: results.append({ 'plate': plate_text, 'vehicle_bbox': [x1, y1, x2, y2], 'plate_bbox': [x1+px1, y1+py1, x1+px2, y1+py2], 'confidence': float(plates[0].boxes.conf[0]) }) return results def _recognize_plate(self, plate_img: np.ndarray) -> str | None: # Preprocessing plate_img = self._preprocess_plate(plate_img) result = self.ocr.ocr(plate_img, cls=False) if not result or not result[0]: return None text = ''.join([line[1][0] for line in result[0]]) text = re.sub(r'[^A-Z0-9А-Я]', '', text.upper()) # Validation of Russian plate format if re.match(r'^[АВЕКМНОРСТУХ]\d{3}[АВЕКМНОРСТУХ]{2}\d{2,3}$', text): return text return text if len(text) >= 6 else None 

Why Image Preprocessing Matters for OCR Quality

OCR accuracy directly depends on how well the plate crop is prepared. We use scaling to a height of 64 pixels, angle alignment, and brightness normalization. This reduces error rate by 15–20% compared to raw frames.

def _preprocess_plate(self, image: np.ndarray) -> np.ndarray: # Scale to standard height target_h = 64 scale = target_h / image.shape[0] new_w = int(image.shape[1] * scale) image = cv2.resize(image, (new_w, target_h), interpolation=cv2.INTER_CUBIC) # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Brightness normalization normalized = cv2.normalize(gray, None, 0, 255, cv2.NORM_MINMAX) return normalized 

How We Handle Different Plate Formats

Russian plates: X000XX00[0] (standard), X000XX000 (transit). Additional formats: customs, diplomatic, military. For international systems, we use multilingual OCR and multiple validation regex patterns. We have accumulated a library of over 20 masks for CIS and European countries.

Real-World Case: Shopping Mall Parking Lot with 8 Cameras

For a large shopping center, the system needed to handle a flow of 30 cars per minute, operate 24/7, and integrate with existing barriers. We deployed the two-stage pipeline on a server with GPU T4. The recognition accuracy reached 98%, false positives under 1%. Response time was 45 ms per frame. After a year of operation, the system required no retraining — only periodic camera calibration.

Comparison: Our System vs Typical OpenALPR Solutions

Our pipeline is twice as fast at the same accuracy: 45 ms vs 95 ms on T4. Through fine-tuning YOLO and PaddleOCR, we achieve 98% accuracy compared to 93% for OpenALPR on challenging plates. Moreover, we support more formats — over 20 masks vs 5 standard.

Step-by-Step ANPR/LPR System Deployment

1. Audit of installation site and camera selection (resolution, IR illumination).
2. Dataset collection: 5,000+ frames in various conditions for model fine-tuning.
3. Training detection and OCR models on a compute cluster (typically 2–3 days on GPU A100).
4. Integration with access control via REST API, Redis setup for LPR lists.
5. One-week testing with real traffic, threshold adjustments.
6. Deployment on the client's server, documentation, and staff training.

Production Performance

What's Included in Turnkey Development

• Site analysis and camera selection
• Training/fine-tuning of detection and OCR models
• Preprocessing and postprocessing configuration
• REST API for integration with access control and databases
• Redis for hot lists (whitelist/blacklist)
• PostgreSQL with pg_trgm for fuzzy search (accounts for OCR errors: 0/O, I/1, B/8)
• Documentation and staff training
• 6-month warranty support

Implementation Timelines

The cost is calculated individually — depends on the number of cameras, required accuracy, and depth of integration. Our engineers hold MLOps certifications and have a combined 10+ years of experience in Computer Vision. Contact us for a free project assessment — we evaluate your project within one business day. We guarantee transparent results and adherence to deadlines.

Technologies used: YOLOv8, PaddleOCR, PyTorch, Redis, PostgreSQL.