Introducción a la creación de imágenes de IA

2025-05-20

Las características de creación de imágenes en Windows AI Foundry admiten las siguientes funcionalidades:

Superresolución de imágenes: escalado y mejora de la nitidez de una imagen.
Descripción de la imagen: generación de texto que describe una imagen.
Segmentación de imágenes: identificación de objetos dentro de una imagen.
Borrar objeto: quitar objetos de una imagen.

Para más información sobre la API, consulte API ref for AI imaging features (Referencia de API para características de creación de imágenes de IA).

Para obtener detalles sobre la moderación de contenido, consulte la seguridad de contenido con APIs de IA generativa.

Importante

A continuación se muestra una lista de las características de windows AI y la versión de Windows App SDK en la que se admiten actualmente.

Versión 1.8 Experimental (1.8.0-experimental1) - Borrado de objeto, Phi Silica, ajuste fino de LoRA para Phi Silica, Resumen de conversación (Inteligencia de Texto)

Versión preliminar privada : búsqueda semántica

Versión 1.7.1 (1.7.250401001): todas las demás API

Estas API solo serán funcionales en dispositivos windows Insider Preview (WIP) que han recibido la actualización del 7 de mayo. El 28 y 29 de mayo, se publicará una actualización opcional en dispositivos que no sean WIP, seguida por la actualización del 10 de junio. Esta actualización le proporcionará los modelos de IA necesarios para que funcionen las API de IA de Windows. Estas actualizaciones también requerirán que cualquier aplicación que use las API de Ia de Windows no podrá hacerlo hasta que la aplicación se haya concedido la identidad del paquete en tiempo de ejecución.

¿Qué puedo hacer con la super resolución de imágenes?

Las API de super resolución de imágenes habilitan el ajuste y el escalado de imágenes.

El escalado se limita a un factor máximo de 8x, ya que los factores de escala más altos pueden introducir artefactos y poner en peligro la precisión de la imagen. Si el ancho final o alto es mayor que 8 veces sus valores originales, se producirá una excepción.

Más detalles sobre Image Scaler

En el ejemplo siguiente se muestra cómo cambiar la escala (targetWidth, targetHeight) de una imagen de mapa de bits de software existente (softwareBitmap) y mejorar la nitidez de la imagen (para mejorar la nitidez sin escalar la imagen, simplemente especificar el ancho y el alto de la imagen existentes) mediante un objeto ImageScaler.

Asegúrese de que el modelo de super resolución de imágenes está disponible llamando al método ImageScaler.GetReadyState y, a continuación, esperando a que el método ImageScaler.EnsureReadyAsync se devuelva correctamente.
Una vez disponible el modelo de super resolución de imágenes, cree un objeto ImageScaler para hacer referencia a él.
Obtenga una versión afilada y escalada de la imagen existente pasando la imagen existente y el ancho y alto deseados al modelo mediante el 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);

¿Qué puedo hacer con la descripción de la imagen?

Importante

La descripción de la imagen no está disponible actualmente en China.

Las API de descripción de imágenes proporcionan la capacidad de generar varios tipos de descripciones de texto para una imagen.

Se admiten los siguientes tipos de descripciones de texto:

Accesibilidad: proporciona una descripción detallada y extensa destinada a usuarios con necesidades de accesibilidad.
Subtítulo: proporciona una breve descripción adecuada para un título de imagen. Valor predeterminado si no se especifica ningún valor.
Narración Detallada: proporciona una descripción larga.
OfficeCharts - proporciona una descripción adecuada para gráficos y diagramas.

Dado que estas API usan modelos de Machine Learning (ML), pueden producirse errores ocasionales en los que el texto no describe correctamente la imagen. Por lo tanto, no se recomienda usar estas API para imágenes en los escenarios siguientes:

Donde las imágenes contienen contenido potencialmente confidencial y descripciones inexactas podrían ser controvertidas, como banderas, mapas, globos, símbolos culturales o símbolos religiosos.
Cuando las descripciones precisas son críticas, como para asesoramiento médico o diagnóstico, contenido legal o documentos financieros.

Obtener la descripción del texto de una imagen

Image Description API toma una imagen, el tipo de descripción de texto deseado (opcional) y el nivel de moderación de contenido que desea emplear (opcional) para protegerse contra el uso perjudicial.

En el ejemplo siguiente se muestra cómo obtener una descripción de texto para una imagen.

Nota:

La imagen debe ser un objeto ImageBuffer , ya que SoftwareBitmap no se admite actualmente. En este ejemplo se muestra cómo convertir SoftwareBitmap en ImageBuffer.

