이 문서에서는 이미지 분석 버전 3.2 API를 호출하여 이미지의 시각적 기능에 대한 정보를 반환하는 방법을 보여 줍니다. 또한 클라이언트 SDK 또는 REST API를 사용하여 반환된 정보를 구문 분석하는 방법을 보여 줍니다.
이 가이드의 코드는 URL에서 참조하는 원격 이미지를 사용합니다. 이미지 분석 기능의 전체 기능을 보기 위해 다른 이미지를 직접 사용해 볼 수 있습니다.
원격 이미지를 분석하는 경우 {"url":"http://example.com/images/test.jpg"} 같이 요청 본문의 형식을 지정하여 이미지 URL을 지정합니다.
로컬 이미지를 분석하려면 HTTP 요청 본문에 이진 이미지 데이터를 배치합니다.
주 클래스에서 분석하려는 이미지의 URL에 대한 참조를 저장합니다.
// URL image used for analyzing an image (image of puppy)
private const string ANALYZE_URL_IMAGE = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/refs/heads/master/ComputerVision/Images/dog.jpg";
로컬 이미지를 분석하려면 ComputerVisionClient 메서드(예: AnalyzeImageInStreamAsync.)를 참조하세요. 또는 로컬 이미지와 관련된 시나리오는 GitHub의 샘플 코드를 참조하세요.
주 클래스에서 분석하려는 이미지의 URL에 대한 참조를 저장합니다.
String pathToRemoteImage = "https://github.com/Azure-Samples/cognitive-services-sample-data-files/raw/master/ComputerVision/Images/faces.jpg";
로컬 이미지를 분석하려면 ComputerVision 메서드(예: AnalyzeImage.)를 참조하세요. 또는 로컬 이미지와 관련된 시나리오는 GitHub의 샘플 코드를 참조하세요.
주 함수에서 분석하려는 이미지의 URL에 대한 참조를 저장합니다.
const describeURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';
로컬 이미지를 분석하려면 ComputerVisionClient 메서드(예: describeImageInStream.)를 참조하세요. 또는 로컬 이미지와 관련된 시나리오는 GitHub의 샘플 코드를 참조하세요.
분석하려는 이미지의 URL에 대한 참조를 저장합니다.
remote_image_url = "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png"
로컬 이미지를 분석하려면 ComputerVisionClientOperationsMixin 메서드(예: analyze_image_in_stream.)를 참조하세요. 또는 로컬 이미지와 관련된 시나리오는 GitHub의 샘플 코드를 참조하세요.
분석 API를 통해 모든 서비스의 이미지 분석 기능에 액세스할 수 있습니다. 자체 사용 사례에 따라 수행할 작업을 선택합니다. 각 기능에 대한 설명은 Azure AI Vision 개요를 참조하세요. 다음 섹션의 예제에서는 사용 가능한 시각적 기능을 모두 추가하지만 실제로 사용하려면 하나 또는 두 개만 필요할 수 있습니다.
분석 API의 URL 쿼리 매개 변수를 설정하여 사용하려는 기능을 지정할 수 있습니다. 매개 변수는 쉼표로 구분된 여러 값을 가질 수 있습니다. 지정하는 각 기능에는 더 많은 계산 시간이 필요하므로 필요한 것만 지정합니다.
| URL 매개 변수 |
값 |
설명 |
features |
Read |
이미지에서 표시되는 텍스트를 읽고 구조화된 JSON 데이터로 출력합니다. |
features |
Description |
는 지원되는 언어로 된 완전한 문장으로 이미지 콘텐츠를 설명합니다. |
features |
SmartCrops |
관심 영역을 유지하면서 이미지를 원하는 가로 세로 비율로 자르는 사각형 좌표를 찾습니다. |
features |
Objects |
이미지 내에서 대략적인 위치를 포함한 다양한 개체를 감지합니다. 인수는 Objects 영어로만 사용할 수 있습니다. |
features |
Tags |
이미지 콘텐츠와 관련된 단어의 자세한 목록으로 이미지에 태그 지정 |
채워진 URL은 다음과 같이 표시됩니다.
<endpoint>/vision/v3.2/analyze?visualFeatures=Tags
이미지 분석에 사용할 새 메서드를 정의합니다. 분석에서 추출하려는 시각적 기능을 지정하는 다음 코드를 추가합니다. 전체 목록은 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
};
분석에서 추출하려는 시각적 기능을 지정합니다. 전체 목록은 VisualFeatureTypes 열거형을 참조하세요.
// This list defines the features to be extracted from the image.
List<VisualFeatureTypes> featuresToExtractFromRemoteImage = new ArrayList<>();
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.DESCRIPTION);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.CATEGORIES);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.TAGS);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.FACES);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.ADULT);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.COLOR);
featuresToExtractFromRemoteImage.add(VisualFeatureTypes.IMAGE_TYPE);
분석에서 추출하려는 시각적 기능을 지정합니다. 전체 목록은 VisualFeatureTypes 열거형을 참조하세요.
// Get the visual feature for analysis
const features = ['Categories','Brands','Adult','Color','Description','Faces','Image_type','Objects','Tags'];
const domainDetails = ['Celebrities','Landmarks'];
분석에서 추출하려는 시각적 기능을 지정합니다. 전체 목록은 VisualFeatureTypes 열거형을 참조하세요.
print("===== Analyze an image - remote =====")
# Select the visual feature(s) you want.
remote_image_features = [VisualFeatureTypes.categories,VisualFeatureTypes.brands,VisualFeatureTypes.adult,VisualFeatureTypes.color,VisualFeatureTypes.description,VisualFeatureTypes.faces,VisualFeatureTypes.image_type,VisualFeatureTypes.objects,VisualFeatureTypes.tags]
remote_image_details = [Details.celebrities,Details.landmarks]
반환되는 데이터의 언어를 지정할 수도 있습니다.
다음 URL 쿼리 매개 변수는 언어를 지정합니다. 기본값은 en입니다.
| URL 매개 변수 |
값 |
설명 |
language |
en |
영어 |
language |
es |
스페인어 |
language |
ja |
일본어 |
language |
pt |
포르투갈어 |
language |
zh |
중국어(간체) |
채워진 URL은 다음과 같이 표시됩니다.
<endpoint>/vision/v3.2/analyze?visualFeatures=Tags&language=en
AnalyzeImageAsync 호출의 언어 매개 변수를 사용하여 언어를 지정합니다.
| 언어 |
값 |
| 영어 |
en |
| 스페인어 |
es |
| 일본어 |
ja |
| 포르투갈어 |
pt |
| 중국어(간체) |
zh |
언어를 지정하는 메서드 호출은 다음과 같이 표시될 수 있습니다.
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features, language: "en");
분석 호출에서 AnalyzeImageOptionalParameter 입력을 사용하여 언어를 지정합니다.
| 언어 |
값 |
| 영어 |
en |
| 스페인어 |
es |
| 일본어 |
ja |
| 포르투갈어 |
pt |
| 중국어(간체) |
zh |
언어를 지정하는 메서드 호출은 다음과 같이 표시될 수 있습니다.
ImageAnalysis analysis = compVisClient.computerVision().analyzeImage().withUrl(pathToRemoteImage)
.withVisualFeatures(featuresToExtractFromLocalImage)
.language("en")
.execute();
분석 호출에서 language ComputerVisionClientAnalyzeImageOptionalParams 입력의 속성을 사용하여 언어를 지정합니다.
| 언어 |
값 |
| 영어 |
en |
| 스페인어 |
es |
| 일본어 |
ja |
| 포르투갈어 |
pt |
| 중국어(간체) |
zh |
언어를 지정하는 메서드 호출은 다음과 같이 표시될 수 있습니다.
const result = (await computerVisionClient.analyzeImage(imageURL,{visualFeatures: features, language: 'en'}));
language analyze_image 호출의 매개 변수를 사용하여 언어를 지정합니다.
| 언어 |
값 |
| 영어 |
en |
| 스페인어 |
es |
| 일본어 |
ja |
| 포르투갈어 |
pt |
| 중국어(간체) |
zh |
언어를 지정하는 메서드 호출은 다음과 같이 표시될 수 있습니다.
results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features, remote_image_details, 'en')
이 섹션에서는 API 호출의 결과를 구문 분석하는 방법을 보여 줍니다. 여기에는 API 호출 자체가 포함됩니다.
이 서비스는 200 HTTP 응답을 반환하며 본문에는 반환된 데이터가 JSON 문자열 형식으로 포함됩니다. 다음 텍스트는 JSON 응답의 예제입니다.
{
"metadata":
{
"width": 300,
"height": 200
},
"tagsResult":
{
"values":
[
{
"name": "grass",
"confidence": 0.9960499405860901
},
{
"name": "outdoor",
"confidence": 0.9956876635551453
},
{
"name": "building",
"confidence": 0.9893627166748047
},
{
"name": "property",
"confidence": 0.9853052496910095
},
{
"name": "plant",
"confidence": 0.9791355729103088
}
]
}
}
오류 코드
가능한 오류 및 오류의 원인에 대한 다음 목록을 참조하세요.
- 400
InvalidImageUrl - 이미지 URL의 형식이 잘못되었거나 액세스할 수 없습니다.InvalidImageFormat - 입력 데이터가 유효한 이미지가 아닙니다.InvalidImageSize - 입력 이미지가 너무 큽NotSupportedVisualFeature - 지정된 기능 유형이 잘못되었습니다.NotSupportedImage - 지원되지 않는 이미지(예: 아동 포르노)InvalidDetails - 지원 detail 되지 않는 매개 변수 값NotSupportedLanguage - 요청된 작업이 지정된 언어로 지원되지 않습니다.BadArgument - 자세한 내용은 오류 메시지에 제공됩니다.
- 415 - 지원되지 않는 미디어 형식 오류입니다. Content-Type은 허용되는 형식이 아닙니다.
- 이미지 URL의 경우 Content-Type이
application/json이어야 합니다.
- 이진 이미지 데이터의 경우 Content-Type이
application/octet-stream 또는 multipart/form-data여야 합니다.
- 500
FailedToProcessTimeout - 이미지 처리 시간이 초과됨InternalServerError
다음 코드는 이미지 분석 API를 호출하고 결과를 콘솔에 출력합니다.
// Analyze the URL image
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features);
// Summarizes the image content.
Console.WriteLine("Summary:");
foreach (var caption in results.Description.Captions)
{
Console.WriteLine($"{caption.Text} with confidence {caption.Confidence}");
}
Console.WriteLine();
// Display categories the image is divided into.
Console.WriteLine("Categories:");
foreach (var category in results.Categories)
{
Console.WriteLine($"{category.Name} with confidence {category.Score}");
}
Console.WriteLine();
// Image tags and their confidence score
Console.WriteLine("Tags:");
foreach (var tag in results.Tags)
{
Console.WriteLine($"{tag.Name} {tag.Confidence}");
}
Console.WriteLine();
// Objects
Console.WriteLine("Objects:");
foreach (var obj in results.Objects)
{
Console.WriteLine($"{obj.ObjectProperty} with confidence {obj.Confidence} at location {obj.Rectangle.X}, " +
$"{obj.Rectangle.X + obj.Rectangle.W}, {obj.Rectangle.Y}, {obj.Rectangle.Y + obj.Rectangle.H}");
}
Console.WriteLine();
// Faces
Console.WriteLine("Faces:");
foreach (var face in results.Faces)
{
Console.WriteLine($"A {face.Gender} of age {face.Age} at location {face.FaceRectangle.Left}, " +
$"{face.FaceRectangle.Left}, {face.FaceRectangle.Top + face.FaceRectangle.Width}, " +
$"{face.FaceRectangle.Top + face.FaceRectangle.Height}");
}
Console.WriteLine();
// Adult or racy content, if any.
Console.WriteLine("Adult:");
Console.WriteLine($"Has adult content: {results.Adult.IsAdultContent} with confidence {results.Adult.AdultScore}");
Console.WriteLine($"Has racy content: {results.Adult.IsRacyContent} with confidence {results.Adult.RacyScore}");
Console.WriteLine($"Has gory content: {results.Adult.IsGoryContent} with confidence {results.Adult.GoreScore}");
Console.WriteLine();
// Well-known (or custom, if set) brands.
Console.WriteLine("Brands:");
foreach (var brand in results.Brands)
{
Console.WriteLine($"Logo of {brand.Name} with confidence {brand.Confidence} at location {brand.Rectangle.X}, " +
$"{brand.Rectangle.X + brand.Rectangle.W}, {brand.Rectangle.Y}, {brand.Rectangle.Y + brand.Rectangle.H}");
}
Console.WriteLine();
// Celebrities in image, if any.
Console.WriteLine("Celebrities:");
foreach (var category in results.Categories)
{
if (category.Detail?.Celebrities != null)
{
foreach (var celeb in category.Detail.Celebrities)
{
Console.WriteLine($"{celeb.Name} with confidence {celeb.Confidence} at location {celeb.FaceRectangle.Left}, " +
$"{celeb.FaceRectangle.Top}, {celeb.FaceRectangle.Height}, {celeb.FaceRectangle.Width}");
}
}
}
Console.WriteLine();
// Popular landmarks in image, if any.
Console.WriteLine("Landmarks:");
foreach (var category in results.Categories)
{
if (category.Detail?.Landmarks != null)
{
foreach (var landmark in category.Detail.Landmarks)
{
Console.WriteLine($"{landmark.Name} with confidence {landmark.Confidence}");
}
}
}
Console.WriteLine();
// Identifies the color scheme.
Console.WriteLine("Color Scheme:");
Console.WriteLine("Is black and white?: " + results.Color.IsBWImg);
Console.WriteLine("Accent color: " + results.Color.AccentColor);
Console.WriteLine("Dominant background color: " + results.Color.DominantColorBackground);
Console.WriteLine("Dominant foreground color: " + results.Color.DominantColorForeground);
Console.WriteLine("Dominant colors: " + string.Join(",", results.Color.DominantColors));
Console.WriteLine();
// Detects the image types.
Console.WriteLine("Image Type:");
Console.WriteLine("Clip Art Type: " + results.ImageType.ClipArtType);
Console.WriteLine("Line Drawing Type: " + results.ImageType.LineDrawingType);
Console.WriteLine();
다음 코드는 이미지 분석 API를 호출하고 결과를 콘솔에 출력합니다.
// Call the Computer Vision service and tell it to analyze the loaded image.
ImageAnalysis analysis = compVisClient.computerVision().analyzeImage().withUrl(pathToRemoteImage)
.withVisualFeatures(featuresToExtractFromRemoteImage).execute();
// Display image captions and confidence values.
System.out.println("\nCaptions: ");
for (ImageCaption caption : analysis.description().captions()) {
System.out.printf("\'%s\' with confidence %f\n", caption.text(), caption.confidence());
}
// Display image category names and confidence values.
System.out.println("\nCategories: ");
for (Category category : analysis.categories()) {
System.out.printf("\'%s\' with confidence %f\n", category.name(), category.score());
}
// Display image tags and confidence values.
System.out.println("\nTags: ");
for (ImageTag tag : analysis.tags()) {
System.out.printf("\'%s\' with confidence %f\n", tag.name(), tag.confidence());
}
// Display any faces found in the image and their location.
System.out.println("\nFaces: ");
for (FaceDescription face : analysis.faces()) {
System.out.printf("\'%s\' of age %d at location (%d, %d), (%d, %d)\n", face.gender(), face.age(),
face.faceRectangle().left(), face.faceRectangle().top(),
face.faceRectangle().left() + face.faceRectangle().width(),
face.faceRectangle().top() + face.faceRectangle().height());
}
// Display whether any adult or racy content was detected and the confidence
// values.
System.out.println("\nAdult: ");
System.out.printf("Is adult content: %b with confidence %f\n", analysis.adult().isAdultContent(),
analysis.adult().adultScore());
System.out.printf("Has racy content: %b with confidence %f\n", analysis.adult().isRacyContent(),
analysis.adult().racyScore());
// Display the image color scheme.
System.out.println("\nColor scheme: ");
System.out.println("Is black and white: " + analysis.color().isBWImg());
System.out.println("Accent color: " + analysis.color().accentColor());
System.out.println("Dominant background color: " + analysis.color().dominantColorBackground());
System.out.println("Dominant foreground color: " + analysis.color().dominantColorForeground());
System.out.println("Dominant colors: " + String.join(", ", analysis.color().dominantColors()));
// Display any celebrities detected in the image and their locations.
System.out.println("\nCelebrities: ");
for (Category category : analysis.categories()) {
if (category.detail() != null && category.detail().celebrities() != null) {
for (CelebritiesModel celeb : category.detail().celebrities()) {
System.out.printf("\'%s\' with confidence %f at location (%d, %d), (%d, %d)\n", celeb.name(),
celeb.confidence(), celeb.faceRectangle().left(), celeb.faceRectangle().top(),
celeb.faceRectangle().left() + celeb.faceRectangle().width(),
celeb.faceRectangle().top() + celeb.faceRectangle().height());
}
}
}
// Display any landmarks detected in the image and their locations.
System.out.println("\nLandmarks: ");
for (Category category : analysis.categories()) {
if (category.detail() != null && category.detail().landmarks() != null) {
for (LandmarksModel landmark : category.detail().landmarks()) {
System.out.printf("\'%s\' with confidence %f\n", landmark.name(), landmark.confidence());
}
}
}
// Display what type of clip art or line drawing the image is.
System.out.println("\nImage type:");
System.out.println("Clip art type: " + analysis.imageType().clipArtType());
System.out.println("Line drawing type: " + analysis.imageType().lineDrawingType());
다음 코드는 이미지 분석 API를 호출하고 결과를 콘솔에 출력합니다.
const result = (await computerVisionClient.analyzeImage(facesImageURL,{visualFeatures: features},{details: domainDetails}));
// Detect faces
// Print the bounding box, gender, and age from the faces.
const faces = result.faces
if (faces.length) {
console.log(`${faces.length} face${faces.length == 1 ? '' : 's'} found:`);
for (const face of faces) {
console.log(` Gender: ${face.gender}`.padEnd(20)
+ ` Age: ${face.age}`.padEnd(10) + `at ${formatRectFaces(face.faceRectangle)}`);
}
} else { console.log('No faces found.'); }
// Formats the bounding box
function formatRectFaces(rect) {
return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12)
+ `right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
}
// Detect Objects
const objects = result.objects;
console.log();
// Print objects bounding box and confidence
if (objects.length) {
console.log(`${objects.length} object${objects.length == 1 ? '' : 's'} found:`);
for (const obj of objects) { console.log(` ${obj.object} (${obj.confidence.toFixed(2)}) at ${formatRectObjects(obj.rectangle)}`); }
} else { console.log('No objects found.'); }
// Formats the bounding box
function formatRectObjects(rect) {
return `top=${rect.y}`.padEnd(10) + `left=${rect.x}`.padEnd(10) + `bottom=${rect.y + rect.h}`.padEnd(12)
+ `right=${rect.x + rect.w}`.padEnd(10) + `(${rect.w}x${rect.h})`;
}
console.log();
// Detect tags
const tags = result.tags;
console.log(`Tags: ${formatTags(tags)}`);
// Format tags for display
function formatTags(tags) {
return tags.map(tag => (`${tag.name} (${tag.confidence.toFixed(2)})`)).join(', ');
}
console.log();
// Detect image type
const types = result.imageType;
console.log(`Image appears to be ${describeType(types)}`);
function describeType(imageType) {
if (imageType.clipArtType && imageType.clipArtType > imageType.lineDrawingType) return 'clip art';
if (imageType.lineDrawingType && imageType.clipArtType < imageType.lineDrawingType) return 'a line drawing';
return 'a photograph';
}
console.log();
// Detect Category
const categories = result.categories;
console.log(`Categories: ${formatCategories(categories)}`);
// Formats the image categories
function formatCategories(categories) {
categories.sort((a, b) => b.score - a.score);
return categories.map(cat => `${cat.name} (${cat.score.toFixed(2)})`).join(', ');
}
console.log();
// Detect Brands
const brands = result.brands;
// Print the brands found
if (brands.length) {
console.log(`${brands.length} brand${brands.length != 1 ? 's' : ''} found:`);
for (const brand of brands) {
console.log(` ${brand.name} (${brand.confidence.toFixed(2)} confidence)`);
}
} else { console.log(`No brands found.`); }
console.log();
// Detect Colors
const color = result.color;
printColorScheme(color);
// Print a detected color scheme
function printColorScheme(colors) {
console.log(`Image is in ${colors.isBwImg ? 'black and white' : 'color'}`);
console.log(`Dominant colors: ${colors.dominantColors.join(', ')}`);
console.log(`Dominant foreground color: ${colors.dominantColorForeground}`);
console.log(`Dominant background color: ${colors.dominantColorBackground}`);
console.log(`Suggested accent color: #${colors.accentColor}`);
}
console.log();
// Detect landmarks
const domain = result.landmarks;
// Prints domain-specific, recognized objects
if (domain.length) {
console.log(`${domain.length} ${domain.length == 1 ? 'landmark' : 'landmarks'} found:`);
for (const obj of domain) {
console.log(` ${obj.name}`.padEnd(20) + `(${obj.confidence.toFixed(2)} confidence)`.padEnd(20) + `${formatRectDomain(obj.faceRectangle)}`);
}
} else {
console.log('No landmarks found.');
}
// Formats bounding box
function formatRectDomain(rect) {
if (!rect) return '';
return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12) +
`right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
}
console.log();
// Detect Adult content
// Function to confirm racy or not
const isIt = flag => flag ? 'is' : "isn't";
const adult = result.adult;
console.log(`This probably ${isIt(adult.isAdultContent)} adult content (${adult.adultScore.toFixed(4)} score)`);
console.log(`This probably ${isIt(adult.isRacyContent)} racy content (${adult.racyScore.toFixed(4)} score)`);
console.log();
다음 코드는 이미지 분석 API를 호출하고 결과를 콘솔에 출력합니다.
# Call API with URL and features
results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features, remote_image_details)
# Print results with confidence score
print("Categories from remote image: ")
if (len(results_remote.categories) == 0):
print("No categories detected.")
else:
for category in results_remote.categories:
print("'{}' with confidence {:.2f}%".format(category.name, category.score * 100))
print()
# Detect faces
# Print the results with gender, age, and bounding box
print("Faces in the remote image: ")
if (len(results_remote.faces) == 0):
print("No faces detected.")
else:
for face in results_remote.faces:
print("'{}' of age {} at location {}, {}, {}, {}".format(face.gender, face.age, \
face.face_rectangle.left, face.face_rectangle.top, \
face.face_rectangle.left + face.face_rectangle.width, \
face.face_rectangle.top + face.face_rectangle.height))
# Adult content
# Print results with adult/racy score
print("Analyzing remote image for adult or racy content ... ")
print("Is adult content: {} with confidence {:.2f}".format(results_remote.adult.is_adult_content, results_remote.adult.adult_score * 100))
print("Has racy content: {} with confidence {:.2f}".format(results_remote.adult.is_racy_content, results_remote.adult.racy_score * 100))
print()
# Detect colors
# Print results of color scheme
print("Getting color scheme of the remote image: ")
print("Is black and white: {}".format(results_remote.color.is_bw_img))
print("Accent color: {}".format(results_remote.color.accent_color))
print("Dominant background color: {}".format(results_remote.color.dominant_color_background))
print("Dominant foreground color: {}".format(results_remote.color.dominant_color_foreground))
print("Dominant colors: {}".format(results_remote.color.dominant_colors))
print()
# Detect image type
# Prints type results with degree of accuracy
print("Type of remote image:")
if results_remote.image_type.clip_art_type == 0:
print("Image is not clip art.")
elif results_remote.image_type.line_drawing_type == 1:
print("Image is ambiguously clip art.")
elif results_remote.image_type.line_drawing_type == 2:
print("Image is normal clip art.")
else:
print("Image is good clip art.")
if results_remote.image_type.line_drawing_type == 0:
print("Image is not a line drawing.")
else:
print("Image is a line drawing")
# Detect brands
print("Detecting brands in remote image: ")
if len(results_remote.brands) == 0:
print("No brands detected.")
else:
for brand in results_remote.brands:
print("'{}' brand detected with confidence {:.1f}% at location {}, {}, {}, {}".format( \
brand.name, brand.confidence * 100, brand.rectangle.x, brand.rectangle.x + brand.rectangle.w, \
brand.rectangle.y, brand.rectangle.y + brand.rectangle.h))
# Detect objects
# Print detected objects results with bounding boxes
print("Detecting objects in remote image:")
if len(results_remote.objects) == 0:
print("No objects detected.")
else:
for object in detect_objects_results_remote.objects:
print("object at location {}, {}, {}, {}".format( \
object.rectangle.x, object.rectangle.x + object.rectangle.w, \
object.rectangle.y, object.rectangle.y + object.rectangle.h))
# Describe image
# Get the captions (descriptions) from the response, with confidence level
print("Description of remote image: ")
if (len(results_remote.description.captions) == 0):
print("No description detected.")
else:
for caption in results_remote.description.captions:
print("'{}' with confidence {:.2f}%".format(caption.text, caption.confidence * 100))
print()
# Return tags
# Print results with confidence score
print("Tags in the remote image: ")
if (len(results_remote.tags) == 0):
print("No tags detected.")
else:
for tag in results_remote.tags:
print("'{}' with confidence {:.2f}%".format(tag.name, tag.confidence * 100))
# Detect celebrities
print("Celebrities in the remote image:")
if (len(results_remote.categories.detail.celebrities) == 0):
print("No celebrities detected.")
else:
for celeb in results_remote.categories.detail.celebrities:
print(celeb["name"])
# Detect landmarks
print("Landmarks in the remote image:")
if len(results_remote.categories.detail.landmarks) == 0:
print("No landmarks detected.")
else:
for landmark in results_remote.categories.detail.landmarks:
print(landmark["name"])