Developer Guide

NNANPR_SetStringParameter(L"APIKEY", L"<your-api-key>");

#include "nnAnpr.h"
#include <iostream>
#pragma comment(lib, "nnAnpr.lib")   // from Include\

int wmain()
{
    if (NNANPR_Init() != NNANPR_RESULT_SUCCESS)          // 1. initialize the engine once
        return -1;

    // NNANPR_SetStringParameter(L"APIKEY", L"...");     //    cloud edition only

    NNANPR_Image_ptr image = nullptr;                    // 2. load the input image
    NNANPR_CreateImage(&image);
    if (NNANPR_LoadImage(L"testdata\\EU2.jpg", image) != NNANPR_RESULT_SUCCESS)
        return -2;

    NNANPR_PlateFinder_ptr     finder     = nullptr;     // 3. create finder + recognizer
    NNANPR_PlateRecognizer_ptr recognizer = nullptr;     //    for your region and device
    NNANPR_CreatePlateFinder    (nngaEurope, nndIntelCPU, &finder);
    NNANPR_CreatePlateRecognizer(nngaEurope, nndIntelCPU, &recognizer);

    NNANPR_Object plates[30];                            // 4. find plates
    size_t        count = 30;                            //    in: capacity, out: found
    if (NNANPR_FindPlates(finder, image, plates, &count) == NNANPR_RESULT_SUCCESS)
    {
        for (size_t i = 0; i < count; ++i)               // 5. read each found plate
        {
            NNANPR_RecognizerResult rr{};
            if (NNANPR_RecognizePlate(recognizer, image, plates[i], &rr) == NNANPR_RESULT_SUCCESS)
                std::wcout << rr.Characters << L"   country: " << rr.Country
                           << L"   confidence: " << rr.CharacterConfidences[0] << L"\n";
        }
    }

    NNANPR_FreePlateRecognizer(recognizer);              // 6. release in reverse order
    NNANPR_FreePlateFinder(finder);
    NNANPR_FreeImage(image);
    return 0;
}

image ──► PlateFinder ──► NNANPR_Object[] ──► PlateRecognizer ──► NNANPR_RecognizerResult
                                                (per object)       text · confidences · country · type

StartCaptureFrameAsync ─► OnFrame:      draw frame; FindPlatesAsync(frame)
                          OnPlateFound: for the best plate → RecognizePlateAsyncWithAccumulator(...)
                          OnRecognition: post result to UI thread (plate text, country, image)

NNANPR_SetUIntParameter(L"CALL PF ASYNC CALLBACK EVEN NO RESULT", 1);

NNANPR_VehicleFinder_ptr          vf  = nullptr;
NNANPR_VehicleModelRecognizer_ptr vmr = nullptr;
NNANPR_CreateVehicleFinder(nndIntelCPU, &vf);
NNANPR_SetupVehicleFinder(vf, 0.5);                    // detection threshold, 0.5 default
NNANPR_CreateVehicleModelRecognizer(nndIntelCPU, &vmr);

NNANPR_Object vehicles[30]; size_t n = 30;
if (NNANPR_FindVehicles(vf, image, vehicles, &n) == NNANPR_RESULT_SUCCESS)
    for (size_t i = 0; i < n; ++i)
    {
        NNANPR_Vehicle v{};  NNANPR_GetVehicle(vehicles[i], v);   // classId: 1 car, 2 bus, 3 truck
        NNANPR_ModelRecognizerResult mr{};
        if (NNANPR_RecognizeVehicleModel(vmr, image, vehicles[i], &mr) == NNANPR_RESULT_SUCCESS)
            std::wcout << mr.ModelName << L"  " << mr.Confidence << L"\n";
    }

NNANPR_FreeVehicleModelRecognizer(vmr);                 // VMM handles use VMM free functions
NNANPR_FreeVehicleFinder(vf);

d=0123456789                ← define character class "d" (digits)
l=ABCDEFGHIJKLMNOPQRSTUVWXYZ  ← define character class "l" (letters)
template=llddlll            ← a legal plate pattern: 2 letters, 2 digits, 3 letters
template=ldddlll            ← list every legal pattern on its own line

