Introduzione all'imaging di intelligenza artificiale

Le funzionalità di creazione di immagini di intelligenza artificiale supportate dalle API di intelligenza artificiale Windows consentono le funzionalità seguenti:

Super risoluzione dell'immagine: ridimensionamento e nitidezza un'immagine.
Descrizione immagine: generazione di testo che descrive un'immagine.
Segmentazione immagine: identificazione di oggetti all'interno di un'immagine.
Estrazione del primo piano dell'immagine: estrazione del primo piano di un'immagine di input
Cancellazione oggetto: rimozione di oggetti da un'immagine.

Per informazioni dettagliate sull'API, vedere Riferimento API per le funzionalità di creazione dell'immagine di intelligenza artificiale.

Per informazioni dettagliate sulla moderazione dei contenuti, vedere Sicurezza dei contenuti con API di intelligenza artificiale generative.

Importante

Requisiti del manifesto del pacchetto: per usare le API di creazione dell'immagine di Intelligenza artificiale di Windows, l'app deve essere inserita in un pacchetto MSIX con la systemAIModels funzionalità dichiarata in Package.appxmanifest. Assicurarsi inoltre che l'attributo del MaxVersionTested manifesto sia impostato su una versione di Windows recente (ad esempio, 10.0.26226.0 o versioni successive) per supportare correttamente le funzionalità di Intelligenza artificiale Windows. L'uso di valori meno recenti può causare errori "Non dichiarati dall'app" durante il caricamento del modello.

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

Cosa posso fare con la Super Risoluzione dell'Immagine?

Le API di super risoluzione delle immagini abilitano la nitidezza e il ridimensionamento delle immagini.

Il ridimensionamento è limitato a un fattore massimo di 8 volte perché i fattori di scala superiore possono introdurre artefatti e compromettere l'accuratezza dell'immagine. Se la larghezza finale o l'altezza è maggiore di 8 volte i valori originali, verrà generata un'eccezione.

Esempio di super-risoluzione dell'immagine

L'esempio seguente mostra come modificare la scala (targetWidth, targetHeight) di un'immagine bitmap software esistente (softwareBitmap) e migliorare la nitidezza dell'immagine usando un ImageScaler oggetto (per migliorare la nitidezza senza ridimensionare l'immagine, specificare semplicemente la larghezza e l'altezza dell'immagine esistenti).

Verificare che il modello image super resolution sia disponibile chiamando il metodo GetReadyState e quindi attendendo che il metodo EnsureReadyAsync venga restituito correttamente.
Quando il modello image super resolution è disponibile, creare un oggetto ImageScaler per farvi riferimento.
Ottenere una versione nitida e ridimensionata dell'immagine esistente passando l'immagine esistente e la larghezza e l'altezza desiderate al modello usando il metodo 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);

Cosa posso fare con la descrizione dell'immagine?

Importante

La descrizione dell'immagine non è attualmente disponibile in Cina.

Le API Descrizione immagine consentono di generare vari tipi di descrizioni di testo per un'immagine.

Sono supportati i tipi di descrizioni di testo seguenti:

Descrizione sintetica: offre un riassunto adatto per grafici e diagrammi.
Dettagliato : fornisce una descrizione lunga.
Diagramma : fornisce una breve descrizione adatta per una didascalia dell'immagine. Valore predefinito se non viene specificato alcun valore.
Accessibile : fornisce una descrizione lunga con i dettagli destinati agli utenti con esigenze di accessibilità.

Poiché queste API usano modelli di Machine Learning (ML), possono verificarsi errori occasionali in cui il testo non descrive correttamente l'immagine. Pertanto, non è consigliabile usare queste API per le immagini negli scenari seguenti:

Dove le immagini contengono contenuti potenzialmente sensibili e descrizioni imprecise potrebbero essere controverse, ad esempio bandiere, mappe, globo, simboli culturali o simboli religiosi.
Quando le descrizioni accurate sono critiche, ad esempio per consulenza medica o diagnosi, contenuto legale o documenti finanziari.

Esempio di Descrizione immagine

Nell'esempio seguente viene illustrato come ottenere una descrizione di testo per un'immagine in base al tipo di descrizione specificato (facoltativo) e al livello di moderazione del contenuto (facoltativo).

Nota

L'immagine deve essere un oggetto ImageBuffer perché SoftwareBitmap non è attualmente supportato (in questo esempio viene illustrato come convertire SoftwareBitmap in ImageBuffer).

Verificare che il modello image super resolution sia disponibile chiamando il metodo GetReadyState e quindi attendendo che il metodo EnsureReadyAsync venga restituito correttamente.
Dopo aver reso disponibile il modello Image Super Resolution, creare un oggetto ImageDescriptionGenerator per farvi riferimento.
(Facoltativo) Creare un oggetto ContentFilterOptions e specificare i valori preferiti. Se si sceglie di usare i valori predefiniti, è possibile passare un oggetto Null.
Ottenere la descrizione dell'immagine (LanguageModelResponse.Response) chiamando il metodo DescribeAsync che specifica l'immagine originale, ImageDescriptionKind (un valore facoltativo per il tipo di descrizione preferito) e l'oggetto ContentFilterOptions (facoltativo).

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

