Guide de segmentation d'image pour iOS

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:

1. Clonez le dépôt Git à l'aide de la commande suivante:

   git clone https://github.com/google-ai-edge/mediapipe-samples/
   

2. 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

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)
    

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)
    

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

@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];
    

@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];
    

@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:

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.

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 objet MPImage.

• Vidéos: utilisez AVAssetImageGenerator. pour extraire des images vidéo CGImage le format d'image, puis les convertir en UIImage images.

// 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)
    

// 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 framework CoreImage 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.

// 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)
    

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

// 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)
    

// 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

let result = try imageSegmenter.segment(image: image)
    

let result = try imageSegmenter.segment(
  videoFrame: image,
  timestampInMilliseconds: timestamp)
    

try imageSegmenter.segmentAsync(
  image: image,
  timestampInMilliseconds: timestamp)
    

Objective-C

MPPImageSegmenterResult *result =
  [imageSegmenter segmentImage:image error:nil];
    

MPPImageSegmenterResult *result =
  [imageSegmenter segmentVideoFrame:image
            timestampInMilliseconds:timestamp
                              error:nil];
    

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 fonction segmentAsync 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.