目录

Before API development, you need to make necessary development preparations, ensure that the Maven repository address of the HMS Core SDK has been configured in your project, and the SDK of this service has been integrated.

Text recognition from images on the device

1. Create the text analyzer MLTextAnalyzer to recognize text in images. You can set MLLocalTextSetting to specify languages that can be recognized. If you do not set the languages, only Latin-based languages can be recognized by default.

  1. // Method 1: Use default parameter settings to configure the on-device text analyzer. Only Latin-based languages can be recognized.
  2. MLTextAnalyzer analyzer = MLAnalyzerFactory.getInstance().getLocalTextAnalyzer();
  3. // Method 2: Use the customized parameter MLLocalTextSetting to configure the text analyzer on the device.
  4. MLLocalTextSetting setting = new MLLocalTextSetting.Factory()
  5.     .setOCRMode(MLLocalTextSetting.OCR_DETECT_MODE)
  6.     // Specify languages that can be recognized.
  7.     .setLanguage("zh")
  8.     .create();
  9. MLTextAnalyzer analyzer = MLAnalyzerFactory.getInstance().getLocalTextAnalyzer(setting);

2. Create an MLFrame using android.graphics.Bitmap. JPG, JPEG, PNG, and BMP images are supported. It is recommended that the length-width ratio range from 1:2 to 2:1.

  1. // Create an MLFrame object using the bitmap, which is the image data in bitmap format. 
  2. MLFrame frame = MLFrame.fromBitmap(bitmap);

3. Pass the MLFrame object to the asyncAnalyseFrame method for text recognition.

  1. Task<MLText> task = analyzer.asyncAnalyseFrame(frame); 
  2. task.addOnSuccessListener(new OnSuccessListener<MLText>() { 
  3.     @Override 
  4.     public void onSuccess(MLText text) { 
  5.         // Recognition success. 
  6.     } 
  7. }).addOnFailureListener(new OnFailureListener() { 
  8.     @Override 
  9.     public void onFailure(Exception e) { 
  10.         // Recognition failure. 
  11.     } 
  12. });

The sample code uses the asynchronous call mode. Local text recognition also supports synchronous call. The recognition result is specified by the MLText.Block array.

  1. Context context = getApplicationContext(); 
  2. MLTextAnalyzer analyzer = new MLTextAnalyzer.Factory(context).create(); 
  3. SparseArray<MLText.Block> blocks = analyzer.analyseFrame(frame);

