Introdução à criação de imagens de IA

As funcionalidades de IA Imaging suportadas pelas APIs de IA do Windows permitem as seguintes capacidades:

• Super Resolução de Imagem: ampliação e melhoramento de uma imagem.
• Descrição da imagem: geração de texto que descreve uma imagem.
• Segmentação de Imagem: identificação de objetos dentro de uma imagem.
• Extração de primeiro plano de imagem: extraindo o primeiro plano de uma imagem de entrada
• Apagar objetos: remover objetos de uma imagem.

Para obter detalhes da API, consulte API ref for AI imaging features.

Para obter detalhes sobre 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 a nitidez e o dimensionamento da 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 a altura final for maior que oito vezes os 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 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 existente).

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

2. Quando o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageScaler para fazer referência a ele.

3. Obtenha uma versão nítida 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 de Imagem fornecem a capacidade de gerar vários tipos de descrições de texto para uma imagem.

Os seguintes tipos de descrições de texto são suportados:

• Breve - Fornece uma descrição adequada para gráficos e diagramas.
• Detalhado - Fornece uma longa descrição.
• 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 a usuários com necessidades de acessibilidade.

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

• Quando as imagens contêm conteúdo potencialmente sensível e descrições imprecisas podem ser controversas, como bandeiras, mapas, globos, símbolos culturais ou símbolos religiosos.
• Quando descrições precisas são críticas, como para aconselhamento médico 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 que o método EnsureReadyAsync retorne com êxito.

2. Quando o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageDescriptionGenerator para fazer referência a ele.

3. (Opcional) Crie um objeto ContentFilterOptions e especifique seus valores preferidos. 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 preferido) 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 considera tanto uma imagem quanto um objeto de "sugestões" e retorna uma máscara do objeto identificado.

As dicas podem ser fornecidas através de qualquer combinação do seguinte:

• 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 dicas para minimizar resultados imprecisos ou erros.

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

A máscara retornada está no formato escala de cinza-8 com os pixels da máscara para o objeto identificado tendo um valor de 255 (todos os outros tendo 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 de 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 retorno bem-sucedido do método EnsureReadyAsync .

2. Quando o modelo de segmentação de imagem estiver disponível, crie um objeto ImageObjectExtractor para fazer referência a ele.

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 trecho 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 trecho 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 Image Foreground Extrator?

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 devolvida está no formato escala de cinzentos-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 de plano de fundo.

Gerando uma máscara a partir de uma imagem bitmap

1. Chame GetReadyState e aguarde a conclusão bem-sucedida de EnsureReadyAsync para confirmar que o objeto ImageForegroundExtractor está pronto.
2. Depois que o modelo estiver pronto, chame CreateAsync para instanciar 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 Object Erase?

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

Exemplo de Apagar Objetos

O exemplo a seguir mostra como remover um objeto de uma imagem. O exemplo pressupõe que você já tenha objetos de 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 removida 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 retorno bem-sucedido do método EnsureReadyAsync .
2. Quando o modelo Object Erase estiver disponível, crie um objeto ImageObjectRemover para fazer referência a ele.
3. Finalmente, 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 criação de imagens sejam confiáveis, seguras e criadas de forma responsável. Recomendamos rever as práticas recomendadas descritas em Desenvolvimento de IA Generativa Responsável no Windows ao implementar recursos de IA em seu aplicativo.

Ver também

• AI Dev Galeria
• Exemplos de API de IA do Windows