DEV Community: Edward Obar Cabigting

Building a License Plate Recognition Engine in C++ — Part 2: Grayscale Image Preprocessing and Local Contrast Edge Detection

Edward Obar Cabigting — Sat, 16 May 2026 02:53:21 +0000

In the previous article, we loaded an image, converted it into grayscale, and introduced the core data structures used by the recognition engine.

In this part, we begin building the preprocessing stage of the LPR pipeline.

The goal of preprocessing is to enhance image regions that are likely to contain license plate characters.

We will implement:

Integral image generation
Local contrast analysis
Edge map extraction
Ternary edge image conversion

These operations are designed for high-speed processing and are suitable for real-time systems.

Why preprocessing matters in LPR

License plates typically contain:

High-contrast characters
Dense vertical and horizontal transitions
Repetitive edge structures

Instead of applying expensive operations across the entire image, preprocessing helps emphasize candidate regions before plate detection begins.

The pipeline implemented in this article focuses on local intensity differences.

Integral Image

The first optimization step is building an integral image.

An integral image allows us to compute the sum of any rectangular region in constant time.

Without an integral image:

Region Sum = O(width × height)

With an integral image:

Region Sum = O(1)

This becomes extremely important when processing every pixel in large images.

Computing the integral image

void CImageProc::ComputeIntegralImage(
    unsigned char* pbGray,
    int nWidth,
    int nHeight,
    int* pnSum)
{
    int nW = nWidth + 1;
    int nH = nHeight + 1;

    int partialsum;

    memset(pnSum, 0, nH * nW * sizeof(int));

    for (int y = 1; y < nH; y++)
    {
        pnSum[y * nW] = 0;
        partialsum = 0;

        for (int x = 1; x < nW; x++)
        {
            partialsum +=
                (int)pbGray[
                    (y - 1) * nWidth + (x - 1)];

            pnSum[y * nW + x] =
                pnSum[(y - 1) * nW + x]
                + partialsum;
        }
    }
}

Fast local contrast edge map

void CImageProc::ComputeLocalContrastEdgeMap(
    unsigned char* pbGray, 
    int* pnSum, 
    int* pnEdge, 
    int nWidth, 
    int nHeight)
{
    if (!pbGray || !pnSum || !pnEdge || nWidth <= 0 || nHeight <= 0)
        return;

    const int rw = 3;
    const int rh = 3;
    const int nW = nWidth + 1;


    const int centerCount = 5;
    const int windowCount = (rw * 2 + 1) * (rh * 2 + 1);
    const int surroundCount = windowCount - centerCount;

    if (nWidth <= rw * 2 || nHeight <= rh * 2)
        return;

    for (int y = rh; y < nHeight - rh; y++)
    {
        const int row = y * nWidth;
        const int prevRow = (y - 1) * nWidth;
        const int nextRow = (y + 1) * nWidth;

        const int top = y - rh;
        const int bottom = y + rh + 1;
        for (int x = (rw + 1); x < nWidth - rw; x++)
        {
            const int left = x - rw;
            const int right = x + rw + 1;

            int centerSum =
                pbGray[prevRow + x] +
                pbGray[row + x - 1] +
                pbGray[row + x] +
                pbGray[row + x + 1] +
                pbGray[nextRow + x];

            int windowSum =
                pnSum[bottom * nW + right]
                - pnSum[top * nW + right]
                - pnSum[bottom * nW + left]
                + pnSum[top * nW + left];

            int surroundSum = windowSum - centerSum;

            double centerAvg = (double)centerSum / centerCount;
            double surroundAvg = (double)surroundSum / surroundCount;

            pnEdge[row + x] = (int)(surroundAvg - centerAvg);
        }
    }
    ComputeBorderLocalContrast(pbGray, pnSum, pnEdge, nWidth, nHeight, 0, nWidth - 1, 0, rh - 1, rw, rh);
    ComputeBorderLocalContrast(pbGray, pnSum, pnEdge, nWidth, nHeight, 0, nWidth - 1, nHeight - rh, nHeight - 1, rw, rh);
    ComputeBorderLocalContrast(pbGray, pnSum, pnEdge, nWidth, nHeight, 0, rw, rh, nHeight - rh, rw, rh);
    ComputeBorderLocalContrast(pbGray, pnSum, pnEdge, nWidth, nHeight, nWidth - rw, nWidth - 1, rh, nHeight - rh, rw, rh);
}

void CImageProc::ComputeBorderLocalContrast(
    unsigned char* pbGray, 
    int* pnSum, 
    int* lpOut, 
    int nWidth, 
    int nHeight, 
    int x0, 
    int x1, 
    int y0, 
    int y1, 
    int rw, 
    int rh)
{
    if (!pbGray || !pnSum || !lpOut || nWidth <= 0 || nHeight <= 0)
        return;

    int nW = nWidth + 1;

    if (x0 < 0) x0 = 0;
    if (y0 < 0) y0 = 0;
    if (x1 >= nWidth) x1 = nWidth - 1;
    if (y1 >= nHeight) y1 = nHeight - 1;

    for (int y = y0; y <= y1; y++)
    {
        int row = y * nWidth;

        for (int x = x0; x <= x1; x++)
        {
            int left = x - rw;
            int right = x + rw;
            int top = y - rh;
            int bottom = y + rh;

            if (left < 0) left = 0;
            if (top < 0) top = 0;
            if (right >= nWidth) right = nWidth - 1;
            if (bottom >= nHeight) bottom = nHeight - 1;

            int surroundCount = (right - left + 1) * (bottom - top + 1);
            int surroundSum = 
                pnSum[(bottom + 1) * nW + (right + 1)] 
                - pnSum[top * nW + (right + 1)] 
                - pnSum[(bottom + 1) * nW + left] 
                + pnSum[top * nW + left];

            int centerSum = 0;
            int centerCount = 0;

            // Center pixel
            centerSum += pbGray[row + x];
            surroundSum -= pbGray[row + x];
            centerCount++;
            surroundCount--;

            // Left
            if (x - 1 >= 0)
            {
                centerSum += pbGray[row + (x - 1)];
                surroundSum -= pbGray[row + (x - 1)];
                centerCount++;
                surroundCount--;
            }

            // Right
            if (x + 1 < nWidth)
            {
                centerSum += pbGray[row + (x + 1)];
                surroundSum -= pbGray[row + (x + 1)];
                centerCount++;
                surroundCount--;
            }

            // Top
            if (y - 1 >= 0)
            {
                centerSum += pbGray[(y - 1) * nWidth + x];
                surroundSum -= pbGray[(y - 1) * nWidth + x];
                centerCount++;
                surroundCount--;
            }

            // Bottom
            if (y + 1 < nHeight)
            {
                centerSum += pbGray[(y + 1) * nWidth + x];
                surroundSum -= pbGray[(y + 1) * nWidth + x];
                centerCount++;
                surroundCount--;
            }

            if (centerCount == 0 || surroundCount <= 0)
            {
                lpOut[row + x] = 0;
                continue;
            }

            double centerAvg = (double)centerSum / centerCount;
            double surroundAvg = (double)surroundSum / surroundCount;
            lpOut[row + x] = (int)(surroundAvg - centerAvg);
        }
    }
}

The algorithm performs:

Local neighborhood extraction
Center intensity averaging
Surrounding intensity averaging
Difference calculation

Result:

Strong intensity transitions
        ↓
High edge responses

This is particularly effective for license plate characters because they contain strong contrast boundaries.

Current preprocessing pipeline
Our LPR engine now performs:

Input Image
      ↓
Grayscale Conversion
      ↓
Integral Image
      ↓
Local Contrast Analysis
      ↓
Edge Map Generation
      ↓
Ternary Edge Image

At this point, the engine can already highlight regions containing dense character-like structures.

In the next article, we will begin locating candidate license plate regions using the generated edge information.

Building a License Plate Recognition Engine in C++ — Part 1: Image Loading and Core LPR Data Structures

Edward Obar Cabigting — Thu, 14 May 2026 08:16:35 +0000

In this series, I’ll build a License Plate Recognition (LPR) engine step by step in C++. The goal is not only to recognize license plates but also to understand the internal mechanics behind image processing and recognition systems.

In this first part we will:

Load an image using OpenCV
Convert the image into grayscale
Introduce the core data structures used by the recognition engine

Future parts will cover:

Image preprocessing
Noise reduction
Edge detection
Plate localization
Character segmentation
Character recognition
Performance optimization

Loading an image

The first step of any vision system is acquiring image data.

We read the image path from command-line arguments:

#include <iostream>
#include "opencv2/opencv.hpp"
#include "RecogEngine.h"

int main(int argc, char* argv[])
{
    if (argc < 2)
    {
        std::cout << "Usage: app.exe <image_path>\n";
        return -1;
    }

    const char* imagePath = argv[1];

    cv::Mat image = cv::imread(imagePath);

    if (image.empty())
    {
        std::cout << "Failed to load image: " << imagePath << "\n";
        return -1;
    }

    cv::Mat gray;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);

    LPRResult carData;

    CRecogEngine recogEngine;

    int nPlate = recogEngine.Recognition(
        gray.data,
        gray.cols,
        gray.rows,
        &carData);

    std::cout << "Recognition completed.\n";

    return 0;
}

Why convert to grayscale?

Most early image-processing stages do not require color information.

Using grayscale provides several advantages:

Reduces memory usage
Simplifies calculations
Improves processing speed
Keeps intensity information needed for edge and pattern analysis

Instead of processing three channels (BGR), we process a single intensity channel.

Designing core LPR data structures

Recognition systems need a structured way to store results.

The following structures define the fundamental objects used by our engine:

#pragma once

#define MULTIRESULT 10

typedef struct LPRRect
{
    long    left;
    long    top;
    long    right;
    long    bottom;
} Rect;


typedef struct LPRPoint
{
    int x;
    int y;
} Point;

typedef struct LPRSize
{
    int width;
    int height;
} Size;

typedef struct PlateCandidate
{
    int     characterCount;
    char    licenseText[20];
    float   confidenceDistance;
    int     confidenceScore;
    Rect    plateRegion;            
    Rect    characterRegions[20];
} LICENSE, * LPLICENSE;

struct LPRResult
{
    int     nPlate;
    LICENSE pPlate[MULTIRESULT];
    int     nProcTime;
};

These structures serve different purposes:

LPRRect

Stores coordinate information

PlateCandidate

Stores recognized text
Stores confidence values
Stores plate position
Stores character locations

LPRResult

Stores all recognition outputs
Supports multiple detected plates

Data flow of our engine

The recognition pipeline currently looks like this:

Input Image
      ↓
Image Loading
      ↓
Grayscale Conversion
      ↓
Recognition Engine
      ↓
LPRResult

At this point, the system can load an image and pass grayscale pixel data into the recognition engine.

In the next article, we'll begin preprocessing the image to prepare it for plate detection.

🚗 I built a Conversational Car Marketplace powered by LLMs

Edward Obar Cabigting — Mon, 04 May 2026 05:05:26 +0000

Most car platforms still rely on rigid filters.
I wanted to explore something better:
👉 What if users could just talk to the system?
So I built a platform where you can type:
“BMW E92 under $20k, manual, 70 miles”
…and the system understands and returns relevant cars instantly.

🧠 What makes it interesting?
Instead of simple keyword matching, the system extracts structured data from natural conversation:

Core vehicle → make, model, generation
Time & usage → year range, mileage
Preferences → transmission, color
Market constraints → location, price range This allows transforming messy human language into precise database queries.

⚙️ Tech Stack

Next.js (frontend)
FastAPI (backend)
PostgreSQL (data layer)
LLM (intent + entity extraction)
Web scraping pipeline (real listings)

🔄 How it works

User enters natural language
LLM extracts structured fields
Backend converts to query filters
PostgreSQL returns matching vehicles
Results improve through conversation

💡 Why this matters
This approach replaces:
❌ Manual filters
❌ Trial-and-error search
With:
✅ Natural interaction
✅ Faster discovery
✅ Smarter recommendations

🚀 Try it here:
https://askdrive-web.vercel.app/
I’m exploring how LLMs can redefine search UX in marketplaces.
Would love to hear your thoughts or feedback👇