Appeler l’API 3.2 Analyse d’image

Article
11/25/2024

Cet article explique comment appeler l’API Analyse d’image version 3.2 pour retourner des informations sur les caractéristiques visuelles d’une image. Il montre également comment analyser les informations retournées à l’aide des SDK clients ou de l’API REST.

Ce guide suppose que vous avez déjà créé une ressource Vision, et obtenu une clé et une URL de point de terminaison. Si vous utilisez un Kit de développement logiciel (SDK) client, vous devez également authentifier un objet client. Pour plus d’informations sur ces étapes, consultez Démarrage rapide : Analyse d’image.

Envoyer des données au service

Le code de ce guide utilise des images distantes référencées par URL. Vous pouvez essayer des images différentes de votre choix pour voir toute la puissance des fonctionnalités d’Analyse d’image.

Lors de l’analyse d’une image distante, vous spécifiez l’URL de l’image en mettant en forme le corps de la demande comme ceci : {"url":"http://example.com/images/test.jpg"}.

Pour analyser une image locale, placez les données binaires de l’image dans le corps de la requête HTTP.

Dans votre classe principale, enregistrez une référence à l’URL de l’image que vous souhaitez analyser.

// 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";

Pour analyser une image locale, consultez les méthodes ComputerVisionClient, comme AnalyzeImageInStreamAsync. Ou consultez l’exemple de code sur GitHub pour obtenir des scénarios impliquant des images locales.

Dans votre classe main, enregistrez une référence à l’URL de l’image que vous souhaitez analyser.

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

Pour analyser une image locale, consultez les méthodes ComputerVision, comme AnalyzeImage. Ou consultez l’exemple de code sur GitHub pour obtenir des scénarios impliquant des images locales.

Dans votre fonction principale, enregistrez une référence à l’URL de l’image que vous souhaitez analyser.

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

Pour analyser une image locale, consultez les méthodes ComputerVisionClient, comme describeImageInStream. Ou consultez l’exemple de code sur GitHub pour obtenir des scénarios impliquant des images locales.

Enregistrez une référence à l’URL de l’image que vous souhaitez analyser.

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

Pour analyser une image locale, consultez les méthodes ComputerVisionClientOperationsMixin, comme analyze_image_in_stream. Ou consultez l’exemple de code sur GitHub pour obtenir des scénarios impliquant des images locales.

Déterminer le mode de traitement des données

Sélectionner des caractéristiques visuelles

L’API Analyser vous permet d’accéder à toutes les fonctionnalités d’analyse d’image du service. Choisissez les opérations à effectuer en fonction de votre propre cas d’usage. Pour obtenir une description de chaque fonctionnalité, consultez la Vue d’ensemble d’Azure AI Vision. Les exemples des sections suivantes ajoutent toutes les caractéristiques visuelles disponibles, mais pour une utilisation pratique, vous n’avez probablement besoin que d’une ou de deux d’entre elles.

Vous pouvez spécifier les caractéristiques que vous voulez utiliser en définissant les paramètres de requête d’URL de l’API Analyse. Un paramètre peut avoir plusieurs valeurs, séparées par des virgules. Chaque caractéristique que vous spécifiez nécessite davantage de temps de calcul : spécifiez donc seulement ce dont vous avez besoin.

Paramètre d’URL	Valeur	Description
`features`	`Read`	Lit le texte visible dans l’image et le génère sous forme de données JSON structurées.
`features`	`Description`	Décrit le contenu de l’image avec une phrase complète dans les langues prises en charge.
`features`	`SmartCrops`	Trouve les coordonnées du rectangle qui rognerait l’image à des proportions souhaitées tout en préservant la zone intéressante.
`features`	`Objects`	détecte les différents objets dans une image, notamment leur emplacement approximatif. L’argument `Objects` est disponible seulement en anglais.
`features`	`Tags`	Étiquette l’image avec une liste détaillée de mots liés au contenu de l’image.

Une URL remplie peut se présenter comme suit :

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

Définissez votre nouvelle méthode d’analyse d’image. Ajoutez le code suivant, qui spécifie les caractéristiques visuelles que vous souhaitez extraire dans votre analyse. Pour obtenir une liste complète, consultez la section sur l’énumération 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
    };

Spécifiez les caractéristiques visuelles que vous souhaitez extraire dans votre analyse. Pour obtenir une liste complète, consultez la section sur l’énumération 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);

Spécifiez les caractéristiques visuelles que vous souhaitez extraire dans votre analyse. Pour obtenir une liste complète, consultez la section sur l’énumération VisualFeatureTypes.

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

Spécifiez les caractéristiques visuelles que vous souhaitez extraire dans votre analyse. Pour obtenir une liste complète, consultez la section sur l’énumération 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]

Spécifier les langues

Vous pouvez également spécifier la langue des données retournées.

Le paramètre de requête d’URL suivant spécifie la langue. La valeur par défaut est en.

Paramètre d’URL	Valeur	Description
`language`	`en`	Anglais
`language`	`es`	Espagnol
`language`	`ja`	Japonais
`language`	`pt`	Portugais
`language`	`zh`	Chinois simplifié

Une URL remplie peut se présenter comme suit :

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

Utilisez le paramètre language de l’appel AnalyzeImageAsync pour spécifier une langue.

Langue	Valeur
Anglais	`en`
Espagnol	`es`
Japonais	`ja`
Portugais	`pt`
Chinois simplifié	`zh`

Un appel de méthode qui spécifie une langue peut ressembler à ce qui suit.

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

Utilisez l’entrée AnalyzeImageOptionalParameter dans votre appel Analyse pour spécifier une langue.

Langue	Valeur
Anglais	`en`
Espagnol	`es`
Japonais	`ja`
Portugais	`pt`
Chinois simplifié	`zh`

Un appel de méthode qui spécifie une langue peut ressembler à ce qui suit.

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

Utilisez la propriété language de l’entrée ComputerVisionClientAnalyzeImageOptionalParams dans votre appel d’Analyser pour spécifier une langue.

Langue	Valeur
Anglais	`en`
Espagnol	`es`
Japonais	`ja`
Portugais	`pt`
Chinois simplifié	`zh`

Un appel de méthode qui spécifie une langue peut ressembler à ce qui suit.

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

Utilisez le paramètre language de votre appel d’analyze_image pour spécifier une langue.

Langue	Valeur
Anglais	`en`
Espagnol	`es`
Japonais	`ja`
Portugais	`pt`
Chinois simplifié	`zh`

Un appel de méthode qui spécifie une langue peut ressembler à ce qui suit.

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

Obtenir les résultats du service

Cette section montre comment analyser les résultats de l’appel d’API. Elle inclut l’appel d’API lui-même.

Notes

Appels d’API étendues

Certaines des fonctionnalités d’Analyse d’image peuvent être appelées directement ou via un appel de l’API Analyser. Par exemple, vous pouvez effectuer une analyse étendue aux étiquettes d’image uniquement en effectuant une requête à <endpoint>/vision/v3.2/tag (ou à la méthode correspondante dans le SDK). Consultez la documentation de référence pour découvrir d’autres fonctionnalités qui peuvent être appelées séparément.

Le service retourne une réponse HTTP 200, et le corps contient les données retournées sous la forme d’une chaîne JSON. Le texte suivant est un exemple de réponse JSON.

{
    "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
            }
        ]
    }
}

Codes d’erreur

Consultez la liste suivante des erreurs possibles et leurs causes :

400
- InvalidImageUrl – L’URL de l’image est incorrecte ou inaccessible.
- InvalidImageFormat – Les données d’entrée ne sont pas une image valide.
- InvalidImageSize – L’image d’entrée est trop grande.
- NotSupportedVisualFeature – Le type de caractéristique spécifié n’est pas valide.
- NotSupportedImage – Image non prise en charge, par exemple de la pédopornographie.
- InvalidDetails – Valeur du paramètre detail non prise en charge.
- NotSupportedLanguage – L’opération demandée n’est pas prise en charge dans la langue spécifiée.
- BadArgument – Plus de détails sont fournis dans le message d’erreur.
415 : erreur de type de support non pris en charge. Le type Content-Type ne figure pas dans les types autorisés :
- Pour une URL d’image, Content-Type doit être application/json
- Pour les données d’image binaire, Content-Type doit être application/octet-stream ou multipart/form-data
500
- FailedToProcess
- Timeout – Le traitement de l’image a dépassé le délai d’expiration.
- InternalServerError

Le code suivant appelle l’API Analyse d’image et imprime les résultats dans la console.

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

Le code suivant appelle l’API Analyse d’image et imprime les résultats dans la console.

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

Le code suivant appelle l’API Analyse d’image et imprime les résultats dans la console.

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

Le code suivant appelle l’API Analyse d’image et imprime les résultats dans la console.

# 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"])

Conseil

Quand vous utilisez Azure AI Vision, vous pouvez rencontrer des défaillances temporaires causées par des limites de taux imposées par le service ou d’autres problèmes passagers comme des pannes du réseau. Pour plus d’informations sur la gestion de ces types d’échecs, consultez le Modèle de nouvelle tentative dans le guide Modèles de conception cloud et le modèle Disjoncteur qui s’y rapporte.

Découvrez le concept de détection d’objet.
Consultez la référence de l’API

Partager via

Appeler l’API 3.2 Analyse d’image

Envoyer des données au service

Déterminer le mode de traitement des données

Sélectionner des caractéristiques visuelles

Spécifier les langues

Obtenir les résultats du service

Codes d’erreur

Commentaires

Ressources supplémentaires

Partager via

Appeler l’API 3.2 Analyse d’image

Envoyer des données au service

Déterminer le mode de traitement des données

Sélectionner des caractéristiques visuelles

Spécifier les langues

Obtenir les résultats du service

Codes d’erreur

Contenu connexe

Commentaires

Ressources supplémentaires