manual de usuário - Quercus Technologies

Transcrição

MANUAL DE USUÁRIO
Versão 6.1.x
www.quercus.biz
www.quercus-technologies.com
www.quercus.com.br
SmartLPR® Engine Manual de Usuário (v 6.1.x)
2014 maio
© 2014 Quercus Technologies. Todos os direitos reservados.
Este manual, assim como o software descreveu em ele, é fornecido sob licença e pode ser usado ou pode ser copiado
só de acordo com os termos de tal licença. O conteúdo deste manual é fornecido para uso instrutivo só, é assunto
mudar sem aviso, e não deve ser interpretado como um compromisso pela Quercus Technologies. Quercus
Technologies não supõe nenhuma responsabilidade nem responsabilidade para erros nem imprecisões que podem
aparecer nesta documentação. Exceto como permitido por tal licença, nenhuma parte desta publicação pode ser
reproduzida, armazenou num sistema de recuperação, nem transmitido, em qualquer forma nem por qualquer meio,
eletrônico, mecânico, registrar, nem contrariamente, sem a permissão escrito prévia da Quercus Technologies.
Tabela de conteúdo
Conceitos básicos...................................................................................6
1. Que é SmartLPR® Engine.................................................................6
1.1. Confiabilidade...........................................................................7
1.2. Integração................................................................................7
1.3. Atualizar pólice e compatibilidade.................................................8
1.3.1. Número de versão...............................................................8
1.3.2. Compatibilidade entre versões...............................................8
1.3.3. Edições disponíveis..............................................................8
Instalação...........................................................................................10
2. Enumeração de material.................................................................10
3. Requisitos de sistema.....................................................................10
3.1. Plataforma MS Windows ...........................................................10
3.2. Plataforma Linux......................................................................10
4. Instalação de software....................................................................11
4.1. Plataforma de MS Windows.......................................................11
4.2. Plataforma de Linux.................................................................11
5. Arquivos instalados........................................................................11
6. Licença ........................................................................................12
6.1. Licença hardware.....................................................................12
6.2. Licença software......................................................................12
Uso de software...................................................................................13
7. Engine tool...................................................................................13
7.1. GUI.......................................................................................13
7.1.1. Barra de botões.................................................................14
7.1.2. Zona de visualização .........................................................15
7.1.3. Resultados do reconhecimento ............................................15
7.1.4. Estatísticas das resultados...................................................15
7.1.5. Controle deslizante de atraso ..............................................15
7.2. Opções...................................................................................16
7.2.1. Regiões de Engine..............................................................16
7.2.2. Parâmetros de Engine.........................................................16
7.2.3. Opções gerais....................................................................17
Programação........................................................................................19
8. Configurar SmartLPR® Engine........................................................19
8.1. Arquivos de configuração .........................................................19
8.1.1. Arquivo de seleção.txt........................................................19
8.1.2. Arquivo global.ini...............................................................19
8.2. Configurar SmartLPR® Engine usando EngineTool........................21
8.3. ConfigurarSmartLPR® Engine manualmente................................21
9. Programação básica.......................................................................22
9.1. C...........................................................................................22
9.1.1. Gerência de memória.........................................................25
9.1.2. Crie o arquivo executável....................................................26
9.2. .NET.....................................................................................26
9.2.1. Construir a DLL.................................................................30
9.2.2. Crie o arquivo executável....................................................30
9.3. Outros exemplos .....................................................................30
10. API............................................................................................31
10.1. Definição de estruturas de dados .............................................31
10.1.1. Imagem..........................................................................31
10.1.2. Ponto.............................................................................31
10.1.3. Retângulo.......................................................................32
10.1.4. License...........................................................................32
10.1.5. Engine............................................................................33
10.2. Definições das funções ...........................................................34
10.2.1. Initialize.........................................................................34
10.2.2. Ler placa.........................................................................34
10.2.3. Ler imagem usando o modo multi-imagem...........................35
10.2.4. Ler placa de arquivo bmp..................................................35
10.2.5. Reconhecimento de Multi-placas.........................................36
10.2.6. Multi reconhecimento de placa usando modo multi-imagem....37
10.2.7. Leia placa de ROI.............................................................38
10.2.8. Que licença é melhor........................................................38
10.2.9. Terminate.......................................................................39
10.2.10. Carregue imagem...........................................................39
10.2.11. Criar imagem.................................................................40
10.2.12. Salvar à arquivo bmp......................................................40
10.2.13. Recortar retângulo..........................................................41
10.2.14. Destruir imagem............................................................41
10.2.15. Executar o mixer ...........................................................41
10.3. Códigos de erros ...................................................................43
10.4. Estruturas obsoletas e funções.................................................44
Apêndice.............................................................................................45
11. Apêndice A: Especificações técnicas ...............................................45
12. Apêndice B: Suporte.....................................................................46
SmartLPR® Engine Manual do Usuário
Conceitos básicos
Conceitos básicos
Esta seção fornece um resumo básico das características de SmartLPR Engine.
1. Que é SmartLPR® Engine
Um leitor das placas (LPR) é um conjunto de elementos de hardware e software que são
usados para identificar veículos mediante suas placas. Ou seja, através de uma imagem de
um veículo, um LPR fornecerá a placa em formato de texto.
LPR
1445 BGY
SmartLPR® Engine é uma biblioteca de software implementando os algoritmos principais de
sistema SmartLPR® Access/Speed desenvolvido por Quercus Technologies. SmartLPR ® Engine
capacita o reconhecimento de placas em imagens onde a placa não é destacada do resto do
veículo, de modo que não importa se
a imagem foi tirada
com luz visível ou com luz
infravermelha.
O propósito do SmartLPR® Engine é reconhecer a placa de um veículo que aparece em uma ou
mais imagens. O período curto de tempo tomado por SmartLPR ® Engine, capacita o
reconhecimento de placas com vídeo livre de fluxo, que transforma SmartLPR ® Engine no
motor ideal de reconhecimento para aplicações de controle de veículo de velocidade. Um
conjunto completo de informações sobre a placa e seu processo de reconhecimento está
disponível aos desenvolvedores, então SmartLPR ® Engine pode ser usado em uma grande
variedade de aplicações.
SmartLPR® Engine é fornecido como uma biblioteca dinâmica de conexão disponível para
plataformas Linux e MS Windows.
Quercus Technologies
7
Conceitos básicos
1.1. Confiabilidade
SmartLPR® Engine foi provado mundialmente com altos índices de reconhecimento. O índice do
sistema de identificações bem-sucedidas depende do estado de conservação das placas de
matrícula, a frota de veículo, e o país.
As placas de matrícula que não são reconhecidos corretamente, correspondem a placas com
caráteres desconhecidos que a unidade substitui com pontos de interrogação. Portanto, os
problemas causados por confusões de caráter são reduzidos.
O alto índice de reconhecimentos de placas, com quase nenhuma confusão de caráteres, e seu
ângulo de captura de até 60º, fornece um conjunto excelente de características de
desempenho para implementar em qualquer tipo sistema de leitura de placas.
1.2. Integração
A aplicação de cliente receberá uma imagem ou um conjunto de imagens de uma fonte
externa, tal como uma câmera. Estas imagens serão usadas pela biblioteca dinamicamente
ligada de SmartLPR® Engine
(DLL), que inclui todas as funcionalidades do sistema, para
extrair a placa. O resultado retornado pela DLL será o Reconhecimento óptico de caracteres
(OCR).
Computador do cliente
Aplicação cliente
Imagem
Imagem
Câmera
Resultado de OCR
SmartLPR® Engine
Biblioteca dinamicamente ligada
8
Conceitos básicos
1.3. Atualizar pólice e compatibilidade
O software entregado é válido para cada produto de reconhecimento de placas da
família
SmartLPR. Este software pode ser atualizado.
1.3.1. Número de versão
Cada número de versão de software/firmware é composto de três números (para exemplo
2.4.5):
●
O primeiro número (nomeou "major") mostra a versão principal de software/firmware.
Indica quantas vezes que mudanças externo/internos importantes foram feitas.
●
O segundo número (nomeou "menor") indica o número de vezes que novas
funcionalidades foram adicionados à versão importante.
●
O
terceiro
(nomeou
"revisão")
indica
o
número
de
correções
feitas
ao
"importante.menor" versão para fixar erros.
1.3.2. Compatibilidade entre versões
O software de cliente é sempre compatível "para atrás", então todas as versões de SmartLPR
Engine pode ser controlado com a última versão de software, a menos que o contrário
explicitamente seja concordado.
Para saber se uma atualização de software é compatível com sua configuração, a versão atual
deve ser verificado e deve ser comparada com a versão de atualização.
Versão
Compatível
Primeiro numero diferente
Não1
Mesmo primeiro numero
Segundo número diferente
Sim
Mesmo
primeiro
e
segundo
numero
Terceiro número diferente
Sim
1.3.3. Edições disponíveis
Há quatro edições disponíveis com níveis diferentes de funcionalidade.
1
Edição
O número de exemplos
de execução
Limitação de tempo
SmartLPR Engine F400
Ilimitado
Ilimitado
SmartLPR Engine S300
1
Ilimitado
A compatibilidade não é excluída, simplesmente não é garantida. Verifique-o com o departamento de suporte de
Quercus Technologies.
9
Conceitos básicos
SmartLPR Engine T200
1
10 petições por segundo
SmartLPR Engine P100
1
3 petições por 5 segundos
10
SmartLPR Engine Manual do Usuário
Instalação
Instalação
Esta seção mostra os passos seguir para instalar o software com êxito.
2. Enumeração de material
O material fornecido por uma licença de SmartLPR Engine é:
●
Um
CD-ROM
de
instalação
com
o
software,
as
bibliotecas
e
arquivos
de
desenvolvimento, as mostras de programa com código fonte, e o manual de
desenvolvimento.
●
Uma chave USB dongle de Quercus (em caso da utilização da licença hardware).
3. Requisitos de sistema
3.1. Plataforma MS Windows
A seguinte lista detallha os requisitos mínimos para desenvolver com SmartLPR ® Engine em
MS Windows:
●
Intel Pentium IV de 2.0 GHz com 256 MB de RAM
●
Microsoft Windows XP
●
Microsoft Visual C++ 2005 express edition 2
●
Microsoft Visual Studio .NET 2010 and .NET Framework 43
3.2. Plataforma Linux
A seguinte lista detalha os requisitos mínimos para desenvolver com SmartLPR ® Engine em
Linux:
2
3
●
Intel Pentium IV em 2,0 GHz com 256 MB de RAM
●
x86 Linux
●
libc.so.6
●
GNU Make + gcc2
●
MONO 2.10 e MonoDevelop3
Este software é necessário só para abrir as amostras de C. A DLL em C fornecida é compatível com qualquer
compilador.
Este software é necessário só para trabalhar com. NET framework. A amostras foram programadas e testadas com
este software, mas não quer dizer que eles não trabalham com antigas versões. O projeto de DLL tem que ser
compilado para gerar a DLL em. NET.
11
Instalação
4. Instalação de software
4.1. Plataforma de MS Windows
Para instalar o software, execute “\Windows\SmartLPR Engine 6.1\setup.exe” de seu CD.
O programa de configuração segue automaticamente os seguintes passos:
●
Lhe Pergunta aceitar ou decair a licença de programa.
●
Pergunte-o escolher o diretório de alvo.
●
Instale arquivos de programa.
●
Estabelece variáveis de ambiente.
4.2. Plataforma de Linux
Para instalar o software, execute "Linux/SmartLPR_Engine_6.1.run" de seu CD.
Os passos automaticamente seguidos pelo programa de setup são:
●
Aceita ou não a licença de programa.
●
Escolha o diretório de destino.
●
Instala arquivos de programa.
●
Estabelece variáveis de ambiente.
●
Lembre-o instalar o daemon de dongle (em caso da utilização da licença hardware).
Para instalar o daemon de dongle, extrair o driver apropriado do dongle localizado no diretório
"INSTALL_DIR/Dongle" e siga as instruções descritas no arquivo "readme.html".
5. Arquivos instalados
As seguintes subpastas são achadas na pasta de instalação:
●
Bin: executáveis e bibliotecas. Os arquivos mais relevantes que contém são:
●
SmartLPR.dll (Windows) ou libSmartLPR.então (Linux) : Arquivo SmartLPR ®
Engine DLL.
●
SLPRMixer(.exe): Mixer de regiões.
●
EngineTool(.exe): programa de teste SmartLPR ® Engine.
●
Data. Os arquivos que são exigidos pelo SmartLPR ® Engine e suas ferramentas. Seus
arquivos mais relevantes são:
●
Engine.ini: configuração de SmartLPR® Engine. As variáveis relacionadas com as
regiões.
●
Global.ini: configuração de SmartLPR® Engine. Variáveis de comportamento
global.
●
Selection.txt: arquivo de seleção de país.
●
Engine.dat: arquivo de licença.
12
Instalação
●
Doc: contém esse manual e o arquivo de licença do SmartLPR Engine.
●
Dongle: contém os drivers para o Dongle USB.
●
Include: Contém o C/C + arquivos de cabeçalho exigiram desenvolver uma aplicação
que usa o SmartLPR® Engine.
●
Lib (Windows): Contém o arquivo "lib" usado para ligar com SmartLPR® Engine.
●
Redist (Windows): paquete redistribuible Microsoft VC 8.0.
●
Samples:
C/C
+
e
programas
de
VB.NET
mostrando
a
maioria
de
SmartLPR®
funcionalidades de Motor. Veja o "readme.txt" arquivo na pasta para mais informações.
●
Src: Contém os arquivos de fonte exigiu desenvolver uma aplicação que usa o
SmartLPR® Engine, usando C ou framework .NET.
6. Licença
Quercus Technologies oferece licença hardware o software.
6.1. Licença hardware
SmartLPR® Engine verifica se o produto é autorizado ao operador com a ajuda de um dongle.
O dongle fornecido deve ser ligado à porta USB.
6.2. Licença software
O software autorizando permite que você execute SmartLPR ® Engine numa máquina
específica. Para obter uma licença de software que você deve:
•
Executar a aplicação HWFingerPrint fornecida pela Quercus Technologies na máquina
onde deseja receber uma licença. Criará um arquivo de impressão digital que você deve
enviar à Quercus Technologies (ex: computerX.dat).
•
Repita o processo em cada máquina que você deseja receber uma licença. É importante
você identifica cada máquina com seu arquivo fingerprint.
•
Depois de validar os arquivos fingerprint fornecidos, Quercus Technologies forcenerá un
arquivo
"Engine.dat"
específico
Engine.dat.computerX.serialnumber).
Cada
para
arquivo
cada
deve
máquina
ser
(ex:
renomeado
como
"Engine.dat" e substituir o encontrado no diretório "Data\" da própria máquina depois
da instalação.
13
Uso do software
Uso de software
7. Engine tool
EngineTool pode ser usado para o operador testar o desempenho de SmartLPR ® Engine assim
como configurá-lo graficamente. Para executar EngineTool, execute a aplicação EngineTool do
diretório "Bin\" ou selecioná-lo no menu de início.
7.1. GUI
A aplicação é dividida em cinco zonas:
●
Barra de botões.
●
Zona de visualização.
●
Resultados do reconhecimento.
●
Resultados estatísticos.
●
Controle deslizante.
Barra de
botões.
Zona de
visualiza
ção.
Resultad
os
estatístic
os.
Resultados
estatísticos.
Controle
deslizante.
14
Uso do software
7.1.1. Barra de botões
1
2
3
A barra de botões ocupa a parte esquerda da tela. Os botões são agrupados
por funcionalidade. Alguns botões estão aplicáveis só em circunstâncias
específicas. Os botões disponíveis são:
1. Saída: Desliga a aplicação.
4
2. Pasta de seleção: Seleciona a pasta contendo as imagens para
5
reconhecer.
6
3. Start: Disponível somente quando uma pasta estiver selecionada e
7
carregada, inicia o processo de reconhecimento, processamento de
8
cada imagem da pasta.
9
4. Reset: Disponível somente quando uma pasta estiver selecionada e
10
carregada, repõe na posição do primeiro arquivo e inicializa as
11
estatísticas.
5. Pausa:
Disponível somente quando o processo de reconhecimento está sendo
executado, pausa a aplicação.
6. Posterior:
Disponível somente quando o aplicativo estiver em pausa, Reconhece a
próxima imagem na pasta.
7. Anterior:
Disponível somente quando o aplicativo estiver em pausa, reconhece a
imagem anterior na pasta.
Note-se que quando uma imagem foi reconhecida
previamente as estatísticas não são atualizadas.
8. Exportar para CSV: Exporta os resultados das estatísticas em um arquivo CSV.
9. Configuração: Configura as diferentes opções de SmartLPR® Engine (ver secção 7.2).
10. Manual de SmartLPR® Engine:
Mostra o manual de referência de SmartLPR Engine.
É necessario ter um visualizador de PDF associado a este tipo de arquivos (Acrobat
Reader que vai encontrar no CD de instalação de SmartLPR® Engine).
11. Sobre: Mostra informações sobre Quercus Technologies.
15
Uso do software
7.1.2. Zona de visualização
A zona de visualização mostra a imagem e a localização da imagem de placa reconhecida.
7.1.3. Resultados do reconhecimento
Os resultados de reconhecimento consistem em: a placa extraida em formato de texto, a placa
corrigida na imagem extraida, a posição de cada caráter reconhecido, a qualidade de cada
caráter assim como a qualidade média do reconhecimento.
Formato de
texto
Imagem da placa e
posição de caráter
A qualidade de cada caráter e
qualidade média
7.1.4. Estatísticas das resultados
Os resultados das estatísticas são atualizados a cada
nova imagem reconhecida. Eles são
organizados em três seções:
Arquivos
•
Atual: O arquivo atual na pasta selecionada.
•
Total: O número total de arquivos na pasta selecionada.
Tempo:
•
Atual: O tempo de processo de reconhecimento para a imagem atual.
•
Media: O tempo médio de processo de reconhecimento.
•
Min: O tempo mínimo de processo de reconhecimento.
•
Max: O tempo máximo de processo de reconhecimento.
Confiabilidade
Estes parâmetros serão computados se as opções de demo estão ativadas para comparar o
nome do arquivo da imagem com a placa detectada (vê seção 7.2.3 para mais detalhes).
•
Acertos: O número de acertos no processo de reconhecimento.
•
Falhas: O número de falhos no processo de reconhecimento.
•
Porcentagem: A porcentagem de placas corretamente reconhecidas até agora.
7.1.5. Controle deslizante de atraso
O controle deslizante de atraso lhe permite escolher o tempo que o resultado de
16
reconhecimento será mostrado em tela antes que a próxima imagem seja
Uso do software
processada. Os
valores aceitadas são entre 0 e 4 segundos.
7.2. Opções
Quando o botão "Opções" é pressionado, a janela de configuração com três etiquetas é
carregada. Cada etiqueta é descrita nas seguintes subseções.
7.2.1. Regiões de Engine
SmartLPR® Engine pode trabalhar com vários países (nomeou "regiões" no sistema SmartLPR ®
Engine). Os países disponível são mostrados na coluna "Disponível" classificada em ordem
alfabética. Esses países que você quer que SmartLPR ® Engine reconheça são mostrados na
coluna "Atual". Pode adicionar ou retirar os países atuais usando os botões direito-esquerdo e
os classifica usando as setas. Lembre-se de que a ordem dos países atuais é importante para
aumentar a velocidade máxima e a confiabilidade. As mudanças só serão aceitas quando o
botão "Aceita" é pressionado. Para descartar as mudanças pressiona o botão "Cancela".
7.2.2. Parâmetros de Engine
SmartLPR® Engine deve ser configurado para usar vários parâmetros (vê seção 8.1.2 para o
17
Uso do software
significado de cada parâmetro). Pode personalizar os parâmetros de configuração marcando a
caixa "Personalizada" ou carrega uma configuração predefinida. Quatro níveis de configuração
são criados para aumentar ao máximo a confiabilidade ou aumentar ao máximo o
desempenho. Pode escolher um dos níveis mencionados utilizando o controle deslizante
fornecido. As mudanças só serão aceitadas quando o botão "Aceita" é pressionado. Para
descartar as mudanças pressiona o botão "Cancela".
7.2.3. Opções gerais
Engine Tool também fornece algumas utilidades que você pode capacitar ou incapacitar.
Modo de demo
•
Quando o modo de demo está ativo, o processo de reconhecimento é cíclico (o processo
é começado de novo depois que foi terminado). O resto das opções estarão
indisponíveis enquanto o modo de demo está ativo.
Teste
•
Compare o nome do arquivo com a placa detectada. Esta opção capacita a computação
de sucessos, falhos e porcentagem dos resultados de estatística.
•
Copie as imagens corretamente detectadas à pasta selecionada (quando a opção de
comparação é ativada).
•
Copie as imagens detectadas incorretamente na pasta selecionada (quando a opção de
18
Uso do software
comparação é ativada).
Renomear
•
Renomee as imagens usando a placa detectada e as guarda na pasta selecionada.
Classificação
•
Classifica as imagens pelo país detectado, criando uma nova pasta para cada país
detectado na pasta selecionada.
As mudanças só serão guardadas quando o botão "Aceita" é pressionado. Para descartar as
mudanças pressionar o botão "Cancela".
19
SmartLPR Engine
Manual do Usuário
Programação
Programação
8. Configurar SmartLPR® Engine
8.1. Arquivos de configuração
8.1.1. Arquivo de seleção.txt
SmartLPR® Engine pode trabalhar com vários países. Os países disponíveis são esses que pode
achar no diretório "Data\Regions". A biblioteca pode ser configurada para trabalhar com um
país até com todos os países juntos. É importante anotar que o tempo de reconhecimento
aumentará com o número de países escolhidos. Também nota que a confiabilidade podia
diminuir se o número de países escolhidos aumenta.
O arquivo "Data\Selection.txt" contém várias linhas. Cada linha refere a um arquivo de "ini" do
diretório "Data\Regions" (refere a um país). Para aumentar ao velocidade máximo e a
confiabilidade, as linhas devem ser
ordenados de acordo com a probabilidade de sua
ocorrência.
8.1.2. Arquivo global.ini
O arquivo "Global.ini" armazena todos os parâmetros de configuração necessarios para
executar o SmartLPR® Engine. O significado de cada parâmetro e seus valores convenientes é
explicado aqui.
Quando SmartLPR® Engine procura candidatos para placas, usa vários parâmetros para
construir a lista de candidatos. Uma vez um candidato de placa foi achado e foi completamente
processado para um país, a placa de matrícula resultante é testada. Se o número de
carácteres desconhecidos não é maior que MaxBadChars, e a qualidade média é igual o maior
que
MinQuality,
o
processo
é
terminado
e
o
resultado
é
liberado
imediatamente.
Contrariamente, o processo continua para o resto de países, candidatos a placas (se mais de
um está disponível). Uma vez uma imagem foi processada, a placa resultante é testada outra
vez. Se o número de caráteres desconhecidos não é maior que MaxCandidateBadChars, e a
qualidade média é igual o maior que MinCandidateQuality, o processo é terminado e o
resultado é liberado imediatamente. Contrariamente, o processo continua para as próximas
imagens (se existem). Valores aceitos para MinQuality e MinCandidateQuality são entre 850 e
999, e para MaxBadChars e MaxCandidateBadChars são entre 0 e 2.
20
SmartLPR Engine
Manual do Usuário
Programação
O parâmetros MinCharHeight e MaxCharHeight limitam a altura (em pixels) dos caráteres
no quadro. Dar um intervalo mais exato reduzirá o número de falsos candidatos acharam no
quadro, reduzindo por conseqüência o tempo necessitou processá-lo.
Valores aceitos para
MinCharHeight e MaxCharHeight devem estar entre 1 e 120.
Quando o algoritmo procura a placa de matrícula no quadro, vários candidatos podem ser
achados. Nesse caso, candidatos são classificados de acordo com sua probabilidade de ser uma
placa de matrícula. O parâmetro MaxNumberOfCandidates limita o número máximo de extra
candidatos que o algoritmo processará, sem levar em conta o número de placas que você quer
achar numa imagem. O mais alto é este parâmetro, a mais alta a probabilidade de achar o
candidato que contém a placa. No entanto, o tempo de reconhecimento aumentará com o
número de candidatos para ser processado. Um valor razoável para este parâmetro é 1.
O identificador MinCharsPerLicense define o número mínimo de caráteres numa placa de
matrícula.
SmartLPR® Engine implementa quatro algoritmos distintos para procurar a placa de matrícula
na imagem. Cada país é configurado para usar os algoritmos que fornecem os melhores
resultados. Se o identificador Algoritmos não é achado em arquivo "Global.ini", cada país
usarão o próprios algoritmos. Contrariamente, o operador pode forçar o Engien a usar certos
algoritmos. Se utiliza todos os algoritmos a confiabilidade aumenta ligeiramente, mas tempo
médio de leitura podia ser multiplicado por quatro em algumas circunstâncias. Os valores
válidos para Algoritmos são "straight", "slope", "sides" e "bruteforce".
O identificador MatchingPenalization é um parâmetro interno usado no processo de
reconhecimento de caráter, para fazer a correspondência mais rigorosa. Valores aceitos para
MatchingPenalization são entre 0 e 30.
O parâmetro que Mixing é usado por SLPRMixer para trabalhar com vários países. É
recomendado não mudar o valor deste parâmetro.
Em alguns países o resultado de reconhecimento de placa pode ser expressado usando a
codificação Ocidental ou Arábe. O identificador ExtendedCodification estabelecido a 1
capacita a codificação Arábe, e a 0 capacita a codificação Ocidental.
21
SmartLPR Engine
Manual do Usuário
Programação
8.2. Configurar SmartLPR® Engine usando EngineTool
Os passos para configurar SmartLPR® Engine usando EngineTool são como segue:
1. Selecione os países que quer que SmartLPR® Engine reconheça (vê seção 7.2.1).
2. Estabelece os parâmetros (vê seção 7.2.2).
3. Salva mudanças.
8.3. ConfigurarSmartLPR® Engine manualmente
Os passos para configurar SmartLPR® Engine manualmente são como segue:
1. Edite o arquivo "Data\Selection.txt" (vê a seção 8.1.1 para mais detalhes) para
configurar SmartLPR® Engine trabalhar com os países desejados.
2. Edite o arquivo "Data\Global.ini" (vê a seção 8.1.2 para mais detalhes) para estabelecer
os parâmetros.
3. Uma vez estes arquivos são salvados execute
a aplicação SLPRMixer do diretório
"Bin\". O arquivo "Data\Current\Engine.ini" refletirá suas mudanças, e o SmartLPR ®
Engine estará preparado para reconhecer placas dos países que você escolheu usando
os parâmetros que você configurou.
22
SmartLPR Engine
Manual do Usuário
Programação
9. Programação básica
Os passos exigidos para desenvolver um programa que é capaz de reconhecer placas usando
SmartLPR® Engine são descritos próximo.
É necessario um conhecimento básico de programação para entender este capítulo (C ou
VB.NET). Se você trabalha geralmente com esta tecnologia, não terá nenhum problema para
seguir os exemplos.
O código de fonte dos exemplos é achado em <installation folder>/Samples.
9.1. C
Um programa curto em C é mostrado a continuação, que é capaz de reconhecer uma placa de
uma imagem BMP, de um buffer de dados lendo o conteúdo de um arquivo RAW, e de um
conjunto de imagens codificadas em vários arquivos RAW, usando a biblioteca de SmartLPR®
Engine.
O
código
fonte
dos
exemplos
é
achado
em
<installation
folder>/Samples/CApi_BasicSample/.
/*------------------------------------------,
| Copyright (C) 2013 Quercus Technologies |
| All rights reserved.
|
`------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include "SmartLPR.h"
/*--------------------------------------------------------------------- */
/* Change this 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);
23
SmartLPR Engine
Manual do Usuário
Programação
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;
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;
}
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;
}
As partes do código de amostra:
#include "SmartLPR.h"
24
SmartLPR Engine
Manual do Usuário
Programação
O único arquivo de cabeçalho exigido para interagir com SmartLPR® Engine em C.
O código é estruturado em vários métodos, para distinguir cómo ler uma licença de:
•
um arquivo BMP
SmartLPRError ReadFromBmp(int h, SmartLPRLicense* pLicense);
•
a buffer
SmartLPRError ReadFromBuffer(int h, SmartLPRLicense* pLicense);
•
um conjunto de buffers (multi image)
SmartLPRError ReadMultifile(int h, SmartLPRLicense* pLicense);
As informações sobre a placa e seu processo de reconhecimento são retornadas numa
estrutura de SmartLPRLicense. No processo de leitura de multi-imagem, a imagem de índice
de base zero em que a placa foi achada (ou em que a placa com a mais alta qualidade foi
achada) também é armazenada na estrutura de SmartLPRLicence.
O processo principal é basicamente composto de:
•
Carregar a configuração.
SmartLPRInitialize(int &h);
•
Ler a licença de um quadro ou um jogo de quadros, usando os métodos mencionados
acima.
•
Faça algo com a placa, neste caso imprimindo alguma informação.
•
Descarregar a configuração.
SmartLPRTerminate(int h);
Agora, será explicado em detalhe cómo é lida uma licença de cada fonte mencionada antes.
Leitura da placa de um arquivo BMP
Isto é a maneira mais simple para reconhecer a placa de uma imagem. Só tem que:
•
Inicializar o tamanho de estrutura de SmartLPRLicense.
SmartLPRCreateImage(&pLicense->PlateImage, width, height);
•
Ler a placa do arquivo de imagem BMP. O resultado do processo será retornado
utilizando a estrutura SmartLPRLicense.
SmartLPRReadLicenseFromBmp(h, imageName, pLicense);
•
Libere as imagens usadas se for necessário, usando a função SmartLPRDestroyImage.
Leitura da placa de um buffer
Os passos para ler uma licença de um buffer de dados são:
25
SmartLPR Engine
•
Manual do Usuário
Programação
Inicialize e reserva o buffer. Pode usar a função SmartLPRLoadImage para carregar e
inicializar o buffer de dados de um arquivo JPG ou BMP usando uma estrutura de
SmartLPRImage.
•
Inicialize o tamanho de estrutura SmartLPRLicense.
•
Leia a placa do buffer de dados, indicando a altura e largura de imagem, e largura de
linha. Como de costume, o resultado do processo será retornado utilizando a estrutura
SmartLPRLicense.
SmartLPRReadLicense(h, image.Height, image.Width, image.LineWidth,
image.Data, pLicense);
•
Libere o buffer de dados e imagens usadas se for necessário.
Leitura de placa de um conjunto de buffers
Uma placa pode ser lida de um conjunto de várias imagens do mesmo veículo. Para fazer isso,
você deve:
•
Inicializar e reservar o buffer de dados com o conteúdo de cada quadro.
•
Inicializar o tamanho de estrutura SmartLPRLicense.
•
Ler a placa do buffer de dados, indicando a altura e largura de imagem, a largura de
linha, e o número de imagens armazenadas no buffer. O resultado do processo será
retornado ussando uma estrutura SmartLPRLicense, e a imagem em que a placa foi
achada também é retornada.
SmartLPRReadLicenseMultiImage(h, imageHeight, imageWidth, imageLineWidth,
numImages, pData, pLicense);
•
Libere o buffer de dados e imagens usadas se for necessário.
9.1.1. Gerência de memória
A estrutura SmartLPRImage exige um pouco de atenção para ser usada corretamente. Esta
estrutura tem um membro de dados chamado Dados que é uma indicação ao conteúdo de
dados da imagem. Este buffer de dados tem que ser alocado pelo operador antes que a
estrutura de SmartLPRImage seja usada, e liberado quando seja necessário. Aquí, um pequeno
código de amostra é fornecido.
Inicialização
A inicialização de estrutura de SmartLPRImage consiste em reservar o buffer de dados e
26
SmartLPR Engine
Manual do Usuário
Programação
atualizar o tamanho de buffer. Ista é a função de SmartLPRCreateImage.
SmartLPRLicense license;
license.Size = sizeof(SmartLPRLicense);
SmartLPRCreateImage(&pLicense->PlateImage, width, heiht);
Uso
Depois de carregar o arquivo de configuração e ler a placa de uma fonte, a estrutura
SmartLPRLicense conterá o resultado do processo de reconhecimento. Se o buffer de dados de
PlateImage foi reservado (criando uma imagem de largura e altura maior que zero) o processo
de reconhecimento o encherá. Uma função para salvar uma estrutura SmartLPRImage a um
arquivo BMP é fornecida também.
SmartLPRInitialize(int &h);
SmartLPRReadLicenseFromBmp(int h, IMAGE_FILE, &license);
SmartLPRSaveToBmp(&license.PlateImage, "license.bmp"))
Terminação
Para terminar a aplicação corretamente, tem que descarregar o arquivo de configuração e
liberar o buffer de dados de SmartLPRImage.
SmartLPRTerminate(int h);
SmartLPRdestroyImage(&license.PlateImage);
9.1.2. Crie o arquivo executável
Visual Studio
●
Abra o arquivo "Samples.sln" da pasta de "Samples".
●
Pressione o botão dereito sobre Sample1 e selecione "Project only → Build only
BasicSample”.
Linux
●
Abra uma consola.
●
Abra a pasta Samples/CApi_BasicSample.
●
Execute o comando "make".
9.2. .NET
A abragência do NET permite que o operador gere uma biblioteca .NET para usar as funções
de API em C em um ambiente de .NET.
Todos os exemplos forneceram com envoltório .NET são programados em Visual Basic. Um
27
SmartLPR Engine
Manual do Usuário
Programação
programa curto em VB.NET é mostrado à continuação, que é capaz de reconhecer uma placa
de uma imagem de BMP, de um buffer de dados lendo o conteúdo de um arquivo RAW, e de
um conjunto de imagens codificadas em vários arquivos RAW, usando a biblioteca de
SmartLPR
Engine.
O
código
fonte
dos
exemplos
é
achado
em
<installation
folder>/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)
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)
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)
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)
System.Console.WriteLine("Terminate fails, err:" + err.ToString())
Exit Sub
End If
28
SmartLPR Engine
Manual do Usuário
Programação
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) As
Dim img As SmartLPR.Image
img = engine.CreateImage(0, 0)
err = engine.LoadImage(img, IMAGE_NAME)
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
Dim ptrs as SmartLPR.IntPtrArray
Dim fName As String
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
As partes do código de amostra:
Todas as classes e tipos de informações necessárias são definidas no namespace SmartLPR.
O código é estruturado em vários métodos, para distinguir cómo ler uma placa de:
•
um arquivo BMP
Function ReadFromBmp(ByVal engine As SmartLPR.Engine, ByRef license As
SmartLPR.License) As SmartLPR.EngineError
•
um buffer
Function ReadFromBuffer(ByVal engine As SmartLPR.Engine, ByRef license As
•
um conjunto de buffers (multi imagem)
Function ReadMultifile(ByVal engine As SmartLPR.Engine, ByRef license As
29
SmartLPR Engine
Manual do Usuário
Programação
As informações sobre a placa e seu processo de reconhecimento são retornadas na classe
License. No processo de leitura de multi-imagem, a imagem de índice de base zero em que a
placa foi achada (ou em que a placa com a mais alta qualidade foi achada) também é
armazenada na classe License.
O processo principal basicamente é composto de:
•
Carregar a configuração, chamando o método Inicialize de classe Engine.
•
Ler a licença de uma imagem ou um conjunto de imagens, usando os métodos
mencionados acima.
•
Faça algo com a licença, neste caso imprimindo alguma informação.
•
Descarregar a configuração, chamando o método Terminate de classe Engine .
Os seguintes parágrafos explicam a maneira de ler uma placa de cada fonte mencionada
antes.
Leitura de placa de um arquivo BMP
Ista é a maneira mais simple de reconhecer uma placa de uma imagem. Você só tem que
chamar o método ReadLicenseFromBmp de classe Engine. O resultado do processo será
retornado usando a classe License.
ReadFromBmp = engine.ReadLicenseFromBmp(IMAGE_NAME, license)
Leitura de placa de um buffer
Os passos para ler uma placa de um buffer de dados são:
•
Inicialize e reserve o buffer de dados. Pode usar o função LoadImage para que a classe
Engine carregue e inicialize o buffer de dados de um arquivo JPG ou BMP usando a
classe Image.
img = engine.CreateImage(0, 0)
err = engine.LoadImage(img, IMAGE_NAME)
•
Leia a placa do buffer de dados, indicando a altura e largura de imagem, e a largura de
linha. Como de costume, o resultado do processo será retornado usando a classe
License.
ReadFromBuffer = engine.ReadLicense(img.Height, img.Width, img.LineWidth,
img.Buffer, license)
Leitura de placa de um conjunto de buffers
30
SmartLPR Engine
Manual do Usuário
Programação
Uma placa pode ser lida de um conjunto de várias imagens do mesmo veículo. Para fazer isso,
você deve:
•
Inicializar e reservar o buffer de dados com o conteúdo de cada imagem.
•
Ler a placa de um buffer dos dados, indicando a altura e largura de imagem, largura de
linha, e o número de imagens armazenadas no buffer. O resultado do processo será
retornado utilizando a classe License, e a imagem em que foi achada a placa também é
retornada.
ReadMultifile = engine.ReadLicenseMultiImage(IMAGE_HEIGHT, IMAGE_WIDTH,
IMAGE_LINE_WIDTH, NUM_MULTI_IMAGES, ptrs.GetIntPtrArray(), license)
9.2.1. Construir a DLL
Se você quer desenvolver usando o envoltório .NET, o primeiro passo é compilar o projeto de
DLL para gerar a DLL em. NET. O projeto fornecido é localizado em <installation
folder>/Src/WrapperNet. Você tem que abrir o arquivo "SmartLPRNet.sln" com Visual Studio
ou MonoDevelop e constroem o projeto de SmartLPRNet. A DLL gerou será localizado em
<installation folder>/Bin/SmartLPRNet.dll
9.2.2. Crie o arquivo executável
Para gerar o arquivo executável que tem que abrir o arquivo "VisualBasic_Samples.sln" achado
na pasta "Samples" com Visual Studio ou MonoDevelop. Então pressione o botão direito sobre
o projeto de BasicSample e contruí-o. O arquivo executável BasicSample.exe será criado.
9.3. Outros exemplos
Na pasta <installation folder>/ Samples há mais exemplos de programação com SmartLPR®
Engine. A pasta inclui um arquivo "Readme.txt" com a descrição dos exemplos incluídos.
31
SmartLPR Engine
Manual do Usuário
Programação
10. API
A seguinte seção descreve as estruturas de dados e funções usadas pela biblioteca de
SmartLPR Engine para explicar seu uso e funcionalidades.
Toda API em .NET é descrita usando a sintaxe C# mas está usável de cada linguagem .NET.
10.1. Definição de estruturas de dados
10.1.1. Imagem
Ista estrutura é usada para poupar um conteúdo de imagem.
C:
SmartLPRImage struct.
C#:
classe Image.
Membros de dados:
●
Len
tamanho de vetor Data.
●
Height
número de linhas de imagem.
●
Width
número de pixels por linha.
●
LineWidth
número de bytes de memória usados por linha.
●
Data
em C, é um ponteiro de datos a imagens. As imagens devem ter um
plano com 8 bits por pixel.
●
Buffer
Em .NET, é um buffer da dados à imagem.
●
BufferPtr
Em. NET, é um ponteiro ao buffer de dados.
As duas representações de buffer usadas em .NET (séries de dados e ponteiro ào dados) são
necessário porque o API em C só trabalha com o poteiro da imagem de dados, mas a
conversão interna entre os ponteiros em C e os em .NET é mais caras que trabalhar com a
série de byte de dados; então o ponteiro de dados só é usada quando é essencial.
Nota: Veja seção 9.1.1 para mais informações sobre o uso correto desta estrutura.
10.1.2. Ponto
Esta estrutura é usada para representar uma posição de pixel numa imagem, usando origem
superior esquerda.
C:
SmartLPRPoint struct.
C#:
Não usado. Usa o objeto System.Drawing.Point.
32
SmartLPR Engine
Manual do Usuário
Programação
Membros de dados:
●
X
A x-coordenada do ponto (positivo de esquerda a direita).
●
Y
A y-coordenada do ponto (positivo de cima para baixo).
10.1.3. Retângulo
Esta estrutura é usada para especificar uma seção retangular numa imagem.
C:
SmartLPRRectangle struct.
C#:
Não usado. Usa o objeto System.Drawing.Rectangle.
Membros de dados:
●
TopLeft
O ponto acima - esquerda do retângulo.
●
BottomRight
O ponto inferior-direito do retângulo.
10.1.4. License
Retorna os resultados de processo de leitura.
C:
SmartLPRLicense struct.
C#:
Classe License.
Membros de dados:
●
Size (C)
Em estrutura em C, é o tamanho de estrutura de SmartLPRLicense em
bytes.Este campo deve ser posto antes de chamar qualquer versão de
SmartLPRReadLicense.
●
License(C), DecoratedLicense(C)
String contendo a licença decorada.
●
NumberOfChars
Número de elementos em Chars, Qualities e CharBoxes.
●
Chars
Série de caracteres lidos da placas (exclui decorativos).
●
Qualities
Série de caracteres não-decorativos das qualidades.
●
IsGrammarOk
Não zero (C) ou VERDADE (C#) se a placa é obediente com o
formato de qualquer país configurado.
●
AvgQuality
A qualidade média do caracteres lidos. Um valor mais grande que
0,97 é um resultado bom. Um valor menos que 0,92 é um
resultado pobre.
●
NumberOfUnknownChars
Número de caracteres que não podiam ser reconhecidos
figuram como ''?” na licença decorada.
●
Country String contendo o país que aceita a placa como válida.
●
Roi
Série contendo a esquerda, topo, correto, e fundo (nesta ordem)
de um o retângulo que contém a placa na imagem de entrada.
●
PlateImage
Imagem da placa extraida da imagem de entrada.
33
SmartLPR Engine
●
Manual do Usuário
BoundingBox
Programação
Série contendo os pontos superior-esquerda, superior-direito,
inferior-direito, inferior-esquerdo aponta (nesta ordem) que
especifica as coordenadas do unir orientado retângulo de caixa
que contém a placa na imagem4de entrada.
●
CharBoxes
Série contendo os retângulos de cada caráter na placa. As
coordenadas de retângulo são relativas a PlateImage.
●
CodePage
Os membros de dados "License" e "Chars" são codificados como
um único valor de código de oito-bit usando esta página de
código.
●
BestImage
Armazena o índice com base em zero da melhor imagem onde foi
achada a placa (ou a com a mais alta qualidade). É usado em
processo de leitura multi-imagem.
10.1.5. Engine
C:
Não existe.
C#:
classe Engine.
Em C, o objeto "Engine" é representado pelo parâmetro "handle" que é usado em cada função
relacionada com o reconhecimento de placa.
Em C# todas estas funções são contidas na classe Engine como métodos públicos.
4 Estes pontos podiam ser negativos (fora dos limites da imagem) se a placa é perto da fronteira de imagem. O
operador é responsável usar estes pontos corretamente, por exemplo em pintar a caixa de selecção na imagem.
34
SmartLPR Engine
Manual do Usuário
Programação
10.2. Definições das funções
Todas as funções abaixo são seguras para threads.
Para lucrar de vantagens de
multithreading, você deve usar um "engine" por thread. Veja o MultiThreadSample localizado
na pasta "Samples/" para mais informações e um exemplo de uso.
10.2.1. Initialize
Initializa um Engine e carrega o arquivo de configuração.
C:
SmartLPRError SmartLPRInitialize(int &handle)
C#:
EngineError Engine::Initialize()
Em C, tem um propósito duplo: criando uma nova instança de Engine e iniciação. O parâmetro
"handle" deve ser usado como entrada em outras funções de SmartLPR.
Valor de retorno:
Esta função retorna um código de erro.
Veja também:
Terminate
10.2.2. Ler placa
Retorne a placa que figura em um buffer de dados.
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 o manipulador que opera no engine você com quer ler.
●
height
Número de linhas da imagem (positivo se linhas são classificadas de cima
para baixo, negativo contrariamente).
●
width
Número de pixeis por linha.
●
LineWidth
Número de bits de memória utilizados por linha.
●
Data
Dados de imagem. As imagens devem ter um plano com 8 bits por pixel.
●
License
Indicação a um objeto reservado da placa, que é enchido com os
resultados de processo de reconhecimento.
35
SmartLPR Engine
Manual do Usuário
Programação
Veja também:
Ler imagem usando o modo multi-imagem, Ler placa de arquivo bmp, Leia placa de ROI
10.2.3. Ler imagem usando o modo multi-imagem
Retorne o melhor resultado (ou um suficientemente bom) de reconhecimento de um conjunto
de imagens (armazendas em buffers) do mesmo veí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 o manipulador que opera no motor com que você quer
ler.
●
Height
Número de linhas da imagem (positivo se linhas são classificadas
de cima para baixo, negativo contrariamente).
●
width
Número de pixels por linha.
●
lineWidth
Número de bytes de memória usou por linha.
●
numberOfPictures
Número de imagens.
●
dataPtrs
Ponteiro a uma série de ponteiros de dados de imagem. As
imagens devem ter um plano com 8 bits por pixel.
●
license
Indicação a um objeto reservado da placa, que é enchido com os
Valor de retorno:
Veja também:
Ler placa, Ler placa de arquivo bmp
10.2.4. Ler placa de arquivo bmp
Retorne a placa que figura na imagem.
C:
SmartLPRError SmartLPRReadLicenseFromBmp (int handle, const char* file,
SmartLPRLicense* license)
C#:
EngineError Engine::ReadLicenseFromBmp (string file,ref License license)
36
SmartLPR Engine
Manual do Usuário
Programação
Parâmetros
●
handle
Identifica o manipulador que opera no engine com que você quer ler.
●
file
Nome do arquivo Windows BMP ou JPEG de 24 cor de bits ou escala de
tons de cinza contendo a imagem de um veículo.
●
license
Ponteiro a um objeto License reservado, que é enchido com os resultados
de processo de reconhecimento.
Valor de retorno:
Veja também:
Ler placa, Ler imagem usando o modo multi-imagem
10.2.5. Reconhecimento de Multi-placas
Esta função permite lê várias placas figurando num buffer de dados.
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 o handle que opera no engine com que você quer ler.
●
height
Número de linhas de imagem (positivo se linhas são classificadas
●
width
Número de pixels por linha.
●
linewidth
Número de bytes de memória usados por linha.
●
data
Dados de imagem. As imagens devem ter um plano com 8 bits
por pixel.
●
numberOfLicenses
Ponteiro a um inteiro, cujo valor denota o número de placas que
você quer achar na imagem5. Isto é um parâmetro de
entrada/saída.
A função usa este parâmetro para retornar o
número de placas realmente achou (menos ou igual que a valor de
entrada).
●
licenseList
Série de objetos license encheu com resultados de processo de
reconhecimento de cada placa.
5 SmartLPR Engine P100 e S200 só permite o reconhecimento de uma placa em uma
imagem.
37
SmartLPR Engine
Manual do Usuário
Programação
Valor de retorno:
Veja também:
Ler placa, Multi reconhecimento de placa usando modo multi-imagem
10.2.6. Multi reconhecimento de placa usando modo multi-imagem
Esta função permite ler várias placas de um conjunto de imagens (armazenadas em 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 o manipulador que opera no engine com que você quer
ler.
●
Height
Número de linhas de imagem (positivo se linhas são classificadas
●
width
●
Linewidth
Número de bytes de memória por linha.
●
DataPtrs
Ponteiro a uma série de ponteiro nos dados da imagem. As
imagens devem ter um plano com 8 bits por pixel.
●
numberOfLicenses
Ponteiro a um número inteiro, cujo valor denota o número de
placas que você quer achar na imagem 6. Isto é um parâmetro de
entrada/saída. A função usa este parâmetro para retornar o
número de placas realmente achou (menos que ou iguala ao valor
de entrada).
●
licenseList
Série de objetos License enchidos com resultados de processo de
reconhecimento de cada placa.
Valor de retorno:
6 SmartLPR Motor P100 e S200 só permite o reconhecimento de uma placa por imagem.
38
SmartLPR Engine
Manual do Usuário
Programação
Veja também:
Reconhecimento de Multi-placas, Ler imagem usando o modo multi-imagem
10.2.7. Leia placa de ROI
Retorne a placa que figura em um buffer de dados dentro do 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 o handle que opero no engine com que você quer ler.
●
height
Número de linhas de imagem (positivo se linhas são classificadas de cima
para baixo, negativo contrariamente).
●
Width
●
Linewidth
Número de bytes de memória por linha.
●
data
Ponteiro aos dados da imagem. As imagens devem ter um plano com 8
bits por pixel.
●
roi
Região de interesse (ROI) onde a licença é querida ser achada.
●
license
Ponteiro a um objeto License reservado, que é enchido com os
Valor de retorno:
Veja também:
Ler placa, Ler placa de arquivo bmp
10.2.8. Que licença é melhor
Compara dois resultados obtidos de imagens distintos do mesmo veículo.
C:
bool SmartLPRIsLicenseBetter(SmartLPRLicense* left, SmartLPRLicense*
right)
C#:
System.Boolean IsLicenseBetter (License left, License right)
39
SmartLPR Engine
Manual do Usuário
Programação
Parâmetros:
●
esquerda
Objeto License obteve de uma chamada a qualquer versão de
função de ReadLicense.
●
direita
Objeto License obteve de uma chamada a qualquer versão de
função de ReadLicense.
Valor de retorno:
Retorna verdade se a placa esquerda é um melhor resultado que a direita.
10.2.9. Terminate
Esta função termina um Engine e descarrega o arquivo de configuração. É o contrário da
função Initialize e deve ser chamada com o manipulador do engine que você quer terminar.
Seu programa deve chamar esta função antes de terminar. Os usos do manipulador depois que
esta função foi chamada e retornou, são ilegais.
C:
SmartLPRError SmartLPRTerminate(int handle)
C#:
EngineError Engine::Terminate()
Parâmetros:
●
handle
Identifica o manipulador que opera no engine que você quer terminar.
Valor de retorno:
Veja também:
Initialize
10.2.10. Carregue imagem
Carrega e inicializa a estrutura SmartLPRImage do arquivo JPG ou BMP. Anote que deve
chamar SmartLPRDestroyImage depois de usar a imagem para remover a alocação do buffer
de dados criado.
C:
SmartLPRError SmartLPRLoadImage(const char* file, SmartLPRImage *pImg)
C#:
EngineError Engine::LoadImage(ref Image pImg, string file)
Parâmetro:
●
file
Nome do arquivo.
●
Pimg
Ponteiro a uma estrutura reservada SmartLPRImage.
40
SmartLPR Engine
Manual do Usuário
Programação
Valor de retorno:
Veja também:
Destruir imagem
10.2.11. Criar imagem
Cria uma nova imagem de tamanho width x height.
Anote que deve chamar a função de
DestroyImage depois de usar a imagem para remover a alocação do buffer de dados criado.
Se um imagem vazia foi criada (usando width = 0, height = 0) nenhuma dealocação é
necessitada.
C:
SmartLPRError SmartLPRCreateImage(SmartLPRImage *pImage, int width, int
height)
C#:
SmartLPR.Image Engine::CreateImage(int width, int height)
Parâmetros:
●
pImage
Ponteiro à imagem.
●
width
Largura da imagem desejada.
●
height
Altura da imagem desejada.
Valor de retorno:
Veja também:
Destruir imagem, Salvar à arquivo bmp
10.2.12. Salvar à arquivo bmp
Salva a imagem em um arquivo bmp.
C:
SmartLPRError SmartLPRSaveToBmp(SmartLPRImage* pImg, const char*
file)
C#:
EngineError Image::SaveToBmp(System.String file)
Parâmetros:
●
pImg
Ponteiro a uma estrutura SmartLPRImage reservada.
●
File
Nome do arquivo.
41
SmartLPR Engine
Manual do Usuário
Programação
Valor de retorno:
10.2.13. Recortar retângulo
Dada uma imagem fonte e uma seção retangular, recorta a imagem gerando um subimage que
contêm a área dada pela seção retangular. Anote que deve chamar SmartLPRDestroyImage
depois de usar a imagem para remover a alocação do buffer de dados na imagem 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
Imagem de destino.
●
ScrImg
Imagem fonte.
●
roi
Roi a seção retangular para ser recortada.
Veja também:
Salvar à arquivo bmp, Destruir imagem
10.2.14. Destruir imagem
Destruí uma imagem reservada.
C:
void SmartLPRDestroyImage(SmartLPRImage *img)
C#:
Não existe. É implícita no destructor de classe Imagem.
Parâmetros:
●
img
Imagem para que será removida a alocação.
Veja também:
Criar imagem
10.2.15. Executar o mixer
Execute o SLPRMixer.
C:
SmartLPRError SmartLPRRunMixer()
C#:
Engine::EngineError RunMixer()
42
SmartLPR Engine
Manual do Usuário
Programação
Valor de retorno:
43
SmartLPR Engine
Manual do Usuário
Programação
10.3. Códigos de erros
A maioria de funções retornam um código de erro. A próxima tabela mostra as descrições de
código de erro.
Etiqueta
Valor
Significado
SLPR_OK
0x0000
Nenhum erro achou.
SLPR_UNEXPECTED_ERROR
0x1001
Erro inesperado achou.
SLPR_INITIALIZED
0x1002
SLPR já foi inicializado.
SLPR_NOT_INITIALIZED
0x1003
SLPR não é inicializado.
SLPR_BAD_IMAGE
0x1004
SLPR_BAD_PARAMETERS
0x1005
Maus parâmetros de função.
SLPR_MIXER_FILE_NOT_FOUND
0x1006
O arquivo de mixer não foi achado o é corrupto.
SLPR_LICENSING_ERROR
0x1007
Erro de licença software o hardware.
SLPR_INSTANCING_ERROR
0x1008
Não são permitidas mais instâncias.
SLPR_READING_DATA_ERROR
0x1009
Erro na leitura de dados.
SLPR_BAD_GLOBAL_SPEC
0x0101
Erros achados no arquivo Global.ini.
SLPR_CORRUPTED_GRAMMAR_FILE
0x0201
O jogo de arquivo de produção não foi achado o é corrupto.
SLPR_BAD_PRODUCTION_SPEC
0x0202
Erro achado numa das produções.
SLPR_CORRUPTED_CALLIGRAPHY_FILE
0x0301
O arquivo de caligrafia *. cal não foi achado o é corrupto.
SLPR_BAD_CALLIGRAPHY_SPEC
0x0302
SLPR_BAD_GRAMMAR_SPEC
0x0303
SLPR_BAD_REGION_GLOBAL_SPEC
0x0401
Má configuração em seção [Global] de arquivo de região.
SLPR_BAD_REGION_CALLIGRAPHY_SPEC
0x0402
Má configuração em seção [Calligraphy] de arquivo de região.
O arquivo de imagem não achou o formato não suportado de
arquivo.
Má configuração em seção [ModelList] de arquivo de caligrafia
*. ini
Má configuração em seção [Grammars] de. arquivo de
caligrafia de ini *. ini
44
SmartLPR Engine
Manual do Usuário
Programação
10.4. Estruturas obsoletas e funções
O séquito é uma lista de estruturas e funções que são obsoletas. Nós mostramos o novos que
deve usar em vez do obsoletos.
Estruturas obsoletas
Novas estruturas
SlprImage
SmartLPRImage
SlprPoint
SmartLPRPoint
SlprRectangle
SmartLPRRectangle
SlprLicense
SmartLPRLicense
SlprErrors
SmartLPRError
Funções obsoletas
Novas funções
SlprInitialize
SmartLPRInitialize
SlprReadLicense
SmartLPRReadLicense
SlprReadLicense2
SmartLPRReadLicenseMultiImage
SlprReadLicenseFromBmp
SmartLPRReadLicenseFromBmp
SlprIsLicenseBetter
SmartLPRIsLicenseBetter
SlprTerminate
SmartLPRTerminate
SlprSaveToBmp
SmartLPRSaveToBmp
SlprCropRectangle
SmartLPRCropRectangle
45
SmartLPR Engine
Manual do Usuário
Programação
Apêndice
11. Apêndice A: Especificações técnicas
Sistemas operacionais Win XP e superior - GNU/Linux.
Linguagens de
programação
C/C++ e .NET
Depende basicamente do estado de conservação da placa e do tamanho da imagem. Por
Tempo de exemplo, com um Dual Core CPU @ 3.2 Ghz, o tempo médio de processamento numa
processamento imagem de pixel 640x480 contendo uma placa em estado correto de conservação é
aproximadamente 15 ms*.
Placa formatada com hífenes e espaços, placa não-formatada, qualidade de cada caráter
Resultados e qualidade média da placa, país, localização da placa na imagem, localização de cada
caráter na imagem, caixa de seleção da placa na imagem, e a imagem da placa extraída.
As placas detectadas Reconhecimento de placas de diferentes países de diferentes continentes
**
Canada (British Columbia), Mexico, USA (Arizona, California, Colorado, Delaware, District
Placas detectadas of Columbia, Florida, Georgia, Illinois, Maryland, New Jersey, New Mexico, New York,
(versão NA)
North Carolina, Oregon, Pennsylvania, South Carolina, Tennessee, Texas, Utah, Virginia,
Washington, West Virginia)
Formato da placa
Uma ou duas linhas de caráteres, retangular ou quadrada.
Os tipos de imagens
suportadas
Tamanho de imagem
Tamanho recomendado
da placa
arquivos bmp e jpg com a profundidade de cor de 8 ou 24 bits, e buffer de dados de 8
bits.
Qualquer tamanho mostrando o tamanho mínimo da placa. Maior é o tamanho, o mais
longo o tempo de processamento será.
140-150 pixeis de primeiro ao último caráter.
*O tempo de processamento pode variar depender do número de países capacitados, os algoritmos e opções que são
usados para procurar a placa.
**Contate-nos para saber os países reconhecidos que já são incluídos em nossos equipamentos. Também os
informaremos sobre os passos à seguir para fazer uma atualização que permite o reconhecimento de seus países
desejados.
46
SmartLPR Engine
Manual do Usuário
Programação
12. Apêndice B: Suporte
Se tem qualquer dúvida sobre configuração ou uso de SmartLPR Engine, não hesite em
contatar nosso departamento de suporte técnico:
●
EUA: +1 201 227 2020
●
Brasil e América latina: +55 (11) 2614 3006 (Ramal 21)
●
EMEA e Asia: +34 977 300 377
Ou por e-mail em: [email protected]
Também pode contatá-nos por nossas páginas da Web:
●
www.quercus.biz
●
www.quercus-technologies.com
●
www.quercus.com.br
47

manual de usuário - Quercus Technologies

Transcrição

Documentos relacionados

bibloo - buscador web especializado em livros com uma eficiente

Detalhes do Produto

Baixar currículo

Catálogo Denon Dj

Detalhes do Produto

SS35N - SS32

galette des rois - Pief escola Frei Joao de Vila Do Conde

SEO – Search Engine Optimization

Hazy Portuguese Map - National Air and Space Museum

SEA – Search Engine Advertising