Prise en main d’AI Imaging

Les fonctionnalités d’ia imaging prises en charge par les API Windows AI permettent les fonctionnalités suivantes :

• Super résolution d’image : mise à l’échelle et netteté d’une image.
• Description de l’image : génération de texte qui décrit une image.
• Segmentation d’image : identification d’objets au sein d’une image.
• Extraction de l'avant-plan d'une image : extraction de l'avant-plan d'une image source
• Effacement d’objet : suppression d’objets d’une image.

Pour plus d’informations sur l’API, consultez la référence d’API pour les fonctionnalités d’imagerie IA.

Pour plus de détails sur la modération du contenu, voir Sécurité du contenu avec les API d’IA générative.

<Dependencies>
  <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
  <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
</Dependencies>

Que puis-je faire avec la super résolution d’images ?

Les API Super-résolution d’images permettent d’affiner et de mettre à l’échelle des images.

La mise à l’échelle est limitée à un facteur maximal de 8x, car des facteurs d’échelle plus élevés peuvent introduire des artefacts et compromettre la précision de l’image. Si la largeur ou la hauteur finale est supérieure à 8 fois la valeur d’origine, une exception est levée.

Exemple de super résolution d’images

L’exemple suivant montre comment modifier l’échelle (targetWidth, targetHeight) d’une image bitmap logicielle existante (softwareBitmap) et améliorer la netteté de l’image à l’aide d’un ImageScaler objet (pour améliorer la netteté sans mettre à l’échelle l’image, spécifiez simplement la largeur et la hauteur de l’image existantes).

1. Vérifiez que le modèle Image Super Resolution est disponible en appelant la méthode GetReadyState , puis en attendant que la méthode EnsureReadyAsync retourne correctement.

2. Une fois le modèle Image Super Resolution disponible, créez un objet ImageScaler pour le référencer.

3. Obtenez une version aiguisée et mise à l’échelle de l’image existante en passant l’image existante et la largeur et la hauteur souhaitées au modèle à l’aide de la méthode ScaleSoftwareBitmap .

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.Management.Deployment;
using Microsoft.Windows.AI;
using Windows.Graphics.Imaging;

if (ImageScaler.GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageScaler.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}
ImageScaler imageScaler = await ImageScaler.CreateAsync();
SoftwareBitmap finalImage = imageScaler.ScaleSoftwareBitmap(softwareBitmap, targetWidth, targetHeight);

#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.Windows.AI.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Graphics.Imaging.h>

using namespace winrt::Microsoft::Graphics::Imaging;
using namespace winrt::Microsoft::Windows::AI;
using namespace winrt::Windows::Foundation; 
using namespace winrt::Windows::Graphics::Imaging; 

if (ImageScaler::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageScaler::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}
int targetWidth = 100;
int targetHeight = 100;
ImageScaler imageScaler = ImageScaler::CreateAsync().get();
Windows::Graphics::Imaging::SoftwareBitmap finalImage = 
    imageScaler.ScaleSoftwareBitmap(softwareBitmap, targetWidth, targetHeight);

Que puis-je faire avec la description de l’image ?

Les API Description d’image permettent de générer différents types de descriptions de texte pour une image.

Les types de descriptions de texte suivants sont pris en charge :

• Résumé : fournit une présentation adaptée aux graphiques et aux diagrammes.
• Détaillé : fournit une description longue.
• Diagramme : fournit une brève description adaptée à une légende d’image. Valeur par défaut si aucune valeur n’est spécifiée.
• Accessible : fournit une description longue avec des détails destinés aux utilisateurs ayant des besoins d’accessibilité.

Étant donné que ces API utilisent des modèles Machine Learning (ML), des erreurs occasionnelles peuvent se produire lorsque le texte ne décrit pas correctement l’image. Par conséquent, nous vous déconseillons d’utiliser ces API pour les images dans les scénarios suivants :

• Lorsque les images contiennent du contenu potentiellement sensible et des descriptions inexactes peuvent être controversées, telles que des drapeaux, des cartes, des globes, des symboles culturels ou des symboles religieux.
• Lorsque des descriptions précises sont essentielles, comme pour les conseils médicaux ou le diagnostic, le contenu juridique ou les documents financiers.

