Rozpoznawanie tekstu na obrazach za pomocą ML Kit na Androidzie

Za pomocą pakietu ML Kit możesz rozpoznawać tekst na obrazach lub w filmach, na przykład i znaku z nazwą ulicy. Główne cechy tej funkcji:

Wypróbuj

• Aby zobaczyć przykład użycia tego interfejsu API, wypróbuj przykładową aplikację.
• Wypróbuj kod samodzielnie, korzystając z ćwiczenia z programowania.

Zanim zaczniesz

1. W pliku build.gradle na poziomie projektu dodaj repozytorium Maven firmy Google w sekcjach buildscript i allprojects.

2. Dodaj zależności do bibliotek ML Kit na Androida do pliku Gradle na poziomie aplikacji modułu. Jest to zwykle app/build.gradle:

   Aby połączyć model z aplikacją:

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

   Aby używać modelu w Usługach 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'
   }
   

3. Jeśli zdecydujesz się użyć modelu w Usługach Google Play, możesz skonfigurować aplikację tak, aby automatycznie pobierała model na urządzenie po zainstalowaniu aplikacji ze Sklepu Play. Aby to zrobić, dodaj do pliku AndroidManifest.xml aplikacji następującą deklarację:

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

   Możesz też sprawdzić dostępność modelu i poprosić o pobieranie za pomocą interfejsu ModuleInstallClient API w Usługach Google Play. Jeśli nie włączysz modelu podczas instalacji pobierze model lub zażąda pobierania wprost, model jest pobierany jako pierwszy po uruchomieniu skanera. Prośby przesłane przed pobraniem nie dało żadnych wyników.

1. Tworzenie instancji maszyny wirtualnej TextRecognizer

// 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())

// 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. Przygotuj obraz wejściowy

Aby rozpoznać tekst na obrazie, utwórz obiekt InputImage z elementu Bitmap, media.Image, ByteBuffer, tablicy bajtów lub pliku na urządzeniu. Następnie prześlij obiekt InputImage do metody processImage obiektu TextRecognizer.

Obiekt InputImage możesz utworzyć z różnych źródeł. Każde z nich opisane jest poniżej.

Korzystanie z: media.Image

Aby utworzyć InputImage z obiektu media.Image, np. podczas przechwytywania obrazu z z aparatu urządzenia, przekaż obiekt media.Image i obiekt obrazu w kierunku InputImage.fromMediaImage().

Jeśli używasz biblioteki CameraX, klasy OnImageCapturedListener i ImageAnalysis.Analyzer obliczają wartość obrotu za Ciebie.

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

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

Jeśli nie używasz biblioteki aparatu, która podaje stopień obrotu obrazu, możesz go obliczyć na podstawie stopnia obrotu urządzenia i orientacji czujnika aparatu na urządzeniu:

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

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

Następnie prześlij obiekt media.Image i wartość stopnia obrotu do InputImage.fromMediaImage():

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

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

Za pomocą identyfikatora URI pliku

Aby utworzyć obiekt InputImage na podstawie identyfikatora URI pliku, prześlij kontekst aplikacji i identyfikator URI pliku do funkcji InputImage.fromFilePath(). Jest to przydatne, gdy użyj intencji ACTION_GET_CONTENT, aby zachęcić użytkownika do wyboru obraz z aplikacji Galeria.

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

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

Przy użyciu: ByteBuffer lub ByteArray

Aby utworzyć InputImage obiektu z ByteBuffer lub ByteArray, najpierw oblicz wartość obrazu stopień obrotu zgodnie z wcześniejszym opisem dla danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą oraz wysokość, szerokość, format kodowania kolorów i stopień obrotu:

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

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

Korzystanie z: Bitmap

Aby utworzyć InputImage z obiektu Bitmap, wypełnij tę deklarację:

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

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

Obraz jest reprezentowany przez obiekt Bitmap z stopniami obrotu.

3. Przetwarzanie obrazu

Przekaż obraz do metody process:

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

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. Wyodrębnianie tekstu z bloków rozpoznanego tekstu

