ultimateALPR SDK
1.0.0
Commencer
Androïde
Raspberry Pi (Raspbian OS), Linux, Nvidia Jetson, Windows et autres
Obtenir de l'aide
Demo Web en ligne sur https://www.doubango.org/webapps/alpr/
Documentation complète pour le SDK à https://www.doubango.org/sdks/anpr/docs/
Langues prises en charge (API): C ++ , C # , Java et Python
Bibliothèque de vision de l'ordinateur open source: https://github.com/doubangotelecom/compv
Mots-clés: 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) et Vehicle Speed Estimation (VSE)
Avez-vous déjà vu un moteur ANPR / ALPR basé sur l'apprentissage en profondeur (numéro automatique / reconnaissance de plaque d'immatriculation) fonctionnant à 64 images par seconde sur un dispositif ARM à 99 $ (Khadas VIM3, 720p Résolution vidéo)?
UltimatealPr est l'implémentation ANPR / AlPR la plus rapide que vous trouverez sur le marché. Être rapide est important mais être précis est crucial.
Nous utilisons des techniques d'apprentissage en profondeur de pointe pour offrir une précision et une précision inégalées. En comparaison, il est n ° 33 fois plus rapide qu'OpenAlPR sur Android. (Voir la section Benchmark pour plus d'informations).
Pas besoin de GPU spéciaux ou dédiés, tout s'exécute sur CPU avec des optimisations de néons SIMD , des opérations mathématiques à virgule fixe et un multithreading. Cela ouvre les portes des possibilités de courir entièrement avec ses solutions (Système de transport intelligent) sur une caméra sans solliciter un nuage. Être en mesure d'exécuter toutes ses applications sur l'appareil réduira considérablement le coût pour acquérir, déployer et maintenir ces systèmes. Veuillez vérifier la section de solution basée sur les périphériques et basée sur le cloud pour plus d'informations sur la façon dont cela réduirait le coût.
La vidéo suivante montre l'échantillon de reconnaissance en cours d'exécution sur Windows:
Le code est accéléré sur CPU , GPU , VPU et FPGA , grâce à Cuda, Nvidia Tensorrt et Intel OpenVino.
En plus de la reconnaissance des plaques d'immatriculation (LPR), nous soutenons l'amélioration de l'image pour la vision nocturne (IENV), l'identification du pays de la plaque d'immatriculation (LPCI), la reconnaissance des couleurs des véhicules (VCR), la reconnaissance du modèle de fabrication de véhicules (VMMR), la reconnaissance du style du corps du véhicule (VBSR), le suivi de direction du véhicule (VDT) et l'estimation de la vitesse du véhicule (VSE).
Sur les GPU nvidia haut de gamme comme le Tesla V100, la fréquence d'images est de 315 ips, ce qui signifie 3,17 millisecondes . Sur les CPU haut de gamme comme Intel Xeon, la fréquence d'images maximale pourrait atteindre 237 images par seconde , grâce à OpenVino. Sur les CPU bas de gamme comme le Raspberry Pi 4, la fréquence d'images moyenne est de 12 ips .
Ne vous croyez pas sur parole, venez vérifier notre implémentation. Aucune inscription, clé de licence ou connexion Internet n'est requise , il suffit de cloner le code et de commencer le codage / les tests. Tout s'exécute sur l'appareil, aucune donnée ne quitte votre ordinateur. Le code publié ici est livré avec de nombreux échantillons prêts à l'emploi pour Android, Raspberry Pi, Linux et Windows pour vous aider à démarrer facilement.
Vous pouvez également consulter notre implémentation en ligne basée sur le cloud ( aucune inscription requise ) pour consulter l'exactitude et la précision avant de commencer à jouer avec le SDK.
Veuillez vérifier la documentation complète sur https://www.doubango.org/sdks/anpr/docs/
Le SDK fonctionne sur de nombreuses plates-formes et est livré avec la prise en charge de nombreux langages de programmation, mais les sections suivantes se concentrent sur Android, Raspberry Pi, Linux et Windows.
Les sections suivantes concernent l'API Android et Java.
Le code source est livré avec des exemples d'Android Applications # 4: Benchmark, VideoParallel, Videosquential et ImagesNap.
Cette application est utilisée pour vérifier que tout est correct et fonctionne aussi vite que prévu. Les informations sur la fréquence d'images maximale ( 237fps sur Intel Xeon, 64FPS sur Khadas VIM3 et 12FPS sur Raspberry Pi 4) ont pu être vérifiée à l'aide de cette application. Il est open source et ne nécessite pas d'enregistrement ou de clé de licence.
Cette application doit être utilisée comme code de référence par tout développeur essayant d'ajouter UltimatealPr à leurs produits. Il montre comment détecter et reconnaître les plaques d'immatriculation en temps réel à l'aide de flux vidéo en direct à partir de l'appareil photo. Veuillez vérifier la section de traitement parallèle versus séquentielle pour plus d'informations sur le mode Parellel.
Identique à VideoParallel mais à travailler sur un mode séquentiel, ce qui signifie plus lent. Cette application est fournie pour faciliter la comparaison des modes: parallèle versus séquentiel.
Cette application lit et affiche le flux vidéo en direct de l'appareil photo mais ne reconnaît qu'une image du flux à la demande.
Pour essayer les exemples d'applications sur Android:
Ouvrez Android Studio et sélectionnez "Ouvrir un projet Android Studio existant"
Accédez à Ultimatealpr-SDK / Samples , sélectionnez le dossier Android et cliquez sur OK
Sélectionnez l'échantillon que vous souhaitez essayer (par exemple VideoParallel ) et appuyez sur Run . Assurez-vous d'avoir l'appareil en mode paysage pour une meilleure expérience.
Le SDK est distribué sous forme de module Android Studio et vous pouvez l'ajouter en tant que référence ou vous pouvez également le construire et ajouter l'AAR à votre projet. Mais, le moyen le plus simple d'ajouter le SDK à votre projet est d'inclure directement la source.
Dans votre fichier build.gradle, ajoutez:
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' ]
}
}
}Il est difficile d'être perdu lorsque vous essayez d'utiliser l'API car il n'y a que 3 fonctions utiles: init, processus et déinit.
L'API C ++ est définie ici.
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 ();
}Encore une fois, veuillez vérifier les exemples d'applications pour Android, Raspberry Pi, Linux et Windows et la documentation complète pour plus d'informations.
Le code source est livré avec des exemples d'applications C ++ # 2: Benchmark et Reconnaître. Ces exemples d'applications peuvent être utilisées sur toutes les plates-formes prises en charge: Android , Windows , Raspberry Pi , iOS , OSX , Linux ...
Cette application est utilisée pour vérifier que tout est correct et fonctionne aussi vite que prévu. Les informations sur la fréquence d'images maximale ( 237fps sur Intel Xeon, 47fps sur Snapdragon 855, 152FPS sur Jetson NX, 64FPS sur Khadas VIM3, 30FPS sur Jetson Nano et 12FPS sur Raspberry PI 4) ont pu être vérifiées en utilisant cette application. Il est open source et ne nécessite pas d'enregistrement ou de clé de licence.
Pour plus d'informations sur la façon de créer et d'exécuter cet échantillon, veuillez vérifier les échantillons / C ++ / Benchmark.
Il s'agit d'une application de ligne de commande utilisée pour détecter et reconnaître une plaque d'immatriculation à partir de toute image JPEG / PNG / BMP.
Pour plus d'informations sur la façon de créer et d'exécuter cet échantillon, veuillez vérifier:
L'API C ++ est définie sur 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());Encore une fois, veuillez vérifier les exemples de demandes pour plus d'informations sur la façon d'utiliser l'API.
Veuillez consulter notre groupe de discussion ou notre compte Twitter