Exemple de description d’image

L’exemple suivant montre comment obtenir une description de texte pour une image en fonction du type de description spécifié (facultatif) et du niveau de modération de contenu (facultatif).

1. Vérifiez que le modèle Image Super Resolution est disponible en appelant la méthode GetReadyState , puis en attendant que la méthode EnsureReadyAsync retourne correctement.

2. Une fois le modèle Image Super Resolution disponible, créez un objet ImageDescriptionGenerator pour le référencer.

3. (Facultatif) Créez un objet ContentFilterOptions et spécifiez vos valeurs préférées. Si vous choisissez d’utiliser des valeurs par défaut, vous pouvez passer un objet Null.

4. Obtenez la description de l’image (LanguageModelResponse.Response) en appelant la méthode DescribeAsync spécifiant l’image d’origine, ImageDescriptionKind (valeur facultative pour le type de description préféré) et l’objet ContentFilterOptions (facultatif).

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.Management.Deployment;  
using Microsoft.Windows.AI;
using Microsoft.Windows.AI.ContentModeration;
using Windows.Storage.StorageFile;  
using Windows.Storage.Streams;  
using Windows.Graphics.Imaging;

if (ImageDescriptionGenerator.GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageDescriptionGenerator.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}

ImageDescriptionGenerator imageDescriptionGenerator = await ImageDescriptionGenerator.CreateAsync();

// Convert already available softwareBitmap to ImageBuffer.
ImageBuffer inputImage = ImageBuffer.CreateCopyFromBitmap(softwareBitmap);  

// Create content moderation thresholds object.
ContentFilterOptions filterOptions = new ContentFilterOptions();
filterOptions.PromptMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;
filterOptions.ResponseMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;

// Get text description.
LanguageModelResponse languageModelResponse = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);
string response = languageModelResponse.Response;

#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Microsoft.Windows.AI.ContentSafety.h>
#include <winrt/Microsoft.Windows.AI.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Graphics.Imaging.h> 
#include <winrt/Windows.Storage.Streams.h>
#include <winrt/Windows.Storage.StorageFile.h>

using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Microsoft::Windows::AI;
using namespace winrt::Microsoft::Windows::AI::ContentSafety; 
using namespace winrt::Microsoft::Windows::AI::Imaging; 
using namespace winrt::Windows::Foundation; 
using namespace winrt::Windows::Graphics::Imaging;
using namespace winrt::Windows::Storage::Streams;
using namespace winrt::Windows::Storage::StorageFile;    

if (ImageDescriptionGenerator::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageDescriptionGenerator::EnsureReadyAsync().get();
    auto loadResult = ImageScaler::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

ImageDescriptionGenerator imageDescriptionGenerator = 
    ImageDescriptionGenerator::CreateAsync().get();

// Convert already available softwareBitmap to ImageBuffer.
auto inputBuffer = Microsoft::Graphics::Imaging::ImageBuffer::CreateForSoftwareBitmap(bitmap); (softwareBitmap);

// Create content moderation thresholds object.

ContentFilterOptions contentFilter{};
contentFilter.PromptMaxAllowedSeverityLevel().Violent(SeverityLevel::Medium);
contentFilter.ResponseMaxAllowedSeverityLevel().Violent(SeverityLevel::Medium);

// Get text description.
auto response = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionKind::BriefDescription, contentFilter).get();
string text = response.Description();

Que puis-je faire avec la segmentation d’images ?

La segmentation d’image peut être utilisée pour identifier des objets spécifiques dans une image. Le modèle prend une image et un objet « indice » et renvoie un masque de l'objet identifié.

Les indices peuvent être fournis à partir de n’importe quelle combinaison des éléments suivants :

• Des coordonnées de points qui font partie de ce que vous voulez identifier.
• Des coordonnées de points qui ne font pas partie de ce que vous voulez identifier.
• Un rectangle de coordonnées qui entoure ce que vous voulez identifier.