Jeśli rozpoznawanie tekstu się powiedzie, obiekt Text zostanie przekazany do słuchaczem sukcesu. Obiekt Text zawiera pełny tekst rozpoznany w i zero lub więcej obiektów TextBlock.

Każdy element TextBlock to prostokątny blok tekstu, które nie zawiera żadnych obiektów Line ani ich więcej. Każdy Obiekt Line reprezentuje wiersz tekstu, który zawiera zero lub więcej obiektów Element. Każdy obiekt Element reprezentuje słowo lub element podobny do słowa, który zawiera co najmniej 0 obiektów Symbol. Co Symbol reprezentuje znak, cyfrę lub element słowny.

W przypadku każdego obiektu TextBlock, Line, Element i Symbol możesz uzyskać tekst rozpoznany w regionie, współrzędne ograniczające regionu oraz wiele innych atrybutów, takich jak informacje o rotacji, wynik wiarygodności itp.

Na przykład:

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

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

Wskazówki dotyczące obrazów wejściowych

• Aby ML Kit mógł dokładnie rozpoznawać tekst, obrazy wejściowe muszą zawierać tekst reprezentowany przez wystarczającą ilość danych pikseli. W idealnym przypadku każdy znak powinien mieć co najmniej 16 x 16 pikseli. Zwykle nie ma korzyści z ustawienia znaków o większych rozmiarach niż 24 x 24 piksele.

  Na przykład obraz o wymiarach 640 x 480 może się dobrze sprawdzić w przypadku skanowania wizytówki, która zajmuje całą szerokość obrazu. Aby zeskanować dokument wydrukowany na na papierze w formacie letter, może być wymagany obraz o wymiarach 720 x 1280 pikseli.

• Złe wyostrzone zdjęcie może wpłynąć na dokładność rozpoznawania tekstu. Jeśli nie uzyskujesz zadowalających wyników, poproś użytkownika o ponowne zrobienie zdjęcia.

• Jeśli rozpoznajesz tekst w aplikacji działającej w czasie rzeczywistym, weź pod uwagę ogólne wymiary obrazów wejściowych. Mniejsze obrazy można przetwarzać szybciej. Aby skrócić czas oczekiwania, tekst powinien zajmować należy robić zdjęcia i robić zdjęcia w niższej rozdzielczości (pamiętając o dokładności powyższe wymagania). Więcej informacji: Wskazówki pozwalające zwiększyć wydajność.

Wskazówki dotyczące poprawy skuteczności

• Jeśli używasz tagu Camera lub camera2 API, ograniczanie wywołań detektora. Jeśli nowy film ramka stanie się dostępna, gdy detektor będzie aktywny, upuść ją. Przykładem jest klasa VisionProcessorBase w przykładowej aplikacji krótkiego wprowadzenia.
• Jeśli używasz interfejsu API CameraX, upewnij się, że strategia obciążenia wstecznego jest ustawiona na wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST Dzięki temu masz pewność, że do analizy zostanie przesłany tylko jeden obraz. Jeśli podczas przetwarzania więcej obrazów zostanie wygenerowanych, zostaną one automatycznie odrzucone i nie zostaną umieszczone w kolejce do przesłania. Po zamknięciu analizowanego obrazu przez wywołanie ImageProxy.close(), zostanie wyświetlony następny najnowszy obraz.
• Jeśli używasz danych wyjściowych z detektora do nakładania grafiki na obraz wejściowy, najpierw uzyskaj wynik z ML Kit, a potem wyrenderuj obraz i nałóż go w jednym kroku. Jest on renderowany na powierzchni wyświetlania tylko raz w przypadku każdej ramki wejściowej. Zobacz CameraSourcePreview i GraphicOverlay w przykładowej aplikacji z krótkim wprowadzeniem.
• Jeśli korzystasz z interfejsu API Camera2, rób zdjęcia w Format: ImageFormat.YUV_420_888. Jeśli używasz starszej wersji interfejsu Camera API, rób zdjęcia w formacie ImageFormat.NV21.
• Rozważ robienie zdjęć w niższej rozdzielczości. Pamiętaj jednak o wymaganiach dotyczących wymiarów obrazu w tym interfejsie API.