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

O Foundry da Microsoft no Windows dá suporte a recursos de Geração de Imagem de IA por meio de um conjunto de APIs baseadas em inteligência artificial, alimentadas por Stable Diffusion (modelo de IA de software livre usado para processamento de imagens) que são enviados no SDK do Windows App. Você pode usar essas APIs em seus aplicativos do Windows para criar, transformar e aprimorar imagens e fotos usando prompts de linguagem natural e modelos generativos no dispositivo.

A Geração de Imagem por IA está otimizada para oferecer eficiência e desempenho em PCs com Windows Copilot+.

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

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

Pré-requisitos

• Versão do Windows: Windows 11, versão 24H2 (build 26100) ou posterior
• SDK do Aplicativo Windows versão:Versão 2.0 Experimental
• Hardware: Copilot+ PC com NPU (obrigatório)

Hardware com suporte

A Geração de Imagem de IA é executada no seguinte hardware:

Disponibilidade e download do modelo

O modelo de Geração de Imagem de IA é optional em um Copilot+ PC — ele é não pré-instalado por padrão, porque o tamanho da instalação é de vários gigabytes. Na primeira vez que seu aplicativo chama EnsureReadyAsync, o modelo é baixado em segundo plano por meio de Windows Update. Os usuários finais também podem remover o modelo posteriormente para recuperar o espaço em disco.

Esse comportamento corresponde ao ciclo de vida do modelo usado por outros grandes modelos opcionais de IA Windows – seu aplicativo deve lidar com o caso "ainda não instalado" explicitamente em vez de assumir que o modelo está presente.

Padrão de UX recomendado

Como o modelo de Geração de Imagem de IA é grande e não está presente por padrão, mostre uma caixa de diálogo de confirmação antes de chamar EnsureReadyAsync para que o usuário possa consentir com o custo de armazenamento e o download em segundo plano. Um padrão típico:

1. Chame GetReadyState e faça a ramificação com base no AIFeatureReadyState retornado:

   • Ready — o modelo está instalado; Prosseguir.
   • NotReady ou EnsureNeeded — mostre sua caixa de diálogo de consentimento (veja abaixo), em seguida, ligue EnsureReadyAsync apenas se o usuário concordar.
   • NotSupportedOnCurrentSystem — o dispositivo não é um PC Copilot+ ou, de outra forma, não atende aos requisitos de Hardware compatível. Ofereça uma experiência alternativa e, quando apropriado, apresente os requisitos de hardware para que o usuário possa tomar uma decisão informada sobre a atualização.

2. Na caixa de diálogo de consentimento, explique:

   • Um modelo de geração de imagem opcional será baixado (vários GB de armazenamento).
   • O download ocorre em segundo plano por meio de Windows Update.
   • O usuário pode monitorar o progresso do download em Settings>Windows Update.
   • Posteriormente, o usuário poderá remover o modelo nosComponentes de IA do> de > se ele não quiser mais.

   Dica

   Em cadeias de caracteres voltadas para o usuário (texto da caixa de diálogo, mensagens de status), consulte o modelo como o "modelo de geração de imagem" ou "modelo de IA opcional" em vez de "SDXL" ou "Difusão Estável". A maioria dos usuários finais não está familiarizada com os nomes de modelo subjacentes e termos genéricos comunicam a finalidade com mais clareza.

3. Enquanto EnsureReadyAsync estiver em andamento, mostre um indicador de progresso em seu aplicativo. Consulte Introdução às APIs de IA do Windows para o padrão de interface de usuário de carregamento.

Depois que o modelo é instalado

O modelo permanece no dispositivo até que o usuário o remova. Os usuários gerenciam modelos instalados, incluindo o modelo de Geração de Imagem de IA, emComponentes de IA>>. Se o usuário remover o modelo posteriormente, a próxima chamada do app para GetReadyState retornará NotReady ou EnsureNeeded, e o fluxo de consentimento + download deverá ser repetido.

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

Use a Geração de Imagem de IA para transformar prompts em artefatos visuais. Os recursos com suporte incluem:

• Texto para Imagem

  Gere imagens a partir de sugestões de texto descritivo. Útil para ilustrações, design, planos de fundo personalizados e visualização conceitual.

• Imagem para imagem

  Transforme uma imagem existente com base nas diretrizes textuais, preservando a estrutura. Útil para estilo, temas e outras variações.

• Preenchimento Mágico

  Preencha regiões mascaradas de uma imagem com conteúdo gerado por IA. Útil para remover objetos, reparar regiões e edição intuitiva (revisões complexas por meio de prompts de texto em vez de ferramentas manuais).

• Estilo do livro de colorir

  Converta imagens em estruturas de tópicos simplificadas que você pode usar para um livro de colorir ou experiência educacional semelhante.

• Restyle

  Aplique estilos artísticos ou visuais a imagens existentes ao preservar a estrutura. Útil para filtros criativos, modos artísticos ou transformações temáticas.

Exemplos

Siga estas etapas básicas ao usar as APIs de Geração de Imagem de IA.

1. Verifique se o modelo está pronto usando EnsureReadyAsync.
2. Crie uma instância do ImageGenerator .
3. Selecione o fluxo de trabalho de geração apropriado (prompt de texto, entrada de imagem ou máscara).
4. Invoque o método de geração correspondente.
5. Receba a saída como um ImageBuffer para exibir, editar ou salvar.

Gerar uma imagem de um prompt de texto (Texto para Imagem)

Este exemplo mostra como gerar uma imagem de um prompt de texto. Especificamente, "Um belo pôr do sol sobre um lago montanhoso".

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

public async Task GenerateImageFromText()
{
    // Check if models are ready
    var readyState = ImageGenerator.GetReadyState();
    if (readyState != AIFeatureReadyState.Ready)
    {
        // Download models if needed
        var result = await ImageGenerator.EnsureReadyAsync();
        if (result.Status != AIFeatureReadyResultState.Success)
        {
            Console.WriteLine("Failed to prepare models");
            return;
        }
    }

    // Create ImageGenerator instance
    using var generator = await ImageGenerator.CreateAsync();
    
    // Configure generation options
    var options = new ImageGenerationOptions
    {
        MaxInferenceSteps = 6,
        Creativity = 0.8,
        Seed = 42
    };

    // Generate image
    var result = generator.GenerateImageFromTextPrompt("A beautiful sunset over a mountain lake", options);
    
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        var imageBuffer = result.Image;
        // Use the generated image (save to file, display, etc.)
        await SaveImageBufferAsync(imageBuffer, "generated_image.png");
    }
    else
    {
        Console.WriteLine($"Image generation failed: {result.Status}");
    }
}

Transformar um estilo de imagem (imagem em imagem)

Este exemplo mostra como transformar uma fotografia em uma pintura a óleo com base em um prompt de texto. Especificamente, "estilo de pintura a óleo, pincel grosso, artístico".

public async Task RestyleImage()
{
    using var generator = await ImageGenerator.CreateAsync();
    
    // Load input image
    var inputImage = await LoadImageBufferAsync("photo.jpg");
    
    var options = new ImageGenerationOptions();
    var styleOptions = new ImageFromImageGenerationOptions
    {
        Style = ImageFromImageGenerationStyle.Restyle,
        ColorPreservation = 0.7f
    };

    var result = generator.GenerateImageFromImageBuffer(
        inputImage, 
        "oil painting style, thick brush strokes, artistic", 
        options, 
        styleOptions);
    
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        await SaveImageBufferAsync(result.Image, "restyled_image.png");
    }
}

Transformar o estilo de uma imagem (processo complexo de imagem para imagem)

Este exemplo mostra como transformar uma fotografia em uma pintura a óleo com base em um prompt de texto. Especificamente, "Uma pintura a óleo, traços de pincel espessos, paleta de cores avançadas, textura de tela tradicional, iluminação realista, estilo clássico de belas artes, tinta em camadas, detalhes altos, contraste dramático, impasto, tela texturizada".

using Microsoft.Windows.AI.Imaging;

public async Task CreateImageFromPrompt()
{
    using ImageGenerator model = await ImageGenerator.CreateAsync();

    // Using default values
    var options = new ImageGenerationOptions();

    // Set ImageFromImageGenerationOptions fields
    var imageFromImageOptions = new ImageFromImageGenerationOptions();
    imageFromImageOptions.Style = ImageFromImageGenerationStyle.Restyle;
    imageFromImageOptions.ColorPreservation = 0.5f; // range [0.0f, 1.0f]

    // Load an input image buffer
    using var inputImage = await Utils.LoadSampleImageBufferAsync("sdxl_input_horse.png");

    var textPrompt = "An oil painting, thick brush strokes, rich color palette, traditional canvas texture, realistic lighting, classical fine art style, layered paint, high detail, dramatic contrast, impasto, textured canvas";

    var result = model.GenerateImageFromImageBuffer(inputImage, textPrompt, options, imageFromImageOptions);
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        // Image generated successfully
        var imageBuffer = result.Image;
        // Process the imageBuffer as needed, e.g., save to file or display
    }
    else
    {
        // Handle error cases based on result.Status
        Console.WriteLine($"Image generation failed with status: {result.Status}");
    }
}

