MANUAL DE USUARIO -...

MANUAL DE USUARIO

Versión 6.1.x

www.quercus.biz

www.quercus-technologies.com

www.quercus.com.br

SmartLPR® Engine Manual de Usuario (v 6.1.x)

Mayo del 2014

© 2014 Quercus Technologies. Derechos reservados.

Este manual, así como el sistema descrito en él, se proporcionan bajo licencia y pueden ser usados únicamente de

acuerdo con los términos descritos por dicha licencia. El contenido de este manual es proporcionado exclusivamente

para uso informativo y puede ser cambiado sin previo aviso. Quercus Technologies no asume ninguna responsabilidad

por los errores o las inexactitudes que puedan aparecer en este documento. Ninguna parte de esta publicación debe

ser reproducida, ubicada en un sistema de distribución, o divulgada de ninguna manera sin el previo consentimiento

de Quercus Technologies.

Índice

Conceptos básicos..................................................................................6

1. Qué es SmartLPR® Engine................................................................6

1.1. Fiabilidad..................................................................................7

1.2. Integración...............................................................................7

1.3. Política de actualizaciones y compatibilidad...................................8

1.3.1. Números de versión.............................................................8

1.3.2. Compatibilidad entre versiones..............................................8

1.3.3. Versiones disponibles...........................................................8

Instalación...........................................................................................10

2. Material suministrado.....................................................................10

3. Requisitos del sistema....................................................................10

3.1. Plataforma MS Windows............................................................10

3.2. Plataforma Linux......................................................................10

4. Instalación del software..................................................................10

4.1. Plataforma MS Windows............................................................10

4.2. Plataforma Linux......................................................................11

5. Ficheros instalados.........................................................................11

6. Licencia .......................................................................................12

6.1. Licencia Hardware....................................................................12

6.2. Licencia de Software................................................................12

Utilización del software..........................................................................13

7. Engine Tool...................................................................................13

7.1. GUI (Interfaz gráfica de usuario)................................................13

7.1.1. Barra de botones...............................................................14

7.1.2. Pantalla de visualización.....................................................15

7.1.3. Resultados del reconocimiento.............................................15

7.1.4. Estadísticas.......................................................................15

7.1.5. El control deslizante del retraso...........................................16

7.2. Opciones................................................................................16

7.2.1. Regiones soportadas..........................................................16

7.2.2. Parámetros de SmartLPR Engine..........................................17

7.2.3. Opciones generales............................................................17

Programación.......................................................................................19

8. La configuración de SmartLPR® Engine............................................19

8.1. Ficheros de configuración..........................................................19

8.1.1. Selección del fichero .txt.....................................................19

8.1.2. Global.ini file.....................................................................19

8.2. Configurar SmartLPR® Engine mediante EngineTool....................21

8.3. Configurar SmartLPR® Engine manualmente...............................21

9. Programación básica......................................................................22

9.1. C...........................................................................................22

9.1.1. Gestión de memoria...........................................................25

9.1.2. Creación del ejecutable.......................................................26

9.2. .NET.....................................................................................27

9.2.1. Construir la DLL ................................................................30

9.2.2. Creación del ejecutable.......................................................30

9.3. Otros ejemplos........................................................................30

10. API............................................................................................31

10.1. Definición de las estructuras de datos.......................................31

10.1.1. Imagen...........................................................................31

10.1.2. Punto.............................................................................31

10.1.3. Rectángulo......................................................................32

10.1.4. License:..........................................................................32

10.1.5. Engine............................................................................33

10.2. Definiciones de las funciones...................................................34

10.2.1. Initialize.........................................................................34

10.2.2. Read license....................................................................34

10.2.3. Leer matrícula usando el modo multi-imagen.......................35

10.2.4. Leer matrícula de un archivo bmp.......................................35

10.2.5. Reconocimiento múltiple de matrículas................................36

10.2.6. Reconocimiento de múltiples matrículas en modo multi-imagen

................................................................................................37

10.2.7. Leer matrículas de ROI.....................................................38

10.2.8. Elegir la mejor matrícula...................................................39

10.2.9. Terminate.......................................................................39

10.2.10. Cargar imagen...............................................................39

10.2.11. Crear imagen.................................................................40

10.2.12. Guardar en formato bmp.................................................40

10.2.13. Recortar el rectángulo.....................................................41

10.2.14. Destruir la imagen..........................................................41

10.2.15. Ejecutar el mezclador......................................................42

10.3. Códigos de errores.................................................................43

10.4. Estructuras y funciones obsoletas.............................................44

Apéndice.............................................................................................45

11. Apéndice A: Especificaciones técnicas.............................................45

12. Apéndice B: soporte.....................................................................46

SmartLPR Engine Manual de Usuario Conceptos básicos

Conceptos básicos

En esta sección se realiza un resumen básico de las características de un sistema SmartLPR®

Engine.

1. Qué es SmartLPR® Engine

Un sistema de reconocimiento de matrículas (LPR) es un conjunto de elementos de hardware y

software utilizado para identificar los vehículos según sus matrículas. Es decir que a partir de

la imagen de un vehículo, el sistema LPR puede devolvernos la matrícula en formato de texto.

SmartLPR® Engine es una librería de software que implementa los principales algoritmos del

sistema SmartLPR® Access/Speed desarrollados por Quercus Technologies. SmartLPR®

Engine permite reconocer matrículas procedentes de imágenes donde la matrícula no resalta

sobre el fondo, por lo que no importa si la imagen fue capturada con luz visible o con

infrarrojo.

El objetivo de SmartLPR® Engine es reconocer la matrícula de un vehículo que aparece en una

o varias imágenes. El período de tiempo muy corto que necesita para procesar la matrícula

permite el reconocimiento de las matrículas con vídeo en modo continuo, lo que hace que

SmartLPR® Engine sea el motor de reconocimiento ideal para las aplicaciones de control de

vehículos que circulan a alta velocidad. Éste incluye toda la información relacionada con el

reconocimiento y procesamiento de las matrículas que puedan necesitar los programadores, de

manera que el software se puede utilizar para un amplio rango de aplicaciones.

SmartLPR® Engine está disponible en forma de librería de enlace dinámico para Windows y

GNU/Linux.

Quercus Technologies 6

LPR

1445 BGY


1.1. Fiabilidad

SmartLPR® Engine dispone de una elevada fiabilidad basada en algoritmos avanzados de

reconocimiento y probada en diferentes países e instalaciones de todo el mundo. Es necesario

entender que el porcentaje de aciertos del sistema es un valor estadístico que depende

básicamente del estado de conservación de las matrículas, de la flota de vehículos a reconocer

y del país de las matrículas.

Las matrículas que no han sido reconocidas correctamente contienen caracteres desconocidos

que son sustituidos por interrogantes para minimizar los problemas derivados de las

confusiones de dichos caracteres.

El alto porcentaje de matrículas reconocidas, prácticamente sin confusiones de caracteres, y la

posibilidad de captura de imágenes en ángulos de hasta 60º le proporcionan unas

características óptimas para su instalación en cualquier sistema de lectura de matrículas.

1.2. Integración

La aplicación cliente recibirá una imagen o un conjunto de imágenes de una fuente externa,

por ejemplo de una cámara. La librería de enlace dinámico SmartLPR® Engine (DLL), que

incluye todas las funcionalidades del sistema, procesará estas imágenes para extraer la

matrícula. El resultado generado será el reconocimiento óptico de los caracteres (OCR).


Resultado OCRImagen

Máquina cliente

Aplicación cliente

SmartLPR Engine

Librería de enlace dinámico

CámaraImagen


1.3. Política de actualizaciones y compatibilidad

El software que se distribuye es compartido por todos los productos de reconocimiento de

matrículas de la familia SmartLPR®. El software puede ser actualizado.

1.3.1. Números de versión

Cada versión del software/firmware está compuesta por tres cifras (por ejemplo 2.4.5):

● La primera cifra (denominada “mayor”) muestra la versión principal de

software/firmware. Esta cifra indica cuantas veces se han producido grandes cambios

internos y/o externos.

● La segunda cifra (denominada “menor”) indica cuantas veces se han añadido nuevas

funcionalidades a la versión “mayor” indicada.

● La tercera cifra (denominada “revisión”) indica cuantas veces se han corregido errores

de la versión “mayor.menor” indicada.

1.3.2. Compatibilidad entre versiones

El software cliente siempre es compatible hacia atrás, es decir, con la última versión del

