Zacznij od obrazowania AI

Funkcje usługi AI Imaging obsługiwane przez interfejsy API sztucznej inteligencji systemu Windows umożliwiają korzystanie z następujących funkcji:

• Super rozdzielczość obrazu: skalowanie i wyostrzanie obrazu.
• Opis obrazu: generowanie tekstu opisującego obraz.
• Segmentacja obrazów: identyfikowanie obiektów na obrazie.
• Wyodrębnianie pierwszego planu obrazu: wyodrębnianie pierwszego planu obrazu wejściowego
• Wymazywanie obiektu: usuwanie obiektów z obrazu.

Aby uzyskać szczegółowe informacje o interfejsie API, zobacz dokumentację interfejsu API dotyczącą funkcji przetwarzania obrazów AI.

Aby uzyskać szczegółowe informacje na temat moderowania zawartości, zobacz Bezpieczeństwo zawartości za pomocą interfejsów API generowania sztucznej inteligencji.

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

Co mogę zrobić z super-rozdzielczością obrazu?

API nadpróbkowania obrazu umożliwiają wyostrzanie i skalowanie obrazów.

Skalowanie jest ograniczone do maksymalnego współczynnika 8x, ponieważ czynniki o większej skali mogą wprowadzać artefakty i naruszyć dokładność obrazu. Jeśli ostateczna szerokość lub wysokość jest większa niż 8x ich oryginalnych wartości, zostanie zgłoszony wyjątek.

Przykład superrozdzielczości obrazu

W poniższym przykładzie pokazano, jak zmienić skalę (, targetWidth) istniejącego obrazu mapy bitowej oprogramowania (targetHeightsoftwareBitmap) i poprawić ostrość obrazu przy użyciu ImageScaler obiektu (aby poprawić ostrość bez skalowania obrazu, po prostu określić istniejącą szerokość i wysokość obrazu).

1. Upewnij się, że model superrozdzielczości obrazu jest dostępny, wywołując metodę GetReadyState, a następnie czekając na pomyślne zakończenie metody EnsureReadyAsync.

2. Po udostępnieniu modelu super rozdzielczości obrazu utwórz obiekt ImageScaler, aby się do niego odwoływać.

3. Pobierz wyostrzoną i skalowaną wersję istniejącego obrazu, przekazując istniejący obraz oraz żądaną szerokość i wysokość do modelu przy użyciu metody ScaleSoftwareBitmap .

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

