目录

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.

Stactiontic image detection

1. Create an object analyzer.

  1. // Use MLObjectAnalyzerSetting.TYPE_PICTURE for static image detection. 
  2. MLObjectAnalyzerSetting setting = new MLObjectAnalyzerSetting.Factory() 
  3.     .setAnalyzerType(MLObjectAnalyzerSetting.TYPE_PICTURE) 
  4.     .allowMultiResults() 
  5.     .allowClassification() 
  6.     .create(); 
  7. MLObjectAnalyzer analyzer = MLAnalyzerFactory.getInstance().getLocalObjectAnalyzer(setting);

2. Create an MLFrame object by using android.graphics.Bitmap for the analyzer to detect images. JPG, JPEG, and PNG images are supported. It is recommended that the image size be greater than or equal to 288 x 288 px.

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

3. Call the asyncAnalyseFrame method to perform object detection.

  1. // Create a task to process the result returned by the object detector. 
  2. Task<List<MLObject>> task = analyzer.asyncAnalyseFrame(frame); 
  3. // Asynchronously process the result returned by the object detector. 
  4. task.addOnSuccessListener(new OnSuccessListener<List<MLObject>>() { 
  5.     @Override 
  6.     public void onSuccess(List<MLObject> objects) { 
  7.        // Detection success. 
  8.     } 
  9. }).addOnFailureListener(new OnFailureListener() { 
  10.     @Override 
  11.     public void onFailure(Exception e) { 
  12.        // Detection failure. 
  13.     } 
  14. });

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

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

5. The asynchronous call mode is used in preceding sample code. Object detection also supports synchronous call of the analyseFrame function to obtain the detection result.

  1. SparseArray<MLObject> objects = analyzer.analyseFrame(frame);

Camera stream detection

You can process camera streams, convert video frames into an MLFrame object, and detect objects using the static image detection method. If the synchronous detection API is called, you can also use the LensEngine class built in the SDK to detect objects in camera streams. The sample code is as follows:

1. Create an object analyzer.

  1. MLObjectAnalyzer analyzer =
  2. MLAnalyzerFactory.getInstance().getLocalObjectAnalyzer();

2. Create the ObjectAnalyzerTransactor class for processing detection results. This class implements the MLAnalyzer.MLTransactor<T> API and uses the transactResult method in this API to obtain the detection results and implement specific services.

  1. public class ObjectAnalyzerTransactor implements MLAnalyzer.MLTransactor<MLObject> {
  2.     @Override
  3.     public void transactResult(MLAnalyzer.Result<MLObject> results) {
  4.         SparseArray<MLObject> 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 ObjectAnalyzerTransactor());

4. Create an instance of the LensEngine class provided by the HMS Core ML SDK to capture dynamic camera streams and pass the streams to the analyzer.

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

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

  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 detection is complete, stop the analyzer to release detection 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.