Wprowadzenie do rozpoznawania tekstu sztucznej inteligencji (OCR)

Rozpoznawanie tekstu, znane również jako optyczne rozpoznawanie znaków (OCR), jest obsługiwane w systemie Windows AI Foundry za pośrednictwem zestawu interfejsów API opartych na sztucznej inteligencji (AI), które mogą wykrywać i wyodrębniać tekst na obrazach i konwertować go na strumienie znaków czytelnych dla maszyny.

Te interfejsy API mogą identyfikować znaki, wyrazy, linie, wielokątne granice tekstu i zapewniać poziomy ufności dla każdego dopasowania. Są także wyłącznie wspierane przez akcelerację sprzętową w urządzeniach z jednostką przetwarzania neuronowego (NPU), co sprawia, że działają szybciej i dokładniej niż starsze interfejsy API Windows.Media.Ocr.OcrEngine w Windows platform SDK.

Aby uzyskać szczegółowe informacje o interfejsie API, zobacz dokumentacja interfejsu API dla funkcji rozpoznawania tekstu (OCR).

Ważne

Poniżej znajduje się lista funkcji sztucznej inteligencji systemu Windows i wersji zestawu SDK aplikacji systemu Windows, w której są one obecnie obsługiwane.

Wersja 1.8 Eksperymentalna (1.8.0-experimental1) - Wymazywanie Obiektów, Phi Silica, Strojenie LoRA dla Phi Silica, Podsumowanie Rozmowy (Analiza tekstu)

Prywatna wersja zapoznawcza — wyszukiwanie semantyczne

Wersja 1.7.1 (1.7.250401001) — wszystkie inne interfejsy API

Te interfejsy API będą działać tylko na urządzeniach windows Insider Preview (WIP), które otrzymały aktualizację z 7 maja. 28-29 maja zostanie wydana opcjonalna aktualizacja na urządzenia inne niż WIP, a następnie aktualizacja z 10 czerwca. Ta aktualizacja przyniesie z nim modele sztucznej inteligencji wymagane do działania interfejsów API sztucznej inteligencji systemu Windows. Te aktualizacje będą również wymagać, aby każda aplikacja korzystająca z interfejsów API sztucznej inteligencji systemu Windows nie mogła tego zrobić, dopóki aplikacja nie otrzyma tożsamości pakietu w czasie wykonywania.

Co mogę zrobić za pomocą funkcji rozpoznawania tekstu sztucznej inteligencji?

Używanie funkcji rozpoznawania tekstu sztucznej inteligencji do identyfikowania i rozpoznawania tekstu na obrazie. Możesz również uzyskać granice tekstu i poziomy ufności dla rozpoznanego tekstu.

Tworzenie elementu ImageBuffer z pliku

W tym przykładzie WinUI, używamy funkcji LoadImageBufferFromFileAsync w celu uzyskania ImageBuffer z pliku graficznego.

W funkcji LoadImageBufferFromFileAsync wykonamy następujące kroki:

1. Utwórz obiekt StorageFile na podstawie określonej ścieżki pliku.
2. Otwórz strumień w pliku StorageFile przy użyciu narzędzia OpenAsync.
3. Utwórz BitmapDecoder dla strumienia.
4. Wywołaj metodę GetSoftwareBitmapAsync na dekoderze mapy bitowej, aby uzyskać obiekt SoftwareBitmap .
5. Zwraca bufor obrazu z elementu 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()};
}

Rozpoznawanie tekstu na obrazie mapy bitowej

W poniższym przykładzie pokazano, jak rozpoznać jakiś tekst w obiekcie SoftwareBitmap jako pojedynczą wartość ciągu:

1. Utwórz obiekt TextRecognizer za pomocą wywołania EnsureModelIsReady funkcji, co potwierdza również obecność modelu językowego w systemie.
2. Używając mapy bitowej uzyskanej w poprzednim fragmencie kodu, wywołujemy funkcję RecognizeTextFromSoftwareBitmap.
3. Wywołaj metodę CreateBufferAttachedToBitmap w pliku obrazu, aby uzyskać obiekt ImageBuffer .
4. Wywołaj metodę RecognizeTextFromImage , aby uzyskać rozpoznany tekst z elementu ImageBuffer.
5. Utwórz obiekt wstringstream i załaduj go rozpoznanym tekstem.
6. Zwróć ciąg.

Notatka

Funkcja EnsureModelIsReady służy do sprawdzania stanu gotowości modelu rozpoznawania tekstu (i zainstalowania go w razie potrzeby).

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();
}

Uzyskaj granice wyrazów i pewność

W tym miejscu pokazano, jak wizualizować BoundingBox każdego wyrazu w obiekcie SoftwareBitmap jako kolekcję wielokątów kodowanych kolorami w elemencie Grid.

Notatka

W tym przykładzie przyjęto założenie, że obiekt TextRecognizer został już utworzony i przekazany do funkcji.

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);
        }
    }
}

Odpowiedzialne używanie sztucznej inteligencji

Użyliśmy kombinacji poniższych kroków, aby upewnić się, że te interfejsy API obrazowania są wiarygodne, bezpieczne i tworzone odpowiedzialnie. Zalecamy zapoznanie się z najlepszymi rozwiązaniami opisanymi w temacie Odpowiedzialne tworzenie sztucznej inteligencji w systemie Windows podczas implementowania funkcji sztucznej inteligencji w aplikacji.

Zobacz także

• Uzyskiwanie dostępu do plików i folderów za pomocą zestawu SDK aplikacji systemu Windows i interfejsów API WinRT
• Galeria deweloperów sztucznej inteligencji
• Przykład interfejsu API sztucznej inteligencji systemu Windows