Vous pouvez utiliser ML Kit pour reconnaître du texte dans des images ou des vidéos, comme le texte d'un un panneau de signalisation. Voici les principales caractéristiques de cette fonctionnalité:
<ph type="x-smartling-placeholder">Fonctionnalité | Sans catégorie | Groupée |
---|---|---|
Nom de la bibliothèque | com.google.android.gms:play-services-mlkit-text-recognition
com.google.android.gms:play-services-mlkit-text-recognition-chinese com.google.android.gms:play-services-mlkit-text-recognition-devanagari com.google.android.gms:play-services-mlkit-text-recognition-japanese com.google.android.gms:play-services-mlkit-text-recognition-korean |
com.google.mlkit:text-recognition
com.google.mlkit:text-recognition-chinese com.google.mlkit:text-recognition-devanagari com.google.mlkit:text-recognition-japanese com.google.mlkit:text-recognition-korean |
Implémentation | Le modèle est téléchargé de manière dynamique via les services Google Play. | Le modèle est associé de manière statique à votre application au moment de la compilation. |
Taille de l'application | Augmentation de la taille d'environ 260 Ko par architecture de script | Augmentation d'environ 4 Mo de la taille par script et par architecture |
Délai d'initialisation | Vous devrez peut-être attendre que le modèle soit téléchargé avant de l'utiliser pour la première fois. | Le modèle est disponible immédiatement. |
Performances | Bibliothèque de script latin en temps réel sur la plupart des appareils, plus lente sur d'autres. | En temps réel sur la plupart des appareils pour la bibliothèque de scripts latins, plus lent pour les autres. |
Essayer
- Testez l'application exemple pour : consultez un exemple d'utilisation de cette API.
- Essayez vous-même le code avec le atelier de programmation.
Avant de commencer
<ph type="x-smartling-placeholder">- Dans le fichier
build.gradle
au niveau du projet, veillez à inclure le dépôt Maven de Google à la fois dans vos sectionsbuildscript
etallprojects
. Ajoutez les dépendances des bibliothèques Android ML Kit au fichier Gradle au niveau de l'application de votre module, qui est généralement
app/build.gradle
:Pour regrouper le modèle avec votre application:
dependencies { // To recognize Latin script implementation 'com.google.mlkit:text-recognition:16.0.1' // To recognize Chinese script implementation 'com.google.mlkit:text-recognition-chinese:16.0.1' // To recognize Devanagari script implementation 'com.google.mlkit:text-recognition-devanagari:16.0.1' // To recognize Japanese script implementation 'com.google.mlkit:text-recognition-japanese:16.0.1' // To recognize Korean script implementation 'com.google.mlkit:text-recognition-korean:16.0.1' }
Pour utiliser le modèle dans les services Google Play:
dependencies { // To recognize Latin script implementation 'com.google.android.gms:play-services-mlkit-text-recognition:19.0.1' // To recognize Chinese script implementation 'com.google.android.gms:play-services-mlkit-text-recognition-chinese:16.0.1' // To recognize Devanagari script implementation 'com.google.android.gms:play-services-mlkit-text-recognition-devanagari:16.0.1' // To recognize Japanese script implementation 'com.google.android.gms:play-services-mlkit-text-recognition-japanese:16.0.1' // To recognize Korean script implementation 'com.google.android.gms:play-services-mlkit-text-recognition-korean:16.0.1' }
Si vous choisissez d'utiliser le modèle dans les services Google Play, vous pouvez configurer votre application pour qu'elle télécharge automatiquement le modèle sur l'appareil après votre application est installée depuis le Play Store. Pour ce faire, ajoutez ce qui suit : dans le fichier
AndroidManifest.xml
de votre application:<application ...> ... <meta-data android:name="com.google.mlkit.vision.DEPENDENCIES" android:value="ocr" > <!-- To use multiple models: android:value="ocr,ocr_chinese,ocr_devanagari,ocr_japanese,ocr_korean,..." --> </application>
Vous pouvez aussi vérifier explicitement la disponibilité du modèle et demander un téléchargement via l'API ModuleInstallClient des services Google Play. Si vous n'activez pas le modèle au moment de l'installation ou demander un téléchargement explicite, le modèle est téléchargé en premier chaque fois que vous exécutez l'outil d'analyse. Les demandes que vous envoyez avant la date de terminée ne produit aucun résultat.
1. Créer une instance de TextRecognizer
Créer une instance de TextRecognizer
en transmettant les options
en lien avec la bibliothèque pour laquelle vous avez déclaré une dépendance ci-dessus:
Kotlin
// When using Latin script library val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS) // When using Chinese script library val recognizer = TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build()) // When using Devanagari script library val recognizer = TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build()) // When using Japanese script library val recognizer = TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build()) // When using Korean script library val recognizer = TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
Java
// When using Latin script library TextRecognizer recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS); // When using Chinese script library TextRecognizer recognizer = TextRecognition.getClient(new ChineseTextRecognizerOptions.Builder().build()); // When using Devanagari script library TextRecognizer recognizer = TextRecognition.getClient(new DevanagariTextRecognizerOptions.Builder().build()); // When using Japanese script library TextRecognizer recognizer = TextRecognition.getClient(new JapaneseTextRecognizerOptions.Builder().build()); // When using Korean script library TextRecognizer recognizer = TextRecognition.getClient(new KoreanTextRecognizerOptions.Builder().build());
2. Préparer l'image d'entrée
Pour reconnaître du texte dans une image, créez un objet InputImage
à partir de
soit un tableau Bitmap
, media.Image
, ByteBuffer
, un tableau d'octets, soit un fichier sur le
appareil. Ensuite, transmettez l'objet InputImage
à la
la méthode processImage
de TextRecognizer
.
Vous pouvez créer un InputImage
de différentes sources. Chacune d'elles est expliquée ci-dessous.
Utiliser un media.Image
Pour créer un InputImage
à partir d'un objet media.Image
, par exemple lorsque vous capturez une image à partir d'un
l'appareil photo de l'appareil, transmettez l'objet media.Image
et l'image
la rotation sur InputImage.fromMediaImage()
.
Si vous utilisez les
<ph type="x-smartling-placeholder"></ph>
la bibliothèque CameraX, les OnImageCapturedListener
et
Les classes ImageAnalysis.Analyzer
calculent la valeur de rotation
pour vous.
Kotlin
private class YourImageAnalyzer : ImageAnalysis.Analyzer { override fun analyze(imageProxy: ImageProxy) { val mediaImage = imageProxy.image if (mediaImage != null) { val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees) // Pass image to an ML Kit Vision API // ... } } }
Java
private class YourAnalyzer implements ImageAnalysis.Analyzer { @Override public void analyze(ImageProxy imageProxy) { Image mediaImage = imageProxy.getImage(); if (mediaImage != null) { InputImage image = InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees()); // Pass image to an ML Kit Vision API // ... } } }
Si vous n'utilisez pas de bibliothèque d'appareils photo qui indique le degré de rotation de l'image, le calcul à partir du degré de rotation de l'appareil et de l'orientation de la caméra capteur de l'appareil:
Kotlin
private val ORIENTATIONS = SparseIntArray() init { ORIENTATIONS.append(Surface.ROTATION_0, 0) ORIENTATIONS.append(Surface.ROTATION_90, 90) ORIENTATIONS.append(Surface.ROTATION_180, 180) ORIENTATIONS.append(Surface.ROTATION_270, 270) } /** * Get the angle by which an image must be rotated given the device's current * orientation. */ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) @Throws(CameraAccessException::class) private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int { // Get the device's current rotation relative to its "native" orientation. // Then, from the ORIENTATIONS table, look up the angle the image must be // rotated to compensate for the device's rotation. val deviceRotation = activity.windowManager.defaultDisplay.rotation var rotationCompensation = ORIENTATIONS.get(deviceRotation) // Get the device's sensor orientation. val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager val sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION)!! if (isFrontFacing) { rotationCompensation = (sensorOrientation + rotationCompensation) % 360 } else { // back-facing rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360 } return rotationCompensation }
Java
private static final SparseIntArray ORIENTATIONS = new SparseIntArray(); static { ORIENTATIONS.append(Surface.ROTATION_0, 0); ORIENTATIONS.append(Surface.ROTATION_90, 90); ORIENTATIONS.append(Surface.ROTATION_180, 180); ORIENTATIONS.append(Surface.ROTATION_270, 270); } /** * Get the angle by which an image must be rotated given the device's current * orientation. */ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing) throws CameraAccessException { // Get the device's current rotation relative to its "native" orientation. // Then, from the ORIENTATIONS table, look up the angle the image must be // rotated to compensate for the device's rotation. int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation(); int rotationCompensation = ORIENTATIONS.get(deviceRotation); // Get the device's sensor orientation. CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE); int sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION); if (isFrontFacing) { rotationCompensation = (sensorOrientation + rotationCompensation) % 360; } else { // back-facing rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360; } return rotationCompensation; }
Ensuite, transmettez l'objet media.Image
et
valeur du degré de rotation sur InputImage.fromMediaImage()
:
Kotlin
val image = InputImage.fromMediaImage(mediaImage, rotation)
Java
InputImage image = InputImage.fromMediaImage(mediaImage, rotation);
Utiliser un URI de fichier
Pour créer un InputImage
à partir d'un URI de fichier, transmettez le contexte de l'application et l'URI du fichier à
InputImage.fromFilePath()
Cela est utile lorsque vous
Utiliser un intent ACTION_GET_CONTENT
pour inviter l'utilisateur à sélectionner
une image de son application Galerie.
Kotlin
val image: InputImage try { image = InputImage.fromFilePath(context, uri) } catch (e: IOException) { e.printStackTrace() }
Java
InputImage image; try { image = InputImage.fromFilePath(context, uri); } catch (IOException e) { e.printStackTrace(); }
Utiliser un ByteBuffer
ou un ByteArray
Pour créer un InputImage
d'un objet ByteBuffer
ou ByteArray
, calculez d'abord l'image
degré de rotation décrit précédemment pour l'entrée media.Image
.
Créez ensuite l'objet InputImage
avec le tampon ou le tableau, ainsi que l'objet image
la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation:
Kotlin
val image = InputImage.fromByteBuffer( byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ) // Or: val image = InputImage.fromByteArray( byteArray, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 )
Java
InputImage image = InputImage.fromByteBuffer(byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ); // Or: InputImage image = InputImage.fromByteArray( byteArray, /* image width */480, /* image height */360, rotation, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 );
Utiliser un Bitmap
Pour créer un InputImage
à partir d'un objet Bitmap
, effectuez la déclaration suivante:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
L'image est représentée par un objet Bitmap
associé à des degrés de rotation.
3. Traiter l'image
Transmettez l'image à la méthode process
:
Kotlin
val result = recognizer.process(image) .addOnSuccessListener { visionText -> // Task completed successfully // ... } .addOnFailureListener { e -> // Task failed with an exception // ... }
Java
Task<Text> result = recognizer.process(image) .addOnSuccessListener(new OnSuccessListener<Text>() { @Override public void onSuccess(Text visionText) { // Task completed successfully // ... } }) .addOnFailureListener( new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
4. Extraire le texte de blocs de texte reconnu
Si l'opération de reconnaissance de texte réussit, un objet Text
est transmis à
l'écouteur de réussite. Un objet Text
contient le texte complet reconnu dans
l'image et zéro, un ou plusieurs objets TextBlock
.
Chaque TextBlock
représente un bloc de texte rectangulaire,
qui contient zéro, un ou plusieurs objets Line
. Chaque
L'objet Line
représente une ligne de texte contenant zéro
ou plusieurs objets Element
. Chaque Element
représente un mot ou une entité de type mot, qui contient zéro ou plusieurs
Objets Symbol
. Chaque Symbol
représente un caractère, un chiffre ou une entité de type mot.
Pour chaque TextBlock
, Line
,
Element
et Symbol
, vous
peut faire reconnaître le texte dans la région, les coordonnées de délimitation
région et de nombreux autres attributs tels que les informations de rotation, le score de confiance
etc.
Exemple :
Kotlin
val resultText = result.text for (block in result.textBlocks) { val blockText = block.text val blockCornerPoints = block.cornerPoints val blockFrame = block.boundingBox for (line in block.lines) { val lineText = line.text val lineCornerPoints = line.cornerPoints val lineFrame = line.boundingBox for (element in line.elements) { val elementText = element.text val elementCornerPoints = element.cornerPoints val elementFrame = element.boundingBox } } }
Java
String resultText = result.getText(); for (Text.TextBlock block : result.getTextBlocks()) { String blockText = block.getText(); Point[] blockCornerPoints = block.getCornerPoints(); Rect blockFrame = block.getBoundingBox(); for (Text.Line line : block.getLines()) { String lineText = line.getText(); Point[] lineCornerPoints = line.getCornerPoints(); Rect lineFrame = line.getBoundingBox(); for (Text.Element element : line.getElements()) { String elementText = element.getText(); Point[] elementCornerPoints = element.getCornerPoints(); Rect elementFrame = element.getBoundingBox(); for (Text.Symbol symbol : element.getSymbols()) { String symbolText = symbol.getText(); Point[] symbolCornerPoints = symbol.getCornerPoints(); Rect symbolFrame = symbol.getBoundingBox(); } } } }
Consignes pour les images d'entrée
-
Pour que ML Kit reconnaisse le texte avec précision, les images d'entrée doivent contenir du texte représenté par suffisamment de données de pixels. Dans l’idéal, chaque caractère doit faire au moins 16 x 16 pixels. Il n'y a généralement pas moins de précision pour les caractères supérieurs à 24 x 24 pixels.
Par exemple, une image de 640 x 480 pixels peut convenir pour numériser une carte de visite. qui occupe toute la largeur de l'image. Pour numériser un document imprimé sur de papier au format lettre, une image de 720 x 1 280 pixels peut être nécessaire.
-
Une mise au point médiocre de l'image peut nuire à la précision de la reconnaissance du texte. Si vous n'êtes pas obtenir des résultats acceptables, essayez de demander à l'utilisateur de reprendre l'image.
-
Si vous reconnaissez du texte dans une application en temps réel, vous devez tenir compte des dimensions globales des images d'entrée. Plus petite les images peuvent être traitées plus rapidement. Pour réduire la latence, assurez-vous que le texte occupe une grande partie de l'image que possible, et capturez des images à des résolutions inférieures (en gardant à l'esprit la précision exigences mentionnées ci-dessus). Pour en savoir plus, consultez Conseils pour améliorer les performances
Conseils pour améliorer les performances
- Si vous utilisez les
Camera
ou APIcamera2
limiter les appels au détecteur. Si une nouvelle vidéo devient disponible pendant l'exécution du détecteur, supprimez la trame. Consultez le <ph type="x-smartling-placeholder"></ph>VisionProcessorBase
de l'application exemple de démarrage rapide. - Si vous utilisez l'API
CameraX
, Assurez-vous que la stratégie de contre-pression est définie sur sa valeur par défaut <ph type="x-smartling-placeholder"></ph>ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
Cela garantit qu'une seule image à la fois sera envoyée pour analyse. Si davantage d'images sont générées lorsque l'analyseur est occupé, elles sont automatiquement abandonnées et ne sont pas mises en file d'attente la livraison. Une fois que l'image en cours d'analyse est fermée en appelant ImageProxy.close(), l'image suivante la plus récente sera diffusée. - Si vous utilisez la sortie du détecteur pour superposer des graphiques sur
l'image d'entrée, récupérez d'abord le résultat à partir de ML Kit, puis effectuez le rendu de l'image.
et les superposer en une seule étape. Le rendu à la surface d'affichage
une seule fois pour chaque
trame d'entrée. Consultez le
<ph type="x-smartling-placeholder"></ph>
CameraSourcePreview
et <ph type="x-smartling-placeholder"></ph>GraphicOverlay
de l'application exemple de démarrage rapide. - Si vous utilisez l'API Camera2, capturez des images
Format
ImageFormat.YUV_420_888
. Si vous utilisez l'ancienne API Camera, capturez les images FormatImageFormat.NV21
. - Envisagez de capturer des images à une résolution plus faible. Cependant, gardez aussi à l'esprit aux exigences de cette API concernant les dimensions de l'image.