Cosa posso fare con la segmentazione delle immagini?

La segmentazione dell'immagine può essere usata per identificare oggetti specifici in un'immagine. Il modello accetta sia un'immagine che un oggetto chiamato "indicazioni" e restituisce una maschera dell'oggetto identificato.

Gli hint possono essere forniti tramite qualsiasi combinazione dei seguenti elementi:

Coordinate per i punti che appartengono all'elemento che stai identificando.
Coordinate per i punti che non appartengono a quello che stai identificando.
Il rettangolo di coordinate che racchiude ciò che stai identificando.

Maggiore è il numero di suggerimenti forniti, maggiore è la precisione del modello. Seguire queste linee guida sui suggerimenti per ridurre al minimo i risultati o gli errori inaccurati.

Evitare di usare più rettangoli in un suggerimento perché possono produrre una maschera imprecisa.
Evitare di usare esclusivamente punti di esclusione senza includere punti o un rettangolo.
Non specificare più del massimo supportato di 32 coordinate (1 per un punto, 2 per un rettangolo) perché verrà restituito un errore.

La maschera restituita è in formato grigio-8 con i pixel della maschera per l'oggetto identificato con un valore pari a 255 (tutti gli altri hanno un valore pari a 0).

Esempio di segmentazione delle immagini

Negli esempi seguenti vengono illustrati i modi per identificare un oggetto all'interno di un'immagine. Gli esempi presuppongono che sia già presente un oggetto bitmap software (softwareBitmap) per l'input.

Verificare che il modello di segmentazione dell'immagine sia disponibile chiamando il metodo GetReadyState e attendendo che il metodo EnsureReadyAsync restituisca correttamente.
Una volta che il modello di "image segmentation" è disponibile, creare un oggetto ImageObjectExtractor per farvi riferimento.
Passare l'immagine a CreateWithSoftwareBitmapAsync.
Creare un oggetto ImageObjectExtractorHint . Altri modi per creare un oggetto hint con input diversi vengono illustrati in un secondo momento.
Inviare l'hint al modello usando il metodo GetSoftwareBitmapObjectMask , che restituisce il risultato finale.

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

Specificare suggerimenti con punti inclusi ed esclusi

Questo frammento di codice illustra come usare punti inclusi ed esclusi come hint.

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

Specificare i suggerimenti con rettangolo

Questo frammento di codice illustra come usare un rettangolo (RectInt32 è X, Y, Width, Height) come hint.

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

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

Cosa è possibile fare con lo strumento Image Foreground Extractor?

Usare ImageForegroundExtractor per segmentare il primo piano di un'immagine di input e abilitare funzionalità come la rimozione dello sfondo e la generazione di adesivi.

La maschera restituita è in formato scala di grigi a 8 bit. I valori pixel sono compresi tra 0 e 255, dove 0 rappresenta i pixel di sfondo, 255 rappresenta i pixel di primo piano e i valori intermedi indicano una miscela di pixel di primo piano e di sfondo.

Generazione di una maschera da un'immagine bitmap

Chiamare GetReadyState e attendere il completamento di EnsureReadyAsync per verificare che l'oggetto ImageForegroundExtractor sia pronto.
Dopo aver pronto il modello, chiamare CreateAsync per creare un'istanza di un oggetto ImageForegroundExtractor.
Chiamare GetMaskFromSoftwareBitmap con l'immagine di input per generare la maschera in primo piano.

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

Cosa posso fare con la cancellazione di oggetti?

La cancellazione degli oggetti può essere usata per rimuovere oggetti dalle immagini. Il modello accetta sia un'immagine che una maschera in scala di grigi che indica l'oggetto da rimuovere, cancella l'area mascherata dall'immagine e sostituisce l'area cancellata con lo sfondo dell'immagine.

Esempio di cancellazione oggetti

Nell'esempio seguente viene illustrato come rimuovere un oggetto da un'immagine. Nell'esempio si presuppone che siano già presenti oggetti bitmap software (softwareBitmap) sia per l'immagine che per la maschera. La maschera deve essere in formato Gray8 con ogni pixel dell'area da rimuovere su 255 e tutti gli altri pixel impostati su 0.

Verificare che il modello di segmentazione dell'immagine sia disponibile chiamando il metodo GetReadyState e attendendo che il metodo EnsureReadyAsync restituisca correttamente.
Quando il modello Di cancellazione oggetti è disponibile, creare un oggetto ImageObjectRemover per farvi riferimento.
Inviare infine l'immagine e la maschera al modello usando il metodo RemoveFromSoftwareBitmap , che restituisce il risultato finale.

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

Intelligenza artificiale responsabile

È stata usata una combinazione dei passaggi seguenti per garantire che queste API di imaging siano affidabili, sicure e create in modo responsabile. È consigliabile esaminare le procedure consigliate descritte in Sviluppo di intelligenza artificiale responsabile in Windows quando si implementano le funzionalità di intelligenza artificiale nell'app.

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-11-17