Asegúrese de que el modelo de super resolución de imágenes está disponible llamando al método ImageDescriptionGenerator.GetReadyState y, a continuación, esperando a que el método ImageDescriptionGenerator.EnsureReadyAsync se devuelva correctamente.
Una vez disponible el modelo de super resolución de imágenes, cree un objeto ImageDescriptionGenerator para hacer referencia a él.
(Opcional) Cree un objeto ContentFilterOptions y especifique los valores preferidos. Si decide usar valores predeterminados, puede pasar un objeto NULL.
Obtenga la descripción de la imagen (LanguageModelResponse.Response) llamando al método ImageDescriptionGenerator.DescribeAsync con la imagen original, una enumeración para el tipo de descripción preferido (opcional) y el 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();

¿Qué puedo hacer con la segmentación de imágenes?

La segmentación de imágenes se puede usar para identificar objetos específicos en una imagen. El modelo toma tanto una imagen como un objeto de "pistas" y devuelve una máscara del objeto identificado.

Las sugerencias se pueden proporcionar a través de cualquier combinación de lo siguiente:

Coordenadas para los puntos que pertenecen a lo que está identificando.
Coordenadas para los puntos que no pertenecen a lo que está identificando.
Rectángulo de coordenadas que incluye lo que está identificando.

Cuantos más sugerencias proporcione, más precisa puede ser el modelo. Siga estas instrucciones de sugerencia para minimizar los resultados o errores inexactos.

Evite usar varios rectángulos en una sugerencia, ya que pueden producir una máscara inexacta.
Evite usar puntos de exclusión exclusivamente sin incluir puntos ni un rectángulo.
No especifique más que el máximo admitido de 32 coordenadas (1 para un punto, 2 para un rectángulo), ya que devolverá un error.

La máscara devuelta está en formato de escala gris-8 con los píxeles de la máscara para el objeto identificado que tiene un valor de 255 (todos los demás tienen un valor de 0).

Identificación de un objeto dentro de una imagen

En los ejemplos siguientes se muestran formas de identificar un objeto dentro de una imagen. En los ejemplos se asume que ya dispones de un objeto de mapa de bits de software (softwareBitmap) para la entrada.

Asegúrese de que el modelo de segmentación de imágenes está disponible llamando al método GetReadyState y esperando a que el método EnsureReadyAsync se devuelva correctamente.
Una vez disponible el modelo de segmentación de imágenes, cree un objeto ImageObjectExtractor para hacer referencia a él.
Pase la imagen a ImageObjectExtractor.CreateWithSoftwareBitmapAsync.
Cree un objeto ImageObjectExtractorHint . Otras formas de crear un objeto de sugerencia con entradas diferentes se muestran más adelante.
Envíe la sugerencia al modelo mediante el método GetSoftwareBitmapObjectMask , que devuelve el 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 sugerencias con puntos incluidos y excluidos

Este fragmento de código muestra cómo usar puntos incluidos y excluidos como sugerencias.

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 sugerencias con rectángulo

Este fragmento de código muestra cómo usar un rectángulo (RectInt32 es X, Y, Width, Height) como sugerencia.

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

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

¿Qué puedo hacer con el borrado de objetos?

El borrado de objetos se puede usar para quitar objetos de imágenes. El modelo toma una imagen y una máscara de escala de grises que indica el objeto que se va a quitar, borra el área enmascarada de la imagen y reemplaza el área borrada por el fondo de la imagen.

Quitar objetos no deseados de una imagen

En el ejemplo siguiente se muestra cómo quitar un objeto de una imagen. En el ejemplo se supone que ya tiene objetos de mapa de bits de software (softwareBitmap) tanto para la imagen como para la máscara. La máscara debe estar en formato Gray8, con cada píxel del área que se va a eliminar ajustado a 255 y todos los demás píxeles ajustados a 0.

Asegúrese de que el modelo de segmentación de imágenes está disponible llamando al método GetReadyState y esperando a que el método EnsureReadyAsync se devuelva correctamente.
Una vez disponible el modelo de borrado de objetos, cree un objeto ImageObjectRemover para hacer referencia a él.
Por último, envíe la imagen y la máscara al modelo mediante el método RemoveFromSoftwareBitmap , que devuelve el 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);

Inteligencia artificial responsable

Hemos usado una combinación de los pasos siguientes para asegurarse de que estas API de creación de imágenes son confiables, seguras y creadas de forma responsable. Se recomienda revisar los procedimientos recomendados descritos en Desarrollo de IA Generativa Responsable en Windows al implementar características de inteligencia artificial en su aplicación.