Aufrufen der Bildanalyse 3.2-API

Artikel
09/04/2024

In diesem Artikel wird veranschaulicht, wie Sie die Bildanalyse 3.2-API aufrufen, um Informationen zu den visuellen Features eines Bilds zurückzugeben. Außerdem wird gezeigt, wie Sie die zurückgegebenen Informationen mithilfe der Client-SDKs oder der REST-API analysieren.

In diesem Leitfaden wird davon ausgegangen, dass Sie bereits eine Vision-Ressource erstellt sowie einen Schlüssel und eine Endpunkt-URL abgerufen haben. Wenn Sie ein Client-SDK verwenden, müssen Sie außerdem ein Clientobjekt authentifizieren. Wenn Sie diese Schritte nicht ausgeführt haben, führen Sie die Schnellstartanleitung aus, um zu beginnen.

Übermitteln von Daten an den Dienst

Der Code in diesem Leitfaden verwendet Remotebilder, auf die über URL verwiesen wird. Möglicherweise möchten Sie selbst verschiedene Bilder ausprobieren, um das ganze Potenzial der Bildanalysefeatures zu erfahren.

Beim Analysieren eines Remotebilds geben Sie die URL des Bilds an, indem Sie den Anforderungstext wie folgt formatieren: {"url":"http://example.com/images/test.jpg"}.

Zur Analyse eines lokalen Bilds platzieren Sie die binären Bilddaten im HTTP-Anforderungstext.

Speichern Sie in Ihrer Main-Klasse einen Verweis auf die URL des Bilds, das Sie analysieren möchten.

// URL image used for analyzing an image (image of puppy)
private const string ANALYZE_URL_IMAGE = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/refs/heads/master/ComputerVision/Images/dog.jpg";

Tipp

Sie können auch ein lokales Bild analysieren. Sehen Sie sich die ComputerVisionClient-Methoden an, etwa AnalyzeImageInStreamAsync. Alternativ finden Sie im Beispielcode auf GitHub Szenarien zu lokalen Bildern.

Speichern Sie in Ihrer Main-Klasse einen Verweis auf die URL des Bilds, das Sie analysieren möchten.

String pathToRemoteImage = "https://github.com/Azure-Samples/cognitive-services-sample-data-files/raw/master/ComputerVision/Images/faces.jpg";

Tipp

Sie können auch ein lokales Bild analysieren. Sehen Sie sich die ComputerVision-Methoden an, etwa AnalyzeImage. Alternativ finden Sie im Beispielcode auf GitHub Szenarien zu lokalen Bildern.

Speichern Sie in Ihrer Main-Funktion einen Verweis auf die URL des Bilds, das Sie analysieren möchten.

const describeURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';

Tipp

Sie können auch ein lokales Bild analysieren. Sehen Sie sich die ComputerVisionClient-Methoden an, etwa describeImageInStream. Alternativ finden Sie im Beispielcode auf GitHub Szenarien zu lokalen Bildern.

Speichern Sie einen Verweis auf die URL des Bilds, das Sie analysieren möchten.

remote_image_url = "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png"

Tipp

Sie können auch ein lokales Bild analysieren. Sehen Sie sich die ComputerVisionClientOperationsMixin-Methoden an, etwa analyze_image_in_stream. Alternativ finden Sie im Beispielcode auf GitHub Szenarien zu lokalen Bildern.

Festlegen, wie die Daten verarbeitet werden sollen

Auswählen visueller Merkmale

Die Analyse-API bietet Ihnen Zugriff auf alle Bildanalysefunktionen des Diensts. Wählen Sie ausgehend von Ihrem eigenen Anwendungsfall aus, welche Vorgänge ausgeführt werden sollen. Eine Beschreibung der einzelnen Features finden Sie in der Übersicht. In den Beispielen in den nachfolgenden Abschnitten werden alle verfügbaren visuellen Features hinzugefügt, aber in der Praxis benötigen Sie wahrscheinlich nur eins oder zwei.

Sie können angeben, welche Funktionen Sie verwenden möchten, indem Sie die URL-Abfrageparameter der Analyse-API festlegen. Ein Parameter kann mehrere, durch Kommas getrennte Werte enthalten. Für jedes von Ihnen angegebene Feature ist weitere Berechnungszeit erforderlich. Geben Sie daher nur die benötigten Features an.