software se pueden controlar todas las versiones de SmartLPR® Engine salvo que se indique

explícitamente lo contrario.

Para saber si una actualización de software es compatible con su configuración, debe

comprobar la versión que está en funcionamiento y compararla con la versión de la

actualización:

Versión Compatible

Primera cifra diferente No1

Primera cifra idéntica Segunda cifra diferente

Sí

Primera y segunda cifra idénticaTercera cifra diferente

Sí

1.3.3. Versiones disponibles

Actualmente, hay 4 versiones disponibles que ofrecen distintos niveles de funcionalidad.

VersiónNúmero de instancias

de ejecuciónLímite de tiempo

SmartLPR Engine F400 Ilimitado Ilimitado

SmartLPR Engine S300 1 Ilimitado

1 1 La compatibilidad no está excluida. Simplemente, no está garantizada. Consulte con el departamento de Soporte Técnico de Quercus Technologies.



SmartLPR Engine T200 1 10 peticiones por segundo

SmartLPR Engine P100 1 3 peticiones por cada 5 segundos


SmartLPR Engine Manual de Usuario Instalación

Instalación

Esta sección muestra los pasos a seguir para instalar con éxito el software.

2. Material suministrado

Junto con la licencia SmartLPR® Engine se le suministra el siguiente material:

● el CD-ROM de instalación que incluye el software, las librerías y los ficheros de

desarrollo, ejemplos de programación con el código fuente y el manual de desarrollo.

● Una llave dongle USB Quercus (sólo para licencia hardware).

3. Requisitos del sistema

3.1. Plataforma MS Windows

Los requisitos mínimos para desarrollar con SmartLPR® Engine en MS Windows se describen a

continuación:

● Intel Pentium IV de 2.0 GHz con 256 MB de RAM

● Microsoft Windows XP

● Microsoft Visual C++ 2005 express edition2

● Microsoft Visual Studio .NET 2010 y .NET Framework 43

3.2. Plataforma Linux

Los requisitos mínimos para desarrollar con SmartLPR® Engine en Linux son:

● Intel Pentium IV de 2.0 GHz con 256 MB de RAM

● x86 Linux

● libc.so.6

● GNU Make + gcc2

● MONO 2.10 y MonoDevelop3

4. Instalación del software

4.1. Plataforma MS Windows

Para instalar el software, ejecute “\Windows\SmartLPR Engine 6.1\setup.exe” de su CD.

2 Este software se necesita solamente para abrir los ejemplos en C. La librería DLL en C que le ha sido proporcionadaes compatible con cualquier compilador.

3 Este software se necesita solamente para trabajar con el marco .NET. Las muestran han sido programadas y testadas con este software, pero eso no significa que no puedan funcionar con versiones más antiguas. El proyecto DLL se tiene que compilar para generar la DLL en el marco .NET.



El programa de configuración sigue estos pasos :

● Le pregunta si acepta o no la licencia del programa.

● Le pide que elija la carpeta de destino.

● Procede a la instalación de los archivos del programa.

● Establece las variables de entorno.

4.2. Plataforma Linux

Para instalar el software, ejecute “Linux/SmartLPR Engine_6.1.run ” de su CD.

El programa de configuración sigue automáticamente los pasos siguientes:

● Le pregunta si acepta o no la licencia del programa.

● Le pide que elija la carpeta de destino.

● Procede a la instalación de los archivos del programa.

● Establece las variables de entorno.

● Le recuerda que tiene que instalar el daemon de la llave dongle (sólo para licencia

hardware).

Para instalar el daemon de la llave dongle extraiga el driver adecuado que se encuentra en la

carpeta “INSTALL_DIR/Dongle” y siga las instrucciones descritas en el fichero "readme.html".

5. Ficheros instaladosEn la carpeta de instalación podrá encontrar las siguientes subcarpetas:

● Bin: Ejecutables y librerías. Los ficheros más importantes son:

● SmartLPR.dll (Windows) or libSmartLPR.so (Linux): fichero DLL de SmartLPR®

Engine.

● SLPRMixer(.exe): mezclador de las regiones.

● EngineTool(.exe): programa de test de SmartLPR® Engine.

● Data. Ficheros requeridos por SmartLPR® Engine y sus herramientas. Los ficheros más

importantes son:

● Engine.ini: configuración de SmartLPR® Engine. Variables relacionadas con las

regiones.

● Global.ini: configuración de SmartLPR® Engine. Variables de comportamiento

global.

● Selection.txt: Fichero con la selección de los países.

● Engine.dat: fichero de licencia.

● Doc: Contiene este manual y el fichero de licencia de SmartLPR® Engine.

● Dongle: Contiene los drivers para la llave USB dongle.

● Include: Contiene los ficheros de cabecera en C/C++ necesarios para desarrollar una



aplicación que utilice SmartLPR® Engine.

● Lib (Windows): Contiene el fichero "lib" utilizado para conectar con SmartLPR® Engine.

● Redist (Windows): el paquete redistribuible de Microsoft VC 8.0.

● Samples: Programas en C/C++ y VB.NET que muestran la mayoría de las

funcionalidades de SmartLPR® Engine. Consulte el fichero “Readme.txt” de dicha

carpeta para más información.

● Src: Contiene los ficheros en código fuente necesarios para desarrollar en C o en el

.NET framework una aplicación que utilice SmartLPR® Engine.

6. Licencia Quercus Technologies proporciona licencias hardware y software.

6.1. Licencia Hardware

SmartLPR® Engine comprueba si el usuario tiene licencia del producto a través de una llave

dongle. La llave dongle proporcionada se tiene que conectar al puerto USB.

6.2. Licencia de Software

La licencia software le permite ejecutar SmartLPR® Engine en un determinado equipo. Para

obtener una licencia software debe seguir los pasos que se muestran a continuación:

● Ejecute la aplicación HWFingerPrint suministrada por Quercus Technologies en el equipo

para el cual quiere obtener la licencia. Se generará un fichero "fingerprint" que debe

enviarse a Quercus Technologies (por ej. computerX.dat)

● Repita el proceso en cada máquina donde quiera obtener una licencia. Es muy

importante identificar cada máquina con su fichero "fingerprint" correspondiente.

● Después de validar los ficheros "fingerprint", Quercus Technologies le proporcionará un

fichero "Engine.dat" específico para cada máquina (por ej.:

Engine.dat.computerX.serialnumber). Después de la instalación, debe renombrar cada

fichero a "Engine.dat" y substituir con él el archivo que se encuentra en la carpeta

"<carpeta instalación SmartLPR Engine>Data\" de su equipo.


SmartLPR Engine User Manual Uso del software

Utilización del software

7. Engine Tool

El usuario puede comprobar el funcionamiento de SmartLPR® Engine así como configurarlo

mediante una interfaz gráfica utilizando EngineTool. Para ello, ejecute la aplicación EngineTool

que se encuentra en la carpeta "Bin\" o selecciónela directamente desde el menú Inicio.

7.1. GUI (Interfaz gráfica de usuario)

La aplicación está dividida en cinco zonas:

● Barra de botones

● Pantalla de visualización

● Resultados del reconocimiento

● Estadísticas

● El control del retraso


Barra de botones Pantalla

de visualización

Estadísticas

Resultados de los reconocimientos

El control deslizante del retraso


7.1.1. Barra de botones

La barra de botones ocupa la parte izquierda de la pantalla. Los botones están

agrupados según su funcionalidad y algunos de ellos sólo se pueden aplicar en

circunstancias determinadas. Los botones disponibles son:

1. Salir: salir de la aplicación.

2. Seleccionar la carpeta: Selecciona la carpeta donde están guardadas las

imágenes a reconocer.

3. Iniciar: Disponible sólo cuando se selecciona y carga una carpeta; inicia

el proceso de reconocimiento procesando cada imagen de la carpeta.

4. Restablecer: Disponible sólo cuando se selecciona y carga una carpeta,

restablece la posición del primer fichero y pone a cero las estadísticas.

5. Botón de Pausa: Disponible solamente cuando el proceso de

reconocimiento se está ejecutando, pausa la aplicación.

6. Siguiente: Disponible solamente cuando se ha detenido la aplicación, pasa a reconocer

la siguiente imagen de la carpeta.

7. Anterior: Disponible solamente cuando se ha detenido la aplicación, reconoce la imagen

anterior de la carpeta. Tenga en cuenta que si una imagen ha sido reconocida

previamente, las estadísticas no se actualizarán.

