Chiamare l'API Image Analysis 3.2

Articolo
05/23/2024

Questo articolo illustra come chiamare l'API Image Analysis 3.2 per restituire informazioni sulle funzionalità visive di un'immagine. Illustra anche come analizzare le informazioni restituite usando gli SDK client o l'API REST.

Questa guida presuppone che sia già stata creata una risorsa di Visione e ottenuta una chiave e un URL dell'endpoint. Se si usa un SDK client, è anche necessario autenticare un oggetto client. Se questi passaggi non sono stati eseguiti, seguire la guida di avvio rapido per iniziare.

Inviare dati al servizio

Il codice riportato in questa guida si avvale di immagini remote a cui fa riferimento l'URL. È possibile provare autonomamente immagini diverse per visualizzare la capacità completa delle funzionalità di Analisi delle immagini.

Quando si analizza un'immagine remota, si specifica l'URL dell'immagine formattando il corpo della richiesta, nel modo seguente: {"url":"http://example.com/images/test.jpg"}.

Per analizzare un'immagine locale, inserire i dati dell'immagine binaria nel corpo della richiesta HTTP.

Nella classe principale, salvare un riferimento all'URL dell'immagine da analizzare.

// URL image used for analyzing an image (image of puppy)
private const string ANALYZE_URL_IMAGE = "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png";

Suggerimento

È anche possibile analizzare un'immagine locale. Vedere i metodi ComputerVisionClient, ad esempio AnalyzeImageInStreamAsync. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Nella classe principale, salvare un riferimento all'URL dell'immagine da analizzare.

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

Suggerimento

È anche possibile analizzare un'immagine locale. Vedere i metodi ComputerVision, ad esempio AnalyzeImage. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Nella funzione principale, salvare un riferimento all'URL dell'immagine da analizzare.

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

Suggerimento

È anche possibile analizzare un'immagine locale. Vedere i metodi ComputerVisionClient, ad esempio describeImageInStream. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Salvare un riferimento all'URL dell'immagine da analizzare.

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

Suggerimento

È anche possibile analizzare un'immagine locale. Vedere i metodi ComputerVisionClientOperationsMixin, ad esempio analyze_image_in_stream. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Determinare come elaborare i dati

Selezionare le funzionalità visive

L'API Analisi consente di accedere a tutte le funzionalità di analisi delle immagini del servizio. Scegliere le operazioni da eseguire in base al caso d'uso specifico. Per una descrizione di ogni funzionalità, fare riferimento alla panoramica. Gli esempi nelle sezioni seguenti aggiungono tutte le funzionalità visive disponibili, ma per un utilizzo pratico sarà probabilmente necessario solo uno o due.

È possibile specificare le funzionalità da usare impostando i parametri di query URL dell'API Analisi. Un parametro può avere più valori, separati da virgole. Ogni funzionalità specificata richiederà più tempo di calcolo, quindi specificare solo gli elementi necessari.

Parametro URL	Valore	Descrizione
`features`	`Read`	legge il testo visibile nell'immagine e lo restituisce come dati JSON strutturati.
`features`	`Description`	descrive il contenuto dell'immagine con una frase completa nelle lingue supportate.
`features`	`SmartCrops`	trova le coordinate del rettangolo che ritaglierebbero l'immagine nelle proporzioni desiderate conservando l'area di interesse.
`features`	`Objects`	rileva vari oggetti all'interno di un'immagine, inclusa la posizione approssimativa. L'argomento Objects è disponibile solo in inglese.
`features`	`Tags`	Contrassegna l'immagine con un elenco dettagliato delle parole correlate con il contenuto dell'immagine.

Un URL popolato potrebbe essere simile al seguente:

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

Definire il nuovo metodo per l'analisi delle immagini. Aggiungere il codice seguente, che specifica le caratteristiche visive da estrarre nell'analisi. Per un elenco completo, vedere l'enumerazione 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
    };

Specificare le caratteristiche visive da estrarre nell'analisi. Per un elenco completo, vedere l'enumerazione 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);

Specificare le caratteristiche visive da estrarre nell'analisi. Per un elenco completo, vedere l'enumerazione VisualFeatureTypes.

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

Specificare le caratteristiche visive da estrarre nell'analisi. Per un elenco completo, vedere l'enumerazione 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]

Specificare le lingue

È anche possibile specificare la lingua dei dati restituiti.

Il parametro di query URL seguente specifica la lingua. Il valore predefinito è en.

Parametro URL	Valore	Descrizione
`language`	`en`	Inglese
`language`	`es`	Spagnolo
`language`	`ja`	Giapponese
`language`	`pt`	Portoghese
`language`	`zh`	Cinese semplificato

Un URL popolato potrebbe essere simile al seguente:

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

Usare il parametro language della chiamata AnalyzeImageAsync per specificare una lingua. Una chiamata a un metodo che specifica una lingua potrebbe essere simile alla seguente.

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

Usare l'input AnalyzeImageOptionalParameter nella chiamata Analizza per specificare una lingua. Una chiamata a un metodo che specifica una lingua potrebbe essere simile alla seguente.

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

Usare la proprietà language dell'input ComputerVisionClientAnalyzeImageOptionalParams nella chiamata Analizza per specificare una lingua. Una chiamata a un metodo che specifica una lingua potrebbe essere simile alla seguente.

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

Usare il parametro language della chiamata analyze_image per specificare una lingua. Una chiamata a un metodo che specifica una lingua potrebbe essere simile alla seguente.

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

Ottenere risultati dal servizio

Questa sezione illustra come analizzare i risultati della chiamata API. Include la chiamata API stessa.

Nota

Chiamate API con ambito

Alcune delle funzionalità di Analisi immagini possono essere chiamate direttamente e tramite la chiamata API Analyze. Ad esempio, è possibile eseguire un'analisi con ambito solo dei tag immagine effettuando una richiesta a <endpoint>/vision/v3.2/tag (o al metodo corrispondente nell'SDK). Vedere la documentazione di riferimento per altre funzionalità che è possibile chiamare separatamente.

Il servizio restituisce una risposta HTTP 200 e il corpo contiene i dati restituiti sotto forma di stringa JSON. Il testo seguente è un esempio di risposta 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
            }
        ]
    }
}

Codici di errore

Vedere l'elenco seguente di possibili errori e delle relative cause:

400
- InvalidImageUrl - L'URL dell'immagine è formattato in modo errato o non è accessibile.
- InvalidImageFormat - I dati di input non sono un'immagine valida.
- InvalidImageSize - L'immagine di input è troppo grande.
- NotSupportedVisualFeature - Il tipo di caratteristica specificato non è valido.
- NotSupportedImage - Immagine non supportata, ad esempio, contenuti pedopornografici.
- InvalidDetails - Tipo di parametro detail non supportato.
- NotSupportedLanguage - L'operazione richiesta non è supportata nella lingua specificata.
- BadArgument - Sono disponibili altri dettagli nel messaggio di errore.
415 - Errore tipo di supporto non supportato. Content-Type non è nei tipi consentiti:
- Per un URL di immagine, Content-Type deve essere application/json
- Per i dati di un'immagine binaria, Content-Type deve essere application/octet-stream o multipart/form-data
500
- FailedToProcess
- Timeout - Timeout dell'elaborazione dell'immagine.
- InternalServerError

Il codice seguente chiama l'API Analisi immagini e stampa i risultati nella 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();

Il codice seguente chiama l'API Analisi immagini e stampa i risultati nella 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());

Il codice seguente chiama l'API Analisi immagini e stampa i risultati nella 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();

Il codice seguente chiama l'API Analisi immagini e stampa i risultati nella 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"])

Suggerimento

Durante l'uso di Visione artificiale di Azure, è possibile che si verifichino errori temporanei causati dai limiti di frequenza applicati dal servizio o da altri problemi temporanei, ad esempio interruzioni di rete. Per informazioni sulla gestione di questi tipi di errori, vedere Modello di ripetizione dei tentativi nella guida Modelli di progettazione cloud e l'articolo correlato Modello a interruttore.

Passaggi successivi

Per altre informazioni su ogni funzionalità, vedere gli articoli sui concetti.
Consultare le informazioni di riferimento sull'API per altre informazioni sulla funzionalità API.

Condividi tramite

Chiamare l'API Image Analysis 3.2

Inviare dati al servizio

Determinare come elaborare i dati

Selezionare le funzionalità visive

Specificare le lingue

Ottenere risultati dal servizio

Codici di errore

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive