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

Os recursos de Imagem de IA compatíveis com as APIs de IA do Windows habilitam os 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.
• Extração em primeiro plano da imagem: extraindo o primeiro plano de uma imagem de entrada
• 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.

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

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.

Exemplo de Super Resolução de Imagem

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 usando um ImageScaler objeto (para melhorar a nitidez sem dimensionar a imagem, basta especificar a largura e a altura da imagem existentes).

1. Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método GetReadyState e aguardando o método EnsureReadyAsync retornar com êxito.

2. Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageScaler para referenciá-lo.

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

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

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:

• Resumo – Oferece uma descrição apropriada para gráficos e diagramas.
• Detalhado – Fornece uma descrição longa.
• Diagrama – Fornece uma breve descrição adequada para uma legenda de imagem. O padrão se nenhum valor for especificado.
• Acessível – Fornece uma longa descrição com detalhes destinados aos usuários com necessidades de acessibilidade.

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.

Exemplo de Descrição da Imagem

O exemplo a seguir mostra como obter uma descrição de texto para uma imagem com base no tipo de descrição especificado (opcional) e no nível de moderação de conteúdo (opcional).

1. Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método GetReadyState e aguardando o método EnsureReadyAsync retornar com êxito.

2. Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageDescriptionGenerator para referenciá-lo.

3. (Opcional) Crie um objeto ContentFilterOptions e especifique seus valores preferenciais. Se você optar por usar valores padrão, poderá passar um objeto nulo.

4. Obtenha a descrição da imagem (LanguageModelResponse.Response) chamando o método DescribeAsync especificando a imagem original, o ImageDescriptionKind (um valor opcional para o tipo de descrição preferencial) 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.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();

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

Exemplo de segmentação de 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.

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

2. Depois que o modelo de Segmentação de Imagem estiver disponível, crie um objeto ImageObjectExtractor para referenciá-lo .

3. Passe a imagem para CreateWithSoftwareBitmapAsync.

4. Crie um objeto ImageObjectExtractorHint . Outras maneiras de criar um objeto de dica com entradas diferentes são demonstradas posteriormente.

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

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 Extrator de Primeiro Plano de Imagem?

Use ImageForegroundExtractor para segmentar o primeiro plano de uma imagem de entrada e habilitar recursos como remoção de plano de fundo e geração de adesivos.

A máscara retornada está no formato greyscale-8. Os valores de pixel variam de 0 a 255, onde 0 representa pixels de plano de fundo, 255 representa pixels de primeiro plano e valores intermediários indicam uma mistura de pixels de primeiro plano e plano de fundo.

Gerando uma máscara de uma imagem bitmap

1. Chame GetReadyState e aguarde a conclusão do EnsureReadyAsync com êxito para confirmar se o objeto ImageForegroundExtractor está pronto.
2. Depois que o modelo estiver pronto, chame CreateAsync para criar uma instância de um objeto ImageForegroundExtractor.
3. Chame GetMaskFromSoftwareBitmap com a imagem de entrada para gerar a máscara de primeiro plano.

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

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.

Exemplo de apagamento de objeto

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.

1. 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.
2. Depois que o modelo de Apagamento de Objeto estiver disponível, crie um objeto ImageObjectRemover para referenciá-lo.
3. 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.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 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.

Consulte também

• Galeria de Desenvolvimento de IA
• Exemplos de API de IA do Windows