Carmen® FreeFlow

Number Plate Recognition Engine with Software Development Kit

Highlighted Features

tried-and-tested

Tried and Tested

Used in over 100,000 systems worldwide.

wolrdwide-anpr-and-mmr

Wolrdwide ANPR and MMR

Worldwide recognition of vehicle plates, make, model, and color with a single integration.

regular-engine-updates

Regular Engine Updates

Four updates released per year.

scalability

Scalability

From small through medium, to large and complex systems.

video-and-image-processing

Video and Image Processing

SDK supports either data input.

support-of-major-op-systems

Support of Major Op Systems

Runs on Windows and Linux.

Sample Codes


    #include "gxsdldr.c"
    #include "cmanpr.h"
    
    // If an error occurred it displays the error and terminates the program
    void term_if_err(int st) {
        int err_code;
        wchar_t err_str[256];
    
        if(st) return;		// No error occurred
        // Displays error code and description
        err_str[(sizeof(err_str)/sizeof(wchar_t))-1] = 0;
        gx_geterror(&err_code, err_str, (sizeof(err_str)/sizeof(wchar_t))-1);
        fprintf(stderr, "GX error (%x) occurred: %ls\n", err_code, err_str);
        // Terminates the program
        exit(1);
    }
    
    int main(void) {
        struct gxHANDLE anprhandle, imagehandle;
        struct gxIMAGE *image;
        struct cmNP *anprresult;
        int st;
        
        // Opens the ANPR module with EUR region
        st = gx_openmodule(&anprhandle, L"cmanpr", L"eur");
        term_if_err(st);
        
        // Opens the image module, allocates the image structure and load the image
        st = gx_openmodule(&imagehandle, L"gximage", L"default");
        term_if_err(st);
        st = gx_allocimage(imagehandle, &image);
        term_if_err(st);
        st = gx_loadimage(imagehandle, image, L"image.jpg", GX_UNDEF);
        term_if_err(st);
        
        // Finds the first license plate
        anprresult = 0;
        st = cm_findfirst(anprhandle, image, &anprresult);
        term_if_err(st);
        
        if(anprresult) {
            char countryCode[256]="";
            // Get short country code
            st = cm_getcountrycode(anprhandle,anprresult->type,(int)CCT_COUNTRY_SHORT,countryCode,sizeof(countryCode));
            term_if_err(st);
            // Displays the result, country code and type
            printf("Plate text: %s\n", anprresult->text);
            printf("Country code: %s\n", countryCode[0] ? countryCode : "No plate type");
            printf("Type: %i\n", anprresult->type);
    
            // Frees up the result
            st = gx_globalfree(anprresult);
            term_if_err(st);
        } else {
            printf("No license plate found\n");
        }
        
        // Frees up the resources
        st = gx_unrefimage(imagehandle, image);
        term_if_err(st);
        st = gx_unrefhandle(&imagehandle);
        term_if_err(st);
        st = gx_unrefhandle(&anprhandle);
        term_if_err(st);
    
        return 0;
    }
    


    #include "gxsdldr.cpp"
    #include "cmanpr.h"
    
    int main() {
        try {
            // Creates the ANPR object with EUR region
            cm::cmAnpr anpr("eur");
    
            // Creates the image object and load the image
            gxImage image;
            image.Load("image.jpg");
    
            // Finds the first license plate
            if(anpr.FindFirst(image)) {
                // Get short country code
                gxOutStr countryCode = anpr.GetCountryCode(anpr.GetType(),(int)cm::CCT_COUNTRY_SHORT);
                std::wstring wCountryCode = countryCode.empty() ? L"No plate type" : countryCode;
    
                // Displays the result, country code and type
                std::wcout << L"Plate text: " << anpr.GetText() << std::endl;
                std::wcout << L"Country code: " << wCountryCode << std::endl;
                std::wcout << L"Type: " << anpr.GetType() << std::endl;
            } else {
                std::wcout << L"No license plate found" << std::endl;
            }
    
        } catch(gxError &e) {
            std::wcerr << L"GX error (" << e.GetErrorCode() << ") occurred: " <<  e.GetErrorString() << std::endl;
            return 1;
        }
    
        return 0;
    }
    


    using System;
    using gx;
    using cm;
    
    namespace carmen
    {
        class MainClass
        {
            public static void Main(string[] args)
            {
                try {
                    // Creates the ANPR object with EUR region
                    cmAnpr anpr = new cmAnpr("eur");
    
                    // Creates the image object and load the image
                    gxImage image = new gxImage();
                    image.Load("image.jpg");
    
                    // Finds the first license plate
                    if (anpr.FindFirst(image)) {
                        // Get short country code
                        String countryCode = anpr.GetCountryCode(anpr.GetType(), (int)CC_TYPE.CCT_COUNTRY_SHORT);
                        countryCode = countryCode.Length > 0 ? countryCode : "No plate type";
    
                        //Displays the result, country code and type
                        Console.WriteLine("Plate text: {0}", anpr.GetText());
                        Console.WriteLine("Country code: {0}", countryCode);
                        Console.WriteLine("Type: {0}", anpr.GetType());
                    } else {
                        Console.WriteLine("No license plate found");
                    }
                } catch(gxException) {
                    Console.Error.WriteLine("GX error (" + gxSystem.GetErrorCode() + ") occured: " + gxSystem.GetErrorString());
                    Environment.Exit(1);
                }
            }
        }
    }
    


    import com.adaptiverecognition.gx.*;
    import com.adaptiverecognition.cm.*;
    
    public class cmanpr {
    
        static {
            try {
                System.loadLibrary("jgx");
                System.loadLibrary("jcmanpr");
            } catch(UnsatisfiedLinkError e) {
                System.err.println("Native code library failed to load." + e);
                System.exit(1);
            }
        }
    
        public static void main(String argv[]) {
            try {
                // Creates the ANPR object with EUR region
                cmAnpr anpr = new cmAnpr("eur");
    
                // Creates the image object and load the image
                gxImage image = new gxImage();
                image.Load("image.jpg");
                
                // Finds the first license plate
                if(anpr.FindFirst(image)) {
                    // Get short country code
                    String countryCode = anpr.GetCountryCode(anpr.GetType(),jcmanprConstants.CCT_COUNTRY_SHORT);
                    countryCode = countryCode.length()>0 ? countryCode : "No plate type";
    
                    // Displays the result, country code and type
                    System.out.println("Plate text: " + anpr.GetText());
                    System.out.println("Country code: " + countryCode);
                    System.out.println("Type: " + anpr.GetType());
                } else {
                    System.out.println("No license plate found");
                }			
    
                // Frees up resources
                anpr.delete();
                image.delete();
            } catch(RuntimeException e) {
                System.err.println("GX error (" + String.format("0x%08x",gxSystem.GetErrorCode()) + ") occured: " + gxSystem.GetErrorString());
                System.exit(1);
            }
        }
    }
    


    Imports System
    Imports gx
    Imports cm
    
    Module Main
        Sub Main()
            Try
                ' Creates the ANPR object with EUR region
                Dim anpr As cmAnpr = New cmAnpr("eur")
    
                ' Creates the image object and load the image
                Dim image As gxImage = New gxImage("default")
                image.Load("image.jpg")
    
                ' Finds the first license plate
                If anpr.FindFirst(image) Then
                    ' Get short country code
                    Dim countryCode As String
                    countryCode = anpr.GetCountryCode(anpr.GetType(), CC_TYPE.CCT_COUNTRY_SHORT)
                    If countryCode.Length = 0 Then countryCode = "No plate type"
    
                    ' Displays the result, country code and type
                    Console.WriteLine("Plate text: {0}", anpr.GetText())
                    Console.WriteLine("Country code: {0}", countryCode)
                    Console.WriteLine("Type: {0}", anpr.GetType())
                Else
                    Console.WriteLine("No license plate found")
                End If
            Catch ex As gxException
                Console.Error.WriteLine("GX error (" + gxSystem.GetErrorCode().ToString() + ") occured: " + gxSystem.GetErrorString())
                Environment.Exit(1)
            End Try
        End Sub
    End Module
     

Licensing Options

k-license-for-low-traffic-projects

K-License for Low Traffic Projects

This type of license is recommended for access control projects with less than 300 parking places.

freeflow-licensing-by-cpu-core

FreeFlow Licensing by CPU Core

Via this option, you can adapt your licensing to the processing capacity of your hardware (see table below).

Licesing Guidelines Based on
Processing Power and Requirements

Guidelines
Single License (Image/Sec) Dual License (Image/Sec) Quad License (Image/Sec)
i3 processor
1 - 5 2 - 10 4 - 20
i5 processor
3 - 7 6 - 14 12 - 28
i7 processor
5 - 10 10 - 20 20 - 40
i3 processor
1 - 5
i5 processor
3 - 7
i7 processor
5 - 10
i3 processor
2 - 10
i5 processor
6 - 14
i7 processor
10 - 20
i3 processor
4 - 20
i5 processor
12 - 28
i7 processor
20 - 40
Image processing capacity depends on numerous factors, such as resolution, the processing capacity of hardware, the complexity of regional license plates, and the number of license plate types in the regional engine.
The values above are guidelines based on FHD resolution and OCR-ready images. For more information, please contact us.

Product Documentation and Other Resources

Contact

AR_PRODUCT

Ez a form a termékekhez. Minden terméknél a preferred product type-ot fix értékkel egy hidden mezőben el kell helyezni. Az Aktív form nevek kezdődjenek így: AR_PRODUCT_(product név)

  • Please describe your type of business
  • This field is for validation purposes and should be left unchanged.

GET MORE INFORMATION OR A QUOTE

Our sales & product experts are here to help you. Contact us or find an affiliate near your location.

View our representatives on a map