public sealed class AnprEngine
{
    // Delegates kept in fields: the native engine calls them from its worker
    // threads for as long as the pipeline exists. If only the garbage collector
    // held them, a collected delegate would crash the process.
    private readonly NNANPROnPlateFoundCallback  _onPlates;
    private readonly NNANPROnRecognitionCallback _onRead;
    private IntPtr _finder, _recognizer;                 // handles are IntPtr, not ulong

    public AnprEngine()
    {
        _onPlates = OnPlatesFound;          // field assignment = GC-rooted
        _onRead   = OnPlateRead;
        nnAnpr.NNANPR_Init();
        nnAnpr.NNANPR_CreatePlateFinder(NNANPR_GeographicalArea.nngaEurope,
                                        NNANPR_Device.nndIntelCPU, ref _finder);
        nnAnpr.NNANPR_CreatePlateRecognizer(NNANPR_GeographicalArea.nngaEurope,
                                        NNANPR_Device.nndIntelCPU, ref _recognizer);
    }

    public void ProcessFrame(IntPtr image) =>
        nnAnpr.NNANPR_FindPlatesAsync(_finder, image, _onPlates, IntPtr.Zero);

    private void OnPlatesFound(ulong[] plates, ulong count, IntPtr image, IntPtr ctx)
    {
        if (count > 0)
            nnAnpr.NNANPR_RecognizePlateAsync(_recognizer, image, plates[0], _onRead, IntPtr.Zero);
    }

    private void OnPlateRead(ref NNANPR_RecognizerResult rr, IntPtr image, IntPtr ctx)
    {
        string plate = new string(rr.Characters).TrimEnd('\0');
        // marshal to the UI thread before touching controls:
        // form.BeginInvoke((Action)(() => label.Text = plate));
    }
}

using System;

class Program
{
    static int Main()
    {
        if (nnAnpr.NNANPR_Init() != nnAnpr.NNANPR_RESULT_SUCCESS)          // 1. initialize once
            return -1;

        // nnAnpr.NNANPR_SetStringParameter("APIKEY", "...");             //    cloud edition only

        IntPtr image = IntPtr.Zero;                                       // 2. load the input image
        nnAnpr.NNANPR_CreateImage(ref image);
        if (nnAnpr.NNANPR_LoadImage(@"testdata\EU2.jpg", image) != nnAnpr.NNANPR_RESULT_SUCCESS)
            return -2;

        IntPtr finder = IntPtr.Zero, recognizer = IntPtr.Zero;            // 3. create finder + recognizer
        nnAnpr.NNANPR_CreatePlateFinder(NNANPR_GeographicalArea.nngaEurope,
                                        NNANPR_Device.nndIntelCPU, ref finder);
        nnAnpr.NNANPR_CreatePlateRecognizer(NNANPR_GeographicalArea.nngaEurope,
                                        NNANPR_Device.nndIntelCPU, ref recognizer);

        ulong[] plates = new ulong[30];                                   // 4. find plates
        ulong   count  = (ulong)plates.Length;                           //    in: capacity, out: found
        if (nnAnpr.NNANPR_FindPlates(finder, image, ref plates[0], ref count) == nnAnpr.NNANPR_RESULT_SUCCESS)
        {
            for (ulong i = 0; i < count; i++)                            // 5. read each found plate
            {
                var rr = new NNANPR_RecognizerResult();
                if (nnAnpr.NNANPR_RecognizePlate(recognizer, image, plates[i], ref rr) == nnAnpr.NNANPR_RESULT_SUCCESS)
                    Console.WriteLine(PlateText(rr.Characters) + "   country: " + PlateText(rr.Country));
            }
        }

        nnAnpr.NNANPR_FreePlateRecognizer(recognizer);                    // 6. release in reverse order
        nnAnpr.NNANPR_FreePlateFinder(finder);
        nnAnpr.NNANPR_FreeImage(image);
        return 0;
    }

    // The result fields are fixed 50-char buffers; trim at the first NUL.
    static string PlateText(char[] a) => new string(a).TrimEnd('\0');
}

program PlateQuickStart;
{$APPTYPE CONSOLE}
uses
  System.SysUtils, nnAnpr;

var
  image      : NNANPR_Image_ptr;
  finder     : NNANPR_PlateFinder_ptr;
  recognizer : NNANPR_PlateRecognizer_ptr;
  objs       : PNNANPR_Object;
  count, i   : UInt64;
  rr         : NNANPR_RecognizerResult;
  plateStr, countryStr : string;
begin
  if NNANPR_Init <> NNANPR_RESULT_SUCCESS then            // 1. initialize once
    Halt(1);

  // NNANPR_SetStringParameter('APIKEY', '...');           //    cloud edition only

  NNANPR_CreateImage(image);                               // 2. load the input image
  if NNANPR_LoadImage('testdata\EU2.jpg', image) <> NNANPR_RESULT_SUCCESS then
    Halt(2);

  NNANPR_CreatePlateFinder(nngaEurope, nndIntelCPU, finder);        // 3. create finder + recognizer
  NNANPR_CreatePlateRecognizer(nngaEurope, nndIntelCPU, recognizer);

  count := 30;                                             // 4. find plates (in: capacity, out: found)
  if NNANPR_FindPlates(finder, image, objs, count) = NNANPR_RESULT_SUCCESS then
    for i := 0 to count - 1 do                             // 5. read each found plate
      if NNANPR_RecognizePlate(recognizer, image, objs[i], rr) = NNANPR_RESULT_SUCCESS then
      begin
        plateStr   := PChar(@rr.Characters[1]);            // fixed buffers are NUL-terminated
        countryStr := PChar(@rr.Country[1]);
        Writeln(plateStr, '   country: ', countryStr);
      end;

  NNANPR_FreePlateRecognizer(recognizer);                  // 6. release in reverse order
  NNANPR_FreePlateFinder(finder);
  NNANPR_FreeImage(image);
end.

#include "nnAnpr.h"
#include <iostream>

struct App {
    NNANPR_PlateFinder_ptr            finder      = nullptr;
    NNANPR_PlateRecognizer_ptr        recognizer  = nullptr;
    NNANPR_RecognitionAccumulator_ptr accumulator = nullptr;
    NNANPR_ImageWindow_ptr            window      = nullptr;
    NNANPR_ImageCapture_ptr           capture     = nullptr;
};

// Runs on an SDK worker thread once a plate has been read (consolidated).
void OnRecognition(const NNANPR_RecognizerResult* rr, const NNANPR_Image_ptr image, void* ctx) {
    if (rr->ErrorCode != NNANPR_RESULT_SUCCESS) return;
    std::wcout << L"Plate: " << rr->Characters << L"  (" << rr->Country << L")\n";
    // In a GUI app, marshal to the UI thread here (PostMessage / Invoke) before touching controls.
}

// Runs on the finder thread once detection completes.
void OnPlateFound(const NNANPR_Object* plates, size_t count, const NNANPR_Image_ptr image, void* ctx) {
    App* a = static_cast<App*>(ctx);
    if (count == 0) return;                              // guard on the COUNT, never the pointer
    NNANPR_RecognizePlateAsyncWithAccumulator(a->recognizer, a->accumulator, image, plates[0],
                                             OnRecognition, ctx);
}

// Runs on the capture thread for every frame.
void OnFrame(const NNANPR_Image_ptr image, void* ctx) {
    App* a = static_cast<App*>(ctx);
    NNANPR_DrawImage(a->window, image);                 // show the live frame
    NNANPR_FindPlatesAsync(a->finder, image, OnPlateFound, ctx);
}

