Bibliotecas cliente para Vision

En esta página, se muestra cómo comenzar a usar las bibliotecas cliente de Cloud para la API de Vision. Las bibliotecas cliente facilitan el acceso a las APIs de Google Cloud mediante un lenguaje compatible. Puedes usar las APIs de Google Cloud directamente mediante solicitudes sin procesar al servidor, pero las bibliotecas cliente proporcionan simplificaciones que reducen de manera significativa la cantidad de código que debes escribir.

Obtén más información sobre las bibliotecas cliente de Cloud y las bibliotecas cliente de las API de Google anteriores en Explicación de las bibliotecas cliente.

Instala la biblioteca cliente

C++

Consulta Configura un entorno de desarrollo de C++ para obtener detalles sobre los requisitos de esta biblioteca cliente y, luego, instala las dependencias.

C#

Si usas Visual Studio 2017 o una versión posterior, abre la ventana del administrador de paquetes de NuGet y escribe lo siguiente:

Install-Package Google.Apis

Si usas las herramientas de la interfaz de línea de comandos de .NET Core para instalar tus dependencias, ejecuta el siguiente comando:

dotnet add package Google.Apis

Para obtener más información, consulta Configura un entorno de desarrollo de C#.

Go

go get cloud.google.com/go/vision/apiv1

Para obtener más información, consulta Configura un entorno de desarrollo de Go.

Java

Si usas Maven, agrega lo siguiente al archivo pom.xml. Para obtener más información sobre las BOM, consulta Las bibliotecas de BOM de Google Cloud Platform.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.34.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-vision</artifactId>
  </dependency>

Si usas Gradle, agrega lo siguiente a las dependencias:

implementation 'com.google.cloud:google-cloud-vision:3.35.0'

Si usas sbt, agrega lo siguiente a las dependencias:

libraryDependencies += "com.google.cloud" % "google-cloud-vision" % "3.35.0"

Si usas Visual Studio Code, IntelliJ o Eclipse, puedes agregar bibliotecas cliente a tu proyecto con los siguientes complementos IDE:

Los complementos brindan funcionalidades adicionales, como administración de claves para las cuentas de servicio. Consulta la documentación de cada complemento para obtener más detalles.

Para obtener más información, consulta Configura un entorno de desarrollo de Java.

Node.js

npm install --save @google-cloud/vision

Para obtener más información, consulta Configura un entorno de desarrollo de Node.js.

PHP

composer require google/apiclient

Para obtener más información, consulta PHP en Google Cloud.

Python

pip install --upgrade google-cloud-vision

Para obtener más información, consulta Configura un entorno de desarrollo de Python.

Ruby

gem install google-api-client

Para obtener más información, consulta Cómo configurar un entorno de desarrollo en Ruby.

Configura la autenticación

Para autenticar llamadas a las API de Google Cloud, las bibliotecas cliente son compatibles con las credenciales predeterminadas de la aplicación (ADC). Las bibliotecas buscan credenciales en un conjunto de ubicaciones definidas y las usan para lo siguiente: autenticar solicitudes en la API. Con ADC, puedes hacer que las credenciales estén disponibles para tu aplicación en una variedad de entornos, como el desarrollo o producción local, sin necesidad de modificar el código de la aplicación.

Para los entornos de producción, la forma en que configuras ADC depende del servicio y el contexto. Para obtener más información, consulta Configura credenciales predeterminadas de la aplicación.

Para un entorno de desarrollo local, puedes configurar ADC con las credenciales asociadas con tu cuenta de Google:

  1. Instala e inicializa gcloud CLI

    Cuando inicialices gcloud CLI, asegúrate de especificar un proyecto de Google Cloud en el que tengas permiso para acceder a los recursos que necesita tu aplicación.

  2. Crea tu archivo de credenciales:

    gcloud auth application-default login

    Aparecerá una pantalla de acceso. Después de acceder, tus credenciales se almacenan en el archivo de credenciales local que usa ADC.

Usa la biblioteca cliente

El siguiente ejemplo muestra cómo usar la biblioteca cliente.

C++


#include "google/cloud/vision/v1/image_annotator_client.h"
#include <iostream>

int main(int argc, char* argv[]) try {
  auto constexpr kDefaultUri =
      "gs://cloud-samples-data/vision/label/wakeupcat.jpg";
  if (argc > 2) {
    std::cerr << "Usage: " << argv[0] << " [gcs-uri]\n"
              << "  The gcs-uri must be in gs://... format. It defaults to "
              << kDefaultUri << "\n";
    return 1;
  }
  auto uri = std::string{argc == 2 ? argv[1] : kDefaultUri};

  namespace vision = ::google::cloud::vision_v1;
  auto client =
      vision::ImageAnnotatorClient(vision::MakeImageAnnotatorConnection());

  // Define the image we want to annotate
  google::cloud::vision::v1::Image image;
  image.mutable_source()->set_image_uri(uri);
  // Create a request to annotate this image with Request text annotations for a
  // file stored in GCS.
  google::cloud::vision::v1::AnnotateImageRequest request;
  *request.mutable_image() = std::move(image);
  request.add_features()->set_type(
      google::cloud::vision::v1::Feature::TEXT_DETECTION);

  google::cloud::vision::v1::BatchAnnotateImagesRequest batch_request;
  *batch_request.add_requests() = std::move(request);
  auto batch = client.BatchAnnotateImages(batch_request);
  if (!batch) throw std::move(batch).status();

  // Find the longest annotation and print it
  auto result = std::string{};
  for (auto const& response : batch->responses()) {
    for (auto const& annotation : response.text_annotations()) {
      if (result.size() < annotation.description().size()) {
        result = annotation.description();
      }
    }
  }
  std::cout << "The image contains this text: " << result << "\n";

  return 0;
} catch (google::cloud::Status const& status) {
  std::cerr << "google::cloud::Status thrown: " << status << "\n";
  return 1;
}

Go


// Sample vision-quickstart uses the Google Cloud Vision API to label an image.
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	vision "cloud.google.com/go/vision/apiv1"
)

func main() {
	ctx := context.Background()

	// Creates a client.
	client, err := vision.NewImageAnnotatorClient(ctx)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer client.Close()

	// Sets the name of the image file to annotate.
	filename := "../testdata/cat.jpg"

	file, err := os.Open(filename)
	if err != nil {
		log.Fatalf("Failed to read file: %v", err)
	}
	defer file.Close()
	image, err := vision.NewImageFromReader(file)
	if err != nil {
		log.Fatalf("Failed to create image: %v", err)
	}

	labels, err := client.DetectLabels(ctx, image, nil, 10)
	if err != nil {
		log.Fatalf("Failed to detect labels: %v", err)
	}

	fmt.Println("Labels:")
	for _, label := range labels {
		fmt.Println(label.Description)
	}
}

Java

// Imports the Google Cloud client library

import com.google.cloud.vision.v1.AnnotateImageRequest;
import com.google.cloud.vision.v1.AnnotateImageResponse;
import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
import com.google.cloud.vision.v1.EntityAnnotation;
import com.google.cloud.vision.v1.Feature;
import com.google.cloud.vision.v1.Feature.Type;
import com.google.cloud.vision.v1.Image;
import com.google.cloud.vision.v1.ImageAnnotatorClient;
import com.google.protobuf.ByteString;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class QuickstartSample {
  public static void main(String... args) throws Exception {
    // 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 vision = ImageAnnotatorClient.create()) {

      // The path to the image file to annotate
      String fileName = "./resources/wakeupcat.jpg";

      // Reads the image file into memory
      Path path = Paths.get(fileName);
      byte[] data = Files.readAllBytes(path);
      ByteString imgBytes = ByteString.copyFrom(data);

      // Builds the image annotation request
      List<AnnotateImageRequest> requests = new ArrayList<>();
      Image img = Image.newBuilder().setContent(imgBytes).build();
      Feature feat = Feature.newBuilder().setType(Type.LABEL_DETECTION).build();
      AnnotateImageRequest request =
          AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
      requests.add(request);

      // Performs label detection on the image file
      BatchAnnotateImagesResponse response = vision.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 (EntityAnnotation annotation : res.getLabelAnnotationsList()) {
          annotation
              .getAllFields()
              .forEach((k, v) -> System.out.format("%s : %s%n", k, v.toString()));
        }
      }
    }
  }
}

Node.js

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

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

  // Performs label detection on the image file
  const [result] = await client.labelDetection('./resources/wakeupcat.jpg');
  const labels = result.labelAnnotations;
  console.log('Labels:');
  labels.forEach(label => console.log(label.description));
}
quickstart();

Python


# Imports the Google Cloud client library
from google.cloud import vision

def run_quickstart() -> vision.EntityAnnotation:
    """Provides a quick start example for Cloud Vision."""

    # Instantiates a client
    client = vision.ImageAnnotatorClient()

    # The URI of the image file to annotate
    file_uri = "gs://cloud-samples-data/vision/label/wakeupcat.jpg"

    image = vision.Image()
    image.source.image_uri = file_uri

    # Performs label detection on the image file
    response = client.label_detection(image=image)
    labels = response.label_annotations

    print("Labels:")
    for label in labels:
        print(label.description)

    return labels

Recursos adicionales

C++

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para C++:

C#

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para C#:

Go

En la siguiente lista, se incluyen vínculos a más recursos relacionados con la biblioteca cliente para Go:

Java

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para Java:

Node.js

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente de Node.js:

PHP

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para PHP:

Python

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para Python:

Ruby

La siguiente lista contiene vínculos a más recursos relacionados con la biblioteca cliente para Ruby:

Bibliotecas cliente adicionales

Además de las bibliotecas que se muestran arriba, Spring Cloud Google Cloud está disponible para aplicaciones de Java. La API de Spring Vision te ayuda a usar Cloud Vision en cualquier aplicación que se compile con Spring Framework.

Para comenzar, aprende a agregar Spring Cloud Vision a tu aplicación.

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de API de Cloud Vision en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Prueba gratis la API de Cloud Vision