Snabbstart: Använda klientbiblioteket för bildanalys eller REST API

Använd klientbiblioteket för bildanalys för att analysera en bild för taggar, textbeskrivning, ansikten, vuxet innehåll med mera.

Referensdokumentation | Bibliotekskällkod | Paket (NuGet) | Exempel

Förutsättningar

• En Azure-prenumeration – Skapa en utan kostnad
• Den Visual Studio IDE eller den aktuella versionen av .NET Core.
• När du har din Azure-prenumeration skapar du Visuellt innehåll resurs för att skapa Visuellt innehåll resurs i Azure Portal för att slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från resursen som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.

Inrätta

Skapa ett nytt C#-program

dotnet new console -n computer-vision-quickstart

dotnet build

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

dotnet add package Microsoft.Azure.CognitiveServices.Vision.ComputerVision --version 7.0.0

Från projektkatalogen öppnar du filen Program.cs i önskad redigerare eller IDE. Lägg till följande using -direktiv:

using System;
using System.Collections.Generic;
using Microsoft.Azure.CognitiveServices.Vision.ComputerVision;
using Microsoft.Azure.CognitiveServices.Vision.ComputerVision.Models;
using System.Threading.Tasks;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Threading;
using System.Linq;

I programmets Program-klass skapar du variabler för resursens Azure-slutpunkt och nyckel.

// Add your Computer Vision subscription key and endpoint
static string subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
static string endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

I programmets -metod Main lägger du till anrop för de metoder som används i den här snabbstarten. Du kommer att skapa dessa senare.

// Create a client
ComputerVisionClient client = Authenticate(endpoint, subscriptionKey);

// Analyze an image to get features and other properties.
AnalyzeImageUrl(client, ANALYZE_URL_IMAGE).Wait();

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i .NET SDK för bildanalys.

Kodexempel

Dessa kodfragment visar hur du utför följande uppgifter med klientbiblioteket för bildanalys för .NET:

• Autentisera klienten
• Analysera en bild

Autentisera klienten

I en ny metod i klassen Program instansierar du en klient med din slutpunkt och nyckel. Skapa ett ApiKeyServiceClientCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett ComputerVisionClient-objekt.

/*
 * AUTHENTICATE
 * Creates a Computer Vision client used by each example.
 */
public static ComputerVisionClient Authenticate(string endpoint, string key)
{
    ComputerVisionClient client =
      new ComputerVisionClient(new ApiKeyServiceClientCredentials(key))
      { Endpoint = endpoint };
    return client;
}

Analysera en bild

Följande kod definierar en -metod, AnalyzeImageUrl , som använder klientobjektet för att analysera en fjärrbild och skriva ut resultatet. Metoden returnerar en textbeskrivning, kategorisering, en lista med taggar, identifierade ansikten, flaggor för vuxet innehåll, huvudfärger och bildtyp.

Konfigurera testbild

Spara en referens till URL:en för den bild som du vill analysera i klassen Program.

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

Ange visuella funktioner

Definiera den nya metoden för bildanalys. Lägg till koden nedan, som anger visuella funktioner som du vill extrahera i analysen. En fullständig lista finns i uppräkning av 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
    };

Anropa API:et Analysera

Metoden AnalyzeImageAsync returnerar ett ImageAnalysis-objekt som innehåller all extraherad information.

Console.WriteLine($"Analyzing the image {Path.GetFileName(imageUrl)}...");
Console.WriteLine();
// Analyze the URL image 
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features);

Följande avsnitt visar hur du parsar den här informationen i detalj.

Infoga något av följande kodblock i metoden AnalyzeImageUrl för att parsa data från de visuella funktioner som du begärde ovan. Kom ihåg att lägga till en avslutande hakparentes i slutet.

}

Hämta bildbeskrivning

Följande kod hämtar listan över genererade bildtexter för avbildningen. Mer information finns i Beskriv bilder.

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

Hämta bildkategori

Följande kod hämtar den identifierade kategorin för bilden. Mer information finns i Kategorisera bilder.

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

Hämta bildtaggar

Följande kod hämtar uppsättningen identifierade taggar i bilden. Mer information finns i Innehållstaggar.

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

Upptäcka objekt

Följande kod identifierar vanliga objekt i bilden och skriver ut dem till konsolen. Mer information finns i Objektidentifiering.

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

Identifiera varumärken

Följande kod identifierar företagets varumärken och logotyper i bilden och skriver ut dem till konsolen. Mer information finns i Varumärkesidentifiering.

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

Identifiera ansikten

Följande kod returnerar de identifierade ansiktena i bilden med deras rektangelkoordinater och väljer ansiktsattribut. Mer information finns i Ansiktsavkänning.

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

Identifiera vuxet, racy- eller gory-innehåll

Följande kod skriver ut den identifierade förekomsten av vuxet innehåll i bilden. Mer information finns i Vuxet, racy, gory-innehåll.

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

Hämta bildfärgschema

Följande kod skriver ut de identifierade färgattributen i bilden, till exempel de dominerande färgerna och accentfärgen. Mer information finns i Färgscheman.

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

Hämta domänspecifikt innehåll

Bildanalys kan använda specialiserade modeller för ytterligare analys av bilder. Mer information finns i Domänspecifikt innehåll.

Följande kod parsar data om identifierade kändisar i bilden.

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

Följande kod parsar data om identifierade landmärken i bilden.

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

Hämta avbildningstypen

Följande kod skriver ut information om typen av bild oavsett — om det är ClipArt eller en linjeritning.

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

Kör programmet

dotnet run

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar klientbiblioteket för bildanalys och gör grundläggande bildanalys-anrop. Härnäst kan du läsa mer om funktionerna i Analysera API.

• Översikt över bildanalys
• Källkoden för det här exemplet finns på GitHub.

Använd klientbiblioteket för bildanalys för att analysera en bild för taggar, textbeskrivning, ansikten, vuxet innehåll med mera.

Referensdokumentation | Bibliotekskällkod | Paket (PiPy) | Exempel

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt

• Python 3.x

  • Python-installationen bör innehålla pip. Du kan kontrollera om pip har installerats genom pip --version att köra på kommandoraden. Hämta pip genom att installera den senaste versionen av Python.

• När du har din Azure-prenumeration skapar Visuellt innehåll resurs en Visuellt innehåll resurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.

  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Installera klientbiblioteket

Du kan installera klientbiblioteket med:

pip install --upgrade azure-cognitiveservices-vision-computervision

Installera även biblioteket Pillow.

pip install pillow

Skapa ett nytt Python-program

Skapa till exempel en — quickstart-file.py Python-fil. Öppna den sedan i önskad redigerare eller IDE och importera följande bibliotek.

from azure.cognitiveservices.vision.computervision import ComputerVisionClient
from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
from azure.cognitiveservices.vision.computervision.models import VisualFeatureTypes
from msrest.authentication import CognitiveServicesCredentials

from array import array
import os
from PIL import Image
import sys
import time

Skapa sedan variabler för resursens Azure-slutpunkt och nyckel.

subscription_key = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE"
endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE"

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Image Analysis Python SDK.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med bildanalysklientbiblioteket för Python:

• Autentisera klienten
• Analysera en bild

Autentisera klienten

Instansiera en klient med din slutpunkt och nyckel. Skapa ett CognitiveServicesCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett ComputerVisionClient-objekt.

computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))

Analysera en bild

Använd klientobjektet för att analysera de visuella funktionerna i en fjärrbild. Spara först en referens till URL:en för en bild som du vill analysera.

remote_image_url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/landmark.jpg"

Hämta bildbeskrivning

Följande kod hämtar listan över genererade bildtexter för bilden. Mer information finns i Beskriv bilder.

'''
Describe an Image - remote
This example describes the contents of an image with the confidence score.
'''
print("===== Describe an image - remote =====")
# Call API
description_results = computervision_client.describe_image(remote_image_url )

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

Hämta bildkategori

Följande kod hämtar den identifierade kategorin för avbildningen. Mer information finns i Kategorisera bilder.

'''
Categorize an Image - remote
This example extracts (general) categories from a remote image with a confidence score.
'''
print("===== Categorize an image - remote =====")
# Select the visual feature(s) you want.
remote_image_features = ["categories"]
# Call API with URL and features
categorize_results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features)

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

Hämta bildtaggar

Följande kod hämtar uppsättningen identifierade taggar i bilden. Mer information finns i Innehållstaggar.

'''
Tag an Image - remote
This example returns a tag (key word) for each thing in the image.
'''
print("===== Tag an image - remote =====")
# Call API with remote image
tags_result_remote = computervision_client.tag_image(remote_image_url )

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

Upptäcka objekt

Följande kod identifierar vanliga objekt i bilden och skriver ut dem till konsolen. Mer information finns i Objektidentifiering.

'''
Detect Objects - remote
This example detects different kinds of objects with bounding boxes in a remote image.
'''
print("===== Detect Objects - remote =====")
# Get URL image with different objects
remote_image_url_objects = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/objects.jpg"
# Call API with URL
detect_objects_results_remote = computervision_client.detect_objects(remote_image_url_objects)

# Print detected objects results with bounding boxes
print("Detecting objects in remote image:")
if len(detect_objects_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))

Identifiera varumärken

Följande kod identifierar företagets varumärken och logotyper i bilden och skriver ut dem till konsolen. Mer information finns i Varumärkesidentifiering.

'''
Detect Brands - remote
This example detects common brands like logos and puts a bounding box around them.
'''
print("===== Detect Brands - remote =====")
# Get a URL with a brand logo
remote_image_url = "https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/gray-shirt-logo.jpg"
# Select the visual feature(s) you want
remote_image_features = ["brands"]
# Call API with URL and features
detect_brands_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

print("Detecting brands in remote image: ")
if len(detect_brands_results_remote.brands) == 0:
    print("No brands detected.")
else:
    for brand in detect_brands_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))

Identifiera ansikten

Följande kod returnerar de identifierade ansiktena i bilden med deras rektangelkoordinater och väljer ansiktsattribut. Mer information finns i Ansiktsigenkänning.

'''
Detect Faces - remote
This example detects faces in a remote image, gets their gender and age, 
and marks them with a bounding box.
'''
print("===== Detect Faces - remote =====")
# Get an image with faces
remote_image_url_faces = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/faces.jpg"
# Select the visual feature(s) you want.
remote_image_features = ["faces"]
# Call the API with remote URL and features
detect_faces_results_remote = computervision_client.analyze_image(remote_image_url_faces, remote_image_features)

# Print the results with gender, age, and bounding box
print("Faces in the remote image: ")
if (len(detect_faces_results_remote.faces) == 0):
    print("No faces detected.")
else:
    for face in detect_faces_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))

Identifiera vuxet, ojämnt eller gory-innehåll

Följande kod skriver ut den identifierade förekomsten av vuxet innehåll i bilden. Mer information finns i Vuxet, racy, gory-innehåll.

'''
Detect Adult or Racy Content - remote
This example detects adult or racy content in a remote image, then prints the adult/racy score.
The score is ranged 0.0 - 1.0 with smaller numbers indicating negative results.
'''
print("===== Detect Adult or Racy Content - remote =====")
# Select the visual feature(s) you want
remote_image_features = ["adult"]
# Call API with URL and features
detect_adult_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

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

Hämta bildfärgschema

Följande kod skriver ut de identifierade färgattributen i bilden, till exempel de dominerande färgerna och accentfärgen. Mer information finns i Färgscheman.

'''
Detect Color - remote
This example detects the different aspects of its color scheme in a remote image.
'''
print("===== Detect Color - remote =====")
# Select the feature(s) you want
remote_image_features = ["color"]
# Call API with URL and features
detect_color_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

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

Hämta domänspecifikt innehåll

Bildanalys kan använda specialiserad modell för ytterligare analys av bilder. Mer information finns i Domänspecifikt innehåll.

Följande kod parsar data om identifierade kändisar i bilden.

'''
Detect Domain-specific Content - remote
This example detects celebrites and landmarks in remote images.
'''
print("===== Detect Domain-specific Content - remote =====")
# URL of one or more celebrities
remote_image_url_celebs = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/faces.jpg"
# Call API with content type (celebrities) and URL
detect_domain_results_celebs_remote = computervision_client.analyze_image_by_domain("celebrities", remote_image_url_celebs)

# Print detection results with name
print("Celebrities in the remote image:")
if len(detect_domain_results_celebs_remote.result["celebrities"]) == 0:
    print("No celebrities detected.")
else:
    for celeb in detect_domain_results_celebs_remote.result["celebrities"]:
        print(celeb["name"])

Följande kod parsar data om identifierade landmärken i bilden.

# Call API with content type (landmarks) and URL
detect_domain_results_landmarks = computervision_client.analyze_image_by_domain("landmarks", remote_image_url)
print()

print("Landmarks in the remote image:")
if len(detect_domain_results_landmarks.result["landmarks"]) == 0:
    print("No landmarks detected.")
else:
    for landmark in detect_domain_results_landmarks.result["landmarks"]:
        print(landmark["name"])

Hämta avbildningstypen

Följande kod skriver ut information om typen av bild oavsett — om det är ClipArt eller linjeritning.

'''
Detect Image Types - remote
This example detects an image's type (clip art/line drawing).
'''
print("===== Detect Image Types - remote =====")
# Get URL of an image with a type
remote_image_url_type = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/type-image.jpg"
# Select visual feature(s) you want
remote_image_features = [VisualFeatureTypes.image_type]
# Call API with URL and features
detect_type_results_remote = computervision_client.analyze_image(remote_image_url_type, remote_image_features)

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

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

Kör programmet

Kör programmet med kommandot python i snabbstartsfilen.

python quickstart-file.py

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar klientbiblioteket för bildanalys och gör grundläggande bildanalys-anrop. Härnäst kan du läsa mer om funktionerna i Analysera API.

• Översikt över bildanalys
• Källkoden för det här exemplet finns på GitHub.

Använd klientbiblioteket för bildanalys för att analysera en bild efter taggar, textbeskrivning, ansikten, vuxet innehåll med mera.

Referensdokumentation | Bibliotekskällkod | Artefakt (Maven) | Exempel

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Java Development Kit (JDK)
• Gradle-byggverktyget, eller någon annan beroendehanterare.
• När du har din Azure-prenumeration skapar Visuellt innehåll en Visuellt innehåll resurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Gradle-projekt

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot gradle init från arbetskatalogen. Det här kommandot skapar viktiga byggfiler för Gradle, inklusive build.gradle.kts, som används vid körning för att skapa och konfigurera ditt program.

gradle init --type basic

Välj en DSL när du uppmanas till det och välj Kotlin.

Installera klientbiblioteket

I den här snabbstarten används Gradle-beroendehanteraren. Du hittar klientbiblioteket och information för andra beroendehanterare på den centrala Maven-lagringsplatsen.

Leta upp build.gradle.kts och öppna det med önskad IDE eller textredigerare. Kopiera sedan följande byggkonfiguration. Den här konfigurationen definierar projektet som ett Java-program vars startpunkt är klassen ImageAnalysisQuickstart. Den importerar Visuellt innehåll biblioteket.

plugins {
    java
    application
}
application { 
    mainClass.set("ImageAnalysisQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.microsoft.azure.cognitiveservices", name = "azure-cognitiveservices-computervision", version = "1.0.6-beta")
}

Skapa en Java-fil

Kör följande kommando från arbetskatalogen för att skapa en projektkällmapp:

mkdir -p src/main/java

Navigera till den nya mappen och skapa en fil med namnet ImageAnalysisQuickstart.java. Öppna den i önskad redigerare eller IDE och lägg till följande import -instruktioner:

import com.microsoft.azure.cognitiveservices.vision.computervision.*;
import com.microsoft.azure.cognitiveservices.vision.computervision.implementation.ComputerVisionImpl;
import com.microsoft.azure.cognitiveservices.vision.computervision.models.*;

import java.io.*;
import java.nio.file.Files;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

Definiera klassen ImageAnalysisQuickstart.

public class ImageAnalysisQuickstart {

}

I klassen ImageAnalysisQuickstart skapar du variabler för resursens nyckel och slutpunkt.

static String subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
static String endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

I programmets huvudmetod lägger du till anrop för de metoder som används i den här snabbstarten. Du definierar dessa senare.

public static void main(String[] args) {
    
    System.out.println("\nAzure Cognitive Services Computer Vision - Java Quickstart Sample");

    // Create an authenticated Computer Vision client.
    ComputerVisionClient compVisClient = Authenticate(subscriptionKey, endpoint); 

    // Analyze local and remote images
    AnalyzeLocalImage(compVisClient);

}

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Image Analysis Java SDK.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med bildanalysklientbiblioteket för Java:

• Autentisera klienten
• Analysera en bild

Autentisera klienten

I en ny metod instansierar du ett ComputerVisionClient-objekt med din slutpunkt och nyckel.

public static ComputerVisionClient Authenticate(String subscriptionKey, String endpoint){
    return ComputerVisionManager.authenticate(subscriptionKey).withEndpoint(endpoint);
}

Analysera en bild

Följande kod definierar en AnalyzeLocalImage -metod, , som använder klientobjektet för att analysera en lokal bild och skriva ut resultatet. Metoden returnerar en textbeskrivning, kategorisering, lista över taggar, identifierade ansikten, flaggor för vuxet innehåll, huvudfärger och bildtyp.

Konfigurera testbild

Skapa först en resurs/mapp i mappen src/main/i projektet och lägg till en bild som du vill analysera. Lägg sedan till följande metoddefinition i klassen ImageAnalysisQuickstart. Ändra värdet för så pathToLocalImage att det matchar bildfilen.

public static void AnalyzeLocalImage(ComputerVisionClient compVisClient) {
    /*
     * Analyze a local image:
     *
     * Set a string variable equal to the path of a local image. The image path
     * below is a relative path.
     */
    String pathToLocalImage = "src\\main\\resources\\myImage.png";

Ange visuella funktioner

Ange sedan vilka visuella funktioner som du vill extrahera i analysen. En fullständig lista finns i Uppräkning av VisualFeatureTypes.

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

Analysera

Det här blocket skriver ut detaljerade resultat till konsolen för varje bildanalysomfång. Metoden analyzeImageInStream returnerar ett ImageAnalysis-objekt som innehåller all extraherad information.

try {
    // Need a byte array for analyzing a local image.
    File rawImage = new File(pathToLocalImage);
    byte[] imageByteArray = Files.readAllBytes(rawImage.toPath());

    // Call the Computer Vision service and tell it to analyze the loaded image.
    ImageAnalysis analysis = compVisClient.computerVision().analyzeImageInStream().withImage(imageByteArray)
            .withVisualFeatures(featuresToExtractFromLocalImage).execute();

I följande avsnitt visas hur du parsar informationen i detalj.

Hämta bildbeskrivning

Följande kod hämtar listan över genererade bildtexter för bilden. Mer information finns i Beskriv bilder.

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

Hämta bildkategori

Följande kod hämtar den identifierade kategorin för avbildningen. Mer information finns i Kategorisera bilder.

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

Hämta bildtaggar

Följande kod hämtar uppsättningen identifierade taggar i bilden. Mer information finns i Innehållstaggar.

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

Identifiera ansikten

Följande kod returnerar de identifierade ansiktena i bilden med deras rektangelkoordinater och väljer ansiktsattribut. Mer information finns i Ansiktsigenkänning.

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

Upptäcka objekt

Följande kod returnerar de identifierade objekten i bilden med deras koordinater. Mer information finns i Objektidentifiering.

// Display any objects found in the image.
System.out.println("\nObjects: ");
for ( DetectedObject object : analysis.objects()) {
    System.out.printf("Object \'%s\' detected at location (%d, %d)\n", object.objectProperty(),
            object.rectangle().x(), object.rectangle().y());
}

Identifiera varumärken

Följande kod returnerar de identifierade varumärkeslogotyperna i bilden med deras koordinater. Mer information finns i Varumärkesidentifiering.

// Display any brands found in the image.
System.out.println("\nBrands: ");
for ( DetectedBrand brand : analysis.brands()) {
    System.out.printf("Brand \'%s\' detected at location (%d, %d)\n", brand.name(),
            brand.rectangle().x(), brand.rectangle().y());
}

Identifiera vuxet, ojämnt eller gory-innehåll

Följande kod skriver ut den identifierade förekomsten av vuxet innehåll i bilden. Mer information finns i Adult, racy, gory content.

// Display whether any adult/racy/gory 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());
System.out.printf("Has gory content: %b with confidence %f\n", analysis.adult().isGoryContent(),
        analysis.adult().goreScore());

Hämta bildfärgschema

Följande kod skriver ut de identifierade färgattributen i bilden, till exempel de dominerande färgerna och accentfärgen. Mer information finns i Färgscheman.

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

Hämta domänspecifikt innehåll

Bildanalys kan använda specialiserad modell för ytterligare analys av bilder. Mer information finns i Domänspecifikt innehåll.

Följande kod parsar data om identifierade kändisar i bilden.

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

Följande kod parsar data om identifierade landmärken i bilden.

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

Hämta avbildningstypen

Följande kod skriver ut information om typen av bild oavsett — om det är ClipArt eller linjeritning.

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

Stäng metoden

Slutför try/catch-blocket och stäng metoden.

    }

    catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
}

Kör programmet

Du kan skapa appen med:

gradle build

Kör programmet med gradle run kommandot :

gradle run

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar klientbiblioteket för bildanalys och gör grundläggande bildanalys-anrop. Härnäst kan du läsa mer om funktionerna i Analysera API.

• Översikt över bildanalys
• Källkoden för det här exemplet finns på GitHub.

Använd klientbiblioteket för bildanalys för att analysera en bild efter taggar, textbeskrivning, ansikten, vuxet innehåll med mera.

Referensdokumentation | Bibliotekskällkod | Paket (npm) | Exempel

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Node.js
• När du har din Azure-prenumeration skapar Visuellt innehåll resurs en Visuellt innehåll resurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Node.js-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot npm init för att skapa ett nodprogram med en package.json fil.

npm init

Installera klientbiblioteket

Installera ms-rest-azure @azure/cognitiveservices-computervision NPM-paketet och :

npm install @azure/cognitiveservices-computervision

Installera även modulen async:

npm install async

Appens package.json fil uppdateras med beroendena.

Skapa en ny fil,index.js, och öppna den i en textredigerare. Lägg till följande importutdrag.

'use strict';

const async = require('async');
const fs = require('fs');
const https = require('https');
const path = require("path");
const createReadStream = require('fs').createReadStream
const sleep = require('util').promisify(setTimeout);
const ComputerVisionClient = require('@azure/cognitiveservices-computervision').ComputerVisionClient;
const ApiKeyCredentials = require('@azure/ms-rest-js').ApiKeyCredentials;

Skapa variabler för resursens Azure-slutpunkt och nyckel.

/**
 * AUTHENTICATE
 * This single client is used for all examples.
 */
const key = 'PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE';
const endpoint = 'PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE';

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i SDK för bildanalys Node.js.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med klientbiblioteket för bildanalys för Node.js:

• Autentisera klienten
• Analysera en bild

Autentisera klienten

Instansiera en klient med din slutpunkt och nyckel. Skapa ett ApiKeyCredentials-objekt med din nyckel och slutpunkt och använd det för att skapa ett ComputerVisionClient-objekt.

const computerVisionClient = new ComputerVisionClient(
  new ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } }), endpoint);

Definiera sedan en funktion och computerVision deklarera en asynkron serie med primär funktion och återanropsfunktion. Du lägger till snabbstartskoden i den primära funktionen och computerVision anropar längst ned i skriptet. Resten av koden i den här snabbstarten hamnar i computerVision funktionen .

function computerVision() {
  async.series([
    async function () {

    },
    function () {
      return new Promise((resolve) => {
        resolve();
      })
    }
  ], (err) => {
    throw (err);
  });
}

computerVision();

Analysera en bild

Koden i det här avsnittet analyserar fjärrbilder för att extrahera olika visuella funktioner. Du kan göra dessa åtgärder som en del av metoden analyzeImage för klientobjektet eller anropa dem med hjälp av enskilda metoder. Mer information finns i referensdokumentationen.

Hämta bildbeskrivning

Följande kod hämtar listan över genererade bildtexter för bilden. Mer information finns i Beskriv bilder.

Definiera först URL:en för en bild som ska analyseras:

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

Lägg sedan till följande kod för att hämta bildbeskrivningen och skriva ut den till konsolen.

// Analyze URL image
console.log('Analyzing URL image to describe...', describeURL.split('/').pop());
const caption = (await computerVisionClient.describeImage(describeURL)).captions[0];
console.log(`This may be ${caption.text} (${caption.confidence.toFixed(2)} confidence)`);

Hämta bildkategori

Följande kod hämtar den identifierade kategorin för avbildningen. Mer information finns i Kategorisera bilder.

const categoryURLImage = 'https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png';

// Analyze URL image
console.log('Analyzing category in image...', categoryURLImage.split('/').pop());
const categories = (await computerVisionClient.analyzeImage(categoryURLImage)).categories;
console.log(`Categories: ${formatCategories(categories)}`);

Definiera hjälpfunktionen formatCategories :

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

Hämta bildtaggar

Följande kod hämtar uppsättningen identifierade taggar i bilden. Mer information finns i Innehållstaggar.

console.log('-------------------------------------------------');
console.log('DETECT TAGS');
console.log();

// Image of different kind of dog.
const tagsURL = 'https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png';

// Analyze URL image
console.log('Analyzing tags in image...', tagsURL.split('/').pop());
const tags = (await computerVisionClient.analyzeImage(tagsURL, { visualFeatures: ['Tags'] })).tags;
console.log(`Tags: ${formatTags(tags)}`);

Definiera hjälpfunktionen formatTags :

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

Upptäcka objekt

Följande kod identifierar vanliga objekt i bilden och skriver ut dem till konsolen. Mer information finns i Objektidentifiering.

// Image of a dog
const objectURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-node-sdk-samples/master/Data/image.jpg';

// Analyze a URL image
console.log('Analyzing objects in image...', objectURL.split('/').pop());
const objects = (await computerVisionClient.analyzeImage(objectURL, { visualFeatures: ['Objects'] })).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.'); }

Definiera hjälpfunktionen för formatRectObjects att returnera de övre, vänstra, nedre och högra koordinaterna, tillsammans med bredd och höjd.

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

Identifiera varumärken

Följande kod identifierar företagets varumärken och logotyper i bilden och skriver ut dem till konsolen. Mer information finns i Varumärkesidentifiering.

const brandURLImage = 'https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/red-shirt-logo.jpg';

// Analyze URL image
console.log('Analyzing brands in image...', brandURLImage.split('/').pop());
const brands = (await computerVisionClient.analyzeImage(brandURLImage, { visualFeatures: ['Brands'] })).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.`); }

Identifiera ansikten

Följande kod returnerar de identifierade ansiktena i bilden med deras rektangelkoordinater och väljer ansiktsattribut. Mer information finns i Ansiktsigenkänning.

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

// Analyze URL image.
console.log('Analyzing faces in image...', facesImageURL.split('/').pop());
// Get the visual feature for 'Faces' only.
const faces = (await computerVisionClient.analyzeImage(facesImageURL, { visualFeatures: ['Faces'] })).faces;

// Print the bounding box, gender, and age from the 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.'); }

Definiera hjälpfunktionen formatRectFaces :

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

Identifiera vuxet, ojämnt eller gory-innehåll

Följande kod skriver ut den identifierade förekomsten av vuxet innehåll i bilden. Mer information finns i Vuxet, racy, gory-innehåll.

Definiera URL:en för avbildningen som ska användas:

// The URL image and local images are not racy/adult. 
// Try your own racy/adult images for a more effective result.
const adultURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';

Lägg sedan till följande kod för att identifiera vuxet innehåll och skriva ut resultatet till konsolen.

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

// Analyze URL image
console.log('Analyzing image for racy/adult content...', adultURLImage.split('/').pop());
const adult = (await computerVisionClient.analyzeImage(adultURLImage, {
  visualFeatures: ['Adult']
})).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)`);

Hämta bildfärgschema

Följande kod skriver ut de identifierade färgattributen i bilden, till exempel de dominerande färgerna och accentfärgen. Mer information finns i Färgscheman.

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

// Analyze URL image
console.log('Analyzing image for color scheme...', colorURLImage.split('/').pop());
console.log();
const color = (await computerVisionClient.analyzeImage(colorURLImage, { visualFeatures: ['Color'] })).color;
printColorScheme(color);

Definiera hjälpfunktionen för printColorScheme att skriva ut information om färgschemat till konsolen.

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

Hämta domänspecifikt innehåll

Bildanalys kan använda specialiserad modell för ytterligare analys av bilder. Mer information finns i Domänspecifikt innehåll.

Definiera först URL:en för en bild som ska analyseras:

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

Följande kod parsar data om identifierade landmärken i bilden.

// Analyze URL image
console.log('Analyzing image for landmarks...', domainURLImage.split('/').pop());
const domain = (await computerVisionClient.analyzeImageByDomain('landmarks', domainURLImage)).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.');
}

Definiera hjälpfunktionen för formatRectDomain att parsa platsdata om identifierade landmärken.

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

Hämta avbildningstypen

Följande kod skriver ut information om typen av bild oavsett — om det är ClipArt- eller linjeritning.

const typeURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-python-sdk-samples/master/samples/vision/images/make_things_happen.jpg';

// Analyze URL image
console.log('Analyzing type in image...', typeURLImage.split('/').pop());
const types = (await computerVisionClient.analyzeImage(typeURLImage, { visualFeatures: ['ImageType'] })).imageType;
console.log(`Image appears to be ${describeType(types)}`);

Definiera hjälpfunktionen describeType :

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

Kör programmet

Kör programmet med kommandot node i snabbstartsfilen.

node index.js

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar klientbiblioteket för bildanalys och gör grundläggande bildanalys-anrop. Härnäst får du lära dig mer om funktionerna i Analysera API.

• Översikt över bildanalys
• Källkoden för det här exemplet finns på GitHub.

Använd klientbiblioteket för bildanalys för att analysera en bild för taggar, textbeskrivning, ansikten, vuxet innehåll med mera.

Referensdokumentation | Bibliotekskällkod | Paketera

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt
• Den senaste versionen av Go
• När du har din Azure-prenumeration skapar Visuellt innehåll resurs en Visuellt innehåll resurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa en Go-projektkatalog

I ett konsolfönster (cmd, PowerShell, Terminal, Bash) skapar du en ny arbetsyta för Go-projektet med namnet my-app och navigerar till den.

mkdir -p my-app/{src, bin, pkg}  
cd my-app

Arbetsytan innehåller tre mappar:

• src – Den här katalogen innehåller källkod och paket. Alla paket som installeras go get med kommandot kommer att placeras i den här katalogen.
• pkg – den här katalogen innehåller de kompilerade Go-paketobjekten. Alla dessa filer har ett .a tillägg.
• bin – Den här katalogen innehåller de binära körbara filer som skapas när du kör go install .

Installera klientbiblioteket för Go

Installera sedan klientbiblioteket för Go:

go get -u https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

eller i din lagringsplatskörning om du använder dep:

dep ensure -add https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

Skapa ett Go-program

Skapa sedan en fil i katalogen src med namnet sample-app.go :

cd src
touch sample-app.go

Öppna sample-app.go i önskad IDE eller textredigerare. Lägg sedan till paketnamnet och importera följande bibliotek:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/computervision"
    "github.com/Azure/go-autorest/autorest"
    "io"
    "log"
    "os"
    "strings"
    "time"
)

Deklarera också en kontext i roten för skriptet. Du behöver det här objektet för att köra de flesta bildanalysfunktionsanrop:

// Declare global so don't have to pass it to all of the tasks.
var computerVisionContext context.Context

Nu ska du börja lägga till kod för att utföra olika Visuellt innehåll åtgärder.

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Image Analysis Go SDK.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med bildanalysklientbiblioteket för Go:

• Autentisera klienten
• Analysera en bild

Autentisera klienten

Skapa en main funktion och lägg till följande kod i den för att instansiera en klient med din slutpunkt och nyckel.

/*  
 * Configure the Computer Vision client
 */
computerVisionClient := computervision.New(endpointURL);
computerVisionClient.Authorizer = autorest.NewCognitiveServicesAuthorizer(computerVisionKey)

computerVisionContext = context.Background()
/*
 * END - Configure the Computer Vision client
 */

Analysera en bild

Följande kod använder klientobjektet för att analysera en fjärrbild och skriva ut resultatet till konsolen. Du kan hämta en textbeskrivning, kategorisering, lista över taggar, identifierade objekt, identifierade varumärken, identifierade ansikten, flaggor för vuxet innehåll, huvudfärger och bildtyp.

Konfigurera testbild

Spara först en referens till URL:en för den bild som du vill analysera. Placera den i din main funktion.

landmarkImageURL := "https://github.com/Azure-Samples/cognitive-services-sample-data-files/raw/master/ComputerVision/Images/landmark.jpg"

Ange visuella funktioner

Följande funktionsanrop extraherar olika visuella funktioner från exempelbilden. Du definierar dessa funktioner i följande avsnitt.

// Analyze features of an image, remote
DescribeRemoteImage(computerVisionClient, landmarkImageURL)
CategorizeRemoteImage(computerVisionClient, landmarkImageURL)
TagRemoteImage(computerVisionClient, landmarkImageURL)
DetectFacesRemoteImage(computerVisionClient, facesImageURL)
DetectObjectsRemoteImage(computerVisionClient, objectsImageURL)
DetectBrandsRemoteImage(computerVisionClient, brandsImageURL)
DetectAdultOrRacyContentRemoteImage(computerVisionClient, adultRacyImageURL)
DetectColorSchemeRemoteImage(computerVisionClient, brandsImageURL)
DetectDomainSpecificContentRemoteImage(computerVisionClient, landmarkImageURL)
DetectImageTypesRemoteImage(computerVisionClient, detectTypeImageURL)
GenerateThumbnailRemoteImage(computerVisionClient, adultRacyImageURL)

Hämta bildbeskrivning

Följande funktion hämtar listan över genererade bildtexter för bilden. Mer information om bildbeskrivning finns i Beskriv bilder.

func DescribeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DESCRIBE IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    maxNumberDescriptionCandidates := new(int32)
    *maxNumberDescriptionCandidates = 1

    remoteImageDescription, err := client.DescribeImage(
            computerVisionContext,
            remoteImage,
            maxNumberDescriptionCandidates,
            "") // language
        if err != nil { log.Fatal(err) }

    fmt.Println("Captions from remote image: ")
    if len(*remoteImageDescription.Captions) == 0 {
        fmt.Println("No captions detected.")
    } else {
        for _, caption := range *remoteImageDescription.Captions {
            fmt.Printf("'%v' with confidence %.2f%%\n", *caption.Text, *caption.Confidence * 100)
        }
    }
    fmt.Println()
}

Hämta bildkategori

Följande funktion hämtar den identifierade kategorin för bilden. Mer information finns i Kategorisera bilder.

func CategorizeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("CATEGORIZE IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesCategories}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Categories from remote image: ")
    if len(*imageAnalysis.Categories) == 0 {
        fmt.Println("No categories detected.")
    } else {
        for _, category := range *imageAnalysis.Categories {
            fmt.Printf("'%v' with confidence %.2f%%\n", *category.Name, *category.Score * 100)
        }
    }
    fmt.Println()
}

Hämta bildtaggar

Följande funktion hämtar uppsättningen identifierade taggar i bilden. Mer information finns i Innehållstaggar.

func TagRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("TAG IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    remoteImageTags, err := client.TagImage(
            computerVisionContext,
            remoteImage,
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Tags in the remote image: ")
    if len(*remoteImageTags.Tags) == 0 {
        fmt.Println("No tags detected.")
    } else {
        for _, tag := range *remoteImageTags.Tags {
            fmt.Printf("'%v' with confidence %.2f%%\n", *tag.Name, *tag.Confidence * 100)
        }
    }
    fmt.Println()
}

Upptäcka objekt

Följande funktion identifierar vanliga objekt i bilden och skriver ut dem till konsolen. Mer information finns i Objektidentifiering.

func DetectObjectsRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT OBJECTS - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    imageAnalysis, err := client.DetectObjects(
            computerVisionContext,
            remoteImage,
    )
    if err != nil { log.Fatal(err) }

    fmt.Println("Detecting objects in remote image: ")
    if len(*imageAnalysis.Objects) == 0 {
        fmt.Println("No objects detected.")
    } else {
        // Print the objects found with confidence level and bounding box locations.
        for _, object := range *imageAnalysis.Objects {
            fmt.Printf("'%v' with confidence %.2f%% at location (%v, %v), (%v, %v)\n",
                *object.Object, *object.Confidence * 100,
                *object.Rectangle.X, *object.Rectangle.X + *object.Rectangle.W,
                *object.Rectangle.Y, *object.Rectangle.Y + *object.Rectangle.H)
        }
    }
    fmt.Println()
}

Identifiera varumärken

Följande kod identifierar företagets varumärken och logotyper i bilden och skriver ut dem till konsolen. Mer information finns i Varumärkesidentifiering.

Deklarera först en referens till en ny avbildning i main din funktion.

brandsImageURL := "https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/gray-shirt-logo.jpg"

Följande kod definierar funktionen för varumärkesidentifiering.

func DetectBrandsRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT BRANDS - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the kinds of features you want returned.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesBrands}

    imageAnalysis, err := client.AnalyzeImage(
        computerVisionContext,
        remoteImage,
        features,
        []computervision.Details{},
        "en")
    if err != nil { log.Fatal(err) }

    fmt.Println("Detecting brands in remote image: ")
    if len(*imageAnalysis.Brands) == 0 {
        fmt.Println("No brands detected.")
    } else {
        // Get bounding box around the brand and confidence level it's correctly identified.
        for _, brand := range *imageAnalysis.Brands {
            fmt.Printf("'%v' with confidence %.2f%% at location (%v, %v), (%v, %v)\n",
                *brand.Name, *brand.Confidence * 100,
                *brand.Rectangle.X, *brand.Rectangle.X + *brand.Rectangle.W,
                *brand.Rectangle.Y, *brand.Rectangle.Y + *brand.Rectangle.H)
        }
    }
    fmt.Println()
}

Identifiera ansikten

Följande funktion returnerar de identifierade ansiktena i bilden med deras rektangelkoordinater och vissa ansiktsattribut. Mer information finns i Ansiktsigenkänning.

func DetectFacesRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT FACES - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you want returned with the API call.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesFaces}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
        if err != nil { log.Fatal(err) }

    fmt.Println("Detecting faces in a remote image ...")
    if len(*imageAnalysis.Faces) == 0 {
        fmt.Println("No faces detected.")
    } else {
        // Print the bounding box locations of the found faces.
        for _, face := range *imageAnalysis.Faces {
            fmt.Printf("'%v' of age %v at location (%v, %v), (%v, %v)\n",
                face.Gender, *face.Age,
                *face.FaceRectangle.Left, *face.FaceRectangle.Top,
                *face.FaceRectangle.Left + *face.FaceRectangle.Width,
                *face.FaceRectangle.Top + *face.FaceRectangle.Height)
        }
    }
    fmt.Println()
}

Identifiera vuxet, ojämnt eller gory-innehåll

Följande funktion skriver ut den identifierade förekomsten av vuxet innehåll i bilden. Mer information finns i Adult, racy, gory content.

func DetectAdultOrRacyContentRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT ADULT OR RACY CONTENT - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you want returned from the API call.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesAdult}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    // Print whether or not there is questionable content.
    // Confidence levels: low means content is OK, high means it's not.
    fmt.Println("Analyzing remote image for adult or racy content: ");
    fmt.Printf("Is adult content: %v with confidence %.2f%%\n", *imageAnalysis.Adult.IsAdultContent, *imageAnalysis.Adult.AdultScore * 100)
    fmt.Printf("Has racy content: %v with confidence %.2f%%\n", *imageAnalysis.Adult.IsRacyContent, *imageAnalysis.Adult.RacyScore * 100)
    fmt.Println()
}

Hämta bildfärgschema

Följande funktion skriver ut de identifierade färgattributen i bilden, till exempel de dominerande färgerna och accentfärgen. Mer information finns i Färgscheman.

func DetectColorSchemeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT COLOR SCHEME - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you'd like returned with the result.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesColor}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    fmt.Println("Color scheme of the remote image: ");
    fmt.Printf("Is black and white: %v\n", *imageAnalysis.Color.IsBWImg)
    fmt.Printf("Accent color: 0x%v\n", *imageAnalysis.Color.AccentColor)
    fmt.Printf("Dominant background color: %v\n", *imageAnalysis.Color.DominantColorBackground)
    fmt.Printf("Dominant foreground color: %v\n", *imageAnalysis.Color.DominantColorForeground)
    fmt.Printf("Dominant colors: %v\n", strings.Join(*imageAnalysis.Color.DominantColors, ", "))
    fmt.Println()
}

Hämta domänspecifikt innehåll

Bildanalys kan använda specialiserade modeller för ytterligare analys av bilder. Mer information finns i Domänspecifikt innehåll.

Följande kod parsar data om identifierade kändisar i bilden.

func DetectDomainSpecificContentRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT DOMAIN-SPECIFIC CONTENT - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    fmt.Println("Detecting domain-specific content in the local image ...")

    // Check if there are any celebrities in the image.
    celebrities, err := client.AnalyzeImageByDomain(
            computerVisionContext,
            "celebrities",
            remoteImage,
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    fmt.Println("\nCelebrities: ")

    // Marshal the output from AnalyzeImageByDomain into JSON.
    data, err := json.MarshalIndent(celebrities.Result, "", "\t")

    // Define structs for which to unmarshal the JSON.
    type Celebrities struct {
        Name string `json:"name"`
    }

    type CelebrityResult struct {
        Celebrities	[]Celebrities `json:"celebrities"`
    }

    var celebrityResult CelebrityResult

    // Unmarshal the data.
    err = json.Unmarshal(data, &celebrityResult)
    if err != nil { log.Fatal(err) }

    //	Check if any celebrities detected.
    if len(celebrityResult.Celebrities) == 0 {
        fmt.Println("No celebrities detected.")
    }	else {
        for _, celebrity := range celebrityResult.Celebrities {
            fmt.Printf("name: %v\n", celebrity.Name)
        }
    }

Följande kod parsar data om identifierade landmärken i bilden.

    fmt.Println("\nLandmarks: ")

    // Check if there are any landmarks in the image.
    landmarks, err := client.AnalyzeImageByDomain(
            computerVisionContext,
            "landmarks",
            remoteImage,
            "")
    if err != nil { log.Fatal(err) }

    // Marshal the output from AnalyzeImageByDomain into JSON.
    data, err = json.MarshalIndent(landmarks.Result, "", "\t")

    // Define structs for which to unmarshal the JSON.
    type Landmarks struct {
        Name string `json:"name"`
    }

    type LandmarkResult struct {
        Landmarks	[]Landmarks `json:"landmarks"`
    }

    var landmarkResult LandmarkResult

    // Unmarshal the data.
    err = json.Unmarshal(data, &landmarkResult)
    if err != nil { log.Fatal(err) }

    // Check if any celebrities detected.
    if len(landmarkResult.Landmarks) == 0 {
        fmt.Println("No landmarks detected.")
    }	else {
        for _, landmark := range landmarkResult.Landmarks {
            fmt.Printf("name: %v\n", landmark.Name)
        }
    }
    fmt.Println()
}

Hämta avbildningstypen

Följande funktion skriver ut information om bildtypen, — oavsett om det är ClipArt eller en linjeritning.

func DetectImageTypesRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT IMAGE TYPES - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesImageType}

    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Image type of remote image:")

    fmt.Println("\nClip art type: ")
    switch *imageAnalysis.ImageType.ClipArtType {
    case 0:
        fmt.Println("Image is not clip art.")
    case 1:
        fmt.Println("Image is ambiguously clip art.")
    case 2:
        fmt.Println("Image is normal clip art.")
    case 3:
        fmt.Println("Image is good clip art.")
    }

    fmt.Println("\nLine drawing type: ")
    if *imageAnalysis.ImageType.LineDrawingType == 1 {
        fmt.Println("Image is a line drawing.")
    }	else {
        fmt.Println("Image is not a line drawing.")
    }
    fmt.Println()
}

Kör programmet

Kör programmet från programkatalogen med go run kommandot .

go run sample-app.go

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar klientbiblioteket för bildanalys och gör grundläggande bildanalys-anrop. Härnäst får du lära dig mer om funktionerna i Analysera API.

• Översikt över bildanalys
• Källkoden för det här exemplet finns på GitHub.

Använd bildanalys-REST API för att:

• Analysera en bild för taggar, textbeskrivning, ansikten, vuxet innehåll med mera.
• Skapa en miniatyrbild med smart beskärning

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt
• När du har din Azure-prenumeration skapar du en Visuellt innehåll-resurs för att skapa Visuellt innehåll resurs i Azure Portal för att slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Visuellt innehåll tjänsten. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.
• cURL installerat

Analysera en bild

Om du vill analysera en bild för en mängd olika visuella funktioner gör du följande:

1. Kopiera följande kommando till en textredigerare.
2. Gör följande ändringar i kommandot där det behövs:
   1. Ersätt värdet för <subscriptionKey> med din prenumerationsnyckel.
   2. Ersätt den första delen av url:en för begäran ( westcentralus ) med texten i din egen slutpunkts-URL.

      Anteckning

      Nya resurser som skapats efter den 1 juli 2019 kommer att använda anpassade under domän namn. Mer information och en fullständig lista över regionala slut punkter finns i anpassade under domän namn för Cognitive Services.

   3. Du kan också ändra bild-URL:en i begärandetexten (http://upload.wikimedia.org/wikipedia/commons/3/3c/Shaki_waterfall.jpg\) till URL:en för en annan bild som ska analyseras.
3. Öppna ett kommandotolksfönster.
4. Klistra in kommandot från textredigeraren i kommandotolkens fönster och kör sedan kommandot.

curl -H "Ocp-Apim-Subscription-Key: <subscriptionKey>" -H "Content-Type: application/json" "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/analyze?visualFeatures=Categories,Description&details=Landmarks" -d "{\"url\":\"http://upload.wikimedia.org/wikipedia/commons/3/3c/Shaki_waterfall.jpg\"}"

Granska svaret

Ett svar som anger att åtgärden lyckades returneras i JSON. Exempelprogrammet parsar och visar ett lyckat svar i kommandotolkens fönster enligt följande exempel:

{
  "categories": [
    {
      "name": "outdoor_water",
      "score": 0.9921875,
      "detail": {
        "landmarks": []
      }
    }
  ],
  "description": {
    "tags": [
      "nature",
      "water",
      "waterfall",
      "outdoor",
      "rock",
      "mountain",
      "rocky",
      "grass",
      "hill",
      "covered",
      "hillside",
      "standing",
      "side",
      "group",
      "walking",
      "white",
      "man",
      "large",
      "snow",
      "grazing",
      "forest",
      "slope",
      "herd",
      "river",
      "giraffe",
      "field"
    ],
    "captions": [
      {
        "text": "a large waterfall over a rocky cliff",
        "confidence": 0.916458423253597
      }
    ]
  },
  "requestId": "b6e33879-abb2-43a0-a96e-02cb5ae0b795",
  "metadata": {
    "height": 959,
    "width": 1280,
    "format": "Jpeg"
  }
}

Skapa en miniatyrbild

Du kan använda bildanalys för att generera en miniatyrbild med smart beskärning. Du anger önskad höjd och bredd, vilket kan skilja sig i proportion till den inmatade bilden. Bildanalys använder smart beskärning för att identifiera det intressanta området och generera koordinater för beskärning i den regionen.

Så här skapar du och kör exemplet:

1. Kopiera följande kommando till en textredigerare.

2. Gör följande ändringar i kommandot där det behövs:

   1. Ersätt värdet för <subscriptionKey> med din prenumerationsnyckel.
   2. Ersätt värdet för <thumbnailFile> med sökvägen och namnet på filen där du vill spara den returnerade miniatyrbilden.
   3. Ersätt den första delen av url:en för begäran ( westcentralus ) med texten i din egen slutpunkts-URL.

      Anteckning

      Nya resurser som skapats efter den 1 juli 2019 kommer att använda anpassade under domän namn. Mer information och en fullständig lista över regionala slut punkter finns i anpassade under domän namn för Cognitive Services.

   4. Du kan också ändra bild-URL i begärandetexten (https://upload.wikimedia.org/wikipedia/commons/thumb/5/56/Shorkie_Poo_Puppy.jpg/1280px-Shorkie_Poo_Puppy.jpg\) till URL-adressen till en annan bild från vilken du kan skapa en miniatyrbild.

3. Öppna ett kommandotolksfönster.

4. Klistra in kommandot från textredigeraren i kommandotolkens fönster.

5. Tryck på Retur för att köra programmet.

   curl -H "Ocp-Apim-Subscription-Key: <subscriptionKey>" -o <thumbnailFile> -H "Content-Type: application/json" "https://westus.api.cognitive.microsoft.com/vision/v3.2/generateThumbnail?width=100&height=100&smartCropping=true" -d "{\"url\":\"https://upload.wikimedia.org/wikipedia/commons/thumb/5/56/Shorkie_Poo_Puppy.jpg/1280px-Shorkie_Poo_Puppy.jpg\"}"
   

Granska svaret

Ett lyckat svar skriver miniatyrbilden till filen som anges i <thumbnailFile>. Om begäran misslyckas innehåller svaret en felkod och ett meddelande som beskriver vad som gick fel. Om begäran verkar lyckas men den skapade miniatyrbilden inte är en giltig bildfil kan det vara så att din prenumerationsnyckel inte är giltig.

Nästa steg

I den här snabbstarten har du lärt dig hur du installerar grundläggande bildanalys-anrop med hjälp av REST API. Härnäst får du lära dig mer om funktionerna i Analysera API.

• Översikt över bildanalys