ML Kit menyediakan SDK yang dioptimalkan untuk segmentasi selfie.
Aset Selfie Segmenter ditautkan secara statis ke aplikasi Anda pada waktu build. Ini akan meningkatkan ukuran download aplikasi Anda sekitar 4,5 MB dan latensi API dapat bervariasi dari 25 md hingga 65 md bergantung pada ukuran gambar input, yang diukur di Pixel 4.
Cobalah
- Cobalah aplikasi contoh untuk melihat contoh penggunaan API ini.
Sebelum memulai
- Dalam file
build.gradle
level project, pastikan Anda menyertakan repositori Maven Google di bagianbuildscript
danallprojects
. - Tambahkan dependensi untuk library Android ML Kit ke file gradle level aplikasi modul Anda, biasanya
app/build.gradle
:
dependencies {
implementation 'com.google.mlkit:segmentation-selfie:16.0.0-beta6'
}
1. Membuat instance Segmenter
Opsi segmentasi
Untuk melakukan segmentasi pada gambar, pertama-tama buat instance Segmenter
dengan menentukan opsi berikut.
Mode Pendeteksi
Segmenter
beroperasi dalam dua mode. Pastikan Anda memilih salah satu yang cocok dengan kasus penggunaan Anda.
STREAM_MODE (default)
Mode ini dirancang untuk streaming frame dari video atau kamera. Dalam mode ini, Segmenter akan memanfaatkan hasil dari frame sebelumnya untuk menampilkan hasil segmentasi yang lebih lancar.
SINGLE_IMAGE_MODE
Mode ini didesain untuk gambar tunggal yang tidak terkait. Dalam mode ini, Segmenter akan memproses setiap gambar secara independen, tanpa ada penyesuaian pada frame.
Aktifkan mask ukuran mentah
Meminta pengklasifikasi untuk menampilkan mask ukuran mentah yang sesuai dengan ukuran output model.
Ukuran mask mentah (misalnya, 256x256) biasanya lebih kecil dari ukuran gambar input. Panggil SegmentationMask#getWidth()
dan SegmentationMask#getHeight()
untuk mendapatkan ukuran mask saat mengaktifkan opsi ini.
Tanpa menentukan opsi ini, pengelompok akan menskalakan ulang mask mentah agar sesuai dengan ukuran gambar input. Pertimbangkan untuk menggunakan opsi ini jika Anda ingin menerapkan logika penskalaan ulang yang disesuaikan atau penskalaan ulang tidak diperlukan untuk kasus penggunaan Anda.
Tentukan opsi pembagi segmen:
Kotlin
val options = SelfieSegmenterOptions.Builder() .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE) .enableRawSizeMask() .build()
Java
SelfieSegmenterOptions options = new SelfieSegmenterOptions.Builder() .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE) .enableRawSizeMask() .build();
Buat instance Segmenter
. Teruskan opsi yang Anda tentukan:
Kotlin
val segmenter = Segmentation.getClient(options)
Java
Segmenter segmenter = Segmentation.getClient(options);
2. Menyiapkan gambar input
Untuk melakukan segmentasi pada gambar, buat objek InputImage
dari Bitmap
, media.Image
, ByteBuffer
, array byte, atau file di
perangkat.
Anda dapat membuat InputImage
dari berbagai sumber, masing-masing akan dijelaskan di bawah ini.
Menggunakan media.Image
Untuk membuat InputImage
dari objek media.Image
, seperti saat Anda mengambil gambar dari
kamera perangkat, teruskan objek media.Image
dan objek
rotasi ke InputImage.fromMediaImage()
.
Jika Anda menggunakan
Library CameraX, OnImageCapturedListener
dan
Class ImageAnalysis.Analyzer
menghitung nilai rotasi
keamanan untuk Anda.
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 // ... } } }
Jika Anda tidak menggunakan pustaka kamera yang memberi derajat rotasi gambar, Anda bisa menghitungnya dari derajat rotasi perangkat dan orientasi kamera sensor di perangkat:
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 }
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; }
Lalu, teruskan objek media.Image
dan
nilai derajat rotasi ke InputImage.fromMediaImage()
:
Kotlin
val image = InputImage.fromMediaImage(mediaImage, rotation)
Java
InputImage image = InputImage.fromMediaImage(mediaImage, rotation);
Menggunakan URI file
Untuk membuat InputImage
dari URI file, teruskan konteks aplikasi dan URI file ke
InputImage.fromFilePath()
. Hal ini berguna ketika Anda
gunakan intent ACTION_GET_CONTENT
untuk meminta pengguna memilih
gambar dari aplikasi galeri mereka.
Kotlin
val image: InputImage try { image = InputImage.fromFilePath(context, uri) } catch (e: IOException) { e.printStackTrace() }
Java
InputImage image; try { image = InputImage.fromFilePath(context, uri); } catch (IOException e) { e.printStackTrace(); }
Menggunakan ByteBuffer
atau ByteArray
Untuk membuat InputImage
dari ByteBuffer
atau ByteArray
, hitung gambar terlebih dahulu
derajat rotasi seperti yang dijelaskan sebelumnya untuk input media.Image
.
Lalu, buat objek InputImage
dengan buffer atau array, beserta elemen
tinggi, lebar, format encoding warna, dan derajat rotasi:
Kotlin
val image = InputImage.fromByteBuffer( byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ) // Or: val image = InputImage.fromByteArray( byteArray, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 )
Java
InputImage image = InputImage.fromByteBuffer(byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ); // Or: InputImage image = InputImage.fromByteArray( byteArray, /* image width */480, /* image height */360, rotation, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 );
Menggunakan Bitmap
Untuk membuat InputImage
dari objek Bitmap
, buat deklarasi berikut:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
Gambar direpresentasikan oleh objek Bitmap
bersama dengan derajat rotasi.
3. Memproses gambar
Teruskan objek InputImage
yang telah disiapkan ke metode process
Segmenter
.
Kotlin
Task<SegmentationMask> result = segmenter.process(image) .addOnSuccessListener { results -> // Task completed successfully // ... } .addOnFailureListener { e -> // Task failed with an exception // ... }
Java
Task<SegmentationMask> result = segmenter.process(image) .addOnSuccessListener( new OnSuccessListener<SegmentationMask>() { @Override public void onSuccess(SegmentationMask mask) { // Task completed successfully // ... } }) .addOnFailureListener( new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
4. Mendapatkan hasil segmentasi
Anda bisa mendapatkan hasil segmentasi sebagai berikut:
Kotlin
val mask = segmentationMask.getBuffer() val maskWidth = segmentationMask.getWidth() val maskHeight = segmentationMask.getHeight() for (val y = 0; y < maskHeight; y++) { for (val x = 0; x < maskWidth; x++) { // Gets the confidence of the (x,y) pixel in the mask being in the foreground. val foregroundConfidence = mask.getFloat() } }
Java
ByteBuffer mask = segmentationMask.getBuffer(); int maskWidth = segmentationMask.getWidth(); int maskHeight = segmentationMask.getHeight(); for (int y = 0; y < maskHeight; y++) { for (int x = 0; x < maskWidth; x++) { // Gets the confidence of the (x,y) pixel in the mask being in the foreground. float foregroundConfidence = mask.getFloat(); } }
Untuk contoh lengkap tentang cara menggunakan hasil segmentasi, silakan lihat Contoh panduan memulai ML Kit.
Tips untuk meningkatkan performa
Kualitas hasil bergantung pada kualitas gambar input:
- Agar ML Kit mendapatkan hasil segmentasi yang akurat, gambar harus berukuran minimal 256x256 piksel.
- Fokus gambar yang buruk juga dapat memengaruhi akurasi. Jika Anda tidak mendapatkan hasil yang dapat diterima, minta pengguna untuk mengambil ulang gambar.
Jika Anda ingin menggunakan segmentasi dalam aplikasi real-time, ikuti panduan berikut untuk mencapai kecepatan frame terbaik:
- Gunakan
STREAM_MODE
. - Sebaiknya ambil gambar dengan resolusi yang lebih rendah. Namun, perhatikan juga persyaratan dimensi gambar API ini.
- Pertimbangkan untuk mengaktifkan opsi mentah size mask dan menggabungkan semua logika penskalaan ulang. Misalnya, daripada membiarkan API menskalakan ulang mask agar sesuai dengan ukuran gambar input terlebih dahulu, lalu Anda menskalakan ulang lagi agar sesuai dengan Ukuran tampilan untuk tampilan, cukup minta mask ukuran mentah, dan gabungkan kedua langkah ini menjadi satu.
- Jika Anda menggunakan
Camera
ataucamera2
API, men-throttle panggilan ke detektor. Jika video baru {i>frame<i} menjadi tersedia saat detektor sedang berjalan, hapus {i>frame<i} tersebut. LihatVisionProcessorBase
dalam aplikasi contoh panduan memulai untuk digunakan sebagai contoh. - Jika Anda menggunakan
CameraX
API, pastikan strategi tekanan balik ditetapkan ke nilai defaultnyaImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
. Hal ini menjamin hanya satu gambar yang akan dikirimkan untuk analisis pada satu waktu. Jika lebih banyak gambar yang dihasilkan ketika penganalisis sedang sibuk, mereka akan dibuang secara otomatis dan tidak diantrekan pengiriman. Setelah gambar yang dianalisis ditutup dengan memanggil ImageProxy.close(), gambar terbaru berikutnya akan dikirimkan. - Jika Anda menggunakan output detektor untuk menempatkan grafik
gambar input, pertama-tama dapatkan hasilnya dari ML Kit, lalu render gambar
dan overlay dalam satu langkah. Tindakan ini merender ke permukaan tampilan
hanya sekali untuk setiap {i>input frame<i}. Lihat
CameraSourcePreview
danGraphicOverlay
dalam aplikasi contoh panduan memulai sebagai contoh. - Jika Anda menggunakan Camera2 API, ambil gambar dengan
Format
ImageFormat.YUV_420_888
. Jika Anda menggunakan Camera API versi lama, ambil gambar dengan FormatImageFormat.NV21
.