ultimateALPR SDK
1.0.0
Erste Schritte
Android
Raspberry Pi (Raspbian OS), Linux, Nvidia Jetson, Windows und andere
Hilfe bekommen
Online -Web -Demo unter https://www.doubango.org/webapps/alpr/
Vollständige Dokumentation für den SDK unter https://www.doubango.org/sdks/anpr/docs/
Unterstützte Sprachen (API): C ++ , C# , Java und Python
Open Source Computer Vision Library: https://github.com/doubangotelecom/compvvvvvvvvv
Schlüsselwörter: 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) Vehicle Speed Estimation (VSE)
Haben Sie jemals einen tief lernbasierten ANPR/ALPR (Automatic Number Number/Nummern Plate Recognition) gesehen, der mit 64 fps auf einem Armgerät von 99 US -Dollar (Khadas VIM3, 720p Videoauflösung) ausgeführt wird?
UltimateAlPR ist die schnellste ANPR/ALPR -Implementierung, die Sie auf dem Markt finden. Schnell zu sein ist wichtig, aber genau zu sein ist entscheidend.
Wir verwenden hochmoderne Deep -Learning -Techniken, um unübertroffene Genauigkeit und Präzision zu bieten. Zum Vergleich ist dies #33 -mal schneller als OpenAlPR auf Android. (Weitere Informationen finden Sie unter Benchmark -Abschnitt).
Keine Notwendigkeit für spezielle oder dedizierte GPUs, alles läuft auf CPU mit SIMD-Arm-Neonoptimierungen , Festpunktmathematikoperationen und Multithreading. Dies öffnet die Türen für die Möglichkeiten, voll ausgestattet zu sein, um seine Lösungen (intelligentes Transportsystem) auf einer Kamera zu leisten, ohne eine Cloud zu bitten. Wenn Sie alle Anwendungen auf dem Gerät ausführen können , wird die Kosten für den Erwerb, die Bereitstellung und die Wartung solcher Systeme erheblich senken . Bitte überprüfen Sie den Abschnitt "Gerätebasierter gegen Cloud-basierte Lösung", um weitere Informationen dazu zu erhalten, wie dies die Kosten senken würde.
Das nächste Video zeigt das unter Windows ausgeführte Erkenner -Beispiel:
Der Code wird dank CPU , GPU , VPU und FPGA dank Cuda, Nvidia Tensorrt und Intel OpenVino beschleunigt.
Zusätzlich zur Kennzeichenerkennung (LPR) unterstützen wir die Bildverbesserung für die Nachtsicht (IENV), die Identifizierung von Nummernschildern (LPCI), die Fahrzeugfarberkennung (VCR), das Fahrzeug machen die Modellerkennung (VMMR), die Erkennung von Fahrzeugkörperstilen (VBSR), die Fahrzeugrichtungsverfolgung (VDT) und die Schätzung der Fahrzeuggeschwindigkeit (VSE).
Bei High-End-Nvidia-GPUs wie dem Tesla V100 beträgt die Bildrate 315 fps, was 3,17 Millisekunden-Inferenzzeit bedeutet . Bei High-End-CPUs wie Intel Xeon könnte die maximale Bildrate dank OpenVino bis zu 237 fps betragen . Bei Low-End-CPUs wie dem Raspberry PI 4 beträgt die durchschnittliche Bildrate 12 fps .
Nehmen Sie unser Wort nicht dafür, überprüfen Sie unsere Implementierung. Es ist keine Registrierung, Lizenzschlüssel oder Internetverbindung erforderlich . Klonen Sie einfach den Code und beginnen Sie mit dem Codieren/Tests. Alles läuft auf dem Gerät, keine Daten verlassen Ihren Computer. Der hier veröffentlichte Code enthält viele herrliche Muster für Android, Raspberry Pi, Linux und Windows, damit Sie einfach loslegen können.
Sie können auch unsere Online-Cloud-basierte Implementierung ( keine Registrierung erforderlich ) überprüfen, um die Genauigkeit und Präzision zu überprüfen, bevor Sie mit dem SDK spielen.
Bitte überprüfen Sie die vollständige Dokumentation unter https://www.doubango.org/sdks/anpr/docs/
Das SDK arbeitet auf vielen Plattformen und unterstützt viele Programmiersprachen, aber die nächsten Abschnitte konzentrieren sich auf Android, Raspberry Pi, Linux und Windows.
In den nächsten Abschnitten geht es um Android und Java API.
Der Quellcode verfügt über #4 Android -Beispielanwendungen: Benchmark, Videoparallel, Videosequential und ImagesNap.
Diese Anwendung wird verwendet, um zu überprüfen, ob alles in Ordnung ist und so schnell wie erwartet ausgeführt wird. Die Informationen über die maximale Bildrate ( 237 fps auf Intel Xeon, 64 fps auf Khadas vim3 und 12 fps auf Raspberry Pi 4) könnten mit dieser Anwendung überprüft werden. Es ist Open Source und erfordert keinen Registrier- oder Lizenzschlüssel.
Diese Anwendung sollte von jedem Entwickler als Referenzcode verwendet werden, der versucht, ihren Produkten UltimatealPR hinzuzufügen. Es zeigt, wie Nummernschilder in Echtzeit mit Live -Video -Stream von der Kamera erkannt und erkannt werden. Weitere Informationen zum Parallel -Modus finden Sie im Abschnitt "Parallel versus sequentieller Verarbeitung".
Gleich wie Videoparallel, aber im sequentiellen Modus arbeiten, was langsamer bedeutet. Diese Anwendung wird bereitgestellt, um die Vergleich der Modi zu erleichtern: parallel versus sequentiell.
Diese Anwendung liest und zeigt den Live -Video -Stream von der Kamera an und erkennt nur ein Bild aus dem Stream on Demand.
Um die Beispielanwendungen auf Android auszuprobieren:
Öffnen Sie Android Studio und wählen Sie "Eröffnen Sie ein vorhandenes Android Studio -Projekt".
Navigieren Sie zu Ultimatealpr-SDK/Proben , wählen Sie Android- Ordner und klicken Sie auf OK
Wählen Sie das Beispiel aus, das Sie ausprobieren möchten (z. B. Videoparallel ) und drücken Sie Run . Stellen Sie sicher, dass das Gerät im Landschaftsmodus eine bessere Erfahrung hat.
Das SDK wird als Android Studio -Modul verteilt und Sie können es als Referenz hinzufügen oder Sie können es auch erstellen und den AAR zu Ihrem Projekt hinzufügen. Der einfachste Weg, das SDK zu Ihrem Projekt hinzuzufügen, besteht darin, direkt die Quelle direkt einzubeziehen.
In Ihrem Build.gradle -Datei fügen Sie hinzu:
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 ist schwierig, verloren zu sein, wenn Sie versuchen, die API zu verwenden, da es nur 3 nützliche Funktionen gibt: init, prozess und deinit.
Die C ++ - API ist hier definiert.
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 ();
}Weitere Informationen für Android, Raspberry Pi, Linux und Windows sowie die vollständige Dokumentation finden Sie in den Beispielanwendungen für Android, Raspberry Pi, Linux und Windows, um weitere Informationen zu erhalten.
Der Quellcode wird mit #2 C ++ Beispielanwendungen ausgestattet: Benchmark und Erkenntnis. Diese Beispielanwendungen können auf allen unterstützten Plattformen verwendet werden: Android , Windows , Raspberry Pi , iOS , OSX , Linux ...
Diese Anwendung wird verwendet, um zu überprüfen, ob alles in Ordnung ist und so schnell wie erwartet ausgeführt wird. Die Informationen über die maximale Bildrate ( 237fps auf Intel Xeon, 47fps auf Snapdragon 855, 152fps auf Jetson NX, 64 fps auf Khadas VIM3, 30fps auf Jetson Nano und 12 FPS auf Raspberry Pi 4) konnten mit dieser Anwendung überprüft werden. Es ist Open Source und erfordert keinen Registrier- oder Lizenzschlüssel.
Weitere Informationen zum Erstellen und Ausführen dieses Beispiels finden Sie unter die Proben/C ++/Benchmark.
Dies ist eine Befehlszeilenanwendung, die zum Erkennen und Erkennen eines Nummernschilds von jedem JPEG/PNG/BMP -Bild verwendet wird.
Weitere Informationen zum Erstellen und Ausführen dieses Beispiels finden Sie unter:
Die C ++-API ist unter https://www.doubango.org/sdks/anpr/docs/cpp-api.html definiert.
# 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());Weitere Informationen zur Verwendung der API finden Sie erneut mit den Beispielanwendungen.
Bitte überprüfen Sie unsere Diskussionsgruppe oder unser Twitter -Konto
