Detectar dicas de corte

As dicas de corte sugerem vértices em uma região de corte de uma imagem.

Imagem antes do corte
Crédito da imagem: Yasmin Dangor em Unsplash (imagem original e recortada mostrada).

Dica de corte aplicada (proporção 2: 1):

Imagem após o corte

Solicitações de detecção de dica de corte

Configurar autenticação e projeto do GCP

Detectar dicas de corte em uma imagem local

A API Vision pode realizar a detecção de recursos em um arquivo de imagem local enviando o conteúdo do arquivo de imagem como uma string codificada em base64 no corpo da sua solicitação.

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • base64-encoded-image: a representação base64 (string ASCII) dos dados da imagem binária. Essa string precisa ser semelhante à seguinte:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Para mais informações, consulte o tópico Codificação base64.

Considerações específicas de campo:

  • cropHintsParams.aspectRatios - um ponto flutuante que corresponde às proporções especificadas para suas imagens (largura:altura). É possível fornecer até 16 proporções de corte.

Método HTTP e URL:

POST https://vision.googleapis.com/v1/images:annotate

Corpo JSON da solicitação:

{
  "requests": [
    {
      "image": {
        "content": "base64-encoded-image"
      },
      "features": [
        {
          "type": "CROP_HINTS"
        }
      ],
      "imageContext": {
        "cropHintsParams": {
          "aspectRatios": [
             2.0
          ]
        }
      }
    }
  ]
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON.

Resposta:



    {
      "responses": [
        {
          "cropHintsAnnotation": {
            "cropHints": [
              {
                "boundingPoly": {
                  "vertices": [
                    {
                      "y": 520
                    },
                    {
                      "x": 2369,
                      "y": 520
                    },
                    {
                      "x": 2369,
                      "y": 1729
                    },
                    {
                      "y": 1729
                    }
                  ]
                },
                "confidence": 0.79999995,
                "importanceFraction": 0.66999996
              }
            ]
          }
        }
      ]
    }

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para C# (em inglês).

// Load an image from a local file.
var image = Image.FromFile(filePath);
var client = ImageAnnotatorClient.Create();
CropHintsAnnotation annotation = client.DetectCropHints(image);
foreach (CropHint hint in annotation.CropHints)
{
    Console.WriteLine("Confidence: {0}", hint.Confidence);
    Console.WriteLine("ImportanceFraction: {0}", hint.ImportanceFraction);
    Console.WriteLine("Bounding Polygon:");
    foreach (Vertex vertex in hint.BoundingPoly.Vertices)
    {
        Console.WriteLine("\tX:\t{0}\tY:\t{1}", vertex.X, vertex.Y);
    }
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Go (em inglês).


// detectCropHints gets suggested croppings the Vision API for an image at the given file path.
func detectCropHints(w io.Writer, file string) error {
	ctx := context.Background()

	client, err := vision.NewImageAnnotatorClient(ctx)
	if err != nil {
		return err
	}

	f, err := os.Open(file)
	if err != nil {
		return err
	}
	defer f.Close()

	image, err := vision.NewImageFromReader(f)
	if err != nil {
		return err
	}
	res, err := client.CropHints(ctx, image, nil)
	if err != nil {
		return err
	}

	fmt.Fprintln(w, "Crop hints:")
	for _, hint := range res.CropHints {
		for _, v := range hint.BoundingPoly.Vertices {
			fmt.Fprintf(w, "(%d,%d)\n", v.X, v.Y)
		}
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido da API Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Java (em inglês).

public static void detectCropHints(String filePath) throws Exception, IOException {
  List<AnnotateImageRequest> requests = new ArrayList<>();

  ByteString imgBytes = ByteString.readFrom(new FileInputStream(filePath));

  Image img = Image.newBuilder().setContent(imgBytes).build();
  Feature feat = Feature.newBuilder().setType(Type.CROP_HINTS).build();
  AnnotateImageRequest request =
      AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
  requests.add(request);

  // Initialize client that will be used to send requests. This client only needs to be created
  // once, and can be reused for multiple requests. After completing all of your requests, call
  // the "close" method on the client to safely clean up any remaining background resources.
  try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
    BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
    List<AnnotateImageResponse> responses = response.getResponsesList();

    for (AnnotateImageResponse res : responses) {
      if (res.hasError()) {
        System.out.format("Error: %s%n", res.getError().getMessage());
        return;
      }

      // For full list of available annotations, see http://g.co/cloud/vision/docs
      CropHintsAnnotation annotation = res.getCropHintsAnnotation();
      for (CropHint hint : annotation.getCropHintsList()) {
        System.out.println(hint.getBoundingPoly());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Node.js (em inglês).


// Imports the Google Cloud client library
const vision = require('@google-cloud/vision');

// Creates a client
const client = new vision.ImageAnnotatorClient();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const fileName = 'Local image file, e.g. /path/to/image.png';

// Find crop hints for the local file
const [result] = await client.cropHints(fileName);
const cropHints = result.cropHintsAnnotation;
cropHints.cropHints.forEach((hintBounds, hintIdx) => {
  console.log(`Crop Hint ${hintIdx}:`);
  hintBounds.boundingPoly.vertices.forEach((bound, boundIdx) => {
    console.log(`  Bound ${boundIdx}: (${bound.x}, ${bound.y})`);
  });
});

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para PHP (em inglês).

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ImageAnnotatorClient;

// $path = 'path/to/your/image.jpg'

function detect_crop_hints($path)
{
    $imageAnnotator = new ImageAnnotatorClient();

    # annotate the image
    $image = file_get_contents($path);
    $response = $imageAnnotator->cropHintsDetection($image);
    $annotations = $response->getCropHintsAnnotation();

    # print the crop hints from the annotation
    if ($annotations) {
        print("Crop hints:" . PHP_EOL);
        foreach ($annotations->getCropHints() as $hint) {
            # get bounds
            $vertices = $hint->getBoundingPoly()->getVertices();
            $bounds = [];
            foreach ($vertices as $vertex) {
                $bounds[] = sprintf('(%d,%d)', $vertex->getX(),
                    $vertex->getY());
            }
            print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
        }
    } else {
        print('No crop hints' . PHP_EOL);
    }

    $imageAnnotator->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Python (em inglês).

def detect_crop_hints(path):
    """Detects crop hints in an image."""
    from google.cloud import vision
    import io
    client = vision.ImageAnnotatorClient()

    with io.open(path, 'rb') as image_file:
        content = image_file.read()
    image = vision.types.Image(content=content)

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

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

    for n, hint in enumerate(hints):
        print('\nCrop Hint: {}'.format(n))

        vertices = (['({},{})'.format(vertex.x, vertex.y)
                    for vertex in hint.bounding_poly.vertices])

        print('bounds: {}'.format(','.join(vertices)))

    if response.error.message:
        raise Exception(
            '{}\nFor more info on error messages, check: '
            'https://cloud.google.com/apis/design/errors'.format(
                response.error.message))

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Ruby (em inglês).

# image_path = "Path to local image file, eg. './image.png'"

require "google/cloud/vision"

image_annotator = Google::Cloud::Vision.image_annotator

response = image_annotator.crop_hints_detection image: image_path

response.responses.each do |res|
  puts "Crop hint bounds:"
  res.crop_hints_annotation.crop_hints.each do |crop_hint|
    crop_hint.bounding_poly.vertices.each do |bound|
      puts "#{bound.x}, #{bound.y}"
    end
  end
end

Detectar dicas de corte em uma imagem remota

Para sua conveniência, a API Vision pode realizar a detecção de recursos diretamente em um arquivo de imagem localizado no Google Cloud Storage ou na Web sem a necessidade de enviar o conteúdo do arquivo de imagem no corpo da solicitação.

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

gs://cloud-samples-data/vision/crop_hints/bubble.jpeg
  • cloud-storage-image-uri: o caminho para um arquivo de imagem válido em um bucket do Cloud Storage. Você precisa ter, pelo menos, privilégios de leitura para o arquivo. Exemplo:
    • gs://storage-bucket/filename.jpg

Considerações específicas de campo:

  • cropHintsParams.aspectRatios - um ponto flutuante que corresponde às proporções especificadas para suas imagens (largura:altura). É possível fornecer até 16 proporções de corte.

Método HTTP e URL:

POST https://vision.googleapis.com/v1/images:annotate

Corpo JSON da solicitação:

{
  "requests": [
    {
      "image": {
        "source": {
          "gcsImageUri": "cloud-storage-image-uri"
        }
      },
      "features": [
        {
          "type": "CROP_HINTS"
        }
      ],
      "imageContext": {
        "cropHintsParams": {
          "aspectRatios": [
             2.0
          ]
        }
      }
    }
  ]
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON.

Resposta:



    {
      "responses": [
        {
          "cropHintsAnnotation": {
            "cropHints": [
              {
                "boundingPoly": {
                  "vertices": [
                    {
                      "y": 520
                    },
                    {
                      "x": 2369,
                      "y": 520
                    },
                    {
                      "x": 2369,
                      "y": 1729
                    },
                    {
                      "y": 1729
                    }
                  ]
                },
                "confidence": 0.79999995,
                "importanceFraction": 0.66999996
              }
            ]
          }
        }
      ]
    }

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para C# (em inglês).

// Specify a Google Cloud Storage uri for the image
// or a publicly accessible HTTP or HTTPS uri.
var image = Image.FromUri(uri);
var client = ImageAnnotatorClient.Create();
CropHintsAnnotation annotation = client.DetectCropHints(image);
foreach (CropHint hint in annotation.CropHints)
{
    Console.WriteLine("Confidence: {0}", hint.Confidence);
    Console.WriteLine("ImportanceFraction: {0}", hint.ImportanceFraction);
    Console.WriteLine("Bounding Polygon:");
    foreach (Vertex vertex in hint.BoundingPoly.Vertices)
    {
        Console.WriteLine("\tX:\t{0}\tY:\t{1}", vertex.X, vertex.Y);
    }
}

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Java (em inglês).

public static void detectCropHintsGcs(String gcsPath) throws Exception, IOException {
  List<AnnotateImageRequest> requests = new ArrayList<>();

  ImageSource imgSource = ImageSource.newBuilder().setGcsImageUri(gcsPath).build();
  Image img = Image.newBuilder().setSource(imgSource).build();
  Feature feat = Feature.newBuilder().setType(Type.CROP_HINTS).build();
  AnnotateImageRequest request =
      AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
  requests.add(request);

  // Initialize client that will be used to send requests. This client only needs to be created
  // once, and can be reused for multiple requests. After completing all of your requests, call
  // the "close" method on the client to safely clean up any remaining background resources.
  try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
    BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
    List<AnnotateImageResponse> responses = response.getResponsesList();

    for (AnnotateImageResponse res : responses) {
      if (res.hasError()) {
        System.out.format("Error: %s%n", res.getError().getMessage());
        return;
      }

      // For full list of available annotations, see http://g.co/cloud/vision/docs
      CropHintsAnnotation annotation = res.getCropHintsAnnotation();
      for (CropHint hint : annotation.getCropHintsList()) {
        System.out.println(hint.getBoundingPoly());
      }
    }
  }
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Go (em inglês).


// detectCropHints gets suggested croppings the Vision API for an image at the given file path.
func detectCropHintsURI(w io.Writer, file string) error {
	ctx := context.Background()

	client, err := vision.NewImageAnnotatorClient(ctx)
	if err != nil {
		return err
	}

	image := vision.NewImageFromURI(file)
	res, err := client.CropHints(ctx, image, nil)
	if err != nil {
		return err
	}

	fmt.Fprintln(w, "Crop hints:")
	for _, hint := range res.CropHints {
		for _, v := range hint.BoundingPoly.Vertices {
			fmt.Fprintf(w, "(%d,%d)\n", v.X, v.Y)
		}
	}

	return nil
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Node.js (em inglês).


// Imports the Google Cloud client libraries
const vision = require('@google-cloud/vision');

// Creates a client
const client = new vision.ImageAnnotatorClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Bucket where the file resides, e.g. my-bucket';
// const fileName = 'Path to file within bucket, e.g. path/to/image.png';

// Find crop hints for the remote file
const [result] = await client.cropHints(`gs://${bucketName}/${fileName}`);
const cropHints = result.cropHintsAnnotation;
cropHints.cropHints.forEach((hintBounds, hintIdx) => {
  console.log(`Crop Hint ${hintIdx}:`);
  hintBounds.boundingPoly.vertices.forEach((bound, boundIdx) => {
    console.log(`  Bound ${boundIdx}: (${bound.x}, ${bound.y})`);
  });
});

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para PHP (em inglês).

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ImageAnnotatorClient;

// $path = 'gs://path/to/your/image.jpg'

function detect_crop_hints_gcs($path)
{
    $imageAnnotator = new ImageAnnotatorClient();

    # annotate the image
    $response = $imageAnnotator->cropHintsDetection($path);
    $annotations = $response->getCropHintsAnnotation();

    # print the crop hints from the annotation
    if ($annotations) {
        print("Crop hints:" . PHP_EOL);
        foreach ($annotations->getCropHints() as $hint) {
            # get bounds
            $vertices = $hint->getBoundingPoly()->getVertices();
            $bounds = [];
            foreach ($vertices as $vertex) {
                $bounds[] = sprintf('(%d,%d)', $vertex->getX(),
                    $vertex->getY());
            }
            print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
        }
    } else {
        print('No crop hints' . PHP_EOL);
    }

    $imageAnnotator->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Python (em inglês).

def detect_crop_hints_uri(uri):
    """Detects crop hints in the file located in Google Cloud Storage."""
    from google.cloud import vision
    client = vision.ImageAnnotatorClient()
    image = vision.types.Image()
    image.source.image_uri = uri

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

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

    for n, hint in enumerate(hints):
        print('\nCrop Hint: {}'.format(n))

        vertices = (['({},{})'.format(vertex.x, vertex.y)
                    for vertex in hint.bounding_poly.vertices])

        print('bounds: {}'.format(','.join(vertices)))

    if response.error.message:
        raise Exception(
            '{}\nFor more info on error messages, check: '
            'https://cloud.google.com/apis/design/errors'.format(
                response.error.message))

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido da Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vision para Ruby (em inglês).

# image_path = "Google Cloud Storage URI, eg. 'gs://my-bucket/image.png'"

require "google/cloud/vision"

image_annotator = Google::Cloud::Vision.image_annotator

response = image_annotator.crop_hints_detection image: image_path

response.responses.each do |res|
  puts "Crop hint bounds:"
  res.crop_hints_annotation.crop_hints.each do |crop_hint|
    crop_hint.bounding_poly.vertices.each do |bound|
      puts "#{bound.x}, #{bound.y}"
    end
  end
end

Comando gcloud

Para realizar a detecção de texto, use o comando gcloud ml vision suggest-crop, como mostrado no exemplo a seguir:

gcloud ml vision suggest-crop gs://cloud-samples-data/vision/crop_hints/bubble.jpeg

Testar

Tente a detecção da dica de corte abaixo. É possível usar a imagem já especificada (gs://cloud-samples-data/vision/crop_hints/bubble.jpeg) ou determinar sua própria imagem. Envie a solicitação selecionando Executar.

Imagem antes do corte
Crédito da imagem: Yasmin Dangor em Unsplash (em inglês).