int wmain() {
    if (NNANPR_Init() != NNANPR_RESULT_SUCCESS) return -1;

    App app;
    NNANPR_CreatePlateFinder    (nngaEurope, nndIntelCPU, &app.finder);
    NNANPR_CreatePlateRecognizer(nngaEurope, nndIntelCPU, &app.recognizer);
    NNANPR_CreateRecognitionAccumulator(&app.accumulator);
    NNANPR_SetupRecognitionAccumulator(app.accumulator, 2000, 5, 20, 3); // 2 s / 5 frames / min 20 px / diff 3
    NNANPR_CreateImageWindow(nullptr, &app.window);

    if (NNANPR_CreateVideoCapture(&app.capture, L"rtsp://user:pass@192.168.1.10/stream")
            != NNANPR_RESULT_SUCCESS)
        return -2;

    NNANPR_StartCaptureFrameAsync(app.capture, OnFrame, &app);   // callbacks now run on SDK threads
    NNANPR_WaitImageWindow(app.window, 0, true);                 // block until the window is closed

    NNANPR_StopCaptureFrameAsync(app.capture);          // 1. stop capture FIRST
    NNANPR_FreeVideoCapture(app.capture);               // 2. then free, in reverse order
    NNANPR_FreeRecognitionAccumulator(app.accumulator);
    NNANPR_FreePlateRecognizer(app.recognizer);
    NNANPR_FreePlateFinder(app.finder);
    NNANPR_FreeImageWindow(app.window);
    return 0;
}

#include "nnAnpr.h"
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;

int wmain(int argc, wchar_t* argv[]) {
    if (argc < 2) { std::wcout << L"usage: batch <folder>\n"; return -1; }
    if (NNANPR_Init() != NNANPR_RESULT_SUCCESS) return -1;

    NNANPR_PlateFinder_ptr     finder     = nullptr;
    NNANPR_PlateRecognizer_ptr recognizer = nullptr;
    NNANPR_CreatePlateFinder    (nngaEurope, nndIntelCPU, &finder);
    NNANPR_CreatePlateRecognizer(nngaEurope, nndIntelCPU, &recognizer);
    NNANPR_SetupPlateFinder(finder, 0.5, 0);

    NNANPR_Image_ptr image = nullptr;
    NNANPR_CreateImage(&image);

    std::wofstream report(L"results.csv");
    report << L"file,plate,country\n";

    for (auto& entry : fs::directory_iterator(argv[1])) {
        auto ext = entry.path().extension().wstring();
        if (ext != L".jpg" && ext != L".png" && ext != L".bmp") continue;
        if (NNANPR_LoadImage(entry.path().c_str(), image) != NNANPR_RESULT_SUCCESS) continue;

        NNANPR_Object plates[30]; size_t count = 30;
        if (NNANPR_FindPlates(finder, image, plates, &count) != NNANPR_RESULT_SUCCESS) continue;

        for (size_t i = 0; i < count; ++i) {            // every plate, not just the first
            NNANPR_RecognizerResult rr{};
            if (NNANPR_RecognizePlate(recognizer, image, plates[i], &rr) == NNANPR_RESULT_SUCCESS)
                report << entry.path().filename().wstring() << L',' << rr.Characters
                       << L',' << rr.Country << L'\n';
        }
    }

    NNANPR_FreeImage(image);
    NNANPR_FreePlateRecognizer(recognizer);
    NNANPR_FreePlateFinder(finder);
    std::wcout << L"Done. Results in results.csv\n";
    return 0;
}

using System;

class LiveAnpr
{
    // delegates kept in fields for the whole run (GC-rooted)
    readonly NNANPROnFrameCallback       _onFrame;
    readonly NNANPROnPlateFoundCallback  _onPlates;
    readonly NNANPROnRecognitionCallback _onRead;
    IntPtr _finder, _recognizer, _accum, _window, _capture;

    LiveAnpr() { _onFrame = OnFrame; _onPlates = OnPlatesFound; _onRead = OnPlateRead; }

    void OnFrame(IntPtr image, IntPtr ctx) {
        nnAnpr.NNANPR_DrawImage(_window, image);
        nnAnpr.NNANPR_FindPlatesAsync(_finder, image, _onPlates, IntPtr.Zero);
    }
    void OnPlatesFound(ulong[] plates, ulong count, IntPtr image, IntPtr ctx) {
        if (count > 0)
            nnAnpr.NNANPR_RecognizePlateAsyncWithAccumulator(_recognizer, _accum, image, plates[0], _onRead, IntPtr.Zero);
    }
    void OnPlateRead(ref NNANPR_RecognizerResult rr, IntPtr image, IntPtr ctx) {
        if (rr.ErrorCode == nnAnpr.NNANPR_RESULT_SUCCESS)
            Console.WriteLine(new string(rr.Characters).TrimEnd('\0'));
    }

