ultimateALPR SDK
1.0.0
Empezando
Androide
Raspberry Pi (Raspbian OS), Linux, Nvidia Jetson, Windows y otros
Obtener ayuda
Demostración web en línea en https://www.doubango.org/webapps/alpr/
Documentación completa para el SDK en https://www.doubango.org/sdks/anpr/docs/
Lenguas compatibles (API): C ++ , C# , Java y Python
Open Source Computer Vision Library: https://github.com/doubangotelecom/compv
Palabras clave: 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) y Vehicle Speed Estimation (VSE)
¿Alguna vez ha visto un motor ANPR/ALPR basado en el aprendizaje profundo (número automático/reconocimiento de matrícula) que se ejecuta a 64 fps en un dispositivo ARM de $ 99 (Khadas VIM3, resolución de video 720p)?
UltimatealPR es la implementación ANPR/ALPR más rápida que encontrará en el mercado. Ser rápido es importante, pero ser preciso es crucial.
Utilizamos técnicas de aprendizaje profundo de última generación para ofrecer precisión y precisión inigualables. Como comparación, esto es #33 veces más rápido que OpenAlpr en Android. (Consulte la sección de referencia para obtener más información).
No hay necesidad de GPU especiales o dedicadas, todo se ejecuta en CPU con optimizaciones de neón SIMD ARM , operaciones matemáticas de puntos fijos y lectura múltiple. Esto abre las puertas para las posibilidades de ejecutar completamente sus soluciones (sistema de transporte inteligente) en una cámara sin solicitar una nube. Poder ejecutar todas sus aplicaciones en el dispositivo reducirá significativamente el costo de adquirir, implementar y mantener dichos sistemas. Verifique la sección de soluciones basada en dispositivos versus basada en la nube para obtener más información sobre cómo esto reduciría el costo.
El siguiente video muestra la muestra de reconocimiento que se ejecuta en Windows:
El código se acelera en CPU , GPU , VPU y FPGA , gracias a Cuda, Nvidia Tensorrt e Intel Openvino.
Además del reconocimiento de matrícula (LPR), apoyamos la mejora de la imagen para la visión nocturna (IENV), la identificación del país de la matrícula (LPCI), el reconocimiento del color del vehículo (VCR), el reconocimiento del modelo (VMMR), el reconocimiento del estilo del cuerpo del vehículo (VBSR), el seguimiento de la dirección del vehículo (VDT) y la estimación de la velocidad del vehículo (VSE).
En las GPU de NVIDIA de alta gama, como las Tesla V100, la velocidad de cuadros es de 315 fps, lo que significa 3.17 milisegundos de tiempo de inferencia . En las CPU de alta gama como Intel Xeon, la velocidad de cuadro máxima podría ser de hasta 237 fps , gracias a OpenVino. En las CPU de gama baja como la Raspberry Pi 4, la velocidad de cuadro promedio es de 12 fps .
No tome nuestra palabra, ven a verificar nuestra implementación. No se requiere registro, clave de licencia o conexión a Internet , simplemente clone el código y comience a codificar/pruebas. Todo se ejecuta en el dispositivo, no hay datos dejando su computadora. El código publicado aquí viene con muchas muestras listas para usar para Android, Raspberry Pi, Linux y Windows para ayudarlo a comenzar fácilmente.
También puede consultar nuestra implementación basada en la nube en línea ( no se requiere registro ) para verificar la precisión y la precisión antes de comenzar a jugar con el SDK.
Consulte la documentación completa en https://www.doubango.org/sdks/anpr/docs/
El SDK funciona en muchas plataformas y viene con soporte para muchos lenguajes de programación, pero las siguientes secciones se centran en Android, Raspberry Pi, Linux y Windows.
Las siguientes secciones son sobre Android y Java API.
El código fuente viene con aplicaciones de muestra #4 de Android: Benchmark, VideoParallel, VideSequential e ImageNap.
Esta aplicación se usa para verificar que todo esté bien y funcionando tan rápido como se esperaba. La información sobre la velocidad de cuadro máxima ( 237 fps en Intel Xeon, 64 fps en Khadas VIM3 y 12 fps en Raspberry Pi 4) podría verificarse utilizando esta aplicación. Es de código abierto y no requiere registro o clave de licencia.
Esta aplicación debe ser utilizada como código de referencia por cualquier desarrollador que intente agregar ultimateRealPR a sus productos. Muestra cómo detectar y reconocer las placas en tiempo real utilizando la transmisión de video en vivo desde la cámara. Consulte la sección de procesamiento paralelo versus secuencial para obtener más información sobre el modo parelel.
Igual que VideoParalelo pero trabajando en modo secuencial, lo que significa más lento. Esta aplicación se proporciona para aliviar la comparación de los modos: paralelo versus secuencial.
Esta aplicación lee y muestra la transmisión de video en vivo desde la cámara, pero solo reconoce una imagen de la transmisión a pedido.
Para probar las aplicaciones de muestra en Android:
Abra Android Studio y seleccione "Abra un proyecto de estudio Android existente"
Navegue a UltimatealPr-SDK/Muestras , seleccione la carpeta Android y haga clic en Aceptar
Seleccione la muestra que desea probar (por ejemplo, VideoParAllel ) y presione Run . Asegúrese de tener el dispositivo en modo de paisaje para una mejor experiencia.
El SDK se distribuye como un módulo de estudio Android y puede agregarlo como referencia o también puede construirlo y agregar el AAR a su proyecto. Pero, la forma más fácil de agregar el SDK a su proyecto es incluir directamente la fuente.
En su archivo build.gradle agregue:
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' ]
}
}
}Es difícil perderse cuando intenta usar la API, ya que solo hay 3 funciones útiles: init, proceso y deinit.
La API C ++ se define aquí.
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 ();
}Nuevamente, consulte las aplicaciones de muestra para Android, Raspberry Pi, Linux y Windows y documentación completa para obtener más información.
El código fuente viene con aplicaciones de muestra #2 C ++: Benchmark and Reconconator. Estas aplicaciones de muestra se pueden usar en todas las plataformas compatibles: Android , Windows , Raspberry PI , iOS , OSX , Linux ...
Esta aplicación se usa para verificar que todo esté bien y funcionando tan rápido como se esperaba. La información sobre la velocidad de cuadro máxima ( 237 fps en Intel Xeon, 47 fps en Snapdragon 855, 152 fps en Jetson NX, 64 fps en Khadas VIM3, 30 fps en Jetson Nano y 12 fps en Raspberry Pi 4) podrían verificarse utilizando esta aplicación. Es de código abierto y no requiere registro o clave de licencia.
Para obtener más información sobre cómo construir y ejecutar esta muestra, verifique las muestras/C ++/Benchmark.
Esta es una aplicación de línea de comando utilizada para detectar y reconocer una placa de cualquier imagen JPEG/PNG/BMP.
Para obtener más información sobre cómo construir y ejecutar esta muestra, verifique:
La API C ++ se define en 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());Nuevamente, consulte las aplicaciones de muestra para obtener más información sobre cómo usar la API.
Consulte nuestro grupo de discusión o cuenta de Twitter