Plus vous fournissez d’indices, plus le modèle sera précis. Suivez ces consignes d'indications pour minimiser les résultats inexacts ou les erreurs.

• Évitez d’utiliser plusieurs rectangles dans un même indice, au risque que le masque créé ne perde en précision.
• Évitez d’utiliser uniquement des points d'exclusion, sans aucun point d'inclusion ni rectangle.
• Le nombre maximum de coordonnées prises en charge est de 32, à raison de 1 coordonnée pour un point et 2 pour un rectangle. Au-delà, un message d'erreur apparaît.

Le masque retourné est au format grisscale-8 avec les pixels du masque pour l’objet identifié ayant une valeur de 255 (toutes les autres ayant une valeur de 0).

Exemple de segmentation d’image

Les exemples suivants montrent comment identifier un objet dans une image. Les exemples supposent que vous disposez déjà d’un objet bitmap logiciel (softwareBitmap) pour l’entrée.

1. Vérifiez que le modèle de segmentation d’image est disponible en appelant la méthode GetReadyState et en attendant que la méthode EnsureReadyAsync retourne correctement.

2. Une fois le modèle de segmentation d’image disponible, créez un objet ImageObjectExtractor pour le référencer.

3. Passez l’image à CreateWithSoftwareBitmapAsync.

4. Créez un objet ImageObjectExtractorHint . D’autres façons de créer un objet hint avec différentes entrées sont illustrées ultérieurement.

5. Envoyez l’indicateur au modèle à l’aide de la méthode GetSoftwareBitmapObjectMask , qui retourne le résultat final.

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.AI;
using Microsoft.Windows.Management.Deployment;
using Windows.Graphics.Imaging;

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}

ImageObjectExtractor imageObjectExtractor = await ImageObjectExtractor.CreateWithSoftwareBitmapAsync(softwareBitmap);

ImageObjectExtractorHint hint = new ImageObjectExtractorHint{
    includeRects: null, 
    includePoints:
        new List<PointInt32> { new PointInt32(306, 212),
                               new PointInt32(216, 336)},
    excludePoints: null};
    SoftwareBitmap finalImage = imageObjectExtractor.GetSoftwareBitmapObjectMask(hint);

#include <winrt/Microsoft.Graphics.Imaging.h> 
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Microsoft::Windows::AI.Imaging;
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation;

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageObjectExtractor::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

ImageObjectExtractor imageObjectExtractor = ImageObjectExtractor::CreateWithSoftwareBitmapAsync(softwareBitmap).get();

ImageObjectExtractorHint hint(
    {},
    {
        Windows::Graphics::PointInt32{306, 212},        
        Windows::Graphics::PointInt32{216, 336}
    },
    {}
);

Windows::Graphics::Imaging::SoftwareBitmap finalImage = imageObjectExtractor.GetSoftwareBitmapObjectMask(hint);

Spécifiez des indices, sous forme de points inclus et de points exclus

Cet extrait de code montre comment utiliser des points inclus et exclus en tant qu’indicateurs.

ImageObjectExtractorHint hint(
    includeRects: null,
    includePoints: 
        new List<PointInt32> { new PointInt32(150, 90), 
                               new PointInt32(216, 336), 
                               new PointInt32(550, 330)},
    excludePoints: 
        new List<PointInt32> { new PointInt32(306, 212) });

ImageObjectExtractorHint hint(
    {}, 
    { 
        PointInt32{150, 90}, 
        PointInt32{216, 336}, 
        PointInt32{550, 330}
    },
    { 
        PointInt32{306, 212}
    }
);

Spécifiez des indices sous forme de rectangle

Cet extrait de code montre comment utiliser un rectangle (RectInt32 est X, Y, Width, Height) comme indicateur.

ImageObjectExtractorHint hint(
    includeRects: 
        new List<RectInt32> {new RectInt32(370, 278, 285, 126)},
    includePoints: null,
    excludePoints: null ); 

ImageObjectExtractorHint hint(
    { 
        RectInt32{370, 278, 285, 126}
    }, 
    {},
    {}
);

