DEV Community: Jeremy

Read license plate with OCR

Jeremy — Sat, 08 Mar 2025 14:55:30 +0000

Abstract

So close! We now have cropped images with just license plate numbers. This is derived from highway-view, down to car-view, down to license plate. In this step, we pre-process the image to improve OCR, and we read the characters from image.

ToC (Step-by-Step)

Recipe

The following pre-processing steps helps focus OCR on just the important image information, and reduces everything else (eg RBG color, grays, small contours). For clarity this sequence of pre-processing prior to OCR is fairly typical pattern prior to OCR taught in computer vision. I’m not inventing or discovering something new here. At the bottom of article, we run OCR with no pre-processing to illustrate the difference.

Before pre-processing - cropped image of license plate from prior steps:

Pre-process step: desaturate colors. Go gray.

RGB color is not helpful here for OCR. Doesn’t matter if license plate numbers are magenta or cyan. Thus discard color information.
Pre-process step: gaussian blur to reduce noise / artifacts slightly.

Nevermind the “gaussian” part. This is just applying a blur filter to the image. That blur filter softens the small differences. And because small differences are reduced (eg dirty-ish license plate), then the big differences are easier to distinguish (eg dark-numbers on white-background).
Pre-process step: threshold to really highlight license plate characters

Thresholding further highlights where we have big differences such as dark-numbers on white-background.
OCR license plate

I experimented with a bunch of OCR libraries here. I found best for this use case was PaddleOCR, better than Tesseract and some others. Run PaddleOCR on thresholded image, and get string text, license plate number, back from the image!
Profit!

import cv2
from paddleocr import PaddleOCR, draw_ocr
from ppocr.utils.logging import get_logger
import logging

# Initialize PaddleOCR
ocr = PaddleOCR(use_angle_cls=True, lang='en', use_space_char=True)
logger = get_logger()
logger.setLevel(logging.ERROR) # avoid debug statements in OCR results

#baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'
baseDir = '/home/pi/Projects/TrainHighwayCarDetector/'
img_path = baseDir + 'photos/yolo_licensePlates/croppedPlates/IMG_4554_0002.jpg'

print("Human readable is CEZ2594")

img = cv2.imread(img_path)

gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

blur = cv2.GaussianBlur(gray, (5,5), 0)

ret, thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_OTSU | cv2.THRESH_BINARY_INV)

# Perform OCR
result = ocr.ocr(thresh, cls=True)

for line in result:
    print(line)

Print statement outputs

[[[[14.0, 29.0], [181.0, 22.0], [184.0, 76.0], [17.0, 83.0]], ('CEZ2594', 0.9654235243797302)]]

We read the license plate! Number to the right of string is confidence ie ~96.5% confident string is correct. And the left side numbers is bounding box coordinates. 🥳

Next Link: Tie it all together: End-to-end License Plate Detection

Appendix: References

Appendix: Interesting Points

Folks might wonder: why not just OCR the original image? You can. But this is what you get:

Note the right hand side not the red bounding box. Firstly, three of seven characters are wrong. This is the same input we just demonstrated, same license plate same image, only without pre-processing steps. Secondly, confidence score is low. This is why the pre-processing steps.

Next Link: TBD -- End-to-end real-time detection of license plates

Crop Bounding Box ( part deux! ) for License Plate

Jeremy — Tue, 04 Mar 2025 13:28:45 +0000

Abstract

We are pre-processing photos to ultimately enable OCR. Prior step we found the bounding box for license plates. Let’s crop down images to only license plates themselves for OCR next.

Step-by-Step

Recipe

The over-arching goal is to read license plate numbers from images. On that journey, we detected cars in highway image captures, cropped to just cars, and detected license plates on car images. Now we crop to just license plates. And those zoomed-in license plate images are inputs to OCR, which will read license plate numbers into database.

Unlike prior cropping step, we can safely assume one license plate per image. It’s not 1:[0,n) it’s 1:[0,1].

Thus, simple step: if we found a license plate (ie have a bounding box), then crop license plate

from ultralytics import YOLO
import cv2 
import imutils
import numpy as np
from os import path

baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'
inputFilePath = baseDir + 'photos/yolo_licensePlates/licensePlates/IMG_4554_0002.jpg'
inputFileName = path.basename(inputFilePath)
outputPhotosDir = baseDir + 'photos/yolo_licensePlates/croppedPlates/'
model = YOLO(baseDir + 'src/runs/detect/yolov8n_100_16_LP_v27/weights/best.pt')

imageOriginal = cv2.imread(inputFilePath)
imageScaled = imutils.resize(imageOriginal, width=1280)

imgRatio = imageOriginal.shape[1] / imageScaled.shape[1]

results = model.predict(source=imageScaled, imgsz=1280)

if results is not None and len(results) > 0 and results[0].boxes is not None and len(results[0].boxes) > 0:
    box = results[0].boxes[0]
    # bounding box in scaled-down image
    x1Float = box.xyxy[0][0].item()
    x2Float = box.xyxy[0][2].item()
    y1Float = box.xyxy[0][1].item()
    y2Float = box.xyxy[0][3].item()

    # calc bounding box in original (scaled-up) image
    x1 = int(imgRatio * x1Float)
    y1 = int(imgRatio * y1Float)
    x2 = int(imgRatio * x2Float)
    y2 = int(imgRatio * y2Float)

    # cropped
    imageCropped = imageOriginal[y1:y2,x1:x2]

    outputFilePath = outputPhotosDir + inputFileName[0:(len(inputFileName)-4)] + '.jpg'
    cv2.imwrite(outputFilePath, imageCropped)
    print('Wrote ' + outputFilePath)

At this point we’re enabling from highway to car to license plate, such as the following:

Almost there! From highway-view image capture, to car, to license plate. Next up: OCR!

Next Link: Read license plate with OCR

Model for Detecting License Plates in Cropped Image

Jeremy — Sat, 01 Mar 2025 18:54:28 +0000

Abstract

Now that we have per-car images, we need to find license plates. License plates might not be present, or might be otherwise difficult to find with heuristic, thus we use YOLO again to find the license plate bounding box.

Step-by-Step

Recipe

We now have cropped images per car. Our high-level goal is OCR on the license plate. OCR needs a tight view to only the license plate characters, and not other distractions. This means within our cropped images, we should find license plate (this article), and crop image to just license plate (next).

We tested heuristics to find license plates such as contour-detection, and they did not generalize well. See image examples below – illustrating that even with reliable car detection, license plates can be easy (centered, large), harder (off-center, smaller), or even not-present. YOLO proved to be a better tool for variation, and thus we train second model for license plates.

Easy-to-see license plate. Centered, large.

Also easy, but less-easy. License plate is no longer centered on car. Can’t find license plate based on location in cropped image. And license plate is smaller in this view.

Harder example. This is a real output from step 3 model for detecting cars. Just not-yet in-frame. Contour heuristic thinks this is a license plate, but we need model capable of understanding its incomplete, and to move on.

Collect training data
- Run step 1 through 4 for a bit to collect training data. In my case, I compiled ~30 cropped images of cars with visible license plates. Example such as the following:
Label training data
- This is time-consuming and manual step, but important.
- I used roboflow.com (same as step 3). I recommend their tooling. I’m sure there’s alternatives if you prefer, but roboflow made e2e process easier. Training the YOLO model requires label data in a particular format, which roboflow automates, and roboflow has online tooling to streamline your labeling data.
- Upload your images
- Hand-label your images. I suggest learning the hotkeys. Sample labeling from roboflow - one of many
- I suggest defining guidelines for yourself to mitigate the monotony. My bounding boxes for labeling generally stretched within the license plate - not encircling the plate border itself. Otherwise top-left to bottom-right within the plate rectangle, and repeat. I’m not saying use the same bounding box. I’m suggesting: know what your guideposts are. Knowing your guideposts will make your labeling consistent and help the tedium.
- Download training data. This is just the formatted xml capturing all your bounding boxes for training.

