Riconoscere il testo nelle immagini con ML Kit su Android

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Puoi utilizzare ML Kit per riconoscere il testo nelle immagini o nei video, ad esempio il testo di un cartello stradale. Le caratteristiche principali di questa funzionalità sono:

API di riconoscimento del testo
DescrizioneRiconosci il testo in latino in immagini o video.
Nome libreriacom.google.android.gms:play-services-mlkit-text-recognition
ImplementazioneLa raccolta viene scaricata dinamicamente tramite Google Play Services.
Impatto sulle dimensioni dell'app260 kB
Tempo di inizializzazionePotrebbe essere necessario attendere il download della raccolta prima del primo utilizzo.
PrestazioniIn tempo reale sulla maggior parte dei dispositivi.

Prova subito

Prima di iniziare

  1. Nel file build.gradle a livello di progetto, assicurati di includere il repository Maven di Google nelle sezioni buildscript e allprojects.
  2. Aggiungi le dipendenze per le librerie Android di ML Kit al file gradle a livello di app del tuo modulo, che in genere è app/build.gradle: 
    dependencies {
  // ...

  implementation 'com.google.android.gms:play-services-mlkit-text-recognition:18.0.2'
}

  3. Facoltativo ma consigliato: puoi configurare la tua app in modo che scarichi automaticamente il modello di machine learning sul dispositivo dopo l'installazione del Play Store. Per farlo, aggiungi la seguente dichiarazione al file AndroidManifest.xml della tua app:

    <application ...>
  ...
  <meta-data
      android:name="com.google.mlkit.vision.DEPENDENCIES"
      android:value="ocr" />
  <!-- To use multiple models: android:value="ocr,model2,model3" -->
</application>

    Puoi anche controllare esplicitamente la disponibilità del modello e richiedere il download tramite l'API ModuleInstallClient di Google Play Services.

    Se non attivi i download del modello al momento dell'installazione, questo verrà scaricato la prima volta che esegui il rilevatore sul dispositivo. Le richieste effettuate prima del completamento del download non produrranno risultati.

1. Crea un'istanza di TextRecognizer

Crea un'istanza di TextRecognizer:

Kotlin

val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
TextRecognitionActivity.kt

Java

TextRecognizer recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS);
TextRecognitionActivity.java

2. Prepara l'immagine di input

Per riconoscere il testo in un'immagine, crea un oggetto InputImage da un Bitmap, da media.Image, da ByteBuffer, da un array di byte o da un file sul dispositivo. Quindi, passa l'oggetto InputImage al metodo processImage di TextRecognizer.

Puoi creare un oggetto InputImage da diverse origini, ognuno dei quali è spiegato di seguito.

media.Image

Per creare un oggetto InputImage da un oggetto media.Image, ad esempio quando acquisisci un'immagine dalla fotocamera di un dispositivo, passa l'oggetto media.Image e la rotazione dell'immagine a InputImage.fromMediaImage().

Se utilizzi la libreria CameraX, le classi OnImageCapturedListener e ImageAnalysis.Analyzer calcolano il valore di rotazione automaticamente.

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
          // ...
        }
    }
}

Se non utilizzi una libreria delle videocamere che ti dà il grado di rotazione dell'immagine, puoi calcolarla in base al grado di rotazione e all'orientamento del sensore della videocamera del dispositivo:

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
}
MLKitVisionImage.kt

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;
}

Quindi, passa l'oggetto media.Image e il valore del grado di rotazione a InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

usando l'URI di un file.

Per creare un oggetto InputImage da un URI del file, passa il contesto dell'app e l'URI del file a InputImage.fromFilePath(). Questa operazione è utile quando utilizzi un intento ACTION_GET_CONTENT per richiedere all'utente di selezionare un'immagine dalla sua app Galleria.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
MLKitVisionImage.kt

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

ByteBuffer o ByteArray

Per creare un oggetto InputImage da un elemento ByteBuffer o ByteArray, innanzitutto calcola il grado di rotazione delle immagini come descritto in precedenza per l'input media.Image. Quindi, crea l'oggetto InputImage con il buffer o l'array, insieme ad altezza, larghezza, formato di codifica dei colori e grado di rotazione dell'immagine:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Bitmap

Per creare un oggetto InputImage da un oggetto Bitmap, effettua la seguente dichiarazione:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

