## Catching Plates in Motion Photos never leave the host, and this pipeline reads plates from local paths returning text, confidence, and boxes in one call. A single function accepts paths and returns plate strings, confidence scores, and pixel coordinates for every detection, running on the local machine so parking, tolling, and security keep footage private without routing frames to an external API. Watching the first image run through feels different. The detector marks each plate with a box and confidence, then the recognizer reads characters off each crop in parallel, and results land as structured data before the eye finishes scanning. Nothing asks for another tool, and the loop from bytes to plates stays short for parking and tolling where each frame counts. ## Neither Desktop Nor Cloud Most plate recognition tools fall into two camps. Desktop suites demand a GUI and manual steps, while cloud APIs send photos to third parties. The gap was a pipeline that runs on premises, keeps photos local, and returns plates with confidence fast. Reading the gap in the editor makes it clear. Photos stay on host, plates return with confidence, no third party sees a frame. The pipeline fills that gap without GUI or network round trip. A detector locates plates locally, a recognizer reads each one, and confidence scores filter noise breaking naive approaches. Every step runs on same host as photos, so latency stays low.  ## Plates That Resist Reading - Desktop suites demand a GUI and manual steps for every batch. - Cloud APIs send photos to a third party and add latency and privacy risk. - Small plates at distance break naive detectors without a confidence gate. - Reading plates at angle and blur needs a recognizer built for real-world noise. ## Detect, Read, Return - Detect plates and filter by size and confidence in one call. - Read text from each plate with a recognizer tuned for real-world noise. - Process multiple plates in the same image concurrently. - Run on premises or in the cloud with photos never leaving the host. - Return text, confidence, and bounding boxes from one entry point. ## Two Stages, Tight Loop The strategy is one pipeline, two stages. A detector designed to locate plates feeds a recognizer designed to read characters, while a preprocessor preserves aspect ratio through letterboxing and a decoder turns per-slot probabilities into plate text. Parallel OCR runs all plates in the same image at once, keeping the loop from bytes to plates short for parking and toll. Tracing the flow in code makes the two-stage shape obvious. A preprocessor letterboxes each image to a square so aspect ratio survives, the detector returns regions with confidence, and a size filter drops plates too small. Each crop feeds the recognizer in parallel, a decoder turns probabilities into text. The loop stays in one entry point, keeping workloads aligned.  ## The Pipeline Walks Every image enters as a file path and leaves as structured plates. A loader designed to decode PNG, JPEG, or WebP feeds the detector, then a preprocessor letterboxes the image to a square so aspect ratio stays intact. The detector returns regions with confidence, and a size filter drops plates too small. Each cropped region goes to a recognizer tuned for real-world noise. ```typescript // Load models, then detect plates in images const recognizer = await ALPR.load({ models: { ocr: './models/ocr.onnx', detector: './models/detector.onnx' }, minPlateSize: { width: 20, height: 10 }, threshold: 0.5 }) const plates = await recognizer.detect(['./images/car1.jpg', './images/car2.jpg']) // plates[0].text, plates[0].confidence, plates[0].bbox ``` | Original Before | Annotated After | | :------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------: | |  |  | |  |  | |  |  | A decoder picks the strongest character per slot and strips padding, producing the final plate string. Detection and recognition share one entry point, photos local and plates returned with confidence and location in one pass for parking and tolling.  ## Delivered, Plate by Plate | Feature | Delivered | | ---------- | ---------------------------------------------- | | Detect | Plates filtered by size and confidence | | Recognize | Text from grayscale plate regions | | Parallel | Multiple plates in same image at once | | Output | Text, confidence, and bounding boxes per plate | | Deployment | On premises or cloud with photos local | ## Confidence Gated the Noise - One entry point kept parking, tolling, and security workloads aligned. - Letterbox preprocessing kept plates intact without distortion. - Parallel OCR cut latency for images with multiple plates. - A confidence gate removed a class of false positives at distance. ## Across Lots, Booths, Gates What began as a way to read plates for one app became a pipeline running across parking, tolling, and security. Detect and recognize share one entry point, keeping photos local and the loop from image to text short, with confidence on every plate. The editor closes on a pipeline that earned its place across workloads. One call, photos kept local, and confidence on each plate. Parking lots, toll booths, and security gates push different shapes and noise, and the pipeline holds up across all three. Letterboxing preserves aspect ratio so plates stay readable at angle, the confidence gate drops plates too small, and parallel OCR keeps latency low when one frame holds several vehicles. Photos never leave the host, keeping the workflow private.