URL-Parameter	Wert	BESCHREIBUNG
`features`	`Read`	Liest den sichtbaren Text auf dem Bild und gibt ihn als strukturierte JSON-Daten aus
`features`	`Description`	Beschreibt den Bildinhalt in unterstützten Sprachen mit einem vollständigen Satz.
`features`	`SmartCrops`	Findet die Rechteckkoordinaten, die das Bild in ein gewünschtes Seitenverhältnis zuschneiden würden, während der relevante Bereich beibehalten wird
`features`	`Objects`	Erkennt verschiedene Objekte in einem Bild, einschließlich der ungefähren Position. Das Objects-Argument ist nur für Englisch verfügbar.
`features`	`Tags`	Erstellt Tags für das Bild in einer detaillierten Liste aus Wörtern, die sich auf den Bildinhalt beziehen.

Eine aufgefüllte URL kann folgendermaßen aussehen:

<endpoint>/vision/v3.2/analyze?visualFeatures=Tags

Definieren Sie Ihre neue Methode für die Bildanalyse. Fügen Sie den folgenden Code hinzu, der angibt, welche visuellen Features Sie bei der Analyse extrahieren möchten. Eine vollständige Liste finden Sie in der Enumeration VisualFeatureTypes .

/* 
 * ANALYZE IMAGE - URL IMAGE
 * Analyze URL image. Extracts captions, categories, tags, objects, faces, racy/adult/gory content,
 * brands, celebrities, landmarks, color scheme, and image types.
 */
public static async Task AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
{
    Console.WriteLine("----------------------------------------------------------");
    Console.WriteLine("ANALYZE IMAGE - URL");
    Console.WriteLine();

    // Creating a list that defines the features to be extracted from the image. 

    List<VisualFeatureTypes?> features = new List<VisualFeatureTypes?>()
    {
        VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
        VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
        VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
        VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
        VisualFeatureTypes.Objects
    };

Geben Sie an, welche visuellen Features Sie in Ihrer Analyse extrahieren möchten. Eine vollständige Liste finden Sie in der Enumeration VisualFeatureTypes.

// This list defines the features to be extracted from the image.
List<VisualFeatureTypes> featuresToExtractFromRemoteImage = new ArrayList<>();
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.DESCRIPTION);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.CATEGORIES);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.TAGS);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.FACES);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.ADULT);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.COLOR);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.IMAGE_TYPE);

Geben Sie an, welche visuellen Features Sie in Ihrer Analyse extrahieren möchten. Eine vollständige Liste finden Sie in der Enumeration VisualFeatureTypes.

// Get the visual feature for analysis
const features = ['Categories','Brands','Adult','Color','Description','Faces','Image_type','Objects','Tags'];
const domainDetails = ['Celebrities','Landmarks'];

Geben Sie an, welche visuellen Features Sie in Ihrer Analyse extrahieren möchten. Eine vollständige Liste finden Sie in der Enumeration VisualFeatureTypes.

print("===== Analyze an image - remote =====")
# Select the visual feature(s) you want.
remote_image_features = [VisualFeatureTypes.categories,VisualFeatureTypes.brands,VisualFeatureTypes.adult,VisualFeatureTypes.color,VisualFeatureTypes.description,VisualFeatureTypes.faces,VisualFeatureTypes.image_type,VisualFeatureTypes.objects,VisualFeatureTypes.tags]
remote_image_details = [Details.celebrities,Details.landmarks]

Angeben von Sprachen

Sie können auch die Sprache der zurückgegebenen Daten angeben.

Die Sprache wird mit dem folgenden URL-Abfrageparameter angegeben. Standardwert: en.

URL-Parameter	Wert	Beschreibung
`language`	`en`	Englisch
`language`	`es`	Spanisch
`language`	`ja`	Japanisch
`language`	`pt`	Portugiesisch (Portugal)
`language`	`zh`	Chinesisch (vereinfacht)

Eine aufgefüllte URL kann folgendermaßen aussehen:

<endpoint>/vision/v3.2/analyze?visualFeatures=Tags&language=en

Verwenden Sie den Parameter language des Aufrufs AnalyzeImageAsync, um eine Sprache anzugeben. Ein Methodenaufruf, der eine Sprache angibt, sieht möglicherweise wie folgt aus.

ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features, language: "en");

