Rychlý start: Použití klientské knihovny analýzy obrázků nebo REST API

Pomocí klientské knihovny pro analýzu obrázků můžete analyzovat obrázek pro značky, text popisu, obličeje, obsah pro dospělé a další.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (NuGet) | Ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Integrované vývojové prostředí (IDE) sady Visual Studio nebo aktuální verze .NET Core.
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace v C#

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

V adresáři projektu otevřete soubor program. cs v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE). Přidejte následující using direktivy:

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;

Do třídy programu aplikace vytvořte proměnné pro koncový bod a klíč Azure prostředku.

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

V Main metodě aplikace přidejte volání metod používaných v rámci tohoto rychlého startu. Budete je vytvářet později.

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

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

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce sady image Analysis .NET SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny pro analýzu imagí pro .NET:

• Ověření klienta
• Analýza obrázku

Ověření klienta

V nové metodě ve třídě program vytvořte instanci klienta s vaším koncovým bodem a klíčem. Vytvořte objekt ApiKeyServiceClientCredentials s klíčem a použijte ho u svého koncového bodu k vytvoření objektu ComputerVisionClient .

/*
 * 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;
}

Analýza obrázku

Následující kód definuje metodu, AnalyzeImageUrl která používá objekt klienta k analýze vzdálené image a vytisknutí výsledků. Metoda vrátí textový popis, kategorizaci, seznam značek, zjištěné plošky, příznaky obsahu pro dospělé, hlavní barvy a typ obrázku.

Nastavit testovací image

Ve vaší třídě programu uložte odkaz na adresu URL obrázku, který chcete analyzovat.

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

Zadat vizuální funkce

Definujte novou metodu pro analýzu obrázků. Přidejte následující kód, který určuje vizuální funkce, které chcete v analýze extrahovat. Úplný seznam najdete v VisualFeatureTypes výčtu.

/* 
 * 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
    };

Volání rozhraní API pro analýzu

Metoda AnalyzeImageAsync vrací objekt ImageAnalysis , který obsahuje všechny extrahované informace.

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

Následující části ukazují, jak podrobně analyzovat tyto informace.

Do své metody AnalyzeImageUrl vložte libovolný z následujících bloků kódu k analýze dat z vizuálních funkcí, které jste si vyžádali výše. Nezapomeňte na konec přidat pravou hranatou závorku.

}

Získat popis obrázku

Následující kód získá seznam generovaných titulků pro obrázek. Další podrobnosti najdete v tématu popisujícím obrázky .

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

Získat kategorii obrázku

Následující kód získá zjištěnou kategorii obrázku. Další podrobnosti najdete v tématu kategorizace imagí .

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

Získat značky obrázku

Následující kód získá sadu zjištěných značek v obrázku. Další podrobnosti najdete v tématu značky obsahu .

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

Detekovat objekty

Následující kód detekuje běžné objekty v imagi a vytiskne je do konzoly. Další podrobnosti najdete v tématu věnovaném detekci objektů .

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

Detekovat značky

Následující kód detekuje firemní značky a loga v imagi a vytiskne je do konzoly. Další podrobnosti najdete v tématu rozpoznávání značek .

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

Rozpoznávání tváří

Následující kód vrátí zjištěné plošky v obrázku s jejich souřadnicemi obdélníku a vyberte možnost atributy obličeje. Další podrobnosti najdete v tématu rozpoznávání tváře .

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

Zjištění obsahu pro dospělé, pikantní nebo gorie

Následující kód vytiskne zjištěnou přítomnost obsahu pro dospělé v imagi. Další podrobnosti najdete v článku obsah pro dospělé, pikantní a gorie .

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

Získat barevné schéma obrázku

Následující kód vytiskne zjištěné atributy barev v obrázku, jako jsou dominantní barvy a Barva zvýraznění. Další podrobnosti najdete v tématu Barevná schémata .

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

Získání obsahu specifického pro doménu

Analýza obrázků může používat specializované modely k dalšímu analýze imagí. Další podrobnosti najdete v tématu obsah specifický pro doménu .

Následující kód analyzuje data o zjištěných celebrit v imagi.

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

Následující kód analyzuje data o zjištěných orientačních seznamech v obrázku.

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

Získat typ obrázku

Následující kód Vytiskne informace o typu obrázku — , ať už se jedná o Klipart nebo kreslení čáry.

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

Spuštění aplikace

dotnet run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro analýzu imagí a provést základní volání analýzy obrázků. V dalším kroku se dozvíte víc o funkcích rozhraní API pro analýzu.

• Přehled analýzy obrázků
• Zdrojový kód pro tuto ukázku najdete na GitHubu.

Pomocí klientské knihovny Analýza obrázků můžete analyzovat obrázky značek, textového popisu, tváří, obsahu pro dospělé a dalších.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (PiPy) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.

• Python 3.x

  • Instalace Pythonu by měla obsahovat pip. Spuštěním příkazu na příkazovém řádku můžete zkontrolovat, jestli máte nainstalovaný pip --version pip. Získejte pip instalací nejnovější verze Pythonu.

• Jakmile máte předplatné Azure, vytvořte prostředek Počítačové zpracování obrazu, který Počítačové zpracování obrazu ve službě Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.

  • Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k Počítačové zpracování obrazu službě. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny

Klientskou knihovnu můžete nainstalovat pomocí:

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

Nainstalujte také knihovnu Kaskády.

pip install pillow

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor — Pythonu quickstart-file.py, například . Pak ho otevřete v upřednostňovaném editoru nebo integrovaném vývojovém prostředí (IDE) a importujte následující knihovny.

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

Pak vytvořte proměnné pro koncový bod a klíč Azure vašeho prostředku.

subscription_key = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE"
endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE"

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi sady Image Analysis Python SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy s klientskou knihovnou Image Analysis pro Python:

• Ověření klienta
• Analýza obrázku

Ověření klienta

Vytvořte instanci klienta s koncovým bodem a klíčem. Vytvořte objekt CognitiveServicesCredentials s vaším klíčem a použijte ho s koncovým bodem k vytvoření objektu ComputerVisionClient.

computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))

Analýza obrázku

Použijte objekt klienta k analýze vizuálních vlastností vzdáleného obrázku. Nejprve uložte odkaz na adresu URL obrázku, který chcete analyzovat.

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

Získání popisu obrázku

Následující kód načte seznam vygenerované titulky pro obrázek. Další podrobnosti najdete v tématu Popis obrázků.

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

Získání kategorie obrázku

Následující kód získá zjištěnou kategorii obrázku. Další podrobnosti najdete v tématu Kategorizace obrázků.

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

Získání značek obrázků

Následující kód získá sadu zjištěných značek na obrázku. Další podrobnosti najdete v tématu Značky obsahu.

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

Rozpoznávání objektů

Následující kód rozpozná běžné objekty v obrázku a vytiskne je do konzoly. Další podrobnosti najdete v tématu Rozpoznávání objektů.

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

Detekce značek

Následující kód detekuje firemní značky a loga na obrázku a vytiskne je na konzole. Další podrobnosti najdete v tématu Detekce značky.

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

Rozpoznávání tváří

Následující kód vrátí zjištěné tváře na obrázku se souřadnicemi obdélníku a vybere atributy tváře. Další podrobnosti najdete v tématu Detekce tváří.

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

Detekce obsahu pro dospělé, nesnášim nebo vousů

Následující kód vytiskne zjištěnou přítomnost obsahu pro dospělé na obrázku. Další podrobnosti najdete v článku o obsahu pro dospělé, nesnášim nebo vousy.

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

Získání barevného schématu obrázku

Následující kód vytiskne zjištěné atributy barev na obrázku, jako jsou dominantní barvy a barva zvýraznění. Další podrobnosti najdete v tématu Barevná schémata.

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

Získání obsahu specifického pro doménu

Analýza obrázků může pomocí specializovaného modelu provést další analýzu obrázků. Další podrobnosti najdete v tématu Obsah specifický pro doménu.

Následující kód analyzuje data o zjištěných celebritách na obrázku.

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

Následující kód analyzuje data o zjištěných orientačních bodech na obrázku.

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

Získání typu image

Následující kód vytiskne informace o typu obrázku bez ohledu na to, jestli se jedná — o klipart nebo kresbu.

'''
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")

Spuštění aplikace

Spusťte aplikaci pomocí python příkazu v souboru rychlého startu.

python quickstart-file.py

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro analýzu imagí a provést základní volání analýzy obrázků. V dalším kroku se dozvíte víc o funkcích rozhraní API pro analýzu.

• Přehled analýzy obrázků
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Pomocí klientské knihovny Analýza obrázků můžete analyzovat obrázky značek, textového popisu, tváří, obsahu pro dospělé a dalších.

Referenční dokumentace | Zdrojový kód knihovny | Artifact (Maven) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Aktuální verze sady Java Development Kit (JDK)
• Nástroj pro sestavení Gradlenebo jiný správce závislostí.
• Jakmile máte předplatné Azure, vytvořte prostředek Počítačové zpracování obrazu, který Počítačové zpracování obrazu ve službě Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.
  • Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k Počítačové zpracování obrazu službě. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nového projektu Gradle

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir myapp && cd myapp

Z gradle init pracovního adresáře spusťte příkaz . Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně build.gradle.kts, který se používá za běhu k vytvoření a konfiguraci aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace klientské knihovny

V tomto rychlém startu se používá správce závislostí Gradle. Klientskou knihovnu a informace o dalších správcích závislostí najdete v centrálním úložišti Maven.

Vyhledejte soubor build.gradle.kts a otevřete ho pomocí upřednostňovaného integrovaného vývojového prostředí nebo textového editoru. Potom zkopírujte následující konfiguraci sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupním bodem je třída ImageAnalysisQuickstart. Importuje knihovnu Počítačové zpracování obrazu.

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

Vytvoření souboru Java

Spuštěním následujícího příkazu v pracovním adresáři vytvořte zdrojovou složku projektu:

mkdir -p src/main/java

Přejděte do nové složky a vytvořte soubor s názvem ImageAnalysisQuickstart.java. Otevřete ho v upřednostňovaném editoru nebo integrovaném vývojovém prostředí (IDE) a přidejte následující import příkazy:

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;

Definujte třídu ImageAnalysisQuickstart.

public class ImageAnalysisQuickstart {

}

Ve třídě ImageAnalysisQuickstart vytvořte proměnné pro klíč a koncový bod vašeho prostředku.

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

V hlavní metodě aplikace přidejte volání metod používaných v tomto rychlém startu. Později je definujete.

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

}

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi sady Image Analysis Java SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny Image Analysis pro Javu provádět následující úlohy:

• Ověření klienta
• Analýza obrázku

Ověření klienta

V nové metodě vytvořte instanci objektu ComputerVisionClient s koncovým bodem a klíčem.

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

Analýza obrázku

Následující kód definuje metodu , která používá objekt klienta k AnalyzeLocalImage analýze místního obrázku a tisku výsledků. Metoda vrátí textový popis, kategorizaci, seznam značek, detekovaných tváří, příznaky obsahu pro dospělé, hlavní barvy a typ obrázku.

Nastavení testovacího obrázku

Nejprve ve složce src/main/ vašeho projektu vytvořte složku resources/ a přidejte obrázek, který chcete analyzovat. Pak do třídy ImageAnalysisQuickstart přidejte následující definici metody. Změňte hodnotu tak, pathToLocalImage aby odpovídala souboru obrázku.

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

Určení vizuálních funkcí

Dále určete, které vizuální funkce chcete v analýze extrahovat. Úplný seznam najdete ve výčtu 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);

Analyzovat

Tento blok vytiskne podrobné výsledky do konzoly pro každý obor analýzy obrázků. Metoda analyzeImageInStream vrátí objekt ImageAnalysis, který obsahuje všechny extrahované informace.

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

Následující části ukazují, jak tyto informace analyzovat podrobně.

Získání popisu obrázku

Následující kód načte seznam vygenerované titulky pro obrázek. Další informace najdete v tématu Popis imagí.

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

Získání kategorie obrázku

Následující kód získá zjištěnou kategorii obrázku. Další informace najdete v tématu Kategorizace obrázků.

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

Získání značek obrázků

Následující kód získá sadu zjištěných značek na obrázku. Další informace najdete v tématu Značky obsahu.

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

Rozpoznávání tváří

Následující kód vrátí zjištěné tváře na obrázku se souřadnicemi obdélníku a vybere atributy tváře. Další informace najdete v tématu Detekce tváří.

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

Rozpoznávání objektů

Následující kód vrátí zjištěné objekty na obrázku s jejich souřadnicemi. Další informace najdete v tématu Rozpoznávání objektů.

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

Detekce značek

Následující kód vrátí zjištěná loga značek na obrázku s jejich souřadnicemi. Další informace najdete v tématu Detekce značky.

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

Detekce obsahu pro dospělé, nesnášim nebo vousů

Následující kód vytiskne zjištěnou přítomnost obsahu pro dospělé na obrázku. Další informace najdete v tématu Obsah pro dospělé, nesycený nebo zamyšlný obsah.

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

Získání barevného schématu obrázku

Následující kód vytiskne zjištěné atributy barev na obrázku, jako jsou dominantní barvy a barvy zvýraznění. Další informace najdete v tématu Barevná schémata.

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

Získání obsahu specifického pro doménu

Analýza obrázků může pomocí specializovaného modelu provést další analýzu obrázků. Další informace najdete v tématu Obsah specifický pro doménu.

Následující kód analyzuje data o zjištěných celebritách na obrázku.

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

Následující kód analyzuje data o zjištěných orientačních bodech na obrázku.

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

Získání typu image

Následující kód vytiskne informace o typu obrázku bez ohledu na to, jestli se jedná — o klipart nebo kresbu.

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

Zavřete metodu .

Dokončete blok try/catch a zavřete metodu .

    }

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

Spuštění aplikace

Aplikaci můžete vytvořit pomocí:

gradle build

Spusťte aplikaci pomocí gradle run příkazu :

gradle run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat klientskou knihovnu Image Analysis a provádět základní volání analýzy obrázků. V dalším kroku se dozvíte další informace o funkcích rozhraní API Analyze.

• Přehled analýzy obrázků
• Zdrojový kód této ukázky najdete na GitHubu.

Pomocí klientské knihovny pro analýzu obrázků můžete analyzovat obrázek pro značky, text popisu, obličeje, obsah pro dospělé a další.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (npm) | Ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Aktuální verze Node.js
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace Node.js

V okně konzoly (například cmd, PowerShell nebo bash) vytvořte nový adresář pro vaši aplikaci a přejděte na něj.

mkdir myapp && cd myapp

Spuštěním npm init příkazu vytvořte aplikaci uzlu se package.json souborem.

npm init

Instalace klientské knihovny

Nainstalujte ms-rest-azure balíček a @azure/cognitiveservices-computervision npm:

npm install @azure/cognitiveservices-computervision

Nainstalujte také modul Async:

npm install async

Soubor vaší aplikace package.json bude aktualizován pomocí závislostí.

Vytvořte nový soubor index.js a otevřete ho v textovém editoru. Přidejte následující příkazy importu.

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

Vytvořte proměnné pro koncový bod a klíč Azure prostředku.

/**
 * 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';

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí sady imagí Analysis Node.js SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úkoly s klientskou knihovnou analýzy imagí pro Node.js:

• Ověření klienta
• Analýza obrázku

Ověření klienta

Vytvořte instanci klienta s vaším koncovým bodem a klíčem. Vytvořte objekt ApiKeyCredentials s klíčem a koncovým bodem a použijte ho k vytvoření objektu ComputerVisionClient .

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

Pak definujte funkci computerVision a deklarujte asynchronní řadu s primární funkcí a funkcí zpětného volání. Do primární funkce přidáte svůj kód pro rychlý Start a zavoláte computerVision se do dolní části skriptu. Zbytek kódu v tomto rychlém startu přechází dovnitř computerVision funkce.

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

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

computerVision();

Analýza obrázku

Kód v této části analyzuje vzdálené image pro extrakci různých vizuálních funkcí. Tyto operace můžete provádět jako součást metody analyzeImage objektu klienta, nebo je můžete volat pomocí individuálních metod. Podrobnosti najdete v referenční dokumentaci .

Získat popis obrázku

Následující kód získá seznam generovaných titulků pro obrázek. Další podrobnosti najdete v tématu popisujícím obrázky .

Nejdřív definujte adresu URL obrázku, který se má analyzovat:

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

Pak přidejte následující kód, který získá popis obrázku a vytiskne ho do konzoly.

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

Získat kategorii obrázku

Následující kód získá zjištěnou kategorii obrázku. Další podrobnosti najdete v tématu kategorizace imagí .

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

Definujte pomocnou funkci 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(', ');
}

Získat značky obrázku

Následující kód získá sadu zjištěných značek v obrázku. Další podrobnosti najdete v tématu značky obsahu .

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

Definujte pomocnou funkci formatTags :

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

Detekovat objekty

Následující kód detekuje běžné objekty v imagi a vytiskne je do konzoly. Další podrobnosti najdete v tématu věnovaném detekci objektů .

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

Definujte pomocnou funkci formatRectObjects pro vrácení souřadnic horní, levý, dolní a pravé, spolu s šířkou a výškou.

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

Detekovat značky

Následující kód detekuje firemní značky a loga v imagi a vytiskne je do konzoly. Další podrobnosti najdete v tématu rozpoznávání značek .

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

Rozpoznávání tváří

Následující kód vrátí zjištěné plošky v obrázku s jejich souřadnicemi obdélníku a vyberte možnost atributy obličeje. Další podrobnosti najdete v tématu rozpoznávání tváře .

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

Definujte pomocnou funkci 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})`;
}

Zjištění obsahu pro dospělé, pikantní nebo gorie

Následující kód vytiskne zjištěnou přítomnost obsahu pro dospělé v imagi. Další podrobnosti najdete v článku obsah pro dospělé, pikantní a gorie .

Zadejte adresu URL obrázku, který se má použít:

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

Pak přidejte následující kód pro zjištění obsahu pro dospělé a vytiskněte výsledky do konzoly.

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

Získat barevné schéma obrázku

Následující kód vytiskne zjištěné atributy barev v obrázku, jako jsou dominantní barvy a Barva zvýraznění. Další podrobnosti najdete v tématu Barevná schémata .

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

Definujte pomocnou funkci printColorScheme pro tisk podrobností o barevném schématu do konzoly.

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

Získání obsahu specifického pro doménu

Analýza obrázků může pomocí specializovaného modelu provádět další analýzu imagí. Další podrobnosti najdete v tématu obsah specifický pro doménu .

Nejdřív definujte adresu URL obrázku, který se má analyzovat:

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

Následující kód analyzuje data o zjištěných orientačních seznamech v obrázku.

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

Definujte pomocnou funkci formatRectDomain pro analýzu dat umístění zjištěných orientačních bodů.

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

Získat typ obrázku

Následující kód vytiskne informace o typu obrázku bez ohledu na to, jestli se jedná — o klipart nebo kresbu.

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

Definujte pomocná funkce 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';
}

Spuštění aplikace

Spusťte aplikaci pomocí node příkazu v souboru rychlého startu.

node index.js

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat klientskou knihovnu Image Analysis a provádět základní volání analýzy obrázků. V dalším kroku se dozvíte další informace o funkcích rozhraní API Analyze.

• Přehled analýzy obrázků
• Zdrojový kód této ukázky najdete na GitHub.

Pomocí klientské knihovny Analýza obrázků můžete analyzovat obrázky značek, textového popisu, tváří, obsahu pro dospělé a dalších.

Referenční dokumentace | Zdrojový kód knihovny | Balíček

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Nejnovější verze Go
• Jakmile máte předplatné Azure, vytvořte prostředek Počítačové zpracování obrazu prostředků Počítačové zpracování obrazu v Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.
  • Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k Počítačové zpracování obrazu službě. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření adresáře projektu Go

V okně konzoly (cmd, PowerShell, Terminal, Bash) vytvořte nový pracovní prostor pro projekt Go s názvem my-app a přejděte do něj.

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

Váš pracovní prostor bude obsahovat tři složky:

• src – Tento adresář bude obsahovat zdrojový kód a balíčky. Všechny balíčky nainstalované pomocí go get příkazu budou v tomto adresáři.
• pkg – tento adresář bude obsahovat zkompilované objekty balíčku Go. Všechny tyto soubory mají .a příponu.
• bin – Tento adresář bude obsahovat binární spustitelné soubory, které se vytvoří při spuštění go install .

Instalace klientské knihovny pro Go

Dále nainstalujte klientskou knihovnu pro Go:

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

nebo pokud používáte program dep, spusťte v rámci svého repo:

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

Vytvoření aplikace v Go

Dále vytvořte soubor v adresáři src s názvem sample-app.go :

cd src
touch sample-app.go

Otevřete sample-app.go v upřednostňovaném integrovaném vývojovém prostředí (IDE) nebo textovém editoru. Pak přidejte název balíčku a naimportujte následující knihovny:

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

Deklarujte také kontext v kořenovém adresáři skriptu. Tento objekt budete potřebovat ke spouštění většiny volání funkce Image Analysis:

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

V dalším kroku začnete přidávat kód, který bude provádět různé Počítačové zpracování obrazu operace.

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi sady Image Analysis Go SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny Image Analysis for Go provádět následující úlohy:

• Ověření klienta
• Analýza obrázku

Ověření klienta

Vytvořte funkci a přidejte do ní následující kód, který vytvoří instanci klienta s koncovým bodem main a klíčem.

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

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

Analýza obrázku

Následující kód používá objekt klienta k analýze vzdáleného obrázku a tisku výsledků do konzoly. Můžete získat textový popis, kategorizaci, seznam značek, zjištěné objekty, zjištěné značky, detekované tváře, příznaky obsahu pro dospělé, hlavní barvy a typ obrázku.

Nastavení testovacího obrázku

Nejprve uložte odkaz na adresu URL obrázku, který chcete analyzovat. Dejte tento soubor do main své funkce.

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

Určení vizuálních funkcí

Následující volání funkce extrahuje různé vizuální funkce z ukázkového obrázku. Tyto funkce definujete v následujících částech.

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

Získání popisu obrázku

Následující funkce načte seznam generovaných popisků obrázku. Další informace o popisu obrázku najdete v tématu Popis obrázků.

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

Získání kategorie obrázku

Následující funkce získá zjištěnou kategorii obrázku. Další informace najdete v tématu Kategorizace obrázků.

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

Získání značek obrázků

Následující funkce získá sadu zjištěných značek na obrázku. Další informace najdete v tématu Značky obsahu.

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

Rozpoznávání objektů

Následující funkce rozpozná běžné objekty v obrázku a vytiskne je do konzoly. Další informace najdete v tématu Rozpoznávání objektů.

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

Detekce značek

Následující kód detekuje firemní značky a loga na obrázku a vytiskne je na konzole. Další informace najdete v detekci značky.

Nejprve deklarujte odkaz na nový obrázek v rámci main vaší funkce.

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

Následující kód definuje funkci detekce značky.

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

Rozpoznávání tváří

Následující funkce vrátí zjištěné tváře na obrázku se souřadnicemi obdélníku a určitými atributy tváře. Další informace najdete v tématu Rozpoznávání tváře.

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

Detekce obsahu pro dospělé, nesnášim nebo vousů

Následující funkce vytiskne zjištěnou přítomnost obsahu pro dospělé na obrázku. Další informace najdete v tématu Obsah pro dospělé, nesycený nebo zamyšlný obsah.

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

Získání barevného schématu obrázku

Následující funkce vytiskne zjištěné atributy barev na obrázku, jako jsou dominantní barvy a barva zvýraznění. Další informace najdete v tématu Barevná schémata.

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

Získání obsahu specifického pro doménu

Analýza obrázků může pomocí specializovaných modelů provést další analýzu obrázků. Další informace najdete v tématu Obsah specifický pro doménu.

Následující kód analyzuje data o zjištěných celebritách na obrázku.

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

Následující kód analyzuje data o zjištěných orientačních bodech na obrázku.

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

Získání typu image

Následující funkce vytiskne informace o typu obrázku bez ohledu na to, jestli se jedná o — klipart nebo kresbu.

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

Spuštění aplikace

Spusťte aplikaci z adresáře aplikace pomocí go run příkazu .

go run sample-app.go

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat klientskou knihovnu Image Analysis a provádět základní volání analýzy obrázků. V dalším kroku se dozvíte další informace o funkcích rozhraní API Analyze.

• Přehled analýzy obrázků
• Zdrojový kód této ukázky najdete na GitHub.

Použijte REST API analýzy obrázků k těmto akcím:

• Analyzujte obrázek pro značky, text Description, obličeje, obsah pro dospělé a další.
• Vygenerovat miniaturu pomocí inteligentního oříznutí

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.
• nainstalovaná složená závorka

Analýza obrázku

Chcete-li analyzovat obrázek pro celou řadu vizuálních funkcí, proveďte následující kroky:

1. Zkopírujte do textového editoru následující příkaz.
2. Proveďte v příkazu na příslušných místech následující změny:
   1. Hodnotu <subscriptionKey> nahraďte klíčem předplatného.
   2. Nahraďte první část adresy URL požadavku ( westcentralus ) textem ve vaší vlastní adrese URL koncového bodu.

      Poznámka

      Nové prostředky vytvořené po 1. červenci 2019 budou používat názvy vlastních subdomén. Další informace a úplný seznam regionálních koncových bodů najdete v tématu názvy vlastních subdomén pro Cognitive Services.

   3. Volitelně můžete změnit adresu URL obrázku v textu požadavku (http://upload.wikimedia.org/wikipedia/commons/3/3c/Shaki_waterfall.jpg\) na adresu URL jiného obrázku, který se má analyzovat.
3. Otevřete okno příkazového řádku.
4. Vložte příkaz z textového editoru do okna příkazového řádku a pak příkaz spusťte.

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\"}"

Prozkoumání odpovědi

Úspěšná odpověď se vrátí ve formátu JSON. Ukázková aplikace provede analýzu a zobrazí úspěšnou odpověď v okně příkazového řádku, podobně jako v následujícím příkladu:

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

Vytvoření miniatury

Pomocí analýzy obrázků můžete vygenerovat miniaturu pomocí inteligentního oříznutí. Určete požadovanou výšku a šířku, která se může lišit v poměru stran od vstupní image. Analýza obrázků používá inteligentní ořezávání k inteligentně identifikaci oblasti zájmu a k vygenerování souřadnic oříznutí kolem této oblasti.

Pokud chcete vytvořit a spustit ukázku, postupujte takto:

1. Zkopírujte do textového editoru následující příkaz.

2. Proveďte v příkazu na příslušných místech následující změny:

   1. Hodnotu <subscriptionKey> nahraďte klíčem předplatného.
   2. Hodnotu nahraďte <thumbnailFile> cestou a názvem souboru, do kterého chcete uložit vrácenou miniaturu.
   3. Nahraďte první část adresy URL požadavku ( westcentralus ) textem ve vaší vlastní adrese URL koncového bodu.

      Poznámka

      Nové prostředky vytvořené po 1. červenci 2019 budou používat názvy vlastních subdomén. Další informace a úplný seznam regionálních koncových bodů najdete v tématu názvy vlastních subdomén pro Cognitive Services.

   4. Volitelně můžete změnit adresu URL obrázku v textu požadavku (https://upload.wikimedia.org/wikipedia/commons/thumb/5/56/Shorkie_Poo_Puppy.jpg/1280px-Shorkie_Poo_Puppy.jpg\) na adresu URL jiného obrázku, ze kterého se má generovat miniatura.

3. Otevřete okno příkazového řádku.

4. Vložte příkaz z textového editoru do okna příkazového řádku.

5. Stiskněte klávesu ENTER a program se spustí.

   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\"}"
   

Prozkoumání odpovědi

Úspěšná odpověď zapíše obrázek miniatury do souboru určeného v <thumbnailFile>. Pokud požadavek selže, bude odpověď obsahovat chybový kód a zprávu, která vám pomůže určit, co se nepovedlo. Pokud se žádost zdá být úspěšná, ale vytvořená Miniatura není platným souborem obrázku, může to být tím, že váš klíč předplatného není platný.

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat základní volání analýzy obrázků pomocí REST API. V dalším kroku se dozvíte víc o funkcích rozhraní API pro analýzu.

• Přehled analýzy obrázků