Introdução à Geração de Imagens de IA

2025-05-20

Os recursos de imagem no Windows AI Foundry dão suporte aos seguintes recursos:

Super Resolução de Imagem: ampliação e melhoria da nitidez de uma imagem.
Descrição da imagem: gerando texto que descreve uma imagem.
Segmentação de imagem: identificando objetos dentro de uma imagem.
Apagamento de objeto: removendo objetos de uma imagem.

Para obter detalhes da API, consulte referência de API para recursos de imagem de IA.

Para obter detalhes de moderação de conteúdo, consulte Segurança de conteúdo com APIs de IA generativas.

Importante

A seguir está uma lista de recursos de IA do Windows e a edição do Windows App SDK em que estão atualmente suportados.

Versão 1.8 Experimental (1.8.0-experimental1) - Apagamento de objeto, Phi Silica, ajuste fino de LoRA para Phi Silica, Resumo de Conversa (Inteligência de Texto)

Visualização privada – Pesquisa Semântica

Versão 1.7.1 (1.7.250401001) – Todas as outras APIs

Essas APIs só estarão funcionais em dispositivos WIP (Windows Insider Preview) que receberam a atualização de 7 de maio. De 28 a 29 de maio, uma atualização opcional será lançada para dispositivos não WIP, seguido pela atualização de 10 de junho. Essa atualização trará consigo os modelos de IA necessários para que as APIs de IA do Windows funcionem. Essas atualizações também exigirão que qualquer aplicativo que use APIs de IA do Windows não possa fazê-lo até que o aplicativo tenha recebido a identidade do pacote em runtime.

O que posso fazer com a Super Resolução de Imagem?

As APIs de Super Resolução de Imagem permitem nitidez e escala de imagem.

O dimensionamento é limitado a um fator máximo de 8x, pois fatores de escala mais altos podem introduzir artefatos e comprometer a precisão da imagem. Se a largura ou altura final for maior que 8x seus valores originais, uma exceção será lançada.

Mais detalhes sobre o Dimensionador de Imagens

O exemplo a seguir mostra como alterar a escala (targetWidth, targetHeight) de uma imagem de bitmap de software existente (softwareBitmap) e melhorar a nitidez da imagem (para melhorar a nitidez sem dimensionar a imagem, basta especificar a largura e a altura da imagem existentes) usando um objeto ImageScaler.

Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método ImageScaler.GetReadyState e aguardando o método ImageScaler.EnsureReadyAsync retornar com êxito.
Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageScaler para referenciá-lo.
Obtenha uma versão afiada e dimensionada da imagem existente passando a imagem existente e a largura e altura desejadas para o modelo usando o método ScaleSoftwareBitmap .

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

if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageScaler.EnsureReadyAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        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);

O que posso fazer com a Descrição da Imagem?

Importante

A Descrição da Imagem está atualmente indisponível na China.

As APIs de Descrição da Imagem fornecem a capacidade de gerar vários tipos de descrições de texto para uma imagem.

Há suporte para os seguintes tipos de descrições de texto:

Acessibilidade – Fornece uma longa descrição com detalhes destinados aos usuários com necessidades de acessibilidade.
Legenda – Fornece uma breve descrição adequada para uma legenda de imagem. O padrão se nenhum valor for especificado.
DetailedNarration – Fornece uma descrição longa.
OfficeCharts – Fornece uma descrição adequada para gráficos e diagramas.

Como essas APIs usam modelos de ML (Machine Learning), erros ocasionais podem ocorrer em que o texto não descreve a imagem corretamente. Portanto, não recomendamos o uso dessas APIs para imagens nos seguintes cenários:

Onde as imagens contêm conteúdo potencialmente confidencial e descrições imprecisas podem ser controversas, como sinalizadores, mapas, globos, símbolos culturais ou símbolos religiosos.
Quando descrições precisas são críticas, como para orientação médica ou diagnóstico, conteúdo legal ou documentos financeiros.

Obter a descrição do texto de uma imagem

A API de Descrição da Imagem usa uma imagem, o tipo de descrição de texto desejado (opcional) e o nível de moderação de conteúdo que você deseja empregar (opcional) para proteger contra uso prejudicial.

O exemplo a seguir mostra como obter uma descrição de texto para uma imagem.

Observação

A imagem deve ser um objeto ImageBuffer , pois o SoftwareBitmap não tem suporte no momento. Este exemplo demonstra como converter SoftwareBitmap em ImageBuffer.

Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método ImageDescriptionGenerator.GetReadyState e aguardando o método ImageDescriptionGenerator.EnsureReadyAsync retornar com êxito.
Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageDescriptionGenerator para referenciá-lo.
(Opcional) Crie um objeto ContentFilterOptions e especifique seus valores preferenciais. Se você optar por usar valores padrão, poderá passar um objeto nulo.
Obtenha a descrição da imagem (LanguageModelResponse.Response) chamando o método ImageDescriptionGenerator.DescribeAsync com a imagem original, uma enumeração para o tipo de descrição preferencial (opcional) e o objeto ContentFilterOptions (opcional).

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.EnsureNeeded) 
{
    var result = await ImageDescriptionGenerator.EnsureReadyAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        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();

O que posso fazer com a Segmentação de Imagem?

A segmentação de imagem pode ser usada para identificar objetos específicos em uma imagem. O modelo utiliza tanto uma imagem quanto um objeto de "dicas" e retorna uma máscara do objeto identificado.

As dicas podem ser fornecidas por meio de qualquer combinação dos seguintes:

Coordenadas para pontos que pertencem ao que você está identificando.
Coordenadas para pontos que não pertencem ao que você está identificando.
Um retângulo de coordenadas que inclui o que você está identificando.

Quanto mais dicas você fornecer, mais preciso o modelo pode ser. Siga estas diretrizes de dica para minimizar resultados ou erros imprecisos.

Evite usar vários retângulos em uma dica, pois eles podem produzir uma máscara imprecisa.
Evite usar pontos de exclusão exclusivamente sem pontos de inclusão ou um retângulo.
Não especifique mais do que o máximo permitido de 32 coordenadas (1 para um ponto, 2 para um retângulo), pois isso retornará um erro.

A máscara retornada está no formato de escala de cinza 8 com os pixels da máscara para o objeto identificado com um valor de 255 (todas as outras com um valor de 0).

Identificar um objeto em uma imagem

Os exemplos a seguir mostram maneiras de identificar um objeto dentro de uma imagem. Os exemplos pressupõem que você já tenha um objeto bitmap de software (softwareBitmap) para a entrada.

Verifique se o modelo de Segmentação de Imagem está disponível chamando o método GetReadyState e aguardando o método EnsureReadyAsync retornar com êxito.
Depois que o modelo de Segmentação de Imagem estiver disponível, crie um objeto ImageObjectExtractor para referenciá-lo .
Passe a imagem para ImageObjectExtractor.CreateWithSoftwareBitmapAsync.
Crie um objeto ImageObjectExtractorHint . Outras maneiras de criar um objeto de dica com entradas diferentes são demonstradas posteriormente.
Envie a dica para o modelo usando o método GetSoftwareBitmapObjectMask , que retorna o resultado final.

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

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageObjectExtractor.EnsureReadyAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        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);

Especificar dicas com pontos incluídos e excluídos

Este snippet de código demonstra como usar pontos incluídos e excluídos como dicas.

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

Especificar dicas com retângulo

Este snippet de código demonstra como usar um retângulo (RectInt32 é X, Y, Width, Height) como uma dica.

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

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

O que posso fazer com o Apagamento de Objeto?

O apagamento de objeto pode ser usado para remover objetos de imagens. O modelo usa uma imagem e uma máscara em escala de cinza que indica o objeto a ser removido, apaga a área mascarada da imagem e substitui a área apagada pelo plano de fundo da imagem.

Remover objetos indesejados de uma imagem

O exemplo a seguir mostra como remover um objeto de uma imagem. O exemplo pressupõe que você já tenha objetos bitmap de software (softwareBitmap) para a imagem e a máscara. A máscara deve estar no formato Gray8 com cada pixel da área a ser removido definido como 255 e todos os outros pixels definidos como 0.

Verifique se o modelo de Segmentação de Imagem está disponível chamando o método GetReadyState e aguardando o método EnsureReadyAsync retornar com êxito.
Depois que o modelo de Apagamento de Objeto estiver disponível, crie um objeto ImageObjectRemover para referenciá-lo.
Por fim, envie a imagem e a máscara para o modelo usando o método RemoveFromSoftwareBitmap , que retorna o resultado final.

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

if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageObjectRemover.EnsureReadyAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        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 responsável

Usamos uma combinação das etapas a seguir para garantir que essas APIs de imagem sejam confiáveis, seguras e criadas com responsabilidade. Recomendamos revisar as práticas recomendadas descritas em Desenvolvimento Responsável de IA Gerativa no Windows ao implementar recursos de IA em seu aplicativo.