4. After the recognition is complete, stop the analyzer to release recognition resources.

  1. try {
  2.     if (analyzer != null) {
  3.        analyzer.stop();
  4.    }
  5. catch (IOException e) {
  6.     // Exception handling.
  7. }

Text recognition from images on the cloud

 1. Creat an analyzer. The recommended way is to using MLRemoteTextSetting. In this way, you can specify to-be-recognized languages for more accurate text recognition.

  1. // Method 1: Use customized parameter settings.
  2. // Create a language set.
  3. List<String> languageList = new ArrayList();
  4. languageList.add("zh");
  5. languageList.add("en");
  6. // Set parameters.
  7. MLRemoteTextSetting setting = new MLRemoteTextSetting.Factory()
  8.     // Set the on-cloud text detection mode.
  9.     // MLRemoteTextSetting.OCR_COMPACT_SCENE: dense text recognition
  10.     // MLRemoteTextSetting.OCR_LOOSE_SCENE: sparse text recognition
  11.     .setTextDensityScene(MLRemoteTextSetting.OCR_LOOSE_SCENE)
  12.     // Specify the languages that can be recognized, which should comply with ISO 639-1.
  13.     .setLanguageList(languageList)
  14.     // Set the format of the returned text border box.
  15.     // MLRemoteTextSetting.NGON: Return the coordinates of the four corner points of the quadrilateral.
  16.     // MLRemoteTextSetting.ARC: Return the corner points of a polygon border in an arc. The coordinates of up to 72 corner points can be returned.
  17.     .setBorderType(MLRemoteTextSetting.ARC)
  18.     .create();
  19. MLTextAnalyzer analyzer = MLAnalyzerFactory.getInstance().getRemoteTextAnalyzer(setting);
  20. // Method 2: Use the default parameter settings to automatically detect languages for text recognition. This method is applicable to sparse text scenarios. The format of the returned text box is MLRemoteTextSetting.NGON.
  21. MLTextAnalyzer analyzer = MLAnalyzerFactory.getInstance().getRemoteTextAnalyzer();

2. Create an MLFrame using the bitmap. JPG, JPEG, PNG, and BMP images are supported.

  1. MLFrame frame = MLFrame.fromBitmap(bitmap);

3. Pass the MLFrame object to the asyncAnalyseFrame method for text recognition.

  1. Task<MLText> task = analyzer.asyncAnalyseFrame(frame);
  2. task.addOnSuccessListener(new OnSuccessListener<MLText>() {
  3.     @Override
  4.     public void onSuccess(MLText text) {
  5.         // Recognition success.
  6.     }
  7. }).addOnFailureListener(new OnFailureListener() {
  8.     @Override
  9.     public void onFailure(Exception e) {
  10.         // If the recognition fails, obtain related exception information.
  11.             try {
  12.             MLException mlException = (MLException)e;
  13.     // Obtain the result codes. You can process the result codes and customize respective messages displayed to users. For details about the result codes, please refer to Result Codes of ML Kit.
  14.             int errorCode = mlException.getErrCode();
  15.    // Obtain the error information. You can quickly locate the fault based on the result code.
  16.            String errorMessage = mlException.getMessage();
  17.        } catch (Exception error) {
  18.            // Handle the conversion error.
  19.        }
  20.    }
  21. });

4. After the recognition is complete, stop the analyzer to release recognition resources.

  1. try { 
  2.     if (analyzer != null) { 
  3.         ananlzer.stop(); 
  4.     } 
  5. } catch (IOException e) { 
  6.     // Exception handling. 
  7. }

Text recognition from camera streams on the device

Your app can process camera streams, convert camera frames into the MLFrame object, and recognize text using the local static image recognition method. If the synchronous recognition API is called, your app can also use the LensEngine class built in the SDK to locally detect text in camera streams and create and initialize a LensEngine object. For details, please refer to Sample Code.

1. Create an analyzer.

  1. MLTextAnalyzer analyzer = new MLTextAnalyzer.Factory(context).create();

2. Create the OcrDetectorProcessor class for processing detection results. This class provides the MLAnalyzer.MLTransactor<T> API, which uses the transactResult method to obtain the detection results and implement specific services.

  1. public class OcrDetectorProcessor implements MLAnalyzer.MLTransactor<MLText.Block> { 
  2.     @Override 
  3.     public void transactResult(MLAnalyzer.Result<MLText.Block> results) { 
  4.         SparseArray<MLText.Block> items = results.getAnalyseList(); 
  5.       // Determine detection result processing as required. Note that only the detection results are processed. 
  6.         // Other detection-related APIs provided by HUAWEI ML Kit cannot be called. 
  7.     } 
  8.     @Override 
  9.     public void destroy() { 
  10.         // Callback method used to release resources when the detection ends. 
  11.     } 
  12. }

3. Set the detection result processor to bind the analyzer to the result processor.

  1. analyzer.setTransactor(new OcrDetectorProcessor());

4. Call the synchronous API to use the built-in LensEngine of the SDK to create an object, register the analyzer, and initialize camera parameters.

  1. LensEngine lensEngine = new LensEngine.Creator(getApplicationContext(),analyzer) 
  2.         .setLensType(LensEngine.BACK_LENS) 
  3.         .applyDisplayDimension(1440, 1080) 
  4.         .applyFps(30.0f) 
  5.         .enableAutomaticFocus(true) 
  6.         .create();

5. Call the run method to start the camera and read camera streams for recognition.

  1. // Implement other logic of the SurfaceView control by yourself. 
  2. SurfaceView mSurfaceView = findViewById(R.id.surface_view); 
  3. try { 
  4.     lensEngine.run(mSurfaceView.getHolder()); 
  5. } catch (IOException e) { 
  6.     // Exception handling logic. 
  7. }

6. After the recognition is complete, stop the analyzer to release recognition resources.

  1. if (analyzer != null) {   
  2.     try { 
  3.         analyzer.stop();     
  4.     } catch (IOException e) {    
  5.     // Exception handling. 
  6.     } 
  7. } 
  8. if (lensEngine != null) { 
  9.     lensEngine.release(); 
  10. }

In camera stream detection, when MLAnalyzer.MLTransactor<T> is inherited to process detection results, if your app needs to stop detection after a specific result is detected and continue detection after the result is processed, please refer to Development for Multi Detections in Camera Stream Detection Mode.