Verwenden Sie die Eingabe AnalyzeImageOptionalParameter in Ihrem Analyseaufruf, um eine Sprache anzugeben. Ein Methodenaufruf, der eine Sprache angibt, sieht möglicherweise wie folgt aus.

ImageAnalysis analysis = compVisClient.computerVision().analyzeImage().withUrl(pathToRemoteImage)
    .withVisualFeatures(featuresToExtractFromLocalImage)
    .language("en")
    .execute();

Verwenden Sie die Eigenschaft Sprache der Eingabe ComputerVisionClientAnalyzeImageOptionalParams in Ihrem Analyseaufruf, um eine Sprache anzugeben. Ein Methodenaufruf, der eine Sprache angibt, sieht möglicherweise wie folgt aus.

const result = (await computerVisionClient.analyzeImage(imageURL,{visualFeatures: features, language: 'en'}));

Verwenden Sie den Parameter language Ihres analyze_image-Aufrufs, um eine Sprache anzugeben. Ein Methodenaufruf, der eine Sprache angibt, sieht möglicherweise wie folgt aus.

results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features, remote_image_details, 'en')

Abrufen von Ergebnissen aus dem Dienst

In diesem Abschnitt wird gezeigt, wie Sie die Ergebnisse des API-Aufrufs analysieren. Er enthält den eigentlichen API-Aufruf.

Hinweis

Bereichsbezogene API-Aufrufe

Einige der Funktionen in der Bildanalyse können sowohl direkt als auch über den Aufruf der Analyse-API aufgerufen werden. Sie können beispielsweise eine Bereichsanalyse nur von Bildtags durchführen, indem Sie eine Anforderung an <endpoint>/vision/v3.2/tag (oder an die entsprechende Methode im SDK) vornehmen. Informationen zu weiteren Funktionen, die separat aufgerufen werden können, finden Sie in der Referenzdokumentation.

Der Dienst gibt eine 200-HTTP-Antwort zurück, und der Text enthält die zurückgegebenen Daten in Form einer JSON-Zeichenfolge. Der folgende Text ist ein Beispiel für eine JSON-Antwort:

{
    "metadata":
    {
        "width": 300,
        "height": 200
    },
    "tagsResult":
    {
        "values":
        [
            {
                "name": "grass",
                "confidence": 0.9960499405860901
            },
            {
                "name": "outdoor",
                "confidence": 0.9956876635551453
            },
            {
                "name": "building",
                "confidence": 0.9893627166748047
            },
            {
                "name": "property",
                "confidence": 0.9853052496910095
            },
            {
                "name": "plant",
                "confidence": 0.9791355729103088
            }
        ]
    }
}

Fehlercodes

Die folgende Liste enthält mögliche Fehler und ihre Ursachen:

400
- InvalidImageUrl: Die Bild-URL ist falsch formatiert, oder es kann nicht darauf zugegriffen werden.
- InvalidImageFormat: Bei den Eingabedaten handelt es sich nicht um ein gültiges Bild.
- InvalidImageSize: Das Eingabebild ist zu groß.
- NotSupportedVisualFeature: Der angegebene Merkmaltyp ist ungültig.
- NotSupportedImage: Nicht unterstütztes Bild, z. B. Kinderpornografie.
- InvalidDetails: Nicht unterstützter Wert des detail-Parameters.
- NotSupportedLanguage: Der angeforderte Vorgang wird in der angegebenen Sprache nicht unterstützt.
- BadArgument: Weitere Details werden in der Fehlermeldung bereitgestellt.
Fehler 415: Nicht unterstützter Medientyp. Für den Inhaltstyp ist kein zulässiger Typ angegeben:
- Für eine Bild-URL sollte „Content-Type“ den Wert application/json haben.
- Für binäre Bilddaten sollte „Content-Type“ den Wert application/octet-stream oder multipart/form-data haben.
500
- FailedToProcess
- Timeout: Timeout bei der Bildverarbeitung.
- InternalServerError

Der folgende Code ruft die Bildanalyse-API auf und gibt die Ergebnisse in der Konsole aus.

// Analyze the URL image 
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features);

// Summarizes the image content.
Console.WriteLine("Summary:");
foreach (var caption in results.Description.Captions)
{
    Console.WriteLine($"{caption.Text} with confidence {caption.Confidence}");
}
Console.WriteLine();

// Display categories the image is divided into.
Console.WriteLine("Categories:");
foreach (var category in results.Categories)
{
    Console.WriteLine($"{category.Name} with confidence {category.Score}");
}
Console.WriteLine();

