ultimateALPR SDK
1.0.0
Começando
Android
Raspberry Pi (OS Raspbian), Linux, Nvidia Jetson, Windows e outros
Obtendo ajuda
Demoção da Web online em https://www.doubango.org/webapps/alpr/
Documentação completa para o SDK em https://www.doubango.org/sdks/anpr/docs/
Idiomas suportados (API): C ++ , C# , Java e Python
Biblioteca de visão computacional de código aberto: https://github.com/doubangotelecom/compv
Palavras-chave: Image Enhancement for Night-Vision (IENV) , License Plate Recognition (LPR) , License Plate Country Identification (LPCI) , Vehicle Color Recognition (VCR) , Vehicle Make Model Recognition (VMMR) , Vehicle Body Style Recognition (VBSR) , Vehicle Direction Tracking (VDT) e Vehicle Speed Estimation (VSE)
Você já viu um mecanismo ANPR/ALPR (ALPR (número automático/placa automático), baseado em aprendizado profundo, rodando a 64fps em um dispositivo de braço de US $ 99 (Khadas Vim3, 720p Video Resolution)?
UltimatealPR é a implementação ANPR/ALPR mais rápida que você encontrará no mercado. Ser rápido é importante, mas ser preciso é crucial.
Utilizamos técnicas de aprendizado profundo de última geração para oferecer precisão e precisão incomparáveis. Como comparação, isso é #33 vezes mais rápido que o OpenalPR no Android. (Consulte a seção de referência para obter mais informações).
Não há necessidade de GPUs especiais ou dedicadas, tudo está sendo executado na CPU com otimizações de neon do ARM SIMD , operações matemáticas de ponto fixo e multithreading. Isso abre as portas para as possibilidades de executar suas soluções (Sistema de Transporte Inteligente) em uma câmera sem solicitar uma nuvem. Ser capaz de executar todos os seus aplicativos no dispositivo reduzirá significativamente o custo para adquirir, implantar e manter esses sistemas. Verifique se a seção Solução baseada em dispositivo versus baseada em nuvem para obter mais informações sobre como isso reduziria o custo.
O próximo vídeo mostra a amostra de reconhecimento em execução no Windows:
O código é acelerado na CPU , GPU , VPU e FPGA , graças a Cuda, Nvidia Tensorrt e Intel Openvino.
Além do reconhecimento de placas (LPR), apoiamos o aprimoramento da imagem para a visão noturna (IENV), identificação por país das placas (LPCI), reconhecimento de cores do veículo (videocassete), reconhecimento de modelo (VMMR), reconhecimento de estilo do corpo do veículo (VBSR), rastreamento de direção do veículo (VDT) e estimativa de velocidade do veículo (VSE).
Em GPUs NVIDIA de ponta, como o Tesla V100, a taxa de quadros é de 315 fps, o que significa tempo de inferência de 3,17 milissegundos . Em CPUs de ponta como a Intel Xeon, a taxa máxima de quadros pode ser de até 237fps , graças ao OpenVino. Em CPUs de ponta, como o Raspberry Pi 4, a taxa média de quadros é de 12fps .
Não aceite nossa palavra, venha verificar nossa implementação. Não é necessário registro, chave de licença ou conexão com a Internet , basta clonar o código e começar a codificar/testar. Tudo é executado no dispositivo, nenhum dado está saindo do seu computador. O código lançado aqui vem com muitas amostras prontas para uso para Android, Raspberry Pi, Linux e Windows para ajudá-lo a começar facilmente.
Você também pode verificar nossa implementação baseada em nuvem on-line ( sem necessidade de registro ) para verificar a precisão e a precisão antes de começar a jogar com o SDK.
Verifique a documentação completa em https://www.doubango.org/sdks/anpr/docs/
O SDK funciona em muitas plataformas e vem com suporte para muitas linguagens de programação, mas as próximas seções se concentram no Android, Raspberry Pi, Linux e Windows.
As próximas seções são sobre Android e Java API.
O código -fonte vem com aplicativos de amostra nº 4 do Android: benchmark, videoparalel, videosequencial e imagensNAP.
Este aplicativo é usado para verificar tudo está ok e funcionando tão rápido quanto o esperado. As informações sobre a taxa máxima de quadros ( 237fps no Intel Xeon, 64fps no Khadas Vim3 e 12fps no Raspberry Pi 4) podem ser verificadas usando este aplicativo. É de código aberto e não requer chave de registro ou licença.
Este aplicativo deve ser usado como código de referência por qualquer desenvolvedor que tenta adicionar ultimatealPR aos seus produtos. Ele mostra como detectar e reconhecer as placas em tempo real usando o fluxo de vídeo ao vivo da câmera. Verifique a seção Paralela versus processamento seqüencial para obter mais informações sobre o modo Parelel.
O mesmo que o videoparalelo, mas trabalhando no modo seqüencial, o que significa mais lento. Este aplicativo é fornecido para facilitar a comparação dos modos: paralelo versus sequencial.
Este aplicativo lê e exibe o fluxo de vídeo ao vivo da câmera, mas reconhece apenas uma imagem do fluxo sob demanda.
Para experimentar os aplicativos de amostra no Android:
Open Android Studio e selecione "Abra um projeto de estúdio Android existente"
Navegue até as amostras ultimatealpr-sdk/
Selecione a amostra que deseja experimentar (por exemplo, videoparalelas ) e pressione Run . Certifique -se de ter o dispositivo no modo de paisagem para uma melhor experiência.
O SDK é distribuído como um módulo Android Studio e você pode adicioná -lo como referência ou também pode construí -lo e adicionar o AAR ao seu projeto. Mas, a maneira mais fácil de adicionar o SDK ao seu projeto é incluir diretamente a fonte.
Em seu arquivo Build.gradle Adicionar:
android {
# This is the block to add within "android { } " section
sourceSets {
main {
jniLibs . srcDirs + = [ 'path-to-your-ultimateALPR-SDK/binaries/android/jniLibs' ]
java . srcDirs + = [ 'path-to-your-ultimateALPR-SDK/java/android' ]
assets . srcDirs + = [ 'path-to-your-ultimateALPR-SDK/assets/models' ]
}
}
}É difícil se perder quando você tenta usar a API, pois existem apenas três funções úteis: init, Process e Deinit.
A API C ++ é definida aqui.
import org . doubango . ultimateAlpr . Sdk . ULTALPR_SDK_IMAGE_TYPE ;
import org . doubango . ultimateAlpr . Sdk . UltAlprSdkEngine ;
import org . doubango . ultimateAlpr . Sdk . UltAlprSdkParallelDeliveryCallback ;
import org . doubango . ultimateAlpr . Sdk . UltAlprSdkResult ;
final static String CONFIG = "{" +
" " debug_level " : " info " ," +
" " gpgpu_enabled " : true," +
" " openvino_enabled " : true," +
" " openvino_device " : " CPU " ," +
" " detect_minscore " : 0.1," +
" " detect_quantization_enabled " : true," +
" " pyramidal_search_enabled " : true," +
" " pyramidal_search_sensitivity " : 0.28," +
" " pyramidal_search_minscore " : 0.5," +
" " pyramidal_search_quantization_enabled " : true," +
" " klass_lpci_enabled " : true," +
" " klass_vcr_enabled " : true," +
" " klass_vmmr_enabled " : true," +
" " recogn_score_type " : " min " ," +
" " recogn_minscore " : 0.3," +
" " recogn_rectify_enabled " : false," +
" " recogn_quantization_enabled " : true" +
"}" ;
/**
* Parallel callback delivery function used to notify about new results.
* This callback will be called few milliseconds (before next frame is completely processed)
* after process function is called.
*/
static class MyUltAlprSdkParallelDeliveryCallback extends UltAlprSdkParallelDeliveryCallback {
@ Override
public void onNewResult ( UltAlprSdkResult result ) { }
}
final MyUltAlprSdkParallelDeliveryCallback mCallback = new MyUltAlprSdkParallelDeliveryCallback (); // set to null to disable parallel mode
@ Override
protected void onCreate ( Bundle savedInstanceState ) {
super . onCreate ( savedInstanceState );
// Initialize the engine
assert UltAlprSdkEngine . init (
getAssets (),
CONFIG ,
mCallback
). isOK ();
}
// Camera listener: https://developer.android.com/reference/android/media/ImageReader.OnImageAvailableListener
final ImageReader . OnImageAvailableListener mOnImageAvailableListener = new ImageReader . OnImageAvailableListener () {
@ Override
public void onImageAvailable ( ImageReader reader ) {
try {
final Image image = reader . acquireLatestImage ();
if ( image == null ) {
return ;
}
// ANPR/ALPR recognition
final Image . Plane [] planes = image . getPlanes ();
final UltAlprSdkResult result = UltAlprSdkEngine . process (
ULTALPR_SDK_IMAGE_TYPE . ULTALPR_SDK_IMAGE_TYPE_YUV420P ,
planes [ 0 ]. getBuffer (),
planes [ 1 ]. getBuffer (),
planes [ 2 ]. getBuffer (),
image . getWidth (),
image . getHeight (),
planes [ 0 ]. getRowStride (),
planes [ 1 ]. getRowStride (),
planes [ 2 ]. getRowStride (),
planes [ 1 ]. getPixelStride ()
);
assert result . isOK ();
image . close ();
} catch ( final Exception e ) {
e . printStackTrace ();
}
}
};
@ Override
public void onDestroy () {
// DeInitialize the engine
assert UltAlprSdkEngine . deInit (). isOK ();
super . onDestroy ();
}Novamente, verifique os aplicativos de amostra para Android, Raspberry Pi, Linux e Windows e documentação completa para obter mais informações.
O código -fonte vem com aplicativos de amostra nº 2 C ++: Benchmark e reconhecedor. Esses aplicativos de amostra podem ser usados em todas as plataformas suportadas: Android , Windows , Raspberry Pi , iOS , OSX , Linux ...
Este aplicativo é usado para verificar tudo está ok e funcionando tão rápido quanto o esperado. As informações sobre a taxa máxima de quadros ( 237fps no Intel Xeon, 47fps no Snapdragon 855, 152fps no Jetson NX, 64fps no Khadas VIM3, 30fps no Jetson Nano e 12fps no Raspberry Pi 4) podem ser verificados usando esse aplicativo. É de código aberto e não requer chave de registro ou licença.
Para obter mais informações sobre como criar e executar esta amostra, verifique amostras/c ++/benchmark.
Este é um aplicativo de linha de comando usado para detectar e reconhecer uma placa de carteira de qualquer imagem JPEG/PNG/BMP.
Para obter mais informações sobre como construir e executar esta amostra, verifique:
A API C ++ é definida em https://www.doubango.org/sdks/anpr/docs/cpp-api.html.
# include < ultimateALPR-SDK-API-PUBLIC.h > // Include the API header file
// JSON configuration string
// More info at https://www.doubango.org/SDKs/anpr/docs/Configuration_options.html
static const char * __jsonConfig =
" { "
" " debug_level " : " info " , "
" " debug_write_input_image_enabled " : false, "
" " debug_internal_data_path " : " . " , "
" "
" " num_threads " : -1, "
" " gpgpu_enabled " : true, "
" " openvino_enabled " : true, "
" " openvino_device " : " CPU " , "
" "
" " detect_roi " : [0, 0, 0, 0], "
" " detect_minscore " : 0.1, "
" "
" " pyramidal_search_enabled " : true, "
" " pyramidal_search_sensitivity " : 0.28, "
" " pyramidal_search_minscore " : 0.3, "
" " pyramidal_search_min_image_size_inpixels " : 800, "
" "
" " klass_lpci_enabled " : true, "
" " klass_vcr_enabled " : true, "
" " klass_vmm_enabled " : true, "
" "
" " recogn_minscore " : 0.3, "
" " recogn_score_type " : " min " "
" } " ;
// Local variable
UltAlprSdkResult result;
// Initialize the engine (should be done once)
ULTALPR_SDK_ASSERT ((result = UltAlprSdkEngine::init(
__jsonConfig
)).isOK());
// Processing (detection + recognition)
// Call this function for every video frame
const void * imageData = nullptr ;
ULTALPR_SDK_ASSERT ((result = UltAlprSdkEngine::process(
ULTMICR_SDK_IMAGE_TYPE_RGB24,
imageData,
imageWidth,
imageHeight
)).isOK());
// DeInit
// Call this function before exiting the app to free the allocate resources
// You must not call process() after calling this function
ULTALPR_SDK_ASSERT ((result = UltAlprSdkEngine::deInit()).isOK());Novamente, verifique os aplicativos de amostra para obter mais informações sobre como usar a API.
Verifique nosso grupo de discussão ou conta do Twitter