Train model YOLO

Note that my output model is “v27” ie I trained several models to experiment with different parameters. I recommend testing and iterating on configurations that work for you: nano model vs medium, less epochs or more, etc.
On MacBook M1 Pro with 32GB memory, took <1 hour to train the winning model.

from ultralytics import YOLO

###########
# Training
# Load the model
baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'
model = YOLO(baseDir + 'resources/yolov8n.pt')

results = model.train(
   imgsz=1280,
#   epochs=100,
#   batch=16,
#   device='mps',
   data=baseDir + 'resources/v4data_LP/data.yaml',
   name=’yolov8n_100_16_LP_v27’
)
###########

Test YOLO.

I trained five model variants on model and epoch variations. nano, medium, xlarge models, and 50 or 100 epochs. I measured performance on precision, recall, map50, and map50-95. Long story short, all variants had near-equal very good performance. Thus I choose simplest model nano with default epochs

from ultralytics import YOLO
import cv2 
from PIL import Image
import imutils

###########
# predict
baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'

###########
# model
model = YOLO(baseDir + 'src/runs/detect/yolov8n_100_16_LP_v27/weights/best.pt')

###########
# images
img = cv2.imread(baseDir + 'photos/yolo_licensePlates/licensePlates/IMG_4566_0002.jpg')

results = model.predict(
   source=img,
   imgsz=1280
)

cv2.imshow("image", results[0].plot())
cv2.waitKey(0)

Sample classification from best model. “license-plates” is the classifier label.

Now we have model detecting license plates inside the cropped image for cars. This enables next step, which is to crop down image to just license plate characters, on the way to OCR after.

Next Link: Crop bounding box for license plate

Crop Bounding Box + Rotate

Jeremy — Thu, 27 Feb 2025 13:28:41 +0000

Abstract

We are pre-processing photos to ultimately enable OCR. We have bounding boxes for rear-end of cars; now let’s rectangularize the license plates with cropped and rotated photos.

Step-by-Step

Recipe

We now have model identifying cars in our streamed images from camera. Our high-level goal is cropped-image reduced only to license plate for OCR reading. That means finding cars in image (article 3), cropping image to just rear bumper of car (this article; 4), so that we can find license plate (next article; 5), and crop image to just license plate (article 6).

This interior step is a processing step to ultimately enable OCR. Note particularly in my captured images that images are both looking down, but also from the distant side, from the cars. That eschew is important feature to reduce. OCR expects a straight-on view, thus part of this step is also corrected eschew (by rotation).

At this point we have bounding box per car. We potentially have multiple cars per image - so within this step is a loop that forks all the following steps (for each car: detect license plate, crop, OCR, repeat).

First, we are cropping image to just bounding box from model in step 3, and rotating to match camera’s eschewed perspective in relation to highway.

For each bounding box (ie for each car)

Input image. Run model, find bounding boxes (cars).
Crop to rear bumper, and rotate to correct eschew

Output images cropped down to just rear bumper with clearer view of license plate. Note rotation artifacts in corners. Now, license is straight-on for easier OCR.

from ultralytics import YOLO
import cv2 
import imutils
import numpy as np
from os import path

baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'
inputFilePath = baseDir + 'photos/yolo_cars/all/IMG_4553.jpg'
inputFileName = path.basename(inputFilePath)
outputPhotosDir = baseDir + 'photos/yolo_cars/licensePlates/'
model = YOLO(baseDir + 'src/runs/detect/yolov8m_v21_100e/weights/best.pt')

imageOriginal = cv2.imread(inputFilePath)
imageScaled = imutils.resize(imageOriginal, width=1280)

imgRatio = imageOriginal.shape[1] / imageScaled.shape[1]

results = model.predict(source=imageScaled, imgsz=1280)

j=0
for box in results[0].boxes:
    j += 1
    # bounding box in scaled-down image
    x1Float = box.xyxy[0][0].item()
    x2Float = box.xyxy[0][2].item()
    y1Float = box.xyxy[0][1].item()
    y2Float = box.xyxy[0][3].item()

    # calc bounding box in original (scaled-up) image
    x1 = int(imgRatio * x1Float)
    y1 = int(imgRatio * y1Float)
    x2 = int(imgRatio * x2Float)
    y2 = int(imgRatio * y2Float)

    # cropped
    imageCropped = imageOriginal[y1:y2,x1:x2]

    # rotated
    image_center = tuple(np.array(imageCropped.shape[1::-1]) / 2)
    rot_mat = cv2.getRotationMatrix2D(image_center, 4.7, 1.0)
    imageRotated = cv2.warpAffine(imageCropped, rot_mat, imageCropped.shape[1::-1], flags=cv2.INTER_LINEAR)

    outputFilePath = outputPhotosDir + inputFileName[0:(len(inputFileName)-4)] + '_' + format(j,'04d') + '.jpg'
    cv2.imwrite(outputFilePath, imageRotated)
    print('Wrote ' + outputFilePath)

Now we have image clearly showing license plate. We still need to enhance-enhance before handing off to OCR. Thus repeat as before: find the license plate in the now-cropped image, in order to subsequently crop to just license plate. Next: YOLO model for license plates!

Next Link: Model for detecting license plates in cropped image

Appendix: Interesting Points

Rotation (2d), and not perspective warping (3d) was an evolution of process. Initially I thought I would use perspective warping via homography as I knew how. But long story short, I realized it was over-engineering after tinkering on the solution. Why go through the effort of calculating perspective warp from my camera to highway, when a simple rotation of the image would work just as well - and a lot more simple?

Model for Detecting Cars

Jeremy — Tue, 25 Feb 2025 11:34:50 +0000

Abstract

Build YOLO model from scratch to find bounding box of cars in images. This includes labeling test images, training model, and evaluating different settings for best model output.

Step-by-Step

Recipe

At this point we have focused camera, automatically capturing and transferring images, and we’re ready to process photos on the way to reading license plate numbers.

As humans, we see cars in the images from prior article. But our computers don't distinguish those entities yet like we can - not without being trained to. Thus, we will teach the computer what a car on a highway looks like.

Enabling computer to know what a car looks like distills essentially to: 1) collect training data, 2) label training data, 3) train model on training data, 4) train models with varying configurations and choose best. We’ll walk through those steps next.

Collect training data
- Use for loop’ing capture from step two under good light for a bit. I compiled 145 images. Sample image
Label training data
- I used roboflow.com. I recommend their tooling. I’m sure there’s alternatives if you prefer, but roboflow made e2e process easier. Training the model requires label data in a particular format, which roboflow automates for you, and roboflow has online tooling to streamline your building of the labeling data.
- Upload your images
- Hand-label your images. This is time consuming. I suggest learning the hotkeys. Sample labeling from roboflow - one of many
- I suggest defining guidelines for yourself to mitigate the monotony. My bounding boxes for labeling generally stretched from top-left turn-signal light to bottom-right wheel-well highlighting the entire rear bumper. I’m not saying use the same bounding box. I’m suggesting: know what your guideposts are. Knowing your guideposts will make your labeling consistent and help the tedium.
- Download training data. This is just the formatted xml capturing all your bounding boxes for training.
Train model YOLO
- Note that my output model is “v21” ie I trained several models to experiment with different parameters. I recommend testing and iterating on configurations that work for you: nano model vs medium, less epochs or more, etc.
- I found medium with default epoch and batch settings produced best results for my training set + labels. I trained five variant models including nano, medium, xlarge, and various permutations of epoch and batch.
- On MacBook M1 Pro with 32GB memory, took 4.5 hours to train the winning model. Five permutations of training different configurations took ~33 hours total.
```
from ultralytics import YOLO

###########
# Training
# Load the model
baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'
model = YOLO(baseDir + 'resources/yolov8m.pt')

results = model.train(
   imgsz=1280,
#   epochs=100,
#   batch=8,
#   device='mps',
   data=baseDir + 'resources/v2data_CARS/data.yaml',
   name='yolov8m_100_8_CARS_v21'
)
###########
```
Test YOLO.
- I compared five model variants on ClearML score dimensions: precision, recall, map50, and map50-95. I confirmed model performance manually visualizing the results with above script. Did this for both best and worst model. Worst model had false-positives, multiple detections on single car, and generally lower confidence score. Best model had no false-positives (in limited testing), no multiple detections, etc. Helped to see the output in addition to ClearML scoring.
```
from ultralytics import YOLO
import cv2 
from PIL import Image
import imutils

###########
# predict
baseDir = '/Users/japollock/Projects/TrainHighwayCarDetector/'

###########
# model
model = YOLO(baseDir + 'src/runs/detect/yolov8m_v21_100e/weights/best.pt')

###########
# images
img = cv2.imread(baseDir + 'photos/yolo_cars/all/IMG_4553.jpg')

results = model.predict(
   source=img,
   imgsz=1280
)

cv2.imshow("image", results[0].plot())
cv2.waitKey(0)
```
Sample classification from best model. “Cars” is the classifier label.

Now we have model detecting cars bounding box. This enables us to hone in on license plate from highway view. Next up is cropping down to bounding box, and perspective warp’ing to rectangular-ize the license plate from eschew.

Next Link: Crop bounding box + rotate.

Appendix: References

Appendix: Interesting Points

Rabbit hole of car detectors
- Training a model to detect cars was an evolution in process. I started with the idea that I could just download an off-the-shelf model somewhere on the Internet and use that.
- First contact with “cars” model https://www.analyticsvidhya.com/blog/2021/12/vehicle-detection-and-counting-system-using-opencv/#wait_approval
- BUT from what I can gather first link was really based on this work https://github.com/andrewssobral/vehicle_detection_haarcascades
- Actual academic style paper detailing classifier https://github.com/andrewssobral/vehicle_detection_haarcascades/blob/master/doc/Automatic_Detection_of_Cars_in_Real_Roads_using_Haar-like_Features.pdf
- Aside from folks using the model without attribution, this model has terrible performance on my camera setup (ie eschewed orientation to cars; only rear-facing), and probably will on yours too. Models generally will have this quality - they will work well on their training data, and not necessarily yours. I’m sure this model was great for detect front-orientation of a car, or side-view. But our setup necessitated training a model from scratch.

Capturing Images from DSLR to RPi

Jeremy — Mon, 24 Feb 2025 13:42:46 +0000

Abstract

Now that camera is capturing (manually) photos of high-speed cars - we need to trigger image capture and transfer to RPi automatically. This enables streaming of images from DSLR to RPi, and then makes those images available for post-processing in subsequent steps.

Step-by-Step

Recipe

At this point we should have camera mounted, connected to RPi, and capturing nicely focused images (manually) of cars and license plates.

Now that we have manual capture working, we will write code to control DSLR from RPi. We will capture image, transfer to RPi, and repeat.

Capture image - borrows heavily from https://thezanshow.com/electronics-tutorials/raspberry-pi/tutorial-41

Use gphoto2 library to communicate with DSLR over USB from RPi. The following code uses basic “--capture-image-and-download” command to capture, transfer, and repeat.
The kill gphoto2 pid is an unfortunate RPi thing, where the OS auto-mounts the DSLR as a drive on USB connection. Thus for gphoto2 to issue capture command, we need to kill pid first. It’s weird, but it is a thing.

from sh import gphoto2 as gp
import signal, os, subprocess
import re

# kill the gphoto process from turning on the camera or rebooting the RPi
def killGphoto2Process():
    p = subprocess.Popen(['ps', '-A'], stdout=subprocess.PIPE)
    out, err = p.communicate()

    # search for the process we want to kill
    for line in out.splitlines():
        if b'gvfsd-gphoto2' in line:
            # kill that process!
            pid = int(line.split(None,1)[0])
            os.kill(pid, signal.SIGKILL)

def captureImages():
    captureFilenameRegex = '(CANON\/(.+JPG))'
    ret = gp(captureCommand)
    captureFilename = re.search(captureFilenameRegex, str(ret))
    if len(captureFilename.groups()) < 2:
        print("did not regex-extract filename. exiting")
        quit()
    return captureFilename.group(2)

##########################################################################
# begin main
captureCommand = ['--capture-image-and-download']
saveLocation = '/home/pi/Projects/TakePhoto1/photos/temp capture/'

# actually operate camera
killGphoto2Process()
os.chdir(saveLocation)

while True:
    captureFilename = captureImages()
    print(captureFilename)

Transfer image

Capture one automatically to RPi
Repeat

Capture, transfer, repeat - automatically from DSLR to RPi.

Now we have DSLR zoomed in on highway, capable of capturing high-speed car with detail, RPi is driving capture and transferring photos to storage. Next up is honing in on license plates per photo by detecting cars in each image.

Next Link: Model for detecting cars

Appendix: References

https://thezanshow.com/electronics-tutorials/raspberry-pi/tutorial-41
http://www.gphoto.org/doc/remote/
More on the need for kill gphoto2 pid https://forums.raspberrypi.com/viewtopic.php?t=202934

Appendix: Interesting Points

Learned through practice that light conditions influence heavily successful capture of images. This rig doesn’t work at night (not yet?) I suspect this is why highway toll cameras are set up in arrays like this - closer to highway surface, and without perspective eschew.
For anyone concerned, taking photos in public (eg of license plates) are not restricted legally. https://www.google.com/search?q=photos+in+public and https://www.acludc.org/en/know-your-rights/if-stopped-photographing-public

Camera and Computer Setup

Jeremy — Sun, 23 Feb 2025 22:03:08 +0000

Abstract

The following article will read like a recipe. We enumerate hardware components (ingredients), describe configuration (recipe), and connect. This is the foundation on which we’ll build.

Step-by-Step

Ingredients (Hardware)

EOS 70D DSLR, and AC adapter for continuous power
300mm AF f/4-5.6 lens for EOS 70D
Tripod for fixed position capture
Raspberry Pi 4 Model B, AC adapter, with Raspbian, Python, and OpenCV installed
USB cable connecting camera to Raspberry Pi, USB-A to USB Mini-B

Recipe

Setup Raspberry Pi with Raspbian, Python, and OpenCV libraries. Links [1] and [2] are good models to follow.
Setup camera. Mount, power it up. Don’t connect USB cable yet; we can work on USB capture after adjusting camera settings next.

Your camera setup will be different; but for folks modeling after mine, here’s how it’s set up.
Focus the camera lens on roadway. Use M setting for custom lens settings. I suggest finding a static piece of roadway like lane-line edge to check tack-sharp focus. Use magnify button to 10x on viewfinder to ensure focus.

This is 10x digital zoom testing lens focus. Picture is of a road reflector in highway asphalt.
- Fair warning: your configuration here will vary based on light and distance. For me, I am ~110 ft from highway surface (camera looking down on highway from home), and I live in rainy Seattle. My lens choice, 300mm zoom lens, and my settings reflect this.
- To discover your best settings, I suggest first 1) set fast shutter speed, then 2) zoom, then 3) focus, then 4) test and iterate with taking picture and confirming with 10x digital zoom that you have sufficient clarity for human eye to read license plate from camera viewfinder.
- My settings were 1/1000 shutter speed, f/5, and auto-ISO
- I spent probably the most time on this step learning about fstop and ISO, and experimenting. This was key for high-speed detailed image capture.
Capture photo - use viewfinder - demonstrating that you have the right zoom/focus. Use viewfinder to zoom and explore photo, and confirm you can read license plate manually.

Demonstrating to myself that I could capture images, and see license plate from viewfinder.
Connect USB cable between camera and Raspberry Pi
Confirm RPi OpenCV with simple script below. Equivalent of OpenCV “hello world!”

# tutorial
# https://docs.opencv.org/4.x/db/deb/tutorial_display_image.html
import cv2 as cv
import sys

photosPath = "/Users/japollock/Projects/TakePhoto1/photos/"
filename = "starry_night.jpg"

img = cv.imread(cv.samples.findFile(photosPath + filename))

if img is None:
    sys.exit("Could not read the image.")

cv.imshow("Display window", img)

k = cv.waitKey(0)

At this point, we have working camera, working RPi, working python OpenCV, and ready to build on this foundation to capture images from DSLR with commands sent by RPi.

Next Link: Capturing images from DSLR to RPi

Appendix: References

Appendix: Interesting Points

DSLR was an evolution in my camera choice, but necessary in the end. I started with a Raspberry Pi HD camera, and could not achieve the zoom and focus required for high-speed car image capture.
In my case, I am 10 stories up from highway surface, and probably 40 ft laterally removed - this is why the 300mm zoom was necessary and fully utilized. This is related to why DSLR + lens was required instead of RPi HD camera.
venv (Virtual env) helped a lot - particularly with going back and forth between writing code on mac book, then executing code on RPi. Helped navigate package dependencies, and avoid dependency-hell that might otherwise have gotten in the way.
pyenv (Python version management) also helped a lot - given that paddleOCR is finicky about which python version works correctly. In my case I used 3.9.21.

OpenCV in Python for End-to-end License Plate Detection

Jeremy — Sun, 23 Feb 2025 21:43:02 +0000

Abstract

The following outlines a multi-step workflow to capture images of cars driving by on the highway, read license plates, and write those to a local database. Each step in the workflow has a dedicated article and how-to. Feel free to hook in wherever!

Background

This article details how I built my own license plate detection rig with the idea that I can help you build something similar. This workflow operates in real time on a raspberry pi 4b connected to a Canon DSLR, with testing and iterating on my MacBook. The camera looks down on the i5 northbound highway in our Seattle condo. I share how the pipeline works end-to-end from capture to detection to ocr and storage. Code is shared and photo/resources for reproducing on your end, as well as outlining challenges I encountered in case you have similar problems.

It’s a weird but fun build, with no intended business application. I thought maybe it would be neat to build a query mechanism for amber alerts - get an alert, then check if/when license was last observed. But just a toy idea. And really I just wanted a hobby project to build after studying computer vision in university – a project that would be fun to enjoy tinkering around.

As of this writing, the workflow is ~90% complete. Only OCR is not working reliably. Each other step has gone through evolutions from ideation to production. For example, the camera rig originally started as a raspberry pi HQ camera. But iterations later, it was clear that a raspberry pi HQ camera could not capture high-speed cars in detail. Instead, an EOS DSLR with 300mm lens proved better. :) This is a journey! Hopefully my experience can help some other folks interested in similar concepts - and so I detail here what I have accomplished.

Step-by-step

Overview: OpenCV in Python for End-to-end License Plate Detection.
Camera and computer setup. Raspberry pi (RPi), Canon DSLR, f-stop and ISO.
Capturing images from DSLR to RPi. Automating image capture and transfer to RPi.
Model for detecting cars. Train YOLO model from scratch and label images.
Crop bounding box + rotate.
Model for detecting license plates. Train a second YOLO model.
Crop bounding box.
Read license plate with OCR. Pre-process image, and extract text with Paddle OCR.
TBD -- End-to-end real-time detection of license plates

Each article is self-contained. If you’re only interested in building and training your own CV model, then you can read just article (3). If you’re interested in how to set up a camera to capture tack-sharp images of highway speed cars, then you can read just article (1). If you want to build a whole system end-to-end, then this series should help. Have fun!

Next Link: Camera and computer setup