使用机器学习套件实现主题分割 (Android)

使用机器学习套件可轻松向应用添加正文分割功能。

功能 详细信息
SDK 名称 play-services-mlkit-subject-segmentation
实现 未捆绑：系统使用 Google Play 服务动态下载模型。
对应用大小的影响 大小增加约 200 KB。
初始化时间 用户可能需要等待模型下载完毕，然后才能首次使用。

试试看

准备工作

  1. 请务必在项目级 build.gradle 文件中的 buildscript 和 allprojects 部分添加 Google 的 Maven 代码库。
  2. 将机器学习套件正文分割库的依赖项添加到模块的应用级 Gradle 文件（通常为 app/build.gradle）：
dependencies {
   implementation 'com.google.android.gms:play-services-mlkit-subject-segmentation:16.0.0-beta1'
}

如上所述，该模型由 Google Play 服务提供。您可以将应用配置为在从 Play 商店安装后自动将模型下载到设备。为此，请将以下声明添加到应用的 AndroidManifest.xml 文件中：

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

您还可以使用 ModuleInstallClient API 明确检查模型可用性，并请求通过 Google Play 服务下载。

如果您未启用在安装时下载模型的选项或未请求显式下载，系统将在您首次运行分段器时下载模型。您在下载完毕之前提出的请求不会产生任何结果。

1. 准备输入图片

如需对图片执行分割，请基于设备上的以下资源创建一个 InputImage 对象：Bitmap、media.Image、ByteBuffer、字节数组或文件。

您可以基于不同来源创建 InputImage 对象，下文分别介绍了具体方法。

使用 media.Image

如需基于 media.Image 对象创建 InputImage 对象（例如从设备的相机捕获图片时），请将 media.Image 对象和图片的旋转角度传递给 InputImage.fromMediaImage()。

如果您使用 CameraX 库，OnImageCapturedListener 和 ImageAnalysis.Analyzer 类会为您计算旋转角度值。

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

如果您不使用可提供图片旋转角度的相机库，则可以根据设备的旋转角度和设备中相机传感器的朝向来计算旋转角度：

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

然后，将 media.Image 对象及其旋转角度值传递给 InputImage.fromMediaImage()：

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


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

使用文件 URI

如需基于文件 URI 创建 InputImage 对象，请将应用上下文和文件 URI 传递给 InputImage.fromFilePath()。如果您使用 ACTION_GET_CONTENT intent 提示用户从图库应用中选择图片，则这一操作非常有用。

KotlinJava
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();
}

使用 ByteBuffer 或 ByteArray

如需基于 ByteBuffer 或 ByteArray 创建 InputImage 对象，请先按先前 media.Image 输入的说明计算图片旋转角度。然后，使用缓冲区或数组以及图片的高度、宽度、颜色编码格式和旋转角度创建 InputImage 对象：

KotlinJava
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

使用 Bitmap

如需基于 Bitmap 对象创建 InputImage 对象，请进行以下声明：

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


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

图片由 Bitmap 对象以及旋转角度表示。

2. 创建 SubjectSegmenter 实例

定义分段器选项

如需对图片进行分割，请先创建 SubjectSegmenterOptions 的实例，如下所示：

KotlinJava
val options = SubjectSegmenterOptions.Builder()
       // enable options
       .build()
 
SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
        // enable options
        .build();

下面详细介绍了每种方案：

前景置信度遮罩

借助前景置信度掩码，您可以将前景正文与背景区分开来。

在 options 中调用 enableForegroundConfidenceMask() 后，您可以稍后通过对处理图片后返回的 SubjectSegmentationResult 对象调用 getForegroundMask() 来检索前景遮罩。

KotlinJava
val options = SubjectSegmenterOptions.Builder()
        .enableForegroundConfidenceMask()
        .build()
 
SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
        .enableForegroundConfidenceMask()
        .build();
前景位图

同样，您还可以获取前景正文的位图。

在选项中调用 enableForegroundBitmap() 后，您可以稍后通过对处理图片后返回的 SubjectSegmentationResult 对象调用 getForegroundBitmap() 来检索前景位图。

KotlinJava
val options = SubjectSegmenterOptions.Builder()
        .enableForegroundBitmap()
        .build()
 
SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
        .enableForegroundBitmap()
        .build();
多正文置信度遮罩

与前景选项一样，您可以使用 SubjectResultOptions 为每个前景正文启用置信度掩码，如下所示：

KotlinJava
val subjectResultOptions = SubjectSegmenterOptions.SubjectResultOptions.Builder()
    .enableConfidenceMask()
    .build()

val options = SubjectSegmenterOptions.Builder()
    .enableMultipleSubjects(subjectResultOptions)
    .build()
 
SubjectResultOptions subjectResultOptions =
        new SubjectSegmenterOptions.SubjectResultOptions.Builder()
            .enableConfidenceMask()
            .build()

SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
      .enableMultipleSubjects(subjectResultOptions)
      .build()
多正文位图

同样，您可以为每个主题启用位图：

KotlinJava
val subjectResultOptions = SubjectSegmenterOptions.SubjectResultOptions.Builder()
    .enableSubjectBitmap()
    .build()

val options = SubjectSegmenterOptions.Builder()
    .enableMultipleSubjects(subjectResultOptions)
    .build()
 
SubjectResultOptions subjectResultOptions =
      new SubjectSegmenterOptions.SubjectResultOptions.Builder()
        .enableSubjectBitmap()
        .build()

SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
      .enableMultipleSubjects(subjectResultOptions)
      .build()

创建主题分割器

指定 SubjectSegmenterOptions 选项后，请调用 getClient() 并将选项作为参数传递，以创建 SubjectSegmenter 实例：

KotlinJava
val segmenter = SubjectSegmentation.getClient(options)
 
SubjectSegmenter segmenter = SubjectSegmentation.getClient(options);

3. 处理图片

将准备好的 InputImage 对象传递给 SubjectSegmenter 的 process 方法：

KotlinJava
segmenter.process(inputImage)
    .addOnSuccessListener { result ->
        // Task completed successfully
        // ...
    }
    .addOnFailureListener { e ->
        // Task failed with an exception
        // ...
    }
 
segmenter.process(inputImage)
    .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(SubjectSegmentationResult result) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });

4. 获取正文分割结果

检索前景遮罩和位图

处理完毕后，您可以调用 getForegroundConfidenceMask() 来检索图片的前景遮罩，如下所示：

KotlinJava
val colors = IntArray(image.width * image.height)

val foregroundMask = result.foregroundConfidenceMask
for (i in 0 until image.width * image.height) {
  if (foregroundMask[i] > 0.5f) {
    colors[i] = Color.argb(128, 255, 0, 255)
  }
}

val bitmapMask = Bitmap.createBitmap(
  colors, image.width, image.height, Bitmap.Config.ARGB_8888
)
 
int[] colors = new int[image.getWidth() * image.getHeight()];

FloatBuffer foregroundMask = result.getForegroundConfidenceMask();
for (int i = 0; i < image.getWidth() * image.getHeight(); i++) {
  if (foregroundMask.get() > 0.5f) {
    colors[i] = Color.argb(128, 255, 0, 255);
  }
}

Bitmap bitmapMask = Bitmap.createBitmap(
      colors, image.getWidth(), image.getHeight(), Bitmap.Config.ARGB_8888
);

您还可以调用 getForegroundBitmap() 来检索图片前景的位图：

KotlinJava
val foregroundBitmap = result.foregroundBitmap
 
Bitmap foregroundBitmap = result.getForegroundBitmap();

检索每个正文的遮罩和位图

同样，您可以通过对每个正文调用 getConfidenceMask() 来检索分割正文的遮罩，如下所示：

KotlinJava
val subjects = result.subjects

val colors = IntArray(image.width * image.height)
for (subject in subjects) {
  val mask = subject.confidenceMask
  for (i in 0 until subject.width * subject.height) {
    val confidence = mask[i]
    if (confidence > 0.5f) {
      colors[image.width * (subject.startY - 1) + subject.startX] =
          Color.argb(128, 255, 0, 255)
    }
  }
}

val bitmapMask = Bitmap.createBitmap(
  colors, image.width, image.height, Bitmap.Config.ARGB_8888
)
 
List subjects = result.getSubjects();

int[] colors = new int[image.getWidth() * image.getHeight()];
for (Subject subject : subjects) {
  FloatBuffer mask = subject.getConfidenceMask();
  for (int i = 0; i < subject.getWidth() * subject.getHeight(); i++) {
    float confidence = mask.get();
    if (confidence > 0.5f) {
      colors[width * (subject.getStartY() - 1) + subject.getStartX()]
          = Color.argb(128, 255, 0, 255);
    }
  }
}

Bitmap bitmapMask = Bitmap.createBitmap(
  colors, image.width, image.height, Bitmap.Config.ARGB_8888
);

您还可以按如下方式访问每个分割对象的位图：

KotlinJava
val bitmaps = mutableListOf()
for (subject in subjects) {
  bitmaps.add(subject.bitmap)
}
 
List bitmaps = new ArrayList<>();
for (Subject subject : subjects) {
  bitmaps.add(subject.getBitmap());
}

提升效果的提示

对于每个应用会话，由于模型初始化，首次推理通常比后续推理慢。如果低延迟至关重要，请考虑提前调用“虚构”推理。

结果的质量取决于输入图片的质量：

  • 为了让机器学习套件获得准确的分割结果，图片应至少为 512x512 像素。
  • 图片聚焦不佳也会影响准确性。如果您无法获得满意的结果，请让用户重新拍摄图片。