    static void Main() {
        if (nnAnpr.NNANPR_Init() != nnAnpr.NNANPR_RESULT_SUCCESS) return;
        var app = new LiveAnpr();
        nnAnpr.NNANPR_CreatePlateFinder(NNANPR_GeographicalArea.nngaEurope, NNANPR_Device.nndIntelCPU, ref app._finder);
        nnAnpr.NNANPR_CreatePlateRecognizer(NNANPR_GeographicalArea.nngaEurope, NNANPR_Device.nndIntelCPU, ref app._recognizer);
        nnAnpr.NNANPR_CreateRecognitionAccumulator(ref app._accum);
        nnAnpr.NNANPR_SetupRecognitionAccumulator(app._accum, 2000, 5, 20, 3);
        nnAnpr.NNANPR_CreateImageWindow(IntPtr.Zero, ref app._window);
        if (nnAnpr.NNANPR_CreateVideoCapture(ref app._capture, "rtsp://user:pass@192.168.1.10/stream") != nnAnpr.NNANPR_RESULT_SUCCESS) return;

        nnAnpr.NNANPR_StartCaptureFrameAsync(app._capture, app._onFrame, IntPtr.Zero);
        nnAnpr.NNANPR_WaitImageWindow(app._window, 0, true);      // block until closed

        nnAnpr.NNANPR_StopCaptureFrameAsync(app._capture);        // stop FIRST, then free
        nnAnpr.NNANPR_FreeVideoCapture(app._capture);
        nnAnpr.NNANPR_FreeRecognitionAccumulator(app._accum);
        nnAnpr.NNANPR_FreePlateRecognizer(app._recognizer);
        nnAnpr.NNANPR_FreePlateFinder(app._finder);
        nnAnpr.NNANPR_FreeImageWindow(app._window);
    }
}

using System;

class Vmm
{
    static int Main()
    {
        if (nnAnpr.NNANPR_Init() != nnAnpr.NNANPR_RESULT_SUCCESS) return -1;

        IntPtr image = IntPtr.Zero;
        nnAnpr.NNANPR_CreateImage(ref image);
        if (nnAnpr.NNANPR_LoadImage(@"testdata\Traker1.jpg", image) != nnAnpr.NNANPR_RESULT_SUCCESS) return -2;

        IntPtr vf = IntPtr.Zero, vmr = IntPtr.Zero;
        nnVmm.NNANPR_CreateVehicleFinder(NNANPR_Device.nndIntelCPU, ref vf);
        nnVmm.NNANPR_SetupVehicleFinder(vf, 0.5);
        nnVmm.NNANPR_CreateVehicleModelRecognizer(NNANPR_Device.nndIntelCPU, ref vmr);

        ulong[] vehicles = new ulong[30];
        ulong   count    = (ulong)vehicles.Length;
        if (nnVmm.NNANPR_FindVehicles(vf, image, ref vehicles[0], ref count) == nnAnpr.NNANPR_RESULT_SUCCESS)
            for (ulong i = 0; i < count; i++) {
                var mr = new NNANPR_ModelRecognizerResult();
                if (nnVmm.NNANPR_RecognizeVehicleModel(vmr, image, vehicles[i], ref mr) == nnAnpr.NNANPR_RESULT_SUCCESS)
                    Console.WriteLine($"{new string(mr.ModelName).TrimEnd('\0')}  {mr.Confidence:0.00}");
            }

        nnVmm.NNANPR_FreeVehicleModelRecognizer(vmr);
        nnVmm.NNANPR_FreeVehicleFinder(vf);
        nnAnpr.NNANPR_FreeImage(image);
        return 0;
    }
}

