manual de usuario -...
TRANSCRIPT
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
SmartLPR Engine Manual de Usuario Conceptos básicos
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).
Quercus Technologies 7
Resultado OCRImagen
Máquina cliente
Aplicación cliente
SmartLPR Engine
Librería de enlace dinámico
CámaraImagen
SmartLPR Engine Manual de Usuario Conceptos básicos
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.
Quercus Technologies 8
SmartLPR Engine Manual de Usuario Conceptos básicos
SmartLPR Engine T200 1 10 peticiones por segundo
SmartLPR Engine P100 1 3 peticiones por cada 5 segundos
Quercus Technologies 9
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.
Quercus Technologies 10
SmartLPR Engine Manual de Usuario Instalación
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
Quercus Technologies 11
SmartLPR Engine Manual de Usuario Instalación
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.
Quercus Technologies 12
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
Quercus Technologies 13
Barra de botones Pantalla
de visualización
Estadísticas
Resultados de los reconocimientos
El control deslizante del retraso
SmartLPR Engine User Manual Uso del software
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.
Quercus Technologies 14
1
2
3
4
5
6
7
8
9
10
11
SmartLPR Engine User Manual Uso del software
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
Quercus Technologies 15
Formato de texto
Imagen de la matrícula y posición de los caracteres
Calidad de cada carácter y calidad media
SmartLPR Engine User Manual Uso del software
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.
Quercus Technologies 16
SmartLPR Engine User Manual Uso del software
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).
Quercus Technologies 17
SmartLPR Engine User Manual Uso del software
• 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.
Quercus Technologies 18
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
Quercus Technologies 19
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 20
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 21
SmartLPR Engine® Manual de Usuario Programación
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);
Quercus Technologies 22
SmartLPR Engine® Manual de Usuario Programación
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"
Quercus Technologies 23
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 24
SmartLPR Engine® Manual de Usuario Programació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.
• Inicializar el tamaño de la estructura SmartLPRLicense.
pLicense->Size = sizeof(SmartLPRLicense);
SmartLPRCreateImage(&pLicense->PlateImage, width, height);
• 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.
• Inicializar el tamaño de la estructura SmartLPRLicense.
pLicense->Size = sizeof(SmartLPRLicense);
SmartLPRCreateImage(&pLicense->PlateImage, width, height);
• 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
Quercus Technologies 25
SmartLPR Engine® Manual de Usuario Programación
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”.
Quercus Technologies 26
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 27
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 28
SmartLPR Engine® Manual de Usuario Programación
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
SmartLPR.License) As SmartLPR.EngineError
• un conjunto de buffers (multi-imagen)
Function ReadMultifile(ByVal engine As SmartLPR.Engine, ByRef license As
SmartLPR.License) As SmartLPR.EngineError
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
Quercus Technologies 29
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 30
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 31
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 32
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 33
SmartLPR Engine® Manual de Usuario Programación
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).
● Width Número de píxeles por línea.
● 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
Quercus Technologies 34
SmartLPR Engine® Manual de Usuario Programación
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:
● 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).
● Width Número de píxeles por línea.
● lineWidth Número de bytes de memoria utilizados por línea.
● 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.
● License Puntero a un objeto previamente reservado de la matrícula, que se llena
con los resultados del proceso de reconocimiento.
Valor de retorno:
Devuelve un código de error.
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,
Quercus Technologies 35
SmartLPR Engine® Manual de Usuario Programación
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.
● License Puntero a un objeto previamente reservado de la matrícula, que se llena
con los resultados del proceso de reconocimiento.
Valor de retorno:
Devuelve un código de error.
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).
● Width Número de píxeles por línea.
● 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.
● 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.
Quercus Technologies 36
SmartLPR Engine® Manual de Usuario Programación
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:
Devuelve un código de error.
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).
● Width Número de píxeles por línea.
● lineWidth Número de bytes de memoria utilizados por línea.
● 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.
Quercus Technologies 37
SmartLPR Engine® Manual de Usuario Programación
● licenseList Vector de objetos License llenados con los resultados del
reconocimiento de cada matrícula encontrada.
Return value:
Devuelve un código de error.
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:
● 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).
● Width Número de píxeles por línea.
● lineWidth Número de bytes de memoria utilizados por línea.
● 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:
Devuelve un código de error.
Ver también:
Read license, Leer matrícula de un archivo bmp
Quercus Technologies 38
SmartLPR Engine® Manual de Usuario Programación
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:
Devuelve un código de error.
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
Quercus Technologies 39
SmartLPR Engine® Manual de Usuario Programación
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:
Devuelve un código de error.
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:
Devuelve un código de error.
Ver también:
Destruir la imagen, Guardar en formato bmp
10.2.12. Guardar en formato bmp
Guarda la imagen en formato bmp.
Quercus Technologies 40
SmartLPR Engine® Manual de Usuario Programación
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:
Devuelve un código de error.
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.
Quercus Technologies 41
SmartLPR Engine® Manual de Usuario Programación
Ver también:
Crear imagen
10.2.15. Ejecutar el mezclador
Ejecuta el SLPRMixer.
C: SmartLPRError SmartLPRRunMixer()
C#: Engine::EngineError RunMixer()
Return value:
Devuelve un código de error.
Quercus Technologies 42
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 43
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 44
SmartLPR Engine® Manual de Usuario Programación
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.
Quercus Technologies 45
SmartLPR Engine® Manual de Usuario Programación
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
Quercus Technologies 46