if (ImageScaler.GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageScaler.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

Co mogę zrobić z opisem obrazu?

Interfejsy API opisu obrazu umożliwiają generowanie różnych typów opisów tekstu dla obrazu.

Obsługiwane są następujące typy opisów tekstu:

• Krótki — zawiera opis odpowiedni dla wykresów i diagramów.
• Szczegółowe — zawiera długi opis.
• Diagram — zawiera krótki opis odpowiedni dla podpisu obrazu. Wartość domyślna, jeśli nie określono żadnej wartości.
• Dostępne — zawiera długi opis ze szczegółami przeznaczonymi dla użytkowników z potrzebami dotyczącymi ułatwień dostępu.

Ponieważ te interfejsy API używają modeli uczenia maszynowego (ML), sporadyczne błędy mogą wystąpić, gdy tekst nie opisuje poprawnie obrazu. W związku z tym nie zalecamy używania tych interfejsów API dla obrazów w następujących scenariuszach:

• Gdzie obrazy zawierają potencjalnie wrażliwą zawartość i niedokładne opisy mogą być kontrowersyjne, takie jak flagi, mapy, globy, symbole kulturowe lub symbole religijne.
• Dokładne opisy mają krytyczne znaczenie, na przykład w przypadku porad medycznych lub diagnostyki, treści prawnych lub dokumentów finansowych.

Przykład opisu obrazu

W poniższym przykładzie pokazano, jak uzyskać opis tekstu dla obrazu na podstawie określonego typu opisu (opcjonalnie) i poziomu moderowania zawartości (opcjonalnie).

1. Upewnij się, że model superrozdzielczości obrazu jest dostępny, wywołując metodę GetReadyState, a następnie czekając na pomyślne zakończenie metody EnsureReadyAsync.

2. Po udostępnieniu modelu Superrozdzielczości obrazu utwórz obiekt ImageDescriptionGenerator, aby się do niego odwołać.

3. (Opcjonalnie) Utwórz obiekt ContentFilterOptions i określ preferowane wartości. Jeśli zdecydujesz się używać wartości domyślnych, możesz przekazać obiekt o wartości null.

4. Pobierz opis obrazu (LanguageModelResponse.Response), wywołując metodę DescribeAsync określając oryginalny obraz, ImageDescriptionKind (opcjonalną wartość preferowanego typu opisu) i obiekt ContentFilterOptions (opcjonalnie).

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.NotReady) 
{
    var result = await ImageDescriptionGenerator.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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();

Co mogę zrobić za pomocą segmentacji obrazów?

Segmentacja obrazów może służyć do identyfikowania określonych obiektów na obrazie. Model przyjmuje zarówno obraz, jak i obiekt podpowiedzi i zwraca maskę zidentyfikowanego obiektu.

Wskazówki można przekazać za pomocą dowolnej kombinacji następujących elementów:

• Współrzędne punktów, które należą do tego, co identyfikujesz.
• Współrzędne punktów, które nie należą do tego, co identyfikujesz.
• Prostokąt współrzędnych, który otacza to, co identyfikujesz.

Tym więcej wskazówek, tym bardziej precyzyjny może być model. Postępuj zgodnie z tymi wskazówkami, aby zminimalizować niedokładne wyniki lub błędy.

• Unikaj używania wielu prostokątów we wskazówce, ponieważ mogą one tworzyć niedokładne maski.
• Unikaj używania wyłącznie punktów wykluczania bez dołączania punktów lub prostokąta.
• Nie podawaj więcej niż obsługiwane maksymalnie 32 współrzędne (1 dla punktu, 2 dla prostokąta), ponieważ to spowoduje wystąpienie błędu.

Zwrócona maska jest w formacie skali szarości 8-bitowej, gdzie piksele maski dla zidentyfikowanego obiektu mają wartość 255 (wszystkie inne mają wartość 0).

Przykład segmentacji obrazów

W poniższych przykładach pokazano sposoby identyfikowania obiektu na obrazie. W przykładach przyjęto założenie, że masz już obiekt mapy bitowej oprogramowania (softwareBitmap) dla danych wejściowych.

1. Upewnij się, że model segmentacji obrazów jest dostępny, wywołując metodę GetReadyState i czekając na pomyślne zwrócenie metody EnsureReadyAsync .

2. Po udostępnieniu modelu segmentacji obrazów utwórz obiekt ImageObjectExtractor w celu odwołania się do niego.

3. Przekaż obraz do CreateWithSoftwareBitmapAsync.

4. Utwórz obiekt ImageObjectExtractorHint . Inne sposoby tworzenia obiektu wskazówek z różnymi danymi wejściowymi są pokazane później.

5. Prześlij wskazówkę do modelu przy użyciu metody GetSoftwareBitmapObjectMask , która zwraca wynik końcowy.

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

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

Określanie wskazówek z dołączonymi i wykluczonymi punktami

Ten fragment kodu pokazuje, jak używać uwzględnionych i wykluczonych punktów jako wskazówek.

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

Określ wskazówki za pomocą prostokąta

Ten fragment kodu pokazuje, jak używać prostokąta (rectInt32 jest X, Y, Width, Height) jako wskazówkę.

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

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

Co mogę zrobić z wyodrębniaczem pierwszego planu obrazu?

Użyj elementu ImageForegroundExtractor , aby podzielić pierwszy plan obrazu wejściowego i włączyć funkcje, takie jak usuwanie tła i generowanie naklejek.

Zwrócona maska ma format greyscale-8. Wartości pikseli wahają się od 0 do 255, gdzie 0 reprezentuje piksele tła, 255 reprezentuje piksele pierwszego planu, a wartości pośrednie wskazują mieszankę pikseli pierwszego planu i tła.

Generowanie maski na podstawie obrazu mapy bitowej

1. Wywołaj metodę GetReadyState i poczekaj na pomyślne ukończenie EnsureReadyAsync, aby potwierdzić, że obiekt ImageForegroundExtractor jest gotowy.
2. Po przygotowaniu modelu wywołaj metodę CreateAsync, aby utworzyć obiekt ImageForegroundExtractor.
3. Wywołaj metodę GetMaskFromSoftwareBitmap z obrazem wejściowym, aby wygenerować maskę pierwszego planu.

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

if (ImageForegroundExtractor.GetReadyState() == AIFeatureReadyState.NotReady)
{
    var result  = await ImageForegroundExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}

var model = await ImageForegroundExtractor.CreateAsync();

// Insert your own softwareBitmap here.
var foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

#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 (ImageForegroundExtractor::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageForegroundExtractor::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

auto model = co_await ImageForegroundExtractor::CreateAsync();

// Insert your own softwareBitmap here.
auto foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

Co mogę zrobić za pomocą wymazywania obiektów?

Wymazywanie obiektów może służyć do usuwania obiektów z obrazów. Model przyjmuje zarówno obraz, jak i maskę w skali szarości wskazującą obiekt do usunięcia, usuwa zamaskowany obszar z obrazu i wypełnia wymazany obszar tłem obrazu.

Przykład wymazywania obiektu

W poniższym przykładzie pokazano, jak usunąć obiekt z obrazu. W tym przykładzie przyjęto założenie, że masz już obiekty map bitowych oprogramowania (softwareBitmap) dla obrazu i maski. Maska musi być w formacie Gray8 z każdym pikselem obszaru do usunięcia ustawionym na 255, a wszystkie pozostałe piksele mają wartość 0.

1. Upewnij się, że model segmentacji obrazów jest dostępny, wywołując metodę GetReadyState i czekając na pomyślne zwrócenie metody EnsureReadyAsync .
2. Gdy model wymazywania obiektów jest dostępny, utwórz obiekt ImageObjectRemover w celu odwołania się do niego.
3. Na koniec prześlij obraz i maskę do modelu przy użyciu metody RemoveFromSoftwareBitmap , która zwraca wynik końcowy.

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

if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectRemover.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

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

• Galeria deweloperów sztucznej inteligencji
• Przykłady interfejsu API sztucznej inteligencji systemu Windows