// Image tags and their confidence score
Console.WriteLine("Tags:");
foreach (var tag in results.Tags)
{
    Console.WriteLine($"{tag.Name} {tag.Confidence}");
}
Console.WriteLine();

// Objects
Console.WriteLine("Objects:");
foreach (var obj in results.Objects)
{
    Console.WriteLine($"{obj.ObjectProperty} with confidence {obj.Confidence} at location {obj.Rectangle.X}, " +
      $"{obj.Rectangle.X + obj.Rectangle.W}, {obj.Rectangle.Y}, {obj.Rectangle.Y + obj.Rectangle.H}");
}
Console.WriteLine();

// Faces
Console.WriteLine("Faces:");
foreach (var face in results.Faces)
{
    Console.WriteLine($"A {face.Gender} of age {face.Age} at location {face.FaceRectangle.Left}, " +
      $"{face.FaceRectangle.Left}, {face.FaceRectangle.Top + face.FaceRectangle.Width}, " +
      $"{face.FaceRectangle.Top + face.FaceRectangle.Height}");
}
Console.WriteLine();

// Adult or racy content, if any.
Console.WriteLine("Adult:");
Console.WriteLine($"Has adult content: {results.Adult.IsAdultContent} with confidence {results.Adult.AdultScore}");
Console.WriteLine($"Has racy content: {results.Adult.IsRacyContent} with confidence {results.Adult.RacyScore}");
Console.WriteLine($"Has gory content: {results.Adult.IsGoryContent} with confidence {results.Adult.GoreScore}");
Console.WriteLine();

// Well-known (or custom, if set) brands.
Console.WriteLine("Brands:");
foreach (var brand in results.Brands)
{
    Console.WriteLine($"Logo of {brand.Name} with confidence {brand.Confidence} at location {brand.Rectangle.X}, " +
      $"{brand.Rectangle.X + brand.Rectangle.W}, {brand.Rectangle.Y}, {brand.Rectangle.Y + brand.Rectangle.H}");
}
Console.WriteLine();

// Celebrities in image, if any.
Console.WriteLine("Celebrities:");
foreach (var category in results.Categories)
{
    if (category.Detail?.Celebrities != null)
    {
        foreach (var celeb in category.Detail.Celebrities)
        {
            Console.WriteLine($"{celeb.Name} with confidence {celeb.Confidence} at location {celeb.FaceRectangle.Left}, " +
              $"{celeb.FaceRectangle.Top}, {celeb.FaceRectangle.Height}, {celeb.FaceRectangle.Width}");
        }
    }
}
Console.WriteLine();

// Popular landmarks in image, if any.
Console.WriteLine("Landmarks:");
foreach (var category in results.Categories)
{
    if (category.Detail?.Landmarks != null)
    {
        foreach (var landmark in category.Detail.Landmarks)
        {
            Console.WriteLine($"{landmark.Name} with confidence {landmark.Confidence}");
        }
    }
}
Console.WriteLine();

// Identifies the color scheme.
Console.WriteLine("Color Scheme:");
Console.WriteLine("Is black and white?: " + results.Color.IsBWImg);
Console.WriteLine("Accent color: " + results.Color.AccentColor);
Console.WriteLine("Dominant background color: " + results.Color.DominantColorBackground);
Console.WriteLine("Dominant foreground color: " + results.Color.DominantColorForeground);
Console.WriteLine("Dominant colors: " + string.Join(",", results.Color.DominantColors));
Console.WriteLine();

// Detects the image types.
Console.WriteLine("Image Type:");
Console.WriteLine("Clip Art Type: " + results.ImageType.ClipArtType);
Console.WriteLine("Line Drawing Type: " + results.ImageType.LineDrawingType);
Console.WriteLine();

Der folgende Code ruft die Bildanalyse-API auf und gibt die Ergebnisse in der Konsole aus.

// Call the Computer Vision service and tell it to analyze the loaded image.
ImageAnalysis analysis = compVisClient.computerVision().analyzeImage().withUrl(pathToRemoteImage)
        .withVisualFeatures(featuresToExtractFromRemoteImage).execute();

// Display image captions and confidence values.
System.out.println("\nCaptions: ");
for (ImageCaption caption : analysis.description().captions()) {
    System.out.printf("\'%s\' with confidence %f\n", caption.text(), caption.confidence());
}

// Display image category names and confidence values.
System.out.println("\nCategories: ");
for (Category category : analysis.categories()) {
    System.out.printf("\'%s\' with confidence %f\n", category.name(), category.score());
}

// Display image tags and confidence values.
System.out.println("\nTags: ");
for (ImageTag tag : analysis.tags()) {
    System.out.printf("\'%s\' with confidence %f\n", tag.name(), tag.confidence());
}

// Display any faces found in the image and their location.
System.out.println("\nFaces: ");
for (FaceDescription face : analysis.faces()) {
    System.out.printf("\'%s\' of age %d at location (%d, %d), (%d, %d)\n", face.gender(), face.age(),
            face.faceRectangle().left(), face.faceRectangle().top(),
            face.faceRectangle().left() + face.faceRectangle().width(),
            face.faceRectangle().top() + face.faceRectangle().height());
}

// Display whether any adult or racy content was detected and the confidence
// values.
System.out.println("\nAdult: ");
System.out.printf("Is adult content: %b with confidence %f\n", analysis.adult().isAdultContent(),
        analysis.adult().adultScore());
System.out.printf("Has racy content: %b with confidence %f\n", analysis.adult().isRacyContent(),
        analysis.adult().racyScore());

// Display the image color scheme.
System.out.println("\nColor scheme: ");
System.out.println("Is black and white: " + analysis.color().isBWImg());
System.out.println("Accent color: " + analysis.color().accentColor());
System.out.println("Dominant background color: " + analysis.color().dominantColorBackground());
System.out.println("Dominant foreground color: " + analysis.color().dominantColorForeground());
System.out.println("Dominant colors: " + String.join(", ", analysis.color().dominantColors()));

// Display any celebrities detected in the image and their locations.
System.out.println("\nCelebrities: ");
for (Category category : analysis.categories()) {
    if (category.detail() != null && category.detail().celebrities() != null) {
        for (CelebritiesModel celeb : category.detail().celebrities()) {
            System.out.printf("\'%s\' with confidence %f at location (%d, %d), (%d, %d)\n", celeb.name(),
                    celeb.confidence(), celeb.faceRectangle().left(), celeb.faceRectangle().top(),
                    celeb.faceRectangle().left() + celeb.faceRectangle().width(),
                    celeb.faceRectangle().top() + celeb.faceRectangle().height());
        }
    }
}

// Display any landmarks detected in the image and their locations.
System.out.println("\nLandmarks: ");
for (Category category : analysis.categories()) {
    if (category.detail() != null && category.detail().landmarks() != null) {
        for (LandmarksModel landmark : category.detail().landmarks()) {
            System.out.printf("\'%s\' with confidence %f\n", landmark.name(), landmark.confidence());
        }
    }
}

// Display what type of clip art or line drawing the image is.
System.out.println("\nImage type:");
System.out.println("Clip art type: " + analysis.imageType().clipArtType());
System.out.println("Line drawing type: " + analysis.imageType().lineDrawingType());