program LiveAnpr;
{$APPTYPE CONSOLE}
uses System.SysUtils, nnAnpr;
var
  Finder     : NNANPR_PlateFinder_ptr;
  Recognizer : NNANPR_PlateRecognizer_ptr;
  Accum      : NNANPR_RecognitionAccumulator_ptr;
  Window     : NNANPR_ImageWindow_ptr;
  Capture    : NNANPR_ImageCapture_ptr;

procedure OnRecognition(rr: PNNANPR_RecognizerResult; image: NNANPR_Image_ptr; ctx: Pointer); cdecl;
begin
  if rr^.ErrorCode = NNANPR_RESULT_SUCCESS then
    Writeln(string(PChar(@rr^.Characters[1])), '  (', string(PChar(@rr^.Country[1])), ')');
end;

procedure OnPlateFound(plates: PNNANPR_Object; count: UInt64; image: NNANPR_Image_ptr; ctx: Pointer); cdecl;
begin
  if count = 0 then Exit;                          // guard on the count
  NNANPR_RecognizePlateAsyncWithAccumulator(Recognizer, Accum, image, plates[0], OnRecognition, nil);
end;

procedure OnFrame(image: NNANPR_Image_ptr; ctx: Pointer); cdecl;
begin
  NNANPR_DrawImage(Window, image);
  NNANPR_FindPlatesAsync(Finder, image, OnPlateFound, nil);
end;

begin
  if NNANPR_Init <> NNANPR_RESULT_SUCCESS then Halt(1);
  NNANPR_CreatePlateFinder(nngaEurope, nndIntelCPU, Finder);
  NNANPR_CreatePlateRecognizer(nngaEurope, nndIntelCPU, Recognizer);
  NNANPR_CreateRecognitionAccumulator(Accum);
  NNANPR_SetupRecognitionAccumulator(Accum, 2000, 5, 20, 3);
  NNANPR_CreateImageWindow(0, Window);
  if NNANPR_CreateVideoCapture(Capture, 'rtsp://user:pass@192.168.1.10/stream') <> NNANPR_RESULT_SUCCESS then Halt(2);

  NNANPR_StartCaptureFrameAsync(Capture, OnFrame, nil);   // callbacks run on SDK threads
  NNANPR_WaitImageWindow(Window, 0, True);                // block until the window is closed

  NNANPR_StopCaptureFrameAsync(Capture);                  // stop FIRST, then free
  NNANPR_FreeVideoCapture(Capture);
  NNANPR_FreeRecognitionAccumulator(Accum);
  NNANPR_FreePlateRecognizer(Recognizer);
  NNANPR_FreePlateFinder(Finder);
  NNANPR_FreeImageWindow(Window);
end.

program VehicleModel;
{$APPTYPE CONSOLE}
uses System.SysUtils, nnAnpr, nnVmm;
var
  image    : NNANPR_Image_ptr;
  vf       : NNANPR_VehicleFinder_ptr;
  vmr      : NNANPR_VehicleModelRecognizer_ptr;
  vehicles : PNNANPR_Object;
  count, i : UInt64;
  mr       : NNANPR_ModelRecognizerResult;
begin
  if NNANPR_Init <> NNANPR_RESULT_SUCCESS then Halt(1);

  NNANPR_CreateImage(image);
  if NNANPR_LoadImage('testdata\Traker1.jpg', image) <> NNANPR_RESULT_SUCCESS then Halt(2);

  NNANPR_CreateVehicleFinder(nndIntelCPU, vf);
  NNANPR_SetupVehicleFinder(vf, 0.5);
  NNANPR_CreateVehicleModelRecognizer(nndIntelCPU, vmr);

  count := 30;
  if NNANPR_FindVehicles(vf, image, vehicles, count) = NNANPR_RESULT_SUCCESS then
    for i := 0 to count - 1 do
      if NNANPR_RecognizeVehicleModel(vmr, image, vehicles[i], mr) = NNANPR_RESULT_SUCCESS then
        Writeln(string(PChar(@mr.ModelName[1])), '  ', FormatFloat('0.00', mr.Confinedce));

  NNANPR_FreeVehicleModelRecognizer(vmr);
  NNANPR_FreeVehicleFinder(vf);
  NNANPR_FreeImage(image);
end.