La tâche "Segmenteur d'images" vous permet de diviser les images en régions en fonction d'éléments prédéfinis et appliquer des effets visuels comme le floutage de l'arrière-plan. Ces vous explique comment utiliser le segmenteur d'images avec les applications iOS.
L'exemple de code décrit dans ces instructions est disponible sur GitHub
Pour voir concrètement en quoi consiste cette tâche, consultez la page Web une démonstration. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez les Aperçu.
Exemple de code
L'exemple de code MediaPipe Tasks contient une implémentation simple d'une Image Segmenter pour iOS.
L'exemple implémente un segmenteur d'images qui génère des masques de catégorie. Il utilise la caméra d'un appareil iOS physique pour effectuer une segmentation d'image sur un flux en direct le flux de la caméra, ou sur les images et vidéos de la galerie de l'appareil.
Vous pouvez utiliser l'application comme point de départ pour votre propre application iOS ou vous y référer. lorsque vous modifiez une application existante. L'exemple de code du segment d'images GitHub
Télécharger le code
Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple à l'aide de l'outil de ligne de commande git.
Pour télécharger l'exemple de code:
Clonez le dépôt Git à l'aide de la commande suivante:
git clone https://github.com/google-ai-edge/mediapipe-samples/
Si vous le souhaitez, vous pouvez configurer votre instance Git pour utiliser le paiement creuse. uniquement les fichiers de l'exemple d'application Segmenter d'images:
cd mediapipe git sparse-checkout init --cone git sparse-checkout set examples/image_segmentation/ios/
Après avoir créé une version locale de l'exemple de code, vous pouvez installer bibliothèque de tâches MediaPipe, ouvrez le projet avec Xcode et exécutez l'application. Pour instructions, consultez le Guide de configuration pour iOS.
Composants clés
Les fichiers suivants contiennent le code essentiel pour l'exemple de segment d'image application:
- ImageSegmenterService.swift: Initialise le segmenteur d'image, gère la sélection du modèle et s'exécute sur les données d'entrée.
- CameraViewController.swift: Implémente l'interface utilisateur pour le mode de saisie du flux de la caméra en direct et permet de visualiser les résultats.
- MediaLibraryViewController.swift Elle implémente l'interface utilisateur pour le mode d'entrée de fichiers d'images fixes et de fichiers vidéo, et pour visualiser les résultats.
Configuration
Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement de code pour utiliser le segment d'images. Pour obtenir des informations générales sur la configuration environnement de développement permettant d'utiliser des tâches MediaPipe, y compris la version de la plate-forme consultez le Guide de configuration pour iOS.
Dépendances
L'outil de segmentation d'images utilise la bibliothèque MediaPipeTasksVision
, qui doit être installée
à l'aide de CocoaPods. La bibliothèque est compatible avec les applications Swift et Objective-C
et ne nécessite aucune configuration de langue supplémentaire.
Pour obtenir des instructions sur l'installation de CocoaPods sous macOS, reportez-vous au document CocoaPods
guide d'installation.
Pour savoir comment créer un Podfile
avec les pods nécessaires pour votre
consultez la section Utilisation
CocoaPods
Ajoutez le pod MediaPipeTasksVision dans le fichier Podfile
à l'aide du code suivant:
target 'MyImageSegmenterApp' do
use_frameworks!
pod 'MediaPipeTasksVision'
end
Si votre application inclut des cibles de tests unitaires, reportez-vous au Guide de configuration
iOS.
votre Podfile
.
Modèle
La tâche MediaPipe Image Segmenter nécessite un modèle entraîné et compatible pour cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour segmenteur d'images, consultez la présentation de la tâche Modèles .
Sélectionnez et téléchargez un modèle, puis ajoutez-le au répertoire de votre projet à l'aide de Xcode. Pour savoir comment ajouter des fichiers à votre projet Xcode, reportez-vous à la section Gestion fichiers et dossiers dans votre Xcode projet.
Utilisez la propriété BaseOptions.modelAssetPath
pour spécifier le chemin d'accès au modèle.
dans votre app bundle. Pour obtenir un exemple de code, consultez la section suivante.
Créer la tâche
Vous pouvez créer la tâche Segmenter d'image en appelant l'un de ses initialiseurs. La
L'initialiseur ImageSegmenter(options:)
accepte les valeurs pour la configuration
options.
Si vous n'avez pas besoin d'un segmenteur d'images initialisé avec une configuration personnalisée
vous pouvez utiliser l'initialiseur ImageSegmenter(modelPath:)
pour créer
Segment d'image avec les options par défaut. Pour en savoir plus sur la configuration
consultez la page Présentation de la configuration.
La tâche "Segmenteur d'images" prend en charge trois types de données d'entrée: images fixes et fichiers vidéo.
et les flux vidéo en direct. Par défaut, ImageSegmenter(modelPath:)
initialise un
pour les images fixes. Si vous souhaitez que votre tâche soit initialisée pour traiter des vidéos
ou de flux vidéo en direct, utilisez ImageSegmenter(options:)
pour spécifier la vidéo
ou diffusion en direct. Le mode "Diffusion en direct" nécessite également
l'option de configuration imageSegmenterLiveStreamDelegate
, qui active
Segment d'image pour fournir les résultats de segmentation d'image au délégué
de manière asynchrone.
Choisissez l'onglet correspondant à votre mode d'exécution pour découvrir comment créer la tâche. et exécuter des inférences.
Swift
Image
import MediaPipeTasksVision let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .image options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false let imageSegmenter = try ImageSegmenter(options: options)
Vidéo
import MediaPipeTasksVision let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .video options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false let imageSegmenter = try ImageSegmenter(options: options)
Diffusion en direct
import MediaPipeTasksVision // Class that conforms to the `imageSegmenterLiveStreamDelegate` protocol and // implements the method that the image segmenter calls once it finishes // performing segmentation of each input frame. class ImageSegmenterResultProcessor: NSObject, ImageSegmenterLiveStreamDelegate { func imageSegmenter( _ imageSegmenter: ImageSegmenter, didFinishSegmentation result: ImageSegmenterResult?, timestampInMilliseconds: Int, error: Error?) { // Process the image segmentation result or errors here. } } let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .liveStream options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false // Set `imageSegmenterLiveStreamDelegate` to the object of the class that // confirms to the `ImageSegmenterLiveStreamDelegate` protocol. let processor = ImageSegmenterResultProcessor() options.imageSegmenterLiveStreamDelegate = processor let imageSegmenter = try ImageSegmenter(options: options)
Objective-C
Image
@import MediaPipeTasksVision; NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeImage; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
Vidéo
@import MediaPipeTasksVision; NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeVideo; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
Diffusion en direct
@import MediaPipeTasksVision; // Class that conforms to the `MPPImageSegmenterLiveStreamDelegate` protocol // and implements the method that the image segmenter calls once it finishes // performing segmentation of each input frame. @interface APPImageSegmenterResultProcessor : NSObject@end @implementation APPImageSegmenterResultProcessor - (void)imageSegmenter:(MPPImageSegmenter *)imageSegmenter didFinishSegmentationWithResult:(MPPImageSegmenterResult *)imageSegmenterResult timestampInMilliseconds:(NSInteger)timestampInMilliseconds error:(NSError *)error { // Process the image segmentation result or errors here. } @end NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeLiveStream; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; // Set `imageSegmenterLiveStreamDelegate` to the object of the class that // confirms to the `MPPImageSegmenterLiveStreamDelegate` protocol. APPImageSegmenterResultProcessor *processor = [APPImageSegmenterResultProcessor new]; options.imageSegmenterLiveStreamDelegate = processor; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
L'exemple d'implémentation de code du segmenteur d'images permet à l'utilisateur de passer différents modes de traitement. L'approche rend le code de création de la tâche plus compliqué et peuvent ne pas être adaptés à votre cas d'utilisation.
Options de configuration
Cette tâche comporte les options de configuration suivantes pour les applications iOS:
Nom de l'option | Description | Plage de valeurs | Valeur par défaut |
---|---|---|---|
runningMode |
Définit le mode d'exécution de la tâche. Il y en a trois
modes: IMAGE: mode utilisé pour la saisie d'une seule image. VIDEO: mode des images décodées d'une vidéo. LIVE_STREAM: mode d'une diffusion en direct des entrées provenant d'un appareil photo, par exemple. Dans ce mode, ImageSegmenterLiveStreamDelegate
doit être définie sur une instance d'une classe qui implémente la classe
ImageSegmenterLiveStreamDelegate pour recevoir la segmentation
les résultats de manière asynchrone.
|
{RunningMode.image, RunningMode.video, RunningMode.liveStream } |
RunningMode.image |
shouldOutputCategoryMask |
Si la valeur est True , le résultat inclut un masque de segmentation.
en tant qu'image uint8, où chaque valeur de pixel indique la catégorie gagnante
. |
{True, False } |
False |
shouldOutputConfidenceMasks |
Si la valeur est True , le résultat inclut un masque de segmentation.
en tant qu'image d'une valeur flottante, où chaque valeur flottante représente le niveau de confiance
tableau des scores de la catégorie. |
{True, False } |
True |
displayNamesLocale |
Définit la langue des libellés à utiliser pour les noms à afficher fournis dans les
les métadonnées du modèle de la tâche, le cas échéant. La valeur par défaut est en pour
anglais. Vous pouvez ajouter des libellés localisés aux métadonnées d'un modèle personnalisé
à l'aide de l'API TensorFlow Lite Metadata Writer ; |
Code des paramètres régionaux | en |
result_callback |
Définit l'écouteur des résultats pour qu'il reçoive les résultats de la segmentation.
de manière asynchrone lorsque le segmenteur d'images est en mode LIVE_STREAM .
Ne peut être utilisé que lorsque le mode d'exécution est défini sur LIVE_STREAM |
N/A | N/A |
Lorsque le mode d'exécution est défini sur LIVE_STREAM
, l'outil de segmentation d'image requiert
l'option de configuration imageSegmenterLiveStreamDelegate
supplémentaire, qui
permet au segment d'image de fournir des résultats de segmentation d'image de manière asynchrone.
Le délégué doit implémenter
imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
,
que l'outil de segmentation d'images appelle après avoir traité les résultats de l'exécution
sur chaque image.
Nom de l'option | Description | Plage de valeurs | Valeur par défaut |
---|---|---|---|
imageSegmenterLiveStreamDelegate |
Permet à l'outil de segmentation d'images de recevoir les résultats des images performantes.
la segmentation de manière asynchrone
en mode diffusion en direct. La classe dont l'instance est
défini sur cette propriété doit implémenter
imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
. |
Non applicable | Non défini |
Préparer les données
Vous devez convertir l'image ou le cadre d'entrée en objet MPImage
avant
et les transmettre à l'outil de segmentation d'images. MPImage
est compatible avec différents types d'images iOS
et peuvent les utiliser dans n'importe quel mode d'exécution pour l'inférence. Pour plus
plus d'informations sur MPImage
, consultez
API MPImage
Choisissez un format d'image iOS en fonction de votre cas d'utilisation et du mode de course que vous
requise par l'application.MPImage
accepte les règles de confidentialité UIImage
, CVPixelBuffer
et
CMSampleBuffer
formats d'image iOS.
UIImage
Le format UIImage
convient bien aux modes d'exécution suivants:
Images : images d'un app bundle, d'une galerie d'utilisateur ou d'un système de fichiers au format suivant : Les images
UIImage
peuvent être converties en objetMPImage
.Vidéos: utilisez AVAssetImageGenerator. pour extraire des images vidéo CGImage le format d'image, puis les convertir en
UIImage
images.
Swift
// Load an image on the user's device as an iOS `UIImage` object. // Convert the `UIImage` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(uiImage: image)
Objective-C
// Load an image on the user's device as an iOS `UIImage` object. // Convert the `UIImage` object to a MediaPipe's Image object having the default // orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
L'exemple initialise un MPImage
avec les valeurs par défaut
UIImage.Orientation.Up
l'orientation. Vous pouvez initialiser un MPImage
avec n'importe laquelle des
UIImage.Orientation
valeurs. Le segmenteur d'images n'est pas compatible avec les orientations en miroir comme .upMirrored
,
.downMirrored
, .leftMirrored
et .rightMirrored
.
Pour plus d'informations sur UIImage
, reportez-vous à UIImage Apple Developer
documentation.
CVPixelBuffer
Le format CVPixelBuffer
convient bien aux applications qui génèrent des frames
et utiliser la classe iOS CoreImage
pour le traitement.
Le format CVPixelBuffer
convient bien aux modes d'exécution suivants:
Images: applications qui génèrent
CVPixelBuffer
images après un traitement utilisant le frameworkCoreImage
d'iOS peuvent être envoyés à l'outil de segmentation d'images d'exécution de l'image.Vidéos: les images vidéo peuvent être converties au format
CVPixelBuffer
pour avant de les envoyer à l'outil de segmentation d'images en mode vidéo.Diffusion en direct: les applications utilisant un appareil photo iOS pour générer des images peuvent être converties au format
CVPixelBuffer
pour être traité avant d'être envoyé au Segmenteur d'images en mode diffusion en direct.
Swift
// Obtain a CVPixelBuffer. // Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(pixelBuffer: pixelBuffer)
Objective-C
// Obtain a CVPixelBuffer. // Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the // default orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
Pour plus d'informations sur CVPixelBuffer
, reportez-vous au fichier CVPixelBuffer
Développeur
documentation.
CMSampleBuffer
Le format CMSampleBuffer
stocke des échantillons multimédias d'un type uniforme et est
bien adapté au streaming en direct. Les images en direct des appareils photo iOS sont
envoyé de manière asynchrone au format CMSampleBuffer
par iOS
AVCaptureVideoDataOutput.
Swift
// Obtain a CMSampleBuffer. // Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(sampleBuffer: sampleBuffer)
Objective-C
// Obtain a `CMSampleBuffer`. // Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the // default orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];
Pour plus d'informations sur CMSampleBuffer
, reportez-vous au fichier CMSampleBuffer
Développeur
documentation.
Exécuter la tâche
Pour exécuter le segmenteur d'image, utilisez la méthode segment()
propre à l'élément
en cours d'exécution:
- Image fixe:
segment(image:)
- Vidéo :
segment(videoFrame:timestampInMilliseconds:)
- Diffusion en direct :
segmentAsync(image:timestampInMilliseconds:)
Les exemples de code suivants illustrent des exemples simples d'exécution du Segmenter d'image ces différents modes de fonctionnement:
Swift
Image
let result = try imageSegmenter.segment(image: image)
Vidéo
let result = try imageSegmenter.segment( videoFrame: image, timestampInMilliseconds: timestamp)
Diffusion en direct
try imageSegmenter.segmentAsync( image: image, timestampInMilliseconds: timestamp)
Objective-C
Image
MPPImageSegmenterResult *result = [imageSegmenter segmentImage:image error:nil];
Vidéo
MPPImageSegmenterResult *result = [imageSegmenter segmentVideoFrame:image timestampInMilliseconds:timestamp error:nil];
Diffusion en direct
BOOL success = [imageSegmenter segmentAsyncImage:image timestampInMilliseconds:timestamp error:nil];
L'exemple de code du segment d'images montre les implémentations de chacun de ces modes.
segment(image:)
,
segment(videoFrame:timestampInMilliseconds:)
segmentAsync(image:timestampInMilliseconds:)
Veuillez noter les points suivants :
En mode vidéo ou flux en direct, vous devez également fournir le paramètre le code temporel de la trame d'entrée à la tâche "Segmenteur d'images".
Lors de l'exécution en mode image ou vidéo, la tâche "Segmenteur d'images" bloque thread actuel jusqu'à ce qu'il ait fini de traiter l'image ou le frame d'entrée. À éviter de bloquer le thread actuel, exécuter le traitement en arrière-plan thread utilisant iOS Dispatch ou NSOperation cadres réglementaires.
Lors de l'exécution en mode de diffusion en direct, la tâche "Segmenteur d'image" est immédiatement renvoyée et ne bloque pas le thread actuel. Elle appelle
imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
avec le segmenteur d'images après avoir traité chaque image d'entrée. La L'outil de segmentation d'images invoque cette méthode de manière asynchrone sur un réseau la file d'attente de distribution. Pour afficher les résultats dans l'interface utilisateur, envoyez la dans la file d'attente principale après leur traitement. Si le La fonctionsegmentAsync
est appelée lorsque la tâche Segmenter d'images est occupée. traite une autre image, le segmenteur d'images ignore la nouvelle image d'entrée.
Gérer et afficher les résultats
Lors de l'exécution de l'inférence, la tâche "Segmenteur d'images" renvoie un ImageSegmenterResult
qui contient les résultats de la tâche de segmentation. Le contenu de la
dépend du type de sortie que vous avez défini au moment
configurée
la tâche.
Les images suivantes illustrent le résultat des tâches pour une catégorie
de valeur. La plage de masques de catégorie est [0, 255]
, et chaque valeur de pixel
représente l'indice de la catégorie d'annonces gagnantes pour la sortie du modèle. Catégorie gagnante
est le score le plus élevé parmi toutes les catégories reconnues par le modèle.
Sortie du masque d'image d'origine et de catégorie. Image source de la Pascal VOC 2012 ensemble de données.
L'exemple de code du segmenteur d'images montre comment afficher ce segment dans les résultats de recherche, consultez le code exemple pour en savoir plus.