Introducción al reconocimiento de texto de IA (OCR)

El reconocimiento de texto, también conocido como reconocimiento óptico de caracteres (OCR), se admite en Windows AI Foundry a través de un conjunto de API respaldadas por inteligencia artificial (AI) que pueden detectar y extraer texto dentro de imágenes y convertirlos en secuencias de caracteres legibles por máquina.

Estas API pueden identificar caracteres, palabras, líneas, límites de texto poligonal y proporcionar niveles de confianza para cada coincidencia. También son compatibles exclusivamente con la aceleración de hardware en dispositivos con una unidad de procesamiento neuronal (NPU), lo que las hace más rápidas y precisas que las API de Windows.Media.Ocr.OcrEngine heredadas en el SDK de la plataforma Windows.

Para obtener más información sobre la API, consulte API ref for Text Recognition (OCR).

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, LoRA ajuste fino 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 el reconocimiento de texto de IA?

Use las características de reconocimiento de texto de IA para identificar y reconocer texto en una imagen. También puede obtener los límites de texto y las puntuaciones de confianza del texto reconocido.

Creación de un elemento ImageBuffer a partir de un archivo

En este ejemplo de WinUI, llamamos a una LoadImageBufferFromFileAsync función para obtener imageBuffer de un archivo de imagen.

En la función LoadImageBufferFromFileAsync, se completan los pasos siguientes:

1. Cree un objeto StorageFile a partir de la ruta de archivo especificada.
2. Abra una secuencia en storageFile mediante OpenAsync.
3. Cree un elemento BitmapDecoder para la secuencia.
4. Llame a GetSoftwareBitmapAsync en el descodificador de mapa de bits para obtener un objeto SoftwareBitmap .
5. Devuelva un búfer de imagen desde CreateBufferAttachedToBitmap.

using Microsoft.Windows.Vision;
using Microsoft.Graphics.Imaging;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Storage.Streams;

public async Task<ImageBuffer> LoadImageBufferFromFileAsync(string filePath)
{
    StorageFile file = await StorageFile.GetFileFromPathAsync(filePath);
    IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
    SoftwareBitmap bitmap = await decoder.GetSoftwareBitmapAsync();

    if (bitmap == null)
    {
        return null;
    }

    return ImageBuffer.CreateBufferAttachedToBitmap(bitmap);
}

#include <iostream>
#include <sstream>
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.UI.Xaml.Controls.h>
#include<winrt/Microsoft.UI.Xaml.Media.h>
#include<winrt/Microsoft.UI.Xaml.Shapes.h>

using namespace winrt;
using namespace Microsoft::UI::Xaml;
using namespace Microsoft::Windows::AI;
using namespace Microsoft::Windows::AI::Imaging;
using namespace winrt::Microsoft::UI::Xaml::Controls;
using namespace winrt::Microsoft::UI::Xaml::Media;


winrt::Windows::Foundation::IAsyncOperation<winrt::hstring> 
    MainWindow::RecognizeTextFromSoftwareBitmap(
        Windows::Graphics::Imaging::SoftwareBitmap const& bitmap)
{
    winrt::Microsoft::Windows::AI::Imaging::TextRecognizer textRecognizer = 
        EnsureModelIsReady().get();
    Microsoft::Graphics::Imaging::ImageBuffer imageBuffer = 
        Microsoft::Graphics::Imaging::ImageBuffer::CreateForSoftwareBitmap(bitmap);
    RecognizedText recognizedText = 
        textRecognizer.RecognizeTextFromImage(imageBuffer);
    std::wstringstream stringStream;
    for (const auto& line : recognizedText.Lines())
    {
        stringStream << line.Text().c_str() << std::endl;
    }
    co_return winrt::hstring{ stringStream.str()};
}

Reconocimiento de texto en una imagen de mapa de bits

En el ejemplo siguiente se muestra cómo reconocer texto en un objeto SoftwareBitmap como un valor de cadena único:

1. Cree un objeto TextRecognizer a través de una llamada a la EnsureModelIsReady función, que también confirma que hay un modelo de lenguaje presente en el sistema.
2. Usando el mapa de bits obtenido en el fragmento de código anterior, llamamos a la función RecognizeTextFromSoftwareBitmap.
3. Llame a CreateBufferAttachedToBitmap en el archivo de imagen para obtener un objeto ImageBuffer .
4. Llame a RecognizeTextFromImage para obtener el texto reconocido de ImageBuffer.
5. Cree un objeto wstringstream y cárguelo con el texto reconocido.
6. Devuelva la cadena.

Nota:

La función EnsureModelIsReady se usa para comprobar el estado de preparación del modelo de reconocimiento de texto (e instalarlo si es necesario).

using Microsoft.Windows.Vision;
using Microsoft.Windows.AI;
using Microsoft.Graphics.Imaging;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Storage.Streams;

