Tutorial sui suggerimenti di ritaglio

Pubblico

L'obiettivo di questo tutorial è aiutarti a sviluppare applicazioni che utilizzano la funzionalità Suggerimenti di ritaglio dell'API Vision. Si presume che tu abbia familiarità con concetti e tecniche di programmazione di base. Tuttavia, anche se sei un programmatore principiante, dovresti essere in grado di seguire ed eseguire questo tutorial senza difficoltà, quindi utilizzare la documentazione di riferimento dell'API Vision per creare applicazioni di base.

Questo tutorial illustra la procedura per eseguire una chiamata all'API Vision per utilizzare la funzionalità Suggerimenti di ritaglio.

Prerequisiti

• Configura un progetto API Vision nella console Google Cloud.

• Configura l'ambiente per l'utilizzo delle Credenziali predefinite dell'applicazione.

Python

• Installa Python.
• Installa pip.
• Installa la libreria client Google Cloud.
• Installa la libreria di imaging di Python

Panoramica

Questo tutorial illustra un'applicazione di base dell'API Vision che utilizza un Richiesta Crop Hints. Puoi fornire l'immagine da elaborare tramite un URI Cloud Storage (posizione del bucket Cloud Storage) o incorporarla nella richiesta. Una risposta Crop Hints corretta restituisce le coordinate di un riquadro di delimitazione ritagliato intorno all'oggetto o al volto dominante nell'immagine.

Elenco di codice

Mentre leggi il codice, ti consigliamo di seguire le istruzioni facendo riferimento alle Riferimento Python per l'API Cloud Vision.

import argparse

from typing import MutableSequence

from google.cloud import vision
from PIL import Image, ImageDraw



def get_crop_hint(path: str) -> MutableSequence[vision.Vertex]:
    """Detect crop hints on a single image and return the first result.

    Args:
        path: path to the image file.

    Returns:
        The vertices for the bounding polygon.
    """
    client = vision.ImageAnnotatorClient()

    with open(path, "rb") as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

    crop_hints_params = vision.CropHintsParams(aspect_ratios=[1.77])
    image_context = vision.ImageContext(crop_hints_params=crop_hints_params)

    response = client.crop_hints(image=image, image_context=image_context)
    hints = response.crop_hints_annotation.crop_hints

    # Get bounds for the first crop hint using an aspect ratio of 1.77.
    vertices = hints[0].bounding_poly.vertices

    return vertices


def draw_hint(image_file: str) -> None:
    """Draw a border around the image using the hints in the vector list.

    Args:
        image_file: path to the image file.
    """
    vects = get_crop_hint(image_file)

    im = Image.open(image_file)
    draw = ImageDraw.Draw(im)
    draw.polygon(
        [
            vects[0].x,
            vects[0].y,
            vects[1].x,
            vects[1].y,
            vects[2].x,
            vects[2].y,
            vects[3].x,
            vects[3].y,
        ],
        None,
        "red",
    )
    im.save("output-hint.jpg", "JPEG")
    print("Saved new image to output-hint.jpg")


def crop_to_hint(image_file: str) -> None:
    """Crop the image using the hints in the vector list.

    Args:
        image_file: path to the image file.
    """
    vects = get_crop_hint(image_file)

    im = Image.open(image_file)
    im2 = im.crop([vects[0].x, vects[0].y, vects[2].x - 1, vects[2].y - 1])
    im2.save("output-crop.jpg", "JPEG")
    print("Saved new image to output-crop.jpg")


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("image_file", help="The image you'd like to crop.")
    parser.add_argument("mode", help='Set to "crop" or "draw".')
    args = parser.parse_args()

    if args.mode == "crop":
        crop_to_hint(args.image_file)
    elif args.mode == "draw":
        draw_hint(args.image_file)

Un'occhiata più da vicino

Importazione delle librerie

import argparse

from typing import MutableSequence

from google.cloud import vision
from PIL import Image, ImageDraw

Importiamo le librerie standard:

• argparse per consentire all'applicazione di accettare i nomi dei file di input come argomenti
• io per file I/O

Altre importazioni:

• La classe ImageAnnotatorClient nella libreria google.cloud.vision per accedere a API Vision.
• Il modulo types all'interno della libreria google.cloud.vision per la creazione delle richieste
• I moduli Image e ImageDraw di Python Imaging Library (PIL). per tracciare un riquadro di confine sull'immagine di input.

Esecuzione dell'applicazione

parser = argparse.ArgumentParser()
parser.add_argument("image_file", help="The image you'd like to crop.")
parser.add_argument("mode", help='Set to "crop" or "draw".')
args = parser.parse_args()

if args.mode == "crop":
    crop_to_hint(args.image_file)
elif args.mode == "draw":
    draw_hint(args.image_file)

Qui analizziamo semplicemente l'argomento passato che specifica il nome del file dell'immagine locale e lo passiamo a una funzione per ritagliare l'immagine o disegnare l'indizio.

Autenticazione nell'API

Prima di comunicare con il servizio API Vision, è necessario di autenticare il servizio utilizzando le credenziali acquisite in precedenza. All'interno di un oggetto un'applicazione, il modo più semplice per ottenere le credenziali è usare Credenziali predefinite dell'applicazione (ADC). Per impostazione predefinita, la libreria client tenterà di recuperare le credenziali dalla variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS, che deve essere impostata in modo da puntare al file della chiave JSON dell'account di servizio (per ulteriori informazioni, consulta Configurare un account di servizio).

Ottenere annotazioni dei suggerimenti di ritaglio per l'immagine

Ora che la libreria client di Vision è autenticata, possiamo accedere al servizio chiamando il metodo crop_hints dell'istanza ImageAnnotatorClient. Le proporzioni dell'output sono specificate in un ImageContext oggetto; Se vengono trasmesse più proporzioni, allora verranno restituiti i suggerimenti di ritaglio, uno per ogni formato.

"""Detect crop hints on a single image and return the first result.

Args:
    path: path to the image file.

Returns:
    The vertices for the bounding polygon.
"""
client = vision.ImageAnnotatorClient()

with open(path, "rb") as image_file:
    content = image_file.read()

image = vision.Image(content=content)

crop_hints_params = vision.CropHintsParams(aspect_ratios=[1.77])
image_context = vision.ImageContext(crop_hints_params=crop_hints_params)

response = client.crop_hints(image=image, image_context=image_context)
hints = response.crop_hints_annotation.crop_hints

# Get bounds for the first crop hint using an aspect ratio of 1.77.
vertices = hints[0].bounding_poly.vertices

La libreria client racchiude i dettagli delle richieste e delle risposte ai messaggi tramite Google Cloud CLI o tramite l'API Compute Engine. Consulta la documentazione di riferimento dell'API Vision per informazioni complete sulla struttura di una richiesta.

Utilizzare la risposta per ritagliare o disegnare il riquadro delimitante dell'indizio

Una volta completata l'operazione, la risposta dell'API contengono le coordinate del riquadro di delimitazione di uno o più cropHint. La Il metodo draw_hint disegna linee intorno al riquadro di delimitazione RitagliaHints, poi scrive l'immagine in output-hint.jpg.

vects = get_crop_hint(image_file)

im = Image.open(image_file)
draw = ImageDraw.Draw(im)
draw.polygon(
    [
        vects[0].x,
        vects[0].y,
        vects[1].x,
        vects[1].y,
        vects[2].x,
        vects[2].y,
        vects[3].x,
        vects[3].y,
    ],
    None,
    "red",
)
im.save("output-hint.jpg", "JPEG")
print("Saved new image to output-hint.jpg")

Il metodo crop_to_hint ritaglia l'immagine utilizzando l'indicazione di ritaglio suggerita.

vects = get_crop_hint(image_file)

im = Image.open(image_file)
im2 = im.crop([vects[0].x, vects[0].y, vects[2].x - 1, vects[2].y - 1])
im2.save("output-crop.jpg", "JPEG")
print("Saved new image to output-crop.jpg")

Esecuzione dell'applicazione

Per eseguire l'applicazione, puoi scarica questo cat.jpg file (potrebbe essere necessario fare clic con il tasto destro del mouse sul link), quindi passa la posizione in cui hai scaricato il file sul tuo computer all'applicazione tutorial (crop_hints.py).

Ecco il comando Python, seguito dall'output della console, che mostra la risposta JSON cropHintsAnnotation. Questa risposta include le coordinate di il riquadro di delimitazione cropHints. Abbiamo richiesto un'area ritagliata di 1,77 proporzioni larghezza-altezza e i valori restituiti in alto a sinistra e in basso a destra Le coordinate x e y del rettangolo di ritaglio sono 0,336, 1100,967.

python crop_hints.py cat.jpeg crop

Nota: valori di coordinate pari a zero omessi. Quando l'API rileva un valore di coordinata ("x" o "y") pari a 0, la coordinata viene omessa nella risposta JSON. Pertanto, una risposta con un poligono di delimitazione intorno all'intera immagine sarebbe
[{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] per un'immagine di 100 pixel per 100 pixel. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API.

{
 "responses": [
  {
   "cropHintsAnnotation": {
    "cropHints": [
     {
      "boundingPoly": {
       "vertices": [
        {
         "y": 336
        },
        {
         "x": 1100,
         "y": 336
        },
        {
         "x": 1100,
         "y": 967
        },
        {
         "y": 967
        }
       ]
      },
      "confidence": 0.79999995,
      "importanceFraction": 0.69
     }
    ]
   }
  }
 ]
}

Ed ecco l'immagine ritagliata.

Complimenti! Hai eseguito l'API Cloud Vision Crop Hints per restituire le coordinate della casella delimitante ottimizzata attorno all'oggetto dominante rilevato nell'immagine.