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 le tecniche e i costrutti 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 Python

Panoramica

Questo tutorial illustra un'applicazione di base dell'API Vision che utilizza una Crop Hints richiesta. 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 codici

Mentre leggi il codice, ti consigliamo di seguire la procedura facendo riferimento al riferimento all'API Cloud Vision per Python.

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 di 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 l'I/O file

Altre importazioni:

• La classe ImageAnnotatorClient all'interno della libreria google.cloud.vision per accedere all'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 disegnare 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 dell'API Vision, devi autenticare il servizio utilizzando le credenziali acquisite in precedenza. All'interno di un'applicazione, il modo più semplice per ottenere le credenziali è utilizzare le 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. Il formato dell'output è specificato in un oggetto ImageContext. Se vengono passati più formati, verranno restituiti più 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 incapsula i dettagli delle richieste e delle risposte all'API. Consulta la documentazione di riferimento per l'API Vision per informazioni complete sulla struttura di una richiesta.

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

Una volta completata l'operazione, la risposta dell'API conterrà le coordinate della scatola delimitante di uno o più cropHint. Il metodo draw_hint disegna linee attorno al riquadro delimitante di CropHints, quindi 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 scaricare questo file cat.jpg (potrebbe essere necessario fare clic con il tasto destro del mouse sul link), quindi passare la posizione in cui hai scaricato il file sulla tua macchina locale all'applicazione del tutorial (crop_hints.py).

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

python crop_hints.py cat.jpeg crop

Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
[{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

{
 "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 riquadro di delimitazione ottimizzata attorno all'oggetto dominante rilevato nell'immagine.