Detecta puntos de referencia

La detección de puntos de referencia detecta estructuras populares naturales y artificiales en una imagen.

Detecta puntos de referencia en una imagen local

Protocolo

Consulta el extremo de API images:annotate para ver todos los detalles.

Para realizar una detección de puntos de referencia, envía una solicitud POST y proporciona el cuerpo de solicitud correspondiente:

POST https://vision.googleapis.com/v1/images:annotate?key=YOUR_API_KEY

{
  "requests": [
    {
      "image": {
        "content": "/9j/7QBEUGhvdG9zaG9...base64-encoded-image-content...fXNWzvDEeYxxxzj/Coa6Bax//Z"
      },
      "features": [
        {
          "type": "LANDMARK_DETECTION"
        }
      ]
    }
  ]
}

Consulta la documentación de referencia de AnnotateImageRequest para obtener más información sobre cómo configurar el cuerpo de la solicitud.

Si la solicitud tiene éxito, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Respuesta:

{
  "responses": [
    {
      "landmarkAnnotations": [
        {
          "mid": "/g/1hg4vfsw1",
          "description": "Palace of Fine Arts",
          "score": 0.47093904,
          "boundingPoly": {
            "vertices": [
              {
                "x": 259,
                "y": 129
              },
              {
                "x": 523,
                "y": 129
              },
              {
                "x": 523,
                "y": 282
              },
              {
                "x": 259,
                "y": 282
              }
            ]
          },
          "locations": [
            {
              "latLng": {
                "latitude": 37.802900859931917,
                "longitude": -122.447777
              }
            }
          ]
        }
      ]
    }
  ]
}

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para C# que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para C#.

Ver en GitHub Comentarios

// Load an image from a local file.
var image = Image.FromFile(filePath);
var client = ImageAnnotatorClient.Create();
var response = client.DetectLandmarks(image);
foreach (var annotation in response)
{
    if (annotation.Description != null)
        Console.WriteLine(annotation.Description);
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Go.

Ver en GitHub Comentarios

// detectLandmarks gets landmarks from the Vision API for an image at the given file path.
func detectLandmarks(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
	}
	annotations, err := client.DetectLandmarks(ctx, image, nil, 10)
	if err != nil {
		return err
	}

	if len(annotations) == 0 {
		fmt.Fprintln(w, "No landmarks found.")
	} else {
		fmt.Fprintln(w, "Landmarks:")
		for _, annotation := range annotations {
			fmt.Fprintln(w, annotation.Description)
		}
	}

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para Java que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

Ver en GitHub Comentarios

public static void detectLandmarks(String filePath, PrintStream out) 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.LANDMARK_DETECTION).build();
  AnnotateImageRequest request =
      AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
  requests.add(request);

  try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
    BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
    List<AnnotateImageResponse> responses = response.getResponsesList();

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

      // For full list of available annotations, see http://g.co/cloud/vision/docs
      for (EntityAnnotation annotation : res.getLandmarkAnnotationsList()) {
        LocationInfo info = annotation.getLocationsList().listIterator().next();
        out.printf("Landmark: %s\n %s\n", annotation.getDescription(), info.getLatLng());
      }
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

Ver en GitHub Comentarios

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';

// Performs landmark detection on the local file
const [result] = await client.landmarkDetection(fileName);
const landmarks = result.landmarkAnnotations;
console.log('Landmarks:');
landmarks.forEach(landmark => console.log(landmark));

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para PHP que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para PHP.

Ver en GitHub Comentarios

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ImageAnnotatorClient;

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

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

    # annotate the image
    $image = file_get_contents($path);
    $response = $imageAnnotator->landmarkDetection($image);
    $landmarks = $response->getLandmarkAnnotations();

    printf('%d landmark found:' . PHP_EOL, count($landmarks));
    foreach ($landmarks as $landmark) {
        print($landmark->getDescription() . PHP_EOL);
    }

    $imageAnnotator->close();
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

Ver en GitHub Comentarios

def detect_landmarks(path):
    """Detects landmarks in the file."""
    from google.cloud import vision
    client = vision.ImageAnnotatorClient()

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

    image = vision.types.Image(content=content)

    response = client.landmark_detection(image=image)
    landmarks = response.landmark_annotations
    print('Landmarks:')

    for landmark in landmarks:
        print(landmark.description)
        for location in landmark.locations:
            lat_lng = location.lat_lng
            print('Latitude {}'.format(lat_lng.latitude))
            print('Longitude {}'.format(lat_lng.longitude))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para Ruby que se encuentran en la Guía de inicio rápido de Vision con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Ruby.

Ver en GitHub Comentarios

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

require "google/cloud/vision"

image_annotator = Google::Cloud::Vision::ImageAnnotator.new

response = image_annotator.landmark_detection image: image_path

response.responses.each do |res|
  res.landmark_annotations.each do |landmark|
    puts landmark.description

    landmark.locations.each do |location|
      puts "#{location.lat_lng.latitude}, #{location.lat_lng.longitude}"
    end
  end
end