8. Exportar a CSV: Exporta las estadísticas de los resultados a un archivo CSV.

9. Configuración: Configura las diferentes opciones de SmartLPR® Engine (véase la sección

7.2).

10.Manual SmartLPR® Engine. Muestra el manual de referencia de SmartLPR® Engine. Es

necesario disponer de un visor de ficheros PDF asociado a dicho tipo de ficheros (podrá

encontrar el programa Acrobat Reader en el CD de instalación de SmartLPR® Engine).

11.Acerca de: muestra información acerca de Quercus Technologies.


1

2

3

4

5

6

7

8

9

10

11


7.1.2. Pantalla de visualización

La pantalla de visualización muestra la imagen y la ubicación de la matrícula reconocida.

7.1.3. Resultados del reconocimiento

Los resultados del reconocimiento consisten en: la matrícula en formato de texto, la imagen

corregida de la matrícula extraída, la posición y calidad de cada carácter reconocido, así como

la calidad media del reconocimiento.

7.1.4. Estadísticas

Las estadísticas de los resultados se actualizan cada vez que una nueva imagen se ha

reconocido. Están organizadas en tres secciones:

Ficheros

• Actual: El fichero actual de la carpeta seleccionada.

• Total: El número total de ficheros en la carpeta seleccionada.

Tiempo:

• Actual: El tiempo de reconocimiento para la imagen actual.

• Media: El tiempo medio de reconocimiento.

• Min: El tiempo mínimo de reconocimiento.

• Max: El tiempo máximo de reconocimiento.

Fiabilidad

Estos parámetros se calcularán si las opciones demo están activadas para comparar el nombre

del fichero de la imagen con la matrícula detectada (véase la sección 7.2.3 para más detalles).

• Aciertos: Número de aciertos en el proceso de reconocimiento.

• Fallos: Número de fallos en el proceso de reconocimiento.

• Porcentaje: Porcentaje de las matrículas reconocidas correctamente hasta el momento.

7.1.5. El control deslizante del retraso

El control deslizante le permite configurar el tiempo que el resultado de la matrícula reconocida


Formato de texto

Imagen de la matrícula y posición de los caracteres

Calidad de cada carácter y calidad media


permanecerá en la pantalla antes de que se procese la siguiente imagen. El control admite

valores de 0 a 4 segundos.

7.2. Opciones

Si pulsa el botón "Opciones" verá la pantalla de configuración con sus tres pestañas que se

describen en las secciones siguientes.

7.2.1. Regiones soportadas

SmartLPR® Engine permite el reconocimiento de varios países (llamados "regiones" en el

sistema SmartLPR® Engine). Los países disponibles se muestran en la columna "Disponibles",

ordenados alfabéticamente. Los países que quiera que SmartLPR® Engine reconozca se

muestran en la columna "Seleccionados". Puede añadir o quitar países de esta lista utilizando

los botones “izquierda”- “derecha”, y las flechas "arriba" y "abajo" para ordenarlos. Tenga en

cuenta que el orden de los países activados es muy importante para aumentar la velocidad y la

fiabilidad. Pulse el botón "Aceptar" para aplicar los cambios o "Cancelar" si quiere descartarlos.



7.2.2. Parámetros de SmartLPR® Engine

Para configurar SmartLPR® Engine es necesario usar varios parámetros (véase la sección 8.1.2

para conocer el significado de cada uno de ellos). Puede personalizar los parámetros de

configuración marcando la casilla "Personalizar" o cargando una configuración predeterminada.

Se han creado cuatro niveles de configuración para aumentar la fiabilidad y el rendimiento del

programa. Puede escoger uno de ellos a través del control deslizante. Pulse el botón "Aceptar"

para aplicar los cambios o "Cancelar" si quiere descartarlos.

7.2.3. Opciones generales

EngineTool tiene funcionalidades que se pueden activar o desactivar.

Modo demo

• En modo demo, el proceso de reconocimiento es cíclico (es decir, el proceso se reinicia

una vez acabado); las demás opciones no están disponibles.

Test

• Compara el nombre del fichero con la matrícula detectada. Esta opción activa el cálculo

de los aciertos, fallos y porcentajes de los reconocimientos en las estadísticas de los

resultados.

• Guarda las imágenes reconocidas correctamente en la carpeta seleccionada (cuando la

opción de comparación está activada).



• Guarda las imágenes que no se ha reconocido correctamente en la carpeta seleccionada

(cuando la opción de comparación está activada).

Cambio de nombre

• Renombra las imágenes utilizando como nombre la matrícula detectada y las guarda en

la carpeta seleccionada.

Clasificación

• Clasifica las imágenes reconocidas por país y crea por cada país reconocido una nueva

carpeta dentro de la carpeta seleccionada .

Pulse el botón "Aceptar" para aplicar los cambios o "Cancelar" si quiere descartarlos.


SmartLPR Engine® Manual de Usuario Programación

Programación

8. La configuración de SmartLPR® Engine

8.1. Ficheros de configuración

8.1.1. Selección del fichero .txt

SmartLPR® Engine permite el reconocimiento de varios países. Los países disponibles se

encuentran en la carpeta "Data\Regions". La biblioteca se puede configurar para trabajar

solamente con un país o con todos los países a la vez. Hay que tener en cuenta que el tiempo

que deberá usar el sistema para llevar a cabo el reconocimiento aumentará como mayor sea el

número de países seleccionados. De la misma manera la fiabilidad del reconocimiento puede

disminuir como mayor sea el número de países seleccionados.

El fichero "Data\Selection.txt" contiene varias líneas. Cada línea hace referencia a un fichero

"ini" (a un país) de la carpeta "Data\Regions". Para aumentar la velocidad y la fiabilidad, las

líneas se tienen que ordenar según la probabilidad de su aparición.

8.1.2. Global.ini file

En el fichero "Global.ini" se guardan todos los parámetros de configuración necesarios para

ejecutar SmartLPR® Engine. A continuación se explica el significado de cada parámetro y sus

valores más apropiados.

Cuando el SmartLPR® Engine está buscando candidatos a matrículas usa varios parámetros

para establecer la lista de candidatos. Una vez se ha encontrado un candidato a matrícula y se

ha procesado correctamente para encontrar el país al cual pertenece, se pasa a la

comprobación de la matrícula resultante. Si el número de caracteres desconocidos es inferior al

MaxBadChars y la calidad media es igual o mayor que MinQuality, el proceso se considera

finalizado y el resultado se genera inmediatamente. De otra manera, el proceso continua para

el resto de países, de candidatos a matrículas y de imágenes (si hay más de una disponible).

Una vez la imagen ha sido procesada, la matrícula resultante se vuelve a comprobar. Los

valores aceptados para el MinQuality son entre 850 y 999 y para MaxBadChars entre 0 y 2.

Los parámetros MinCharHeight y MaxCharHeight establecen los límites para la altura (en

píxeles) de los caracteres de la imagen. Si se establece un intervalo más preciso, el número

de falsos candidatos en la imagen disminuirá y por lo tanto se reducirá el tiempo necesario



para procesarlos. Los valores aceptados para MinCharHeight y MaxCharHeight están

comprendidos entre 1 y 120.

Cuando el algoritmo está buscando una matrícula en la imagen, se pueden encontrar varios

candidatos a matrícula. En este caso, los candidatos están ordenados según su probabilidad de

ser una matrícula. El parámetro MaxNumberOfCandidates limita el número máximo de

candidatos que van a ser procesados por el algoritmo, sin tener en cuenta el número de

matrículas que se quieran encontrar en una imagen. Como mayor sea este parámetro, la

probabilidad de encontrar el candidato que contiene la matrícula incrementa. Sin embargo, el

tiempo de reconocimiento aumentará con el número de candidatas que van a ser procesadas.

Un valor razonable para este parámetro es 1.

El identificador MinCharsPerLicense define el número mínimo de caracteres en una

matrícula.

SmartLPR® Engine implementa 4 algoritmos distintos para buscar la matrícula en la imagen.

Cada país tiene configurado los algoritmos que proporcionan los mejores resultados. Si el

identificador Algorithms no se encuentra en el fichero "Global.ini", cada país utilizará sus

propios algoritmos. También es posible que el usuario configure SmartLPR® Engine para que

use determinados algoritmos. Si se usan todos los algoritmos la fiabilidad aumenta

ligeramente, pero el tiempo medio de lectura puede llegar a multiplicarse por cuatro en

algunas circunstancias. Los valores válidos para Algorithms son "straight", "slope", "sides" y

"bruteforce".

El resto de parámetros son de uso interno de SmartLPR® Engine y se recomienda no cambiar

su valor.

El resultado del reconocimiento de la matrícula se puede expresar para algunos países

mediante codificación Árabe u Occidental. El identificador ExtendedCodification con valor 1

activa la codificación árabe; el valor 0 activa la codificación occidental.



8.2. Configurar SmartLPR® Engine mediante EngineTool

Para configurar el SmartLPR® Engine mediante EngineTool siga estos pasos:

1. Seleccione los países que quiera que SmartLPR® Engine reconozca (véase la sección

7.2.1).

2. Ajuste los parámetros (véase la sección 7.2.2).

3. Guarde los cambios.

8.3. Configurar SmartLPR® Engine manualmente

Para configurar SmartLPR® Engine manualmente siga estos pasos:

1. Edite el fichero “Data\Selection.txt” (consulte la sección 8.1.1 para más información)

para configurar los países con que trabajará SmartLPR® .

2. Edite el fichero “Data\Global.ini” (consulte la sección 8.1.2 para más información) para

ajustar los parámetros.

3. Guarde estos ficheros y luego ejecute la aplicación SLPRMixer de la carpeta "Bin\". Los

cambios quedarán reflejados en "Data\Current\Engine.ini" y SmartLPR® Engine ya

estará listo para reconocer las matrículas procedentes de los países seleccionados

mediante los parámetros que ha configurado.



9. Programación básicaA continuación se describen los pasos necesarios para desarrollar un programa de

reconocimiento de matrículas mediante el SmartLPR® Engine.

En este capítulo se presuponen unos conocimientos básicos de programación (C y VB.NET). Si

usted trabaja habitualmente con alguna de estas tecnologías no tendrá ningún problema en

seguir los ejemplos.

El código fuente de los ejemplos se encuentra en <carpeta instalación>/Samples.

9.1. C

A continuación se muestra un programa mínimo en C, que puede reconocer, utilizando la

librería SmartLPR® Engine, una matrícula de una imagen en formato BMP, de un buffer de

datos con el contenido de un fichero RAW, y de un conjunto de imágenes codificadas en varios

ficheros RAW. El código fuente de los ejemplos se encuentra en <carpeta de

instalación>/Samples/CApi_BasicSample/.

/*------------------------------------------,| Copyright (C) 2013 Quercus Technologies || All rights reserved. |`------------------------------------------*/

#include <stdio.h>#include <stdlib.h>#include "SmartLPR.h"

/*--------------------------------------------------------------------- *//* Change these values in order to change the behavior of the program *//*--------------------------------------------------------------------- */#define IMAGE_NAME "1445BGY.bmp"#define NUM_MULTI_IMAGES 3/*multi image filenames: img1.bmp, image2.bmp, ..., imageN.bmp*/

/*--------------------------------------------------------------------- */SmartLPRError ReadFromBmp(int h, SmartLPRLicense* pLicense);SmartLPRError ReadFromBuffer(int h, SmartLPRLicense* pLicense);SmartLPRError ReadMultifile(int h, SmartLPRLicense* pLicense);

int main(int argc, char* argv[]){ SmartLPRLicense license; SmartLPRError err; int h;

/* Initializing */ err = SmartLPRInitialize(&h); printf("Initialized -> 0x%x\n", err); if (err) return -1;

/* Reading license from bmp file */ err = ReadFromBmp(h, &license);



if (!err) printf("%s, %s (%f)\n", IMAGE_NAME, license.License, license.AvgQuality); else printf("%s, Error found (0x%x)\n", IMAGE_NAME, err);

/* Reading license from raw buffer */ err = ReadFromBuffer(h, &license); if (!err) printf("%s, %s (%f)\n", IMAGE_NAME, license.License, license.AvgQuality); else printf("%s, Error found (0x%x)\n", IMAGE_NAME, err);

/* Reading license from a set of raw buffers */ err = ReadMultifile(h, &license); if (!err) printf("%s, %s (%f) bestImage=img%d\n", "multifiles", license.License,

license.AvgQuality, license.BestImage+1); else printf("%s, Error found (0x%x)\n", "multifiles", err);

/* Terminating */ err = SmartLPRTerminate(h); printf("Terminated -> 0x%x\n", err);

return 0;}

SmartLPRError ReadFromBmp(int h, SmartLPRLicense* pLicense){ pLicense->Size = sizeof(SmartLPRLicense); SmartLPRCreateImage(&pLicense->PlateImage, 0, 0); return SmartLPRReadLicenseFromBmp(h, IMAGE_NAME, pLicense);}

SmartLPRError ReadFromBuffer(int h, SmartLPRLicense* pLicense){ SmartLPRError err; SmartLPRImage image;

err = SmartLPRLoadImage(IMAGE_NAME, &image); if (err != SLPR_OK) return err;

pLicense->Size = sizeof(SmartLPRLicense); SmartLPRCreateImage(&pLicense->PlateImage, 0, 0); err = SmartLPRReadLicense(h, image.Height, image.Width, image.LineWidth, image.Data, pLicense); SmartLPRDestroyImage(&image); return err;}

SmartLPRError ReadMultifile(int h, SmartLPRLicense* pLicense){ void *pData[NUM_MULTI_IMAGES]; char filename[256]; SmartLPRError err; int i; SmartLPRImage image[NUM_MULTI_IMAGES];

for (i=0; i<NUM_MULTI_IMAGES; i++) { sprintf(filename, "img%d.bmp", i+1); err = SmartLPRLoadImage(filename, &image[i]); pData[i] = image[i].Data; }

pLicense->Size = sizeof(SmartLPRLicense); SmartLPRCreateImage(&pLicense->PlateImage, 0, 0); err = SmartLPRReadLicenseMultiImage(h, image[0].Height, image[0].Width, image[0].LineWidth,

NUM_MULTI_IMAGES, pData, pLicense); for (i=0; i<NUM_MULTI_IMAGES; i++) SmartLPRDestroyImage(&image[i]); return err;}

Partes que componen el código del ejemplo:

#include "SmartLPR.h"



Es el único fichero de cabecera necesario para interactuar con SmartLPR® Engine desde C.

El código se estructura en varios métodos para distinguir cómo leer una matrícula desde:

• un fichero BMP

SmartLPRError ReadFromBmp(int h, SmartLPRLicense* pLicense);

• un buffer

SmartLPRError ReadFromBuffer(int h, SmartLPRLicense* pLicense);

• un conjunto de buffers (multi-imagen)

SmartLPRError ReadMultifile(int h, SmartLPRLicense* pLicense);

La información sobre la matrícula y su proceso de reconocimiento se devuelve en una

estructura específica SmartLPRLicense. En el proceso de reconocimiento multi-imagen, la

imagen con el índice basado en cero en la cual se ha encontrado la matrícula (o en la cual se

ha encontrado la imagen con la mayor calidad) se almacena también en una estructura

SmartLPRLicense.

El proceso principal se compone básicamente de las siguientes acciones:

• Carga de la configuración.

SmartLPRInitialize(int &h);

• Lectura de la matrícula a partir de una imagen o de un conjunto de imágenes,

utilizando los métodos anteriormente mencionados.

• Realizar alguna acción sobre la matrícula, en este caso, imprimir alguna información.

• Descarga de la configuración.

SmartLPRTerminate(int h);

A continuación se explica más detalladamente cómo se desarrolla la lectura de matrícula

procedente de cada una de las fuentes:

Leer la matrícula desde un archivo BMP

Éste es el método más fácil para reconocer la matrícula en una imagen. Solamente se tiene

que:

• Inicializar el tamaño de la estructura SmartLPRLicense.

pLicense->Size = sizeof(SmartLPRLicense);

SmartLPRCreateImage(&pLicense->PlateImage, width, height);

• Leer la matrícula del fichero bmp. Los resultados del proceso se devuelven utilizando la

estructura SmartLPRLicense.

SmartLPRReadLicenseFromBmp(h, imageName, pLicense);

• Liberar, si es necesario, las imágenes usadas mediante la función



SmartLPRDestroyImage.

Leer la matrícula de un buffer

Los pasos a seguir para leer la matrícula de un buffer son los siguientes:

• Inicializar y reservar la memoria del buffer. Puede usar la función SmartLPRLoadImage

para cargar y inicializar el buffer desde un fichero JPG y BMP utilizando una estructura

SmartLPRImage.




• Leer la matrícula del buffer, indicando la altura y la anchura de la imagen, y

el ancho de línea. El resultado de este proceso se devuelve utilizando la estructura

SmartLPRLicense.

SmartLPRReadLicense(h, image.Height, image.Width, image.LineWidth,

image.Data, pLicense);

• Liberar, si es necesario, el buffer de datos y las imágenes usadas.

Leer la matrícula desde un conjunto de buffers

Una matrícula se puede leer también desde un conjunto de imágenes del mismo vehículo. Para

ello, tendrá que:

• Inicializar y reservar la memoria del buffer con el contenido de cada imagen.




• Leer la matrícula del buffer, indicando la altura y la anchura de la imagen, el ancho de

línea y el número de imágenes almacenadas en el buffer. El resultado de este proceso y

la imagen donde se ha reconocido la matrícula se devuelven utilizando la estructura

SmartLPRLicense.

SmartLPRReadLicenseMultiImage(h, imageHeight, imageWidth, imageLineWidth,

numImages, pData, pLicense);

• Liberar, si es necesario, el buffer de datos y las imágenes usadas.

9.1.1. Gestión de memoria

La estructura SmartLPRImage requiere un poco de atención para usarla correctamente. Esta

estructura tiene un miembro de datos llamado Data que es un puntero al contenido de datos

de la imagen. Este buffer tiene que ser asignado por el usuario antes de usar la estructura

SmartLPRImage y liberado cuando sea necesario. A continuación se muestra un pequeño



ejemplo del código:

Inicialización

La inicialización de la estructura SmartLPRImage consiste en reservar la memoria del buffer y

actualizar su tamaño. Ésta es la función de SmartLPRCreateImage.

SmartLPRLicense license;

license.Size = sizeof(SmartLPRLicense);SmartLPRCreateImage(&pLicense->PlateImage, width, heiht);

Uso

Después de cargar el fichero de configuración y leer la matrícula de una fuente, la estructura

SmartLPRLicense contendrá el resultado del proceso de reconocimiento. Si el buffer de

PlateImage ha sido reservado (generando una imagen con altura y anchura superiores a cero),

éste se llenará durante el proceso de reconocimiento. Se proporciona también una función

para guardar la estructura SmartLPRImage en un fichero BMP.

SmartLPRInitialize(int &h);SmartLPRReadLicenseFromBmp(int h, IMAGE_FILE, &license);SmartLPRSaveToBmp(&license.PlateImage, "license.bmp"))

Finalización

Para finalizar la aplicación correctamente, es necesario descargar el fichero de configuración y

liberar el buffer de SmartLPRImage.

SmartLPRTerminate(int h);SmartLPRdestroyImage(&license.PlateImage);

9.1.2. Creación del ejecutable

Visual Studio

● Abra el fichero “Samples.sln” de la carpeta “Samples”.

● Pulse con el botón derecho sobre Sample1 y seleccione “Project only Build only→

BasicSample".

Linux

● Abra una consola.

● Abra la carpeta Samples/CApi_BasicSample.

● Ejecute el comando “make”.



9.2. .NET

El recubrimiento .NET le permite al usuario generar una librería .NET para usar las funciones

de la API en C en un entorno .NET.

Todos los ejemplos proporcionados con el recubrimiento .NET están programados en Visual

Basic. A continuación se muestra un programa mínimo en VB.NET, que puede reconocer,

utilizando la librería SmartLPR® Engine, una matrícula de una imagen en formato BMP, de un

buffer de datos con el contenido de un fichero RAW, y de un conjunto de imágenes codificadas

en varios ficheros RAW. El código fuente de los ejemplos se encuentra en <carpeta de

instalación>/Samples/VisualBasic_BasicSample/.

Module Module1

Const IMAGE_HEIGHT As Integer = 480 Const IMAGE_WIDTH As Integer = 640 Const IMAGE_LINE_WIDTH As Integer = 640 Const IMAGE_NAME As String = "1445BGY.bmp" 'multi image filenames: img1.bmp, image2.bmp, ..., imageN.bmp Const NUM_MULTI_IMAGES As Integer = 3

Sub Main()

Dim engine As New SmartLPR.Engine Dim license As New SmartLPR.License Dim err As SmartLPR.EngineError

'Initializing err = engine.Initialize() System.Console.WriteLine("Initialized -> {0}", err) If err <> SmartLPR.EngineError.SLPR_OK Then Exit Sub End If

'Reading license from bmp file err = ReadFromBmp(engine, license) If err <> SmartLPR.EngineError.SLPR_OK Then System.Console.WriteLine("ReadLicenseFromBmp fails, err:" + err.ToString()) Exit Sub Else System.Console.WriteLine("{0}, {1} ({2})", IMAGE_NAME, license.DecoratedLicense, license.AvgQuality) End If

'Reading license from buffer err = ReadFromBuffer(engine, license) If err <> SmartLPR.EngineError.SLPR_OK Then System.Console.WriteLine("ReadLicenseFromRaw fails, err:" + err.ToString()) Exit Sub Else System.Console.WriteLine("{0}, {1} ({2})", IMAGE_NAME, license.DecoratedLicense, license.AvgQuality) End If

'Reading multi file license err = ReadMultifile(engine, license) If err <> SmartLPR.EngineError.SLPR_OK Then System.Console.WriteLine("ReadMultifileRaw fails, err:" + err.ToString()) Exit Sub Else



System.Console.WriteLine("multifiles, {0} ({1}) bestImage=img{2}", license.DecoratedLicense, license.AvgQuality, license.BestImage + 1) End If

'Terminating err = engine.Terminate() System.Console.WriteLine("Terminated -> {0}", err) If err <> SmartLPR.EngineError.SLPR_OK Then System.Console.WriteLine("Terminate fails, err:" + err.ToString()) Exit Sub End If End Sub

Function ReadFromBmp(ByVal engine As SmartLPR.Engine, ByRef license As SmartLPR.License) As SmartLPR.EngineError ReadFromBmp = engine.ReadLicenseFromBmp(IMAGE_NAME, license) End Function

Function ReadFromBuffer(ByVal engine As SmartLPR.Engine, ByRef license As SmartLPR.License) AsSmartLPR.EngineError Dim img As SmartLPR.Image Dim err As SmartLPR.EngineError

img = engine.CreateImage(0, 0) err = engine.LoadImage(img, IMAGE_NAME) If err <> SmartLPR.EngineError.SLPR_OK Then ReadFromBuffer = err End If ReadFromBuffer = engine.ReadLicense(img.Height, img.Width, img.LineWidth, img.Buffer, license) End Function

Function ReadMultifile(ByVal engine As SmartLPR.Engine, ByRef license As SmartLPR.License) As SmartLPR.EngineError Dim img As SmartLPR.Image Dim ptrs as SmartLPR.IntPtrArray Dim fName As String Dim err As SmartLPR.EngineError

ptrs=new SmartLPR.IntPtrArray(NUM_MULTI_IMAGES) For i As Integer = 0 To NUM_MULTI_IMAGES - 1 fName = "img" + (i + 1).ToString() + ".bmp" img = engine.CreateImage(IMAGE_WIDTH, IMAGE_HEIGHT) err = engine.LoadImage(img, fName) ptrs.Add(img.BufferPtr) Next i

ReadMultifile = engine.ReadLicenseMultiImage(IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_LINE_WIDTH, NUM_MULTI_IMAGES, ptrs.GetIntPtrArray(), license)

End Function

End Module

Partes que componen el código de ejemplo:

Todas las clases y los tipos de información necesaria se definen en el espacio de nombres

SmartLPR.

El código se estructura en varios métodos para distinguir entre las diferentes posibilidades de

leer una matrícula a partir de:

• un fichero BMP



Function ReadFromBmp(ByVal engine As SmartLPR.Engine, ByRef license As

SmartLPR.License) As SmartLPR.EngineError

• un buffer

Function ReadFromBuffer(ByVal engine As SmartLPR.Engine, ByRef license As


• un conjunto de buffers (multi-imagen)

Function ReadMultifile(ByVal engine As SmartLPR.Engine, ByRef license As


La información sobre la matrícula y el proceso de reconocimiento de la misma se devuelve en

la clase License. En el proceso de reconocimiento multi-imagen, la imagen con el índice basado

en cero en la cual se ha encontrado la matrícula (o en la cual se ha encontrado la imagen con

la mayor calidad) se almacena en la clase Licence.

El proceso principal se compone básicamente de las siguientes acciones:

• Carga de la configuración y llamada al método Initialize de la clase Engine.

• Lectura de la matrícula de una imagen o de un conjunto de imágenes, utilizando los

métodos mencionados anteriormente.

• Realizar alguna acción sobre la matrícula, en este caso, imprimir alguna información.

• Descarga de la configuración y llamada al método Terminate de la clase Engine.

A continuación se explica cómo leer una matrícula de cada fuente:

Leer la matrícula desde un fichero BMP

Éste es el método más fácil para reconocer la matrícula en una imagen. Solamente se tiene

que llamar el método ReadLicenseFromBmp de la clase Engine. El resultado del proceso se

devuelve utilizando la clase License.

ReadFromBmp = engine.ReadLicenseFromBmp(IMAGE_NAME, license)

Leer la matrícula de un buffer

Los pasos a seguir para leer la matrícula de un buffer son los siguientes:

• Inicializar y reservar el buffer. Puede usar la función SmartLPRLoadImage que le

permite a la clase Engine cargar e inicializar el buffer de un fichero JPG o MBP utilizando

la clase Image.

Dim img As SmartLPR.Image

img = engine.CreateImage(0, 0)

err = engine.LoadImage(img, IMAGE_NAME)

• Leer la matrícula del buffer, indicando la altura y la anchura de la imagen, y



el ancho de línea. El resultado de este proceso se devuelve como siempre utilizando la

clase License.

ReadFromBuffer = engine.ReadLicense(img.Height, img.Width, img.LineWidth,

img.Buffer, license)

Leer la matrícula desde un conjunto de buffers

Una matrícula se puede leer también desde un conjunto de imágenes del mismo vehículo. Para

ello, tendrá que:

• Inicializar y reservar el buffer con el contenido de cada imagen.

• Leer la matrícula del buffer, indicando la altura y la anchura de la imagen, el ancho de

línea y el número de imágenes almacenadas en el buffer. Los resultados de este

proceso se devolverán utilizando la clase License.

ReadMultifile = engine.ReadLicenseMultiImage(IMAGE_HEIGHT, IMAGE_WIDTH,

IMAGE_LINE_WIDTH, NUM_MULTI_IMAGES, ptrs.GetIntPtrArray(), license)

9.2.1. Construir la DLL

Si quiere desarrollar mediante el recubrimiento .NET, lo primero que tiene que hacer es

compilar el proyecto DLL para poder generar luego la DLL en .NET. El proyecto facilitado se

encuentra en la <carpeta de instalación>/Src/WrapperNet. Abra el fichero “SmartLPRNet.sln”

con Visual Studio o MonoDevelop y construye el proyecto SmartLPRNET. La DLL generada se

encontrará en <carpeta de instalación>/Bin/SmartLPRNet.dll.

9.2.2. Creación del ejecutable

Para generar el fichero ejecutable, abra el archivo “VisualBasic_Samples.sln” de la carpeta

"Samples" con Visual Studio o Mono Develop. Pulse con el botón derecho sobre el proyecto

BasicSample y constrúyelo. A continuación se creará el fichero ejecutable BasicSample.exe.

9.3. Otros ejemplos

En la carpeta <carpeta de instalación>/Samples podrá encontrar más ejemplos de

programación con SmartLPR® Engine y un fichero “Readme.txt” con la descripción de los

ejemplos.



10. APIEn este apartado se describen las estructuras de datos y las funciones que usa la librería

SmartLPR® Engine, y se explica su uso y sus funcionalidades.

Toda la API .NET se describe utilizando la sintaxis de C# pero se puede usar con cualquier

lenguaje .NET.

10.1. Definición de las estructuras de datos

10.1.1. Imagen

Esta estructura guarda el contenido de una imagen.

C: Estructura SmartLPRImage.

C#: Clase Image

Datos miembro:

● Len Tamaño del vector Data.

● Height Número de líneas de la imagen.

● Width Número de píxeles por línea.

● LineWidth Número de bytes de memoria utilizados por línea.

● Data En C, es un puntero a los datos de la imagen. Las imágenes deben tener

un plano de color de 8 bits por píxel.

● Buffer En .NET, es el buffer de datos de la imagen.

● BufferPtr En .NET, es el puntero al buffer de datos.

Las dos representaciones del buffer en .NET (vector de datos y puntero de datos) son

necesarias ya que la API en C sólo funciona con el puntero de los datos de la imagen, pero la

conversión interna de los punteros de C y .NET es más costosa que trabajar con el vector de

datos en bytes, por lo que el puntero de datos solamente se utiliza cuando su uso es

imprescindible.

Nota: Para más información sobre la utilización correcta de dicha estructura, consulte el

apartado 9.1.1.

10.1.2. Punto

Esta estructura se usa para representar la posición de un píxel en la imagen, utilizando como

punto de partida el lado superior izquierdo.



C: estructura SmartLPRPoint.

C#: No utilizado. Utiliza el objeto System.Drawing.Point.

Datos miembro:

● X La coordenada x del punto (positivo de izquierda a derecha).

● Y La coordenada y del punto (positivo de arriba a abajo).

10.1.3. Rectángulo

Esta estructura se utiliza para hacer referencia a una sección rectangular de una imagen.

C: estructura SmartLPRRectangle.

C#: No utilizado. Utiliza el objeto System.Drawing.Rectangle.

Datos miembro:

● TopLeft El punto superior izquierdo del rectángulo.

● BottomRight El punto inferior derecho del rectángulo.

10.1.4. License:

Se usa para devolver los resultados del proceso de lectura de matrículas.

C: estructura SmartLPRLicense.

C#: Clase License.

Datos miembro:

● Size(C) En la estructura en C, representa el tamaño en bytes de

la estructura SmartLPRLicense. Este campo se debe

rellenar antes de llamar cualquier versión de

SmartLPRReadLicense.

● License(C), DecoratedLicense(C#) Cadena que contiene la matrícula adornada.

● NumberOfChars Número de elementos en Chars, Qualities y CharBoxes.

● Chars Vector de caracteres de las matrículas reconocidas ( sin los

"adornos").

● Qualities Vector de calidades de los caracteres no decorativos.

● IsGrammarOk Diferente a cero (C) o TRUE (C#) si la matrícula cumple

con la gramática de algún país configurado.

● AvgQuality La calidad media de los caracteres reconocidos. Los

resultados satisfactorios tienen un valor superior al 0.97.

Un valor inferior al 0.92 constituye un mal resultado.

● NumberOfUnknownChars Número de caracteres desconocidos, marcados como



interrogantes en la matrícula adornada.

● Country Cadena con el país que reconoce la matrícula como válida.

● Roi Vector que contiene las coordenadas izquierda, arriba, derecha y

abajo (en este orden) del rectángulo que contiene la matrícula

de la imagen.

● PlateImage La imagen de la matrícula reconocida en la imagen tomada.

● BoundingBox Vector que contiene los puntos superior-izquierdo, superior-

derecho, inferior-derecho, inferior-izquierdo (en este orden) que

indica las coordenadas del rectángulo de selección que

contiene la matrícula de la imagen4.

● CharBoxes Vector que contiene los rectángulos de cada carácter de la

matrícula. Las coordenadas del rectángulo son relativas al

PlateImage.

● CodePage Los datos miembro “License” y “Chars” están codificados con un

valor único de ocho bits mediante esta página de códigos.

● BestImage Almacena el índice basado en cero de la mejor imagen en la cual

se ha encontrado la matrícula (o la que tiene la mejor calidad).

Se utiliza en el proceso de lectura multi-imagen.

10.1.5. Engine

C: No existe.

C#: clase Engine.

En C, el objeto "Engine" está representado por el parámetro "handle" (manejador) que se

utiliza en cada función relacionada con el reconocimiento de matrículas.

En C# todas estas funciones se encuentran en la clase Engine como métodos públicos.

4 Estos puntos pueden tener un valor negativo (fuera de los límites de la imagen) si la matrícula es tá cerca de los

márgenes de la imagen. Es la responsabilidad del usuario utilizar estos puntos correctamente, por ejemplo, al dibujar

el rectángulo de selección dentro de la imagen.



10.2. Definiciones de las funciones

Todas las funciones que se presentan a continuación son seguras para hilos. Para poder

beneficiarse de todas las ventajas de un programa multihilo, debería usar un "Engine" por cada

hilo. Véase MultiThreadSample de la carpeta “Samples/” para más información y para ver un

ejemplo de su uso.

10.2.1. Initialize

Inicializa un Engine y carga el archivo de configuración.

C: SmartLPRError SmartLPRInitialize(int &handle)

C#: EngineError Engine::Initialize()

En C, tiene una doble función: crea una nueva instancia de Engine y la inicializa. El parámetro

"handle" se utiliza como parámetro de entrada en otras funciones SmartLPR.

Valor de retorno:

Devuelve un código de error.

Ver también:

Terminate

10.2.2. Read license

Devuelve la matrícula que aparece en el buffer.

C: SmartLPRError SmartLPRReadLicense (int handle, int height, int width, int

lineWidth, void* data, SmartLPRLicense* license)

C#: EngineError Engine::ReadLicense(int height, int width, int lineWidth,

System.Byte[] data, ref License license)

Parámetros:

● handle Identifica el manejador que actúa sobre el Engine con el que quiere leer.

● height Número de líneas de la imagen (positivo si las líneas están ordenadas de

arriba abajo, negativo en el caso contrario).


● lineWidth Número de bytes de memoria utilizados por línea.

● Data Datos de la imagen. Las imágenes deben tener un plano de 8 bits por

píxel.

● License Puntero a un objeto previamente reservado de la matrícula, que se llena



con los resultados del proceso de reconocimiento.

Ver también:

Leer matrícula usando el modo multi-imagen, Leer matrícula de un archivo bmp, Leer

matrículas de ROI

10.2.3. Leer matrícula usando el modo multi-imagen

Devuelve el mejor resultado (o uno suficientemente bueno) de la lectura de matrícula de un

conjunto de imágenes (almacenadas en buffers) del mismo vehículo.

C: SmartLPRError SmartLPRReadLicenseMultiImage(int handle, int height, int

width, int lineWidth, int numberOfPictures, void** dataPtrs, SmartLPRLicense*

license)

C#: EngineError Engine::ReadLicenseMultiImage(int height, int width, int lineWidth,

int numberOfPictures, System.IntPtr[] dataPtrs, ref License license)

Parámetros:


● Height Número de líneas de la imagen (positivo si las líneas están ordenadas de

arriba abajo, negativo en caso contrario).



● numberOfPictures Número de imágenes.

● DataPtr Puntero a un vector de punteros a imagen. Las imágenes deben tener

un plano de 8 bits por píxel.



Valor de retorno:


Ver también:

Read license, Leer matrícula de un archivo bmp

10.2.4. Leer matrícula de un archivo bmp

Devuelve la matrícula que aparece en la imagen.

C: SmartLPRError SmartLPRReadLicenseFromBmp (int handle, const char* file,



SmartLPRLicense* license)

C#: EngineError Engine::ReadLicenseFromBmp (string file,ref License license)

Parámetros:

● handle Identifica el manejador que actúa sobre el Engine con el que se quiere

leer.

● File Nombre del fichero BMP o JPEG (en Windows) de 24 bits, en color o en

escala de grises, que contiene la imagen del vehículo.



Valor de retorno:


Ver también:

Read license, Leer matrícula usando el modo multi-imagen

10.2.5. Reconocimiento múltiple de matrículas

Esta función permite la lectura de varias matrículas que se encuentran en un buffer de datos.

C: SmartLPRError SmartLPRReadMultiLicense(int handle, int height, int width, int

lineWidth, void* data, int *numberOfLicenses, SmartLPRLicense licenseList[])

C#: EngineError Engine::ReadMultiLicense(int height, int width, int lineWidth,

System.Byte[] data, ref int numberOfLicenses, ref License[] licenseList)

Parámetros:

● handle Identifica el manejador que actúa sobre el Engine con el que

quiere leer.

● height Número de líneas de la imagen (positivo si las líneas están

ordenadas de arriba abajo, negativo en caso contrario).



● Data Datos de la imagen. Las imágenes deben tener un plano de 8 bits

por píxel.

● numberOfLicenses Puntero a un entero, cuyo valor indica el número de matrículas

que se desea encontrar en la imagen5. Se trata de un parámetro

de entrada/salida. Dicha función usa este parámetro para

5 SmartLPR Engine P100 y S200 permiten solamente reconocer una matrícula por cada fotografía.



retornar el número de matrículas encontradas (menor o igual al

valor de entrada).

● licenseList Vector de objetos License llenados con los resultados del

reconocimiento de cada matrícula encontrada.

Valor de retorno:


Ver también:

Read license, Reconocimiento de múltiples matrículas en modo multi-imagen

10.2.6. Reconocimiento de múltiples matrículas en modo multi-imagen

Esta función permite la lectura de varias matrículas de un conjunto de imágenes (almacenadas

en buffers).

C: SmartLPRError SmartLPRReadMultiLicenseMultiImage(int handle, int height, int

width, int lineWidth, int numberOfPictures, void* dataPtrs[], int

numberOfLicenses, SmartLPRLicense licenseList[]);

C#: EngineError Engine::ReadMultiLicenseMultiImage(int height, int width, int

lineWidth, int numberOfPictures, System.IntPtr[] dataPtrs, ref int

numberOfLicenses, ref License[] licenseList)

Parámetros:

● handle Identifica el manejador que actúa sobre el Engine con el que

quiere leer.

● height Número de líneas de la imagen (positivo si las líneas están

ordenadas de arriba abajo, negativo en caso contrario).



● dataPtrs Puntero a un vector de punteros a imágenes. Las imágenes deben

tener un plano de 8 bits por píxel.

● numberOfLicenses Puntero a un entero, cuyo valor indica el número de matrículas

que se desea encontrar en la imagen6. Se trata de un parámetro

de entrada/salida. La función usa este parámetro para retornar el

número de matrículas encontradas (menor o igual al valor de

entrada).

6 SmartLPR Engine P100 y S200 permiten solamente reconocer una matrícula por cada fotografía.



● licenseList Vector de objetos License llenados con los resultados del

reconocimiento de cada matrícula encontrada.

Return value:


Ver también:

Reconocimiento múltiple de matrículas, Leer matrícula usando el modo multi-imagen

10.2.7. Leer matrículas de ROI

Devuelve la matrícula que se encuentra en el buffer de datos dentro del ROI.

C: SmartLPRError SmartLPRReadLicenseFromRoi(int handle, int height, int width,

int lineWidth, void* data, SmartLPRRectangle *roi, SmartLPRLicense* license);

C#: EngineError Engine::ReadLicenseFromRoi(int height, int width, int

lineWidth, System.Byte[] data, System.Drawing.Rectangle roi, ref

License license)

Parámetros:


● Height Número de líneas de la imagen (positivo si las líneas están ordenadas de

arriba abajo, negativo en caso contrario).



● Data Puntero a los datos de la imagen. Las imágenes deben tener un plano de

8 bits por píxel.

● roi Región de interés (ROI) donde se espera encontrar la matrícula.

● License Puntero a un objeto asignado de la matrícula, que se llena con los

resultados del proceso de reconocimiento.

Return value:


Ver también:

Read license, Leer matrícula de un archivo bmp



10.2.8. Elegir la mejor matrícula

Compara dos resultados obtenidos tras leer la matrícula a partir de varias imágenes del mismo

vehículo.

C: bool SmartLPRIsLicenseBetter(SmartLPRLicense* left, SmartLPRLicense*

right)

C#: System.Boolean IsLicenseBetter (License left, License right)

Parámetros:

● left Objeto de la matrícula obtenido después de una invocación a cualquier

versión de la función ReadLicense.

● right Objeto de la matrícula obtenido después de una invocación a cualquier

versión de la función ReadLicense.

Return value:

Devuelve verdadero si la matrícula izquierda constituye un resultado mejor que la matrícula

derecha.

10.2.9. Terminate

Esta función finaliza el Engine y descarga el fichero de configuración. Es el contrario de la

función Initialize y se debe llamar con el manejador del Engine que se quiere finalizar. Su

programa debería llamar esta función antes de finalizar. Otros usos del manejador después de

que dicha función haya sido invocada no son válidos.

C: SmartLPRError SmartLPRTerminate(int handle)

C#: EngineError Engine::Terminate()

Parámetros:

● handle Identifica el manejador que actúa sobre el Engine que se quiere finalizar.

Return Value:


Ver también:

Initialize

10.2.10. Cargar imagen

Carga e inicializa la estructura SmartLPRImage de un fichero JPG o BMP. Tenga en cuenta que



debe llamar la función DestroyImage después de utilizar la imagen para liberar el buffer

creado.

C: SmartLPRError SmartLPRLoadImage(const char* file, SmartLPRImage *pImg)

C#: EngineError Engine::LoadImage(ref Image pImg, string file)

Parámetros:

● file El nombre del fichero.

● pImg Puntero a una estructura SmartLPR asignada.

Return value:


Ver también:

Destruir la imagen

10.2.11. Crear imagen

Crea una nueva imagen de tamaño width x height. Tenga en cuenta que debe llamar la función

DestroyImage después de utilizar la imagen para liberar el buffer creado. Si se ha creado una

imagen vacía (usando anchura=0, altura=0) la liberación no es necesaria.

C: SmartLPRError SmartLPRCreateImage(SmartLPRImage *pImage, int width, int

height)

C#: SmartLPR.Image Engine::CreateImage(int width, int height)

Variables:

● pImage Puntero a la imagen.

● width Anchura de la imagen.

● height Altura de la imagen.

Return value:


Ver también:

Destruir la imagen, Guardar en formato bmp

10.2.12. Guardar en formato bmp

Guarda la imagen en formato bmp.



C: SmartLPRError SmartLPRSaveToBmp(SmartLPRImage* pImg, const char*

file)

C#: EngineError Image::SaveToBmp(System.String file)

Variables:

● pImg Puntero a una estructura SmartLPRImage asignada.

● file El nombre del fichero.

Return value:


10.2.13. Recortar el rectángulo

Dada una imagen y una sección rectangular, recorta la imagen generando una subimagen del

área definida por la sección rectangular. Tenga en cuenta que debe llamar la función

SmartDestroyImage después de utilizar la imagen si quiere liberar el buffer creado en la

imagen de destino.

C: void SmartLPRCropRectangle(SmartLPRImage* dstImg, SmartLPRImage*

srcImg, SmartLPRRectangle* roi)

C#: void Image::CropRectangle (ref Image dstImg, System.Drawing.Rectangle roi)

Parámetros:

● dstImg Imagen de destino.

● SrcImg Imagen fuente.

● roi Roi de la sección rectangular a recortar.

Ver también:

Guardar en formato bmp, Destruir la imagen

10.2.14. Destruir la imagen

Destruye una imagen reservada.

C: void SmartLPRDestroyImage(SmartLPRImage *img)

C#: No existe. Es implícita en el destructor de la clase Imagen.

Variables:

● img Imagen que se quiere liberar.



Ver también:

Crear imagen

10.2.15. Ejecutar el mezclador

Ejecuta el SLPRMixer.

C: SmartLPRError SmartLPRRunMixer()

C#: Engine::EngineError RunMixer()

Return value:




10.3. Códigos de errores

La mayoría de las funciones devuelven un código de error. La siguiente tabla muestra las

descripciones de estos códigos.

Etiqueta Valor Significado

SLPR_OK 0x0000 No se han encontrado errores.

SLPR_UNEXPECTED_ERROR 0x1001 Se ha producido un error inesperado.

SLPR_INITIALIZED 0x1002 SLPR ya se había inicializado.

SLPR_NOT_INITIALIZED 0x1003 SLPR no se ha inicializado.

SLPR_BAD_IMAGE 0x1004 El fichero imagen no se encuentra o formato no admitido.

SLPR_BAD_PARAMETERS 0x1005 Parámetros incorrectos de la función.

SLPR_MIXER_FILE_NOT_FOUND 0x1006 El mixer no se encuentra o está dañado.

SLPR_LICENSING_ERROR 0x1007 Error de licencia software o hardware.

SLPR_INSTANCING_ERROR 0x1008 No se admiten más instancias.

SLPR_READING_DATA_ERROR 0x1009 Error al leer datos.

SLPR_BAD_GLOBAL_SPEC 0x0101 Se han encontrado errores en Global.ini.

SLPR_CORRUPTED_GRAMMAR_FILE 0x0201El fichero de conjuntos de producción no se encuentra o está

dañado.

SLPR_BAD_PRODUCTION_SPEC 0x0202 Errores encontrados en una de las producciones.

SLPR_CORRUPTED_CALLIGRAPHY_FILE 0x0301 El fichero de caligrafía *.cal no se encuentra o está dañado.

SLPR_BAD_CALLIGRAPHY_SPEC 0x0302Configuración incorrecta en la sección [ModelList] del fichero

de caligrafía *.ini.

SLPR_BAD_GRAMMAR_SPEC 0x0303Configuración incorrecta en la sección [Grammars] del fichero

de caligrafía *.ini.

SLPR_BAD_REGION_GLOBAL_SPEC 0x0401Configuración incorrecta en la sección [Global] del fichero de

regiones.

SLPR_BAD_REGION_CALLIGRAPHY_SPEC 0x0402Configuración incorrecta en la sección [Calligraphy] del

fichero de regiones.



10.4. Estructuras y funciones obsoletas

La siguiente lista presenta las estructuras y funciones obsoletas. Le proporcionamos también

las nuevas funciones que debería usar en su lugar.

Estructuras obsoletas Estructuras nuevas

SlprImage SmartLPRImage

SlprPoint SmartLPRPoint

SlprRectangle SmartLPRRectangle

SlprLicense SmartLPRLicense

SlprErrors SmartLPRError

Funciones obsoletas Funciones nuevas

SlprInitialize SmartLPRInitialize

SlprReadLicense SmartLPRReadLicense

SlprReadLicense2 SmartLPRReadLicenseMultiImage

SlprReadLicenseFromBmp SmartLPRReadLicenseFromBmp

SlprIsLicenseBetter SmartLPRIsLicenseBetter

SlprTerminate SmartLPRTerminate

SlprSaveToBmp SmartLPRSaveToBmp

SlprCropRectangle SmartLPRCropRectangle



Apéndice

11. Apéndice A: Especificaciones técnicas

Sistemas operativos Win XP y superior- GNU/Linux.

Lenguajes de

programaciónC/C++ y .NET

Tiempo de

procesamiento

Depende principalmente del estado de conservación de la matrícula y del tamaño de la

imagen. Por ejemplo, en un Dual Core CPU @ 3.2 Ghz, el tiempo medio de

procesamiento para una imagen de 640x480 píxeles en un bueno estado de

conservación es de 15 ms aproximadamente*.

Resultados

Matrícula formateada con guiones y espacios, matrícula no formateada, calidad de cada

carácter y calidad media de la matrícula, país, posición de la matrícula en la imagen,

posición de cada carácter en la imagen, el rectángulo de selección de la matrícula y la

imagen de la matrícula.

Matrículas detectadas Reconocimiento de matrículas de diferentes países de varios continentes **

Matrículas detectadas

(versión NA)

Canada (British Columbia), Mexico, USA (Arizona, California, Colorado, Delaware, District

of Columbia, Florida, Georgia, Illinois, Maryland, New Jersey, New Mexico, New York,

North Carolina, Oregon, Pennsylvania, South Carolina, Tennessee, Texas, Utah, Virginia,

Washington, West Virginia)

Formato de matrícula Una o dos líneas de caracteres, rectangular o cuadrada.

Tipos de imágenes

soportadasficheros bmp y jpg con la profundidad de color de 8 o de 24 bits y bufers de 8 bits.

Tamaño de imagenCualquier tamaño que muestre el tamaño mínimo de la matrícula. Como más grande sea

el tamaño, el tiempo de procesamiento incrementará.

Mida recomendada para

la matrícula140-150 píxeles del primer al último carácter.

**El tiempo de proceso puede variar dependiendo del número de países activos, de los algoritmos y las opciones

utilizadas para encontrar la matrícula.

****Contacte con el departamento de soporte de Quercus Technologies para saber los países reconocidos que ya

incluyen nuestros equipos. Le informaremos también sobre los pasos a seguir para instalar una actualización que

activará el reconocimiento para los países que quiera reconocer.



12. Apéndice B: soporte

Si tiene cualquier duda sobre la configuración o el uso de SmartLPR® Engine, no dude en

contactar con nuestro departamento de soporte técnico:

EE.UU: +1 201 227 2020

Brasil y América Latina: +55 (11) 2614 3006 (Extensión 21)

EMEA y Asia: +34 977 300 377

Por email a: [email protected]

O visite nuestras páginas web:

www.quercus.biz

www.quercus-technologies.com

www.quercus.com.br


MANUAL DE USUARIO -...

Documents

Transcript of MANUAL DE USUARIO -...