Der folgende Code ruft die Bildanalyse-API auf und gibt die Ergebnisse in der Konsole aus.

     const result = (await computerVisionClient.analyzeImage(facesImageURL,{visualFeatures: features},{details: domainDetails}));

     // Detect faces
     // Print the bounding box, gender, and age from the faces.
     const faces = result.faces
     if (faces.length) {
       console.log(`${faces.length} face${faces.length == 1 ? '' : 's'} found:`);
       for (const face of faces) {
         console.log(`    Gender: ${face.gender}`.padEnd(20)
           + ` Age: ${face.age}`.padEnd(10) + `at ${formatRectFaces(face.faceRectangle)}`);
       }
     } else { console.log('No faces found.'); }

     // Formats the bounding box
     function formatRectFaces(rect) {
       return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12)
         + `right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
     }

     // Detect Objects
     const objects = result.objects;
     console.log();
     // Print objects bounding box and confidence
     if (objects.length) {
       console.log(`${objects.length} object${objects.length == 1 ? '' : 's'} found:`);
       for (const obj of objects) { console.log(`    ${obj.object} (${obj.confidence.toFixed(2)}) at ${formatRectObjects(obj.rectangle)}`); }
     } else { console.log('No objects found.'); }

     // Formats the bounding box
     function formatRectObjects(rect) {
       return `top=${rect.y}`.padEnd(10) + `left=${rect.x}`.padEnd(10) + `bottom=${rect.y + rect.h}`.padEnd(12)
         + `right=${rect.x + rect.w}`.padEnd(10) + `(${rect.w}x${rect.h})`;
     }
     console.log();

     // Detect tags
     const tags = result.tags;
     console.log(`Tags: ${formatTags(tags)}`);

     // Format tags for display
     function formatTags(tags) {
       return tags.map(tag => (`${tag.name} (${tag.confidence.toFixed(2)})`)).join(', ');
     }
     console.log();

     // Detect image type
     const types = result.imageType;
     console.log(`Image appears to be ${describeType(types)}`);

     function describeType(imageType) {
       if (imageType.clipArtType && imageType.clipArtType > imageType.lineDrawingType) return 'clip art';
       if (imageType.lineDrawingType && imageType.clipArtType < imageType.lineDrawingType) return 'a line drawing';
       return 'a photograph';
     }
     console.log();

     // Detect Category
     const categories = result.categories;
     console.log(`Categories: ${formatCategories(categories)}`);

     // Formats the image categories
     function formatCategories(categories) {
       categories.sort((a, b) => b.score - a.score);
       return categories.map(cat => `${cat.name} (${cat.score.toFixed(2)})`).join(', ');
     }
     console.log();

     // Detect Brands
     const brands = result.brands;

     // Print the brands found
     if (brands.length) {
       console.log(`${brands.length} brand${brands.length != 1 ? 's' : ''} found:`);
       for (const brand of brands) {
         console.log(`    ${brand.name} (${brand.confidence.toFixed(2)} confidence)`);
       }
     } else { console.log(`No brands found.`); }
     console.log();

     // Detect Colors
     const color = result.color;
     printColorScheme(color);

     // Print a detected color scheme
     function printColorScheme(colors) {
       console.log(`Image is in ${colors.isBwImg ? 'black and white' : 'color'}`);
       console.log(`Dominant colors: ${colors.dominantColors.join(', ')}`);
       console.log(`Dominant foreground color: ${colors.dominantColorForeground}`);
       console.log(`Dominant background color: ${colors.dominantColorBackground}`);
       console.log(`Suggested accent color: #${colors.accentColor}`);
     }
     console.log();

     // Detect landmarks
     const domain = result.landmarks;

     // Prints domain-specific, recognized objects
     if (domain.length) {
       console.log(`${domain.length} ${domain.length == 1 ? 'landmark' : 'landmarks'} found:`);
       for (const obj of domain) {
         console.log(`    ${obj.name}`.padEnd(20) + `(${obj.confidence.toFixed(2)} confidence)`.padEnd(20) + `${formatRectDomain(obj.faceRectangle)}`);
       }
     } else {
       console.log('No landmarks found.');
     }

     // Formats bounding box
     function formatRectDomain(rect) {
       if (!rect) return '';
       return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12) +
         `right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
     }

     console.log();

     // Detect Adult content
     // Function to confirm racy or not
     const isIt = flag => flag ? 'is' : "isn't";

     const adult = result.adult;
     console.log(`This probably ${isIt(adult.isAdultContent)} adult content (${adult.adultScore.toFixed(4)} score)`);
     console.log(`This probably ${isIt(adult.isRacyContent)} racy content (${adult.racyScore.toFixed(4)} score)`);
     console.log();

Der folgende Code ruft die Bildanalyse-API auf und gibt die Ergebnisse in der Konsole aus.

# Call API with URL and features
results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features, remote_image_details)

# Print results with confidence score
print("Categories from remote image: ")
if (len(results_remote.categories) == 0):
    print("No categories detected.")
else:
    for category in results_remote.categories:
        print("'{}' with confidence {:.2f}%".format(category.name, category.score * 100))
print()

# Detect faces
# Print the results with gender, age, and bounding box
print("Faces in the remote image: ")
if (len(results_remote.faces) == 0):
    print("No faces detected.")
else:
    for face in results_remote.faces:
        print("'{}' of age {} at location {}, {}, {}, {}".format(face.gender, face.age, \
        face.face_rectangle.left, face.face_rectangle.top, \
        face.face_rectangle.left + face.face_rectangle.width, \
        face.face_rectangle.top + face.face_rectangle.height))

# Adult content
# Print results with adult/racy score
print("Analyzing remote image for adult or racy content ... ")
print("Is adult content: {} with confidence {:.2f}".format(results_remote.adult.is_adult_content, results_remote.adult.adult_score * 100))
print("Has racy content: {} with confidence {:.2f}".format(results_remote.adult.is_racy_content, results_remote.adult.racy_score * 100))
print()

# Detect colors
# Print results of color scheme
print("Getting color scheme of the remote image: ")
print("Is black and white: {}".format(results_remote.color.is_bw_img))
print("Accent color: {}".format(results_remote.color.accent_color))
print("Dominant background color: {}".format(results_remote.color.dominant_color_background))
print("Dominant foreground color: {}".format(results_remote.color.dominant_color_foreground))
print("Dominant colors: {}".format(results_remote.color.dominant_colors))
print()

# Detect image type
# Prints type results with degree of accuracy
print("Type of remote image:")
if results_remote.image_type.clip_art_type == 0:
    print("Image is not clip art.")
elif results_remote.image_type.line_drawing_type == 1:
    print("Image is ambiguously clip art.")
elif results_remote.image_type.line_drawing_type == 2:
    print("Image is normal clip art.")
else:
    print("Image is good clip art.")

if results_remote.image_type.line_drawing_type == 0:
    print("Image is not a line drawing.")
else:
    print("Image is a line drawing")

# Detect brands
print("Detecting brands in remote image: ")
if len(results_remote.brands) == 0:
    print("No brands detected.")
else:
    for brand in results_remote.brands:
        print("'{}' brand detected with confidence {:.1f}% at location {}, {}, {}, {}".format( \
        brand.name, brand.confidence * 100, brand.rectangle.x, brand.rectangle.x + brand.rectangle.w, \
        brand.rectangle.y, brand.rectangle.y + brand.rectangle.h))

# Detect objects
# Print detected objects results with bounding boxes
print("Detecting objects in remote image:")
if len(results_remote.objects) == 0:
    print("No objects detected.")
else:
    for object in detect_objects_results_remote.objects:
        print("object at location {}, {}, {}, {}".format( \
        object.rectangle.x, object.rectangle.x + object.rectangle.w, \
        object.rectangle.y, object.rectangle.y + object.rectangle.h))


# Describe image
# Get the captions (descriptions) from the response, with confidence level
print("Description of remote image: ")
if (len(results_remote.description.captions) == 0):
    print("No description detected.")
else:
    for caption in results_remote.description.captions:
        print("'{}' with confidence {:.2f}%".format(caption.text, caption.confidence * 100))
print()

# Return tags
# Print results with confidence score
print("Tags in the remote image: ")
if (len(results_remote.tags) == 0):
    print("No tags detected.")
else:
    for tag in results_remote.tags:
        print("'{}' with confidence {:.2f}%".format(tag.name, tag.confidence * 100))

# Detect celebrities
print("Celebrities in the remote image:")
if (len(results_remote.categories.detail.celebrities) == 0):
    print("No celebrities detected.")
else:
    for celeb in results_remote.categories.detail.celebrities:
        print(celeb["name"])

# Detect landmarks
print("Landmarks in the remote image:")
if len(results_remote.categories.detail.landmarks) == 0:
    print("No landmarks detected.")
else:
    for landmark in results_remote.categories.detail.landmarks:
        print(landmark["name"])

Tipp

Bei der Verwendung von Azure KI Vision kann es zu vorübergehenden Fehlern kommen. Diese können auf durch den Dienst erzwungene Ratengrenzwerte oder andere vorübergehende Probleme (etwa Netzwerkausfälle) zurückzuführen sein. Informationen zur Behandlung solcher Fehler finden Sie im Leitfaden für Cloudentwurfsmuster unter Wiederholungsmuster sowie unter dem dazugehörigen Trennschalter-Muster.

Nächste Schritte

Erkunden Sie die Konzeptartikel, um mehr über die einzelnen Features zu erfahren.
Weitere Informationen zur API-Funktionalität finden Sie in der API-Referenz.

Freigeben über

Aufrufen der Bildanalyse 3.2-API

Übermitteln von Daten an den Dienst

Festlegen, wie die Daten verarbeitet werden sollen

Auswählen visueller Merkmale

Angeben von Sprachen

Abrufen von Ergebnissen aus dem Dienst

Fehlercodes

Nächste Schritte

Feedback

Zusätzliche Ressourcen