Methods

Note: Examples in this guide assume you have already configured LicensePlateRecognizerConfig with model specifications. See Configuration Guide for complete setup details.

Methods Overview

Method	Purpose	Input	Best For
predict()	Recognize plates in one image	One image	Single photo processing
predict_batch()	Recognize plates in multiple images	Image iterator	Video/batch processing

Performance tip: Use predict_batch() for multiple items - it provides ~2-3x speedup through pipeline parallelism.

InferenceResults

predict() and predict_batch() return DeGirum InferenceResults objects with a .license_plates property containing detected plates.

Key property: .license_plates - List of LPRResult objects, each with plate_number (text), ocr_score (OCR confidence), detection_score (detection confidence), bbox (bounding box)

See InferenceResults documentation for standard PySDK methods like image_overlay(), results, etc.

---

predict()

Recognize license plates in a single image.

Signature

predict(frame: Any) -> degirum.postprocessor.InferenceResults

Parameters

• frame - Image as numpy array or file path (str)

Returns

• degirum.postprocessor.InferenceResults - Object with .license_plates property containing list of detected plates. See InferenceResults documentation

How It Works

1. Detects all license plates in the image

2. Crops each detected plate region

3. Runs OCR on each cropped plate

4. Returns results with recognized text in label field

Examples

Recognize from file path:

import degirum_vehicle

lpr = degirum_vehicle.LicensePlateRecognizer(
    degirum_vehicle.LicensePlateRecognizerConfig()
)

result = lpr.predict('photos/car.jpg')

print(f"Found {len(result.license_plates)} plates")
for plate in result.license_plates:
    print(f"Plate: {plate.plate_number}")
    print(f"OCR Score: {plate.ocr_score:.2f}")
    print(f"Detection Score: {plate.detection_score:.2f}")
    print(f"Bounding box: {plate.bbox}")
# Output: Found 1 plates
#         Plate: ABC123
#         OCR Score: 0.95
#         Detection Score: 0.92
#         Bounding box: [100, 200, 300, 250]

Recognize from numpy array:

import degirum_vehicle
import cv2

lpr = degirum_vehicle.LicensePlateRecognizer(
    degirum_vehicle.LicensePlateRecognizerConfig()
)

image = cv2.imread('photos/car.jpg')
result = lpr.predict(image)

for plate in result.license_plates:
    print(f"Detected plate: {plate.plate_number}")

Using demo image:

from degirum_tools import remote_assets

result = lpr.predict(remote_assets.car)
for plate in result.license_plates:
    print(f"{plate.plate_number} ({plate.ocr_score:.2%})")

Best Practices

• Use clear images - Better lighting and focus improve OCR accuracy

• Frame the plate - Closer views of plates work better

• Check confidence scores - Filter results by plate.ocr_score threshold

---

predict_batch()

Recognize license plates in multiple images efficiently.

Signature

predict_batch(frames: Iterable) -> Iterator[degirum.postprocessor.InferenceResults]

Parameters

• frames - Iterator yielding frames as numpy arrays or file paths

Returns

• Iterator yielding degirum.postprocessor.InferenceResults objects with .license_plates property

How It Works

1. Processes all images through detection → cropping → OCR pipeline

2. Pipeline parallelism makes this faster than calling predict() repeatedly

3. Yields results as they're processed

Examples

Process multiple images:

import degirum_vehicle

lpr = degirum_vehicle.LicensePlateRecognizer(
    degirum_vehicle.LicensePlateRecognizerConfig()
)

# Prepare data
image_paths = ['car1.jpg', 'car2.jpg', 'car3.jpg']

# Process all at once
for idx, result in enumerate(lpr.predict_batch(image_paths)):
    print(f"\nImage {idx}:")
    for plate in result.license_plates:
        print(f"  Plate: {plate.plate_number} ({plate.ocr_score:.2f})")
# Output: 
# Image 0:
#   Plate: ABC123 (0.95)
# Image 1:
#   Plate: XYZ789 (0.92)
# Image 2:
#   Plate: DEF456 (0.88)

Process video frames:

import cv2

def video_frames(path):
    cap = cv2.VideoCapture(path)
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        yield frame
    cap.release()

# Process video
for result in lpr.predict_batch(video_frames("traffic.mp4")):
    for plate in result.license_plates:
        print(f"Frame plate: {plate.plate_number}")

Filter by confidence:

image_paths = ['car1.jpg', 'car2.jpg', 'car3.jpg']

for result in lpr.predict_batch(image_paths):
    high_conf_plates = [
        p for p in result.license_plates 
        if p.ocr_score > 0.8
    ]
    for plate in high_conf_plates:
        print(f"High confidence: {plate.plate_number}")

Best Practices

• Use iterators - Pass iterators (not lists) for memory efficiency

• Pipeline parallelism - predict_batch() is 2-3x faster than multiple predict() calls

• Process video frames - Ideal for frame-by-frame video analysis

• Filter results - Apply confidence thresholds to get high-quality detections

Complete Example

import degirum_vehicle
from degirum_tools import remote_assets

# Create recognizer with default configuration
config = degirum_vehicle.LicensePlateRecognizerConfig()
lpr = degirum_vehicle.LicensePlateRecognizer(config)

# Single image
print("Single image:")
result = lpr.predict(remote_assets.car)
for plate in result.license_plates:
    print(f"  {plate.plate_number} - {plate.ocr_score:.2%}")

# Batch processing
print("\nBatch processing:")
images = ["car1.jpg", "car2.jpg", "car3.jpg"]
for idx, result in enumerate(lpr.predict_batch(images)):
    print(f"Image {idx}:")
    for plate in result.license_plates:
        print(f"  {plate.plate_number} ({plate.ocr_score:.2f})")