Aan de slag met AI Text Recognition (OCR)

Tekstherkenning, ook wel optische tekenherkenning (OCR) genoemd, wordt ondersteund door een set Windows AI-API's waarmee tekst in afbeeldingen kan worden gedetecteerd en geëxtraheerd en geconverteerd naar machineleesbare tekenstromen.

Deze API's kunnen tekens, woorden, regels, veelhoekige tekstgrenzen identificeren en betrouwbaarheidsniveaus bieden voor elke overeenkomst. Ze worden ook uitsluitend ondersteund door hardwareversnelling op apparaten met een NPU (neurale verwerkingseenheid), waardoor ze sneller en nauwkeuriger zijn dan de verouderde Windows.Media.Ocr.OcrEngine-API's in de Windows-platform-SDK.

Zie API-details in de API-ref voor Tekstherkenning (OCR).

Wat kan ik doen met AI Text Recognition?

Gebruik AI Text Recognition-functies om tekst in een afbeelding te identificeren en te herkennen. U kunt ook de tekstgrenzen en betrouwbaarheidsscores voor de herkende tekst ophalen.

Een ImageBuffer maken op basis van een bestand

In dit WinUI-voorbeeld roepen we een functie aan om een LoadImageBufferFromFileAsyncImageBuffer op te halen uit een afbeeldingsbestand.

In de functie LoadImageBufferFromFileAsync voeren we de volgende stappen uit:

1. Maak een StorageFile-object op basis van het opgegeven bestandspad.
2. Open een stream in het StorageFile met behulp van OpenAsync.
3. Maak een BitmapDecoder voor de stream.
4. Roep GetSoftwareBitmapAsync aan op de bitmapdecoder om een SoftwareBitmap-object op te halen.
5. Retourneert een afbeeldingsbuffer van CreateBufferAttachedToBitmap.

using Microsoft.Windows.AI.Imaging;
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()};
}

Tekst herkennen in een bitmapafbeelding

In het volgende voorbeeld ziet u hoe u tekst in een SoftwareBitmap-object herkent als één tekenreekswaarde:

1. Maak een TextRecognizer-object via een aanroep naar de EnsureModelIsReady functie, die ook bevestigt dat er een taalmodel aanwezig is op het systeem.
2. Met behulp van de bitmap die u in het vorige fragment hebt verkregen, roepen we de RecognizeTextFromSoftwareBitmap functie aan.
3. Roep CreateBufferAttachedToBitmap aan in het afbeeldingsbestand om een ImageBuffer-object op te halen.
4. Roep RecognizeTextFromImage aan om de herkende tekst op te halen uit de ImageBuffer.
5. Maak een wstringstream-object en laad het met de herkende tekst.
6. Geef de tekenreeks terug.

using Microsoft.Windows.AI.Imaging;
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.NotReady)
    {
        var loadResult = await TextRecognizer.EnsureReadyAsync();
        if (loadResult.Status != AIFeatureReadyResultState.Success)
        {
            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();
}

Woordgrenzen en zekerheidsniveau ophalen

Hier laten we zien hoe u het Begrenzingsvak van elk woord in een SoftwareBitmap-object kunt visualiseren als een verzameling met kleuren gecodeerde veelhoeken op een rasterelement .

using Microsoft.Windows.AI.Imaging;
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);
        }
    }
}

Verantwoorde AI

We hebben de belangrijkste principes en procedures gevolgd die worden beschreven in de Microsoft Responsible AI Standards om ervoor te zorgen dat deze API's betrouwbaar, veilig en op verantwoorde wijze zijn gebouwd. Zie Responsible Ative AI Development in Windows voor meer informatie over het implementeren van AI-functies in uw app.

Zie ook

• Toegang tot bestanden en mappen met Windows App SDK en WinRT-API's
• AI Dev Gallery
• Voorbeelden van Windows AI-API