public async Task<string> RecognizeTextFromSoftwareBitmap(SoftwareBitmap bitmap)
{
    TextRecognizer textRecognizer = await EnsureModelIsReady();
    ImageBuffer imageBuffer = ImageBuffer.CreateBufferAttachedToBitmap(bitmap);
    RecognizedText recognizedText = textRecognizer.RecognizeTextFromImage(imageBuffer);
    StringBuilder stringBuilder = new StringBuilder();

    foreach (var line in recognizedText.Lines)
    {
        stringBuilder.AppendLine(line.Text);
    }

    return stringBuilder.ToString();
}

public async Task<TextRecognizer> EnsureModelIsReady()
{
    if (TextRecognizer.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
    {
        var loadResult = await TextRecognizer.EnsureReadyAsync();
        if (loadResult.Status != PackageDeploymentStatus.CompletedSuccess)
        {
            throw new Exception(loadResult.ExtendedError().Message);
        }
    }

    return await TextRecognizer.CreateAsync();
}

winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::Windows::AI::Imaging::TextRecognizer> MainWindow::EnsureModelIsReady()
{
    if (winrt::Microsoft::Windows::AI::Imaging::TextRecognizer::GetReadyState() == AIFeatureReadyState::NotReady)
    {
        auto loadResult = TextRecognizer::EnsureReadyAsync().get();
           
        if (loadResult.Status() != AIFeatureReadyResultState::Success)
        {
            throw winrt::hresult_error(loadResult.ExtendedError());
        }
    }

    return winrt::Microsoft::Windows::AI::Imaging::TextRecognizer::CreateAsync();
}

Obtención de límites de palabras y confianza

Aquí se muestra cómo visualizar boundingBox de cada palabra en un objeto SoftwareBitmap como una colección de polígonos codificados por colores en un elemento Grid .

Nota:

En este ejemplo se supone que ya se ha creado un objeto TextRecognizer y se ha pasado a la función .

using Microsoft.Windows.Vision;
using Microsoft.Graphics.Imaging;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Storage.Streams;

public void VisualizeWordBoundariesOnGrid(
    SoftwareBitmap bitmap,
    Grid grid,
    TextRecognizer textRecognizer)
{
    ImageBuffer imageBuffer = ImageBuffer.CreateBufferAttachedToBitmap(bitmap);
    RecognizedText result = textRecognizer.RecognizeTextFromImage(imageBuffer);

    SolidColorBrush greenBrush = new SolidColorBrush(Microsoft.UI.Colors.Green);
    SolidColorBrush yellowBrush = new SolidColorBrush(Microsoft.UI.Colors.Yellow);
    SolidColorBrush redBrush = new SolidColorBrush(Microsoft.UI.Colors.Red);

    foreach (var line in result.Lines)
    {
        foreach (var word in line.Words)
        {
            PointCollection points = new PointCollection();
            var bounds = word.BoundingBox;
            points.Add(bounds.TopLeft);
            points.Add(bounds.TopRight);
            points.Add(bounds.BottomRight);
            points.Add(bounds.BottomLeft);

            Polygon polygon = new Polygon();
            polygon.Points = points;
            polygon.StrokeThickness = 2;

            if (word.Confidence < 0.33)
            {
                polygon.Stroke = redBrush;
            }
            else if (word.Confidence < 0.67)
            {
                polygon.Stroke = yellowBrush;
            }
            else
            {
                polygon.Stroke = greenBrush;
            }

            grid.Children.Add(polygon);
        }
    }
}

void MainWindow::VisualizeWordBoundariesOnGrid(
    Windows::Graphics::Imaging::SoftwareBitmap const& bitmap,
    Grid const& grid,
    TextRecognizer const& textRecognizer)
{
    Microsoft::Graphics::Imaging::ImageBuffer imageBuffer = 
        Microsoft::Graphics::Imaging::ImageBuffer::CreateForSoftwareBitmap(bitmap);

    RecognizedText result = textRecognizer.RecognizeTextFromImage(imageBuffer);

    auto greenBrush = SolidColorBrush(winrt::Microsoft::UI::Colors::Green());
    auto yellowBrush = SolidColorBrush(winrt::Microsoft::UI::Colors::Yellow());
    auto redBrush = SolidColorBrush(winrt::Microsoft::UI::Colors::Red());
    for (const auto& line : result.Lines())
    {
        for (const auto& word : line.Words())
        {
            PointCollection points;
            const auto& bounds = word.BoundingBox();
            points.Append(bounds.TopLeft);
            points.Append(bounds.TopRight);
            points.Append(bounds.BottomRight);
            points.Append(bounds.BottomLeft);

            winrt::Microsoft::UI::Xaml::Shapes::Polygon polygon{};
            polygon.Points(points);
            polygon.StrokeThickness(2);
            if (word.MatchConfidence() < 0.33)
            {
                polygon.Stroke(redBrush);
            }
            else if (word.MatchConfidence() < 0.67)
            {
                polygon.Stroke(yellowBrush);
            }
            else
            {
                polygon.Stroke(greenBrush);
            }

            grid.Children().Append(polygon);
        }
    }
}

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 IA en la aplicación.

Consulte también

• Acceso a archivos y carpetas con el SDK de aplicaciones de Windows y las API de WinRT
• Galería de desarrollo de IA
• Ejemplo de API de IA de Windows