Image Analysis

def analyze_image(url, visual_features=None, details=None, language="en", description_exclude=None, model_version="latest", custom_headers=None, raw=False, **operation_config):
    """
    Extract rich visual features from image content.
    
    Args:
        url (str): Publicly reachable URL of an image
        visual_features (list[VisualFeatureTypes], optional): Visual feature types to return.
            Available values: Categories, Tags, Description, Faces, ImageType, Color, Adult, Objects, Brands
        details (list[Details], optional): Domain-specific details to include.
            Available values: Celebrities, Landmarks
        language (str, optional): Output language for descriptions and tags.
            Supported: "en", "es", "ja", "pt", "zh". Default: "en"
        description_exclude (list[DescriptionExclude], optional): Domain models to exclude from descriptions.
            Available values: Celebrities, Landmarks
        model_version (str, optional): AI model version to use. Default: "latest"
        custom_headers (dict, optional): Custom HTTP headers
        raw (bool, optional): Return raw response. Default: False
        
    Returns:
        ImageAnalysis: Complete analysis results containing requested features
        
    Raises:
        ComputerVisionErrorResponseException: API error occurred
    """

def analyze_image_in_stream(image, visual_features=None, details=None, language="en", description_exclude=None, model_version="latest", custom_headers=None, raw=False, **operation_config):
    """
    Analyze image from binary stream instead of URL.
    
    Args:
        image (Generator): Binary image data stream
        visual_features (list[VisualFeatureTypes], optional): Same as analyze_image
        details (list[Details], optional): Same as analyze_image
        language (str, optional): Same as analyze_image
        description_exclude (list[DescriptionExclude], optional): Same as analyze_image
        model_version (str, optional): Same as analyze_image
        
    Returns:
        ImageAnalysis: Complete analysis results
    """

def analyze_image_by_domain(model, url, language="en", custom_headers=None, raw=False, **operation_config):
    """
    Analyze image using domain-specific model.
    
    Args:
        model (str): Domain model name. Available models: "celebrities", "landmarks"
        url (str): Publicly reachable URL of an image
        language (str, optional): Output language. Default: "en"
        
    Returns:
        DomainModelResults: Domain-specific analysis results
    """

def analyze_image_by_domain_in_stream(model, image, language="en", custom_headers=None, raw=False, **operation_config):
    """
    Domain-specific analysis from binary stream.
    
    Args:
        model (str): Domain model name
        image (Generator): Binary image data stream
        
    Returns:
        DomainModelResults: Domain-specific analysis results
    """

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

# Initialize client
credentials = CognitiveServicesCredentials("your-api-key")
client = ComputerVisionClient("https://your-endpoint.cognitiveservices.azure.com/", credentials)

# Analyze image with multiple features
image_url = "https://example.com/photo.jpg"
visual_features = [
    VisualFeatureTypes.categories,
    VisualFeatureTypes.description,
    VisualFeatureTypes.faces,
    VisualFeatureTypes.objects,
    VisualFeatureTypes.adult
]

analysis = client.analyze_image(image_url, visual_features=visual_features)

# Access different analysis results
print(f"Description: {analysis.description.captions[0].text}")
print(f"Confidence: {analysis.description.captions[0].confidence}")

# Categories
for category in analysis.categories:
    print(f"Category: {category.name} (confidence: {category.score})")

# Detected faces
for face in analysis.faces:
    print(f"Face at ({face.face_rectangle.left}, {face.face_rectangle.top})")
    print(f"Age: {face.age}, Gender: {face.gender}")

# Objects
for obj in analysis.objects:
    print(f"Object: {obj.object_property} (confidence: {obj.confidence})")
    rect = obj.rectangle
    print(f"Location: ({rect.x}, {rect.y}, {rect.w}, {rect.h})")

# Adult content check
adult = analysis.adult
print(f"Adult content: {adult.is_adult_content} (score: {adult.adult_score})")
print(f"Racy content: {adult.is_racy_content} (score: {adult.racy_score})")

# Analyze for celebrities using domain model
celebrity_results = client.analyze_image_by_domain("celebrities", image_url)

if celebrity_results.result and 'celebrities' in celebrity_results.result:
    for celebrity in celebrity_results.result['celebrities']:
        print(f"Celebrity: {celebrity['name']}")
        print(f"Confidence: {celebrity['confidence']}")
        
        # Face location
        face_rect = celebrity['faceRectangle']
        print(f"Face location: ({face_rect['left']}, {face_rect['top']}, "
              f"{face_rect['width']}, {face_rect['height']})")

# Analyze image from local file
with open("local_image.jpg", "rb") as image_stream:
    analysis = client.analyze_image_in_stream(
        image_stream,
        visual_features=[VisualFeatureTypes.description, VisualFeatureTypes.tags]
    )
    
    print(f"Description: {analysis.description.captions[0].text}")
    for tag in analysis.tags:
        print(f"Tag: {tag.name} (confidence: {tag.confidence})")

class ImageAnalysis:
    """
    Complete image analysis results.
    
    Attributes:
        categories (list[Category]): Image categories with confidence scores
        adult (AdultInfo): Adult content detection results  
        tags (list[ImageTag]): Generated tags with confidence scores
        description (ImageDescription): Generated descriptions
        faces (list[FaceDescription]): Detected faces with demographics
        color (ColorInfo): Color analysis results
        image_type (ImageType): Image type classification
        objects (list[DetectedObject]): Detected objects with bounding boxes
        brands (list[DetectedBrand]): Detected brands with locations
        request_id (str): Request identifier
        metadata (ImageMetadata): Image dimensions and format
        model_version (str): AI model version used for analysis
    """

class Category:
    """
    Image category classification result.
    
    Attributes:
        name (str): Category name (e.g., "outdoor_", "people_group")
        score (float): Confidence score (0.0 to 1.0)
        detail (CategoryDetail): Additional category details
    """

class AdultInfo:
    """
    Adult content detection results.
    
    Attributes:
        is_adult_content (bool): Whether image contains adult-oriented content
        is_racy_content (bool): Whether image contains racy/suggestive content
        is_gory_content (bool): Whether image contains gory/violent content
        adult_score (float): Adult content confidence score (0.0 to 1.0)
        racy_score (float): Racy content confidence score (0.0 to 1.0)
        gore_score (float): Gore content confidence score (0.0 to 1.0)
    """

class FaceDescription:
    """
    Face detection result with demographics.
    
    Attributes:
        age (int): Estimated age
        gender (Gender): Gender classification (Male/Female)
        face_rectangle (FaceRectangle): Face bounding box
    """

class FaceRectangle:
    """
    Face bounding rectangle.
    
    Attributes:
        left (int): Left coordinate
        top (int): Top coordinate  
        width (int): Rectangle width
        height (int): Rectangle height
    """

class ColorInfo:
    """
    Image color analysis results.
    
    Attributes:
        dominant_color_foreground (str): Dominant foreground color
        dominant_color_background (str): Dominant background color
        dominant_colors (list[str]): List of dominant colors
        accent_color (str): Accent color in hex format
        is_bw_img (bool): Whether image is black and white
    """

class ImageType:
    """
    Image type classification.
    
    Attributes:
        clip_art_type (int): Clip art classification (0-3)
        line_drawing_type (int): Line drawing classification (0-3)
    """

class DomainModelResults:
    """
    Domain-specific analysis results.
    
    Attributes:
        result (dict): Domain model results (celebrities, landmarks)
        request_id (str): Request identifier
        metadata (ImageMetadata): Image metadata
        model_version (str): Model version used
    """