L'immagine è rappresentata da un oggetto Bitmap insieme ai gradi di rotazione.

3. Elabora immagine

Passa l'immagine al metodo process:

Kotlin

val result = recognizer.process(image)
        .addOnSuccessListener { visionText ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
TextRecognitionActivity.kt

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
                                // ...
                            }
                        });
TextRecognitionActivity.java

4. Estrazione del testo dai blocchi di testo riconosciuti

Se l'operazione di riconoscimento del testo ha esito positivo, viene trasmesso un oggetto Text al listener riuscito. Un oggetto Text contiene il testo completo riconosciuto nell'immagine e zero o più oggetti TextBlock.

Ogni TextBlock rappresenta un blocco di testo rettangolare, che contiene zero o più oggetti Line. Ogni oggetto Line rappresenta una riga di testo, che contiene zero o più oggetti Element. Ogni oggetto Element rappresenta una parola o un'entità simile alla parola, che contiene zero o più oggetti Symbol. Ogni oggetto Symbol rappresenta un carattere, una cifra o un'entità simile a una parola.

Per ogni oggetto TextBlock, Line, Element e Symbol, puoi riconoscere il testo nella regione, le coordinate di delimitazione della regione e molti altri attributi come le informazioni sulla rotazione, il punteggio di affidabilità e così via.

Ad esempio:

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
        }
    }
}
TextRecognitionActivity.kt

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();
            }
        }
    }
}
TextRecognitionActivity.java

Linee guida sull'immagine di input

  • Affinché ML Kit possa riconoscere con precisione il testo, le immagini di input devono contenere testo rappresentato da dati pixel sufficienti. Idealmente, ogni carattere dovrebbe essere di almeno 16 x 16 pixel. In genere, la presenza di caratteri più grandi di 24 x 24 pixel non ha alcun vantaggio in termini di precisione.

    Ad esempio, un'immagine 640 x 480 potrebbe essere adatta alla scansione di un biglietto da visita che occupa l'intera larghezza dell'immagine. Per scansionare un documento stampato su carta in formato lettera, potrebbe essere necessaria un'immagine di 720 x 1280 pixel.

  • Una messa a fuoco dell'immagine scadente può influire sulla precisione del riconoscimento del testo. Se non ottieni risultati accettabili, prova a chiedere all'utente di riprendere l'immagine.

  • Se riconosci il testo in un'applicazione in tempo reale, devi considerare le dimensioni complessive delle immagini di input. Le immagini più piccole possono essere elaborate più rapidamente. Per ridurre la latenza, assicurati che il testo occupi la maggiore quantità possibile di immagini e acquisisci immagini a risoluzioni inferiori (ricordando i requisiti di accuratezza menzionati sopra). Per maggiori informazioni, consulta la pagina Suggerimenti per migliorare le prestazioni.

Suggerimenti per migliorare il rendimento

  • Se utilizzi l'API Camera o camera2, limita le chiamate al rilevatore. Se è disponibile un nuovo frame video mentre il rilevatore è in esecuzione, elimina il frame. Guarda la classe VisionProcessorBase nell'app di esempio della guida rapida per un esempio.
  • Se utilizzi l'API CameraX, assicurati che la strategia di contropressione sia impostata sul valore predefinito ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. In questo modo, verrà fornita una sola immagine alla volta per l'analisi. Se vengono generate più immagini quando lo strumento di analisi è occupato, verranno eliminate automaticamente e non saranno messe in coda per la pubblicazione. Una volta che l'immagine analizzata viene chiusa chiamando ImageProxy.close(), verrà pubblicata l'ultima immagine successiva.
  • Se utilizzi l'output del rilevatore per sovrapporre la grafica all'immagine di input, prima ottieni il risultato da ML Kit, quindi visualizza l'immagine e l'overlay in un solo passaggio. Questo viene visualizzato nella superficie di visualizzazione una sola volta per ogni frame di input. Guarda un esempio delle classi CameraSourcePreview e GraphicOverlay nell'app di esempio della guida rapida.
  • Se utilizzi l'API Camera2, acquisisci le immagini nel formato ImageFormat.YUV_420_888. Se utilizzi la versione precedente dell'API Camera, acquisisci le immagini in formato ImageFormat.NV21.
  • Potresti acquisire immagini a una risoluzione inferiore. Tuttavia, tieni presente anche i requisiti relativi alle dimensioni delle immagini di questa API.