Que puis-je faire avec l’extracteur de premier plan d’image ?

Utilisez ImageForegroundExtractor pour segmenter le premier plan d’une image d’entrée et activer des fonctionnalités telles que la suppression d’arrière-plan et la génération d’autocollants.

Le masque retourné est au format grisscale-8. Les valeurs de pixels sont comprises entre 0 et 255, où 0 représente les pixels d’arrière-plan, 255 représente les pixels de premier plan et les valeurs intermédiaires indiquent un mélange de pixels de premier plan et d’arrière-plan.

Génération d’un masque à partir d’une image bitmap

1. Appelez GetReadyState et attendez que EnsureReadyAsync se termine correctement pour confirmer que l’objet ImageForegroundExtractor est prêt.
2. Une fois le modèle prêt, appelez CreateAsync pour instancier un objet ImageForegroundExtractor.
3. Appelez GetMaskFromSoftwareBitmap avec l’image d’entrée pour générer le masque de premier plan.

using Microsoft.Windows.AI.Imaging;
using Microsoft.Windows.AI;

if (ImageForegroundExtractor.GetReadyState() == AIFeatureReadyState.NotReady)
{
    var result  = await ImageForegroundExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}

var model = await ImageForegroundExtractor.CreateAsync();

// Insert your own softwareBitmap here.
var foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

#include <winrt/Microsoft.Graphics.Imaging.h> 
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Microsoft::Windows::AI.Imaging;
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation;

if (ImageForegroundExtractor::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageForegroundExtractor::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

auto model = co_await ImageForegroundExtractor::CreateAsync();

// Insert your own softwareBitmap here.
auto foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

Que puis-je faire avec l’effacement d’objet ?

L’effacement d’objet peut être utilisé pour supprimer des objets d’images. Le modèle prend à la fois une image et un masque en niveaux de gris indiquant l'objet à supprimer, efface la zone masquée de l'image, et remplace la zone effacée par l'arrière-plan de l'image.

Exemple d’effacement d’objet

L’exemple suivant montre comment supprimer un objet d’une image. L’exemple suppose que vous disposez déjà d’objets bitmap logiciels (softwareBitmap) pour l’image et le masque. Le masque doit être au format Gray8 avec chaque pixel de la zone à supprimer défini sur 255 et tous les autres pixels définis sur 0.

1. Vérifiez que le modèle de segmentation d’image est disponible en appelant la méthode GetReadyState et en attendant que la méthode EnsureReadyAsync retourne correctement.
2. Une fois le modèle Object Erase disponible, créez un objet ImageObjectRemover pour le référencer.
3. Enfin, envoyez l’image et le masque au modèle à l’aide de la méthode RemoveFromSoftwareBitmap , qui retourne le résultat final.

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.AI;
using Microsoft.Windows.Management.Deployment;
using Windows.Graphics.Imaging;

if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectRemover.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}
ImageObjectRemover imageObjectRemover = await ImageObjectRemover.CreateAsync();
SoftwareBitmap finalImage = imageObjectRemover.RemoveFromSoftwareBitmap(imageBitmap, maskBitmap); // Insert your own imagebitmap and maskbitmap

#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging;
using namespace winrt::Microsoft::Windows::AI.Imaging;
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation;
if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageObjectRemover::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

ImageObjectRemover imageObjectRemover = ImageObjectRemover::CreateAsync().get();
// Insert your own imagebitmap and maskbitmap
Windows::Graphics::Imaging::SoftwareBitmap buffer = 
    imageObjectRemover.RemoveFromSoftwareBitmap(imageBitmap, maskBitmap);

IA responsable

Nous avons utilisé une combinaison des étapes suivantes pour garantir que ces API d’imagerie sont fiables, sécurisées et générées de manière responsable. Nous vous recommandons de consulter les meilleures pratiques décrites dans développement d’IA responsable sur Windows lors de l’implémentation de fonctionnalités IA dans votre application.

Voir aussi

• Galerie de développement d’IA
• Exemples d’API Windows AI