Preenchimento Mágico com Máscara

Este exemplo mostra como usar uma máscara para preencher uma região de uma imagem. Especificamente, "um carro esportivo vermelho".

public async Task FillMaskedRegion()
{
    using var generator = await ImageGenerator.CreateAsync();
    
    var inputImage = await LoadImageBufferAsync("scene.jpg");
    var maskImage = await LoadImageBufferAsync("mask.png"); // GRAY8 format
    
    var options = new ImageGenerationOptions();
    
    var result = generator.GenerateImageFromImageBufferAndMask(
        inputImage, 
        maskImage, 
        "a red sports car", 
        options);
    
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        await SaveImageBufferAsync(result.Image, "filled_image.png");
    }
}

Gerar imagem no estilo de livro de colorir

Este exemplo mostra como gerar uma imagem em um estilo de livro de colorir. Especificamente, um "Gato na nave espacial".

using Microsoft.Windows.AI.Imaging;

public async Task CreateImageFromPrompt()
{
    using ImageGenerator model = await ImageGenerator.CreateAsync();

    // Using default values
    var options = new ImageGenerationOptions();

    // Set ImageFromTextGenerationOptions fields
    var imageFromTextOptions = new ImageFromTextGenerationOptions();
    imageFromTextOptions.Style = ImageFromTextGenerationStyle.ColoringBook;

    var result = model.GenerateImageFromTextPrompt("Cat in spaceship", options, imageFromTextOptions);
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        // Image generated successfully
        var imageBuffer = result.Image;
        // Process the imageBuffer as needed, e.g., save to file or display
    }
    else
    {
        // Handle error cases based on result.Status
        Console.WriteLine($"Image generation failed with status: {result.Status}");
    }
}

Gerar imagem usando parâmetros personalizados de ImageGenerationOptions

Este exemplo mostra como gerar uma imagem com base em um conjunto de filtros de conteúdo e restrições. Especificamente, um "gato em uma nave espacial" usando um TextContentFilterSeverity de Baixo e um ImageContentFilterSeverity de Mínimo.

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

public async Task CreateImageFromPromptAndCustomOptions()
{
    using ImageGenerator model = await ImageGenerator.CreateAsync();

    // Using default values
    var options = new ImageGenerationOptions();

    // Set custom ImageGenerationOptions fields
    options.MaxInferenceSteps = 6;
    options.Creativity = 0.8;
    options.Seed = 1234;
    ContentFilterOptions contentFilterOptions = new ContentFilterOptions();
    contentFilterOptions.PromptMaxAllowedSeverityLevel = new TextContentFilterSeverity { Hate = SeverityLevel.Low, Sexual = SeverityLevel.Low, Violent = SeverityLevel.Low, SelfHarm = SeverityLevel.Low };
    contentFilterOptions.ImageMaxAllowedSeverityLevel = new ImageContentFilterSeverity { AdultContentLevel = SeverityLevel.Minimum, GoryContentLevel = SeverityLevel.Minimum, RacyContentLevel = SeverityLevel.Minimum, ViolentContentLevel = SeverityLevel.Minimum };
    options.ContentFilterOptions = contentFilterOptions;

    var result = model.GenerateImageFromTextPrompt("Cat in spaceship", options);
    if (result.Status == ImageGeneratorResultStatus.Success)
    {
        // Image generated successfully
        var imageBuffer = result.Image;
        // Process the imageBuffer as needed, e.g., save to file or display
    }
    else
    {
        // Handle error cases based on result.Status
        Console.WriteLine($"Image generation failed with status: {result.Status}");
    }
}

IA responsável

Siga as recomendações de IA responsáveis, incluindo transparência e confiança do usuário, ao usar essas APIs para modificar ou gerar imagens em seus aplicativos do Windows. Para ajudar os usuários a entender a origem e o histórico de imagens geradas ou modificadas, forneça credenciais de conteúdo conforme especificado pelos padrões C2PA (Coalizão para Procedência e Autenticidade de Conteúdo ).

Consulte Desenvolvimento responsável de IA Generativa no Windows para obter as melhores práticas ao implementar recursos de IA em aplicativos do Windows.

Consulte também

• Ref de API para recursos de imagem de IA