# Methods

**Note:** Examples in this guide assume you have already configured `LicensePlateRecognizerConfig` with model specifications. See [Configuration Guide](/vehicle-analytics/guides/overview/configuration.md) 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](https://docs.degirum.com/pysdk/user-guide-pysdk/api-ref/postprocessor) for standard PySDK methods like `image_overlay()`, `results`, etc.

***

## predict()

Recognize license plates in a single image.

### Signature

```python
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](https://docs.degirum.com/pysdk/user-guide-pysdk/api-ref/postprocessor)

### 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:**

```python
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:**

```python
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:**

```python
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

```python
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:**

```python
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:**

```python
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:**

```python
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

```python
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})")
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.degirum.com/vehicle-analytics/guides/overview/methods.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.