Reconocimiento de logotipos

La API de Video Intelligence puede detectar, seguir y reconocer la presencia de más de 100,000 marcas y logotipos en el contenido de video.

En esta página, se describe cómo reconocer un logotipo en un video con la API de Video Intelligence.

Anota un video en Cloud Storage

La siguiente muestra de código demuestra cómo detectar logotipos en un video en Cloud Storage.

REST

Envía la solicitud de proceso

Para realizar una anotación en un archivo de video local, codifica el contenido del archivo de video en base64. Incluye el contenido codificado en Base64 en el campo inputContent de la solicitud. Para obtener información sobre cómo codificar en Base64 el contenido de un archivo de video, consulta Codificación en Base64.

A continuación, se muestra cómo enviar una solicitud POST al método videos:annotate. En el ejemplo, se usa el token de acceso correspondiente a la configuración de una cuenta de servicio para el proyecto con Google Cloud CLI. Para obtener instrucciones sobre cómo instalar Google Cloud CLI, la configuración de un proyecto con una cuenta y obtener un token de acceso, consulta la Guía de inicio rápido de Video Intelligence.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • INPUT_URI: Es el bucket de Cloud Storage que contiene el archivo que deseas anotar, incluido el nombre del archivo. Debe comenzar con gs://.
    Por ejemplo:
    "inputUri": "gs://cloud-videointelligence-demo/assistant.mp4",
  • PROJECT_NUMBER: Es el identificador numérico del proyecto de Google Cloud.

Método HTTP y URL:

POST https://videointelligence.googleapis.com/v1/videos:annotate

Cuerpo JSON de la solicitud:

{
    "inputUri":"INPUT_URI",
    "features": ["LOGO_RECOGNITION"]
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/operations/OPERATION_ID"
}

Si la respuesta es correcta, la API de Video Intelligence muestra name para tu operación. A continuación, se muestra un ejemplo de la respuesta, en la que project-number es el número de tu proyecto y operation-id es el ID de la operación de larga duración creada para la solicitud.

  • PROJECT_NUMBER: Es el número de tu proyecto.
  • LOCATION_ID: Es la región de Cloud en la que se debe realizar la anotación. Las regiones en la nube compatibles son: us-east1, us-west1, europe-west1, asia-east1. Si no se especifica ninguna región, se determinará una región en función de la ubicación del archivo de video.
  • OPERATION_ID: Es el ID de la operación de larga duración creada para la solicitud y proporcionada en la respuesta cuando iniciaste la operación, por ejemplo 12345....

Obtén los resultados

Para obtener los resultados de tu solicitud, debes enviar una solicitud GET con el nombre de la operación que se muestra de la llamada a videos:annotate, como se muestra en el siguiente ejemplo.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • OPERATION_NAME: Es el nombre de la operación que muestra la API de Video Intelligence. El nombre de la operación tiene el formato projects/PROJECT_NUMBER/locations/LOCATION_ID/operations/OPERATION_ID.
  • PROJECT_NUMBER: El identificador numérico de tu proyecto de Google Cloud

Método HTTP y URL:

GET https://videointelligence.googleapis.com/v1/OPERATION_NAME

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Descarga los resultados de las anotaciones

Copia la anotación de la fuente al bucket de destino: (consulta Cómo copiar archivos y objetos)

gcloud storage cp gcs_uri gs://my-bucket

Nota: Si el usuario proporciona el URI de GCS de salida, la anotación se almacena en ese URI de GCS.

Go

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"
	"time"

	video "cloud.google.com/go/videointelligence/apiv1"
	videopb "cloud.google.com/go/videointelligence/apiv1/videointelligencepb"
	"github.com/golang/protobuf/ptypes"
)

// logoDetectionGCS analyzes a video and extracts logos with their bounding boxes.
func logoDetectionGCS(w io.Writer, gcsURI string) error {
	// gcsURI := "gs://cloud-samples-data/video/googlework_tiny.mp4"

	ctx := context.Background()

	// Creates a client.
	client, err := video.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("video.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*180)
	defer cancel()

	op, err := client.AnnotateVideo(ctx, &videopb.AnnotateVideoRequest{
		InputUri: gcsURI,
		Features: []videopb.Feature{
			videopb.Feature_LOGO_RECOGNITION,
		},
	})
	if err != nil {
		return fmt.Errorf("AnnotateVideo: %w", err)
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %w", err)
	}

	// Only one video was processed, so get the first result.
	result := resp.GetAnnotationResults()[0]

	// Annotations for list of logos detected, tracked and recognized in video.
	for _, annotation := range result.LogoRecognitionAnnotations {
		fmt.Fprintf(w, "Description: %q\n", annotation.Entity.GetDescription())
		// Opaque entity ID. Some IDs may be available in Google Knowledge
		// Graph Search API (https://developers.google.com/knowledge-graph/).
		if len(annotation.Entity.EntityId) > 0 {
			fmt.Fprintf(w, "\tEntity ID: %q\n", annotation.Entity.GetEntityId())
		}

		// All logo tracks where the recognized logo appears. Each track
		// corresponds to one logo instance appearing in consecutive frames.
		for _, track := range annotation.Tracks {
			// Video segment of a track.
			segment := track.GetSegment()
			start, _ := ptypes.Duration(segment.GetStartTimeOffset())
			end, _ := ptypes.Duration(segment.GetEndTimeOffset())
			fmt.Fprintf(w, "\tSegment: %v to %v\n", start, end)
			fmt.Fprintf(w, "\tConfidence: %f\n", track.GetConfidence())

			// The object with timestamp and attributes per frame in the track.
			for _, timestampedObject := range track.TimestampedObjects {
				// Normalized Bounding box in a frame, where the object is
				// located.
				box := timestampedObject.GetNormalizedBoundingBox()
				fmt.Fprintf(w, "\tBounding box position:\n")
				fmt.Fprintf(w, "\t\tleft  : %f\n", box.GetLeft())
				fmt.Fprintf(w, "\t\ttop   : %f\n", box.GetTop())
				fmt.Fprintf(w, "\t\tright : %f\n", box.GetRight())
				fmt.Fprintf(w, "\t\tbottom: %f\n", box.GetBottom())

				// Optional. The attributes of the object in the bounding box.
				for _, attribute := range timestampedObject.Attributes {
					fmt.Fprintf(w, "\t\t\tName: %q\n", attribute.GetName())
					fmt.Fprintf(w, "\t\t\tConfidence: %f\n", attribute.GetConfidence())
					fmt.Fprintf(w, "\t\t\tValue: %q\n", attribute.GetValue())
				}
			}

			// Optional. Attributes in the track level.
			for _, trackAttribute := range track.Attributes {
				fmt.Fprintf(w, "\t\tName: %q\n", trackAttribute.GetName())
				fmt.Fprintf(w, "\t\tConfidence: %f\n", trackAttribute.GetConfidence())
				fmt.Fprintf(w, "\t\tValue: %q\n", trackAttribute.GetValue())
			}
		}

		// All video segments where the recognized logo appears. There might be
		// multiple instances of the same logo class appearing in one VideoSegment.
		for _, segment := range annotation.Segments {
			start, _ := ptypes.Duration(segment.GetStartTimeOffset())
			end, _ := ptypes.Duration(segment.GetEndTimeOffset())
			fmt.Fprintf(w, "\tSegment: %v to %v\n", start, end)
		}
	}

	return nil
}

Java

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.videointelligence.v1.AnnotateVideoProgress;
import com.google.cloud.videointelligence.v1.AnnotateVideoRequest;
import com.google.cloud.videointelligence.v1.AnnotateVideoResponse;
import com.google.cloud.videointelligence.v1.DetectedAttribute;
import com.google.cloud.videointelligence.v1.Entity;
import com.google.cloud.videointelligence.v1.Feature;
import com.google.cloud.videointelligence.v1.LogoRecognitionAnnotation;
import com.google.cloud.videointelligence.v1.NormalizedBoundingBox;
import com.google.cloud.videointelligence.v1.TimestampedObject;
import com.google.cloud.videointelligence.v1.Track;
import com.google.cloud.videointelligence.v1.VideoAnnotationResults;
import com.google.cloud.videointelligence.v1.VideoIntelligenceServiceClient;
import com.google.cloud.videointelligence.v1.VideoSegment;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class LogoDetectionGcs {

  public static void detectLogoGcs() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String gcsUri = "gs://YOUR_BUCKET_ID/path/to/your/video.mp4";
    detectLogoGcs(gcsUri);
  }

  public static void detectLogoGcs(String inputUri)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (VideoIntelligenceServiceClient client = VideoIntelligenceServiceClient.create()) {
      // Create the request
      AnnotateVideoRequest request =
          AnnotateVideoRequest.newBuilder()
              .setInputUri(inputUri)
              .addFeatures(Feature.LOGO_RECOGNITION)
              .build();

      // asynchronously perform object tracking on videos
      OperationFuture<AnnotateVideoResponse, AnnotateVideoProgress> future =
          client.annotateVideoAsync(request);

      System.out.println("Waiting for operation to complete...");
      // The first result is retrieved because a single video was processed.
      AnnotateVideoResponse response = future.get(600, TimeUnit.SECONDS);
      VideoAnnotationResults annotationResult = response.getAnnotationResults(0);

      // Annotations for list of logos detected, tracked and recognized in video.
      for (LogoRecognitionAnnotation logoRecognitionAnnotation :
          annotationResult.getLogoRecognitionAnnotationsList()) {
        Entity entity = logoRecognitionAnnotation.getEntity();
        // Opaque entity ID. Some IDs may be available in
        // [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).
        System.out.printf("Entity Id : %s\n", entity.getEntityId());
        System.out.printf("Description : %s\n", entity.getDescription());
        // All logo tracks where the recognized logo appears. Each track corresponds to one logo
        // instance appearing in consecutive frames.
        for (Track track : logoRecognitionAnnotation.getTracksList()) {

          // Video segment of a track.
          Duration startTimeOffset = track.getSegment().getStartTimeOffset();
          System.out.printf(
              "\n\tStart Time Offset: %s.%s\n",
              startTimeOffset.getSeconds(), startTimeOffset.getNanos());
          Duration endTimeOffset = track.getSegment().getEndTimeOffset();
          System.out.printf(
              "\tEnd Time Offset: %s.%s\n", endTimeOffset.getSeconds(), endTimeOffset.getNanos());
          System.out.printf("\tConfidence: %s\n", track.getConfidence());

          // The object with timestamp and attributes per frame in the track.
          for (TimestampedObject timestampedObject : track.getTimestampedObjectsList()) {

            // Normalized Bounding box in a frame, where the object is located.
            NormalizedBoundingBox normalizedBoundingBox =
                timestampedObject.getNormalizedBoundingBox();
            System.out.printf("\n\t\tLeft: %s\n", normalizedBoundingBox.getLeft());
            System.out.printf("\t\tTop: %s\n", normalizedBoundingBox.getTop());
            System.out.printf("\t\tRight: %s\n", normalizedBoundingBox.getRight());
            System.out.printf("\t\tBottom: %s\n", normalizedBoundingBox.getBottom());

            // Optional. The attributes of the object in the bounding box.
            for (DetectedAttribute attribute : timestampedObject.getAttributesList()) {
              System.out.printf("\n\t\t\tName: %s\n", attribute.getName());
              System.out.printf("\t\t\tConfidence: %s\n", attribute.getConfidence());
              System.out.printf("\t\t\tValue: %s\n", attribute.getValue());
            }
          }

          // Optional. Attributes in the track level.
          for (DetectedAttribute trackAttribute : track.getAttributesList()) {
            System.out.printf("\n\t\tName : %s\n", trackAttribute.getName());
            System.out.printf("\t\tConfidence : %s\n", trackAttribute.getConfidence());
            System.out.printf("\t\tValue : %s\n", trackAttribute.getValue());
          }
        }

        // All video segments where the recognized logo appears. There might be multiple instances
        // of the same logo class appearing in one VideoSegment.
        for (VideoSegment segment : logoRecognitionAnnotation.getSegmentsList()) {
          System.out.printf(
              "\n\tStart Time Offset : %s.%s\n",
              segment.getStartTimeOffset().getSeconds(), segment.getStartTimeOffset().getNanos());
          System.out.printf(
              "\tEnd Time Offset : %s.%s\n",
              segment.getEndTimeOffset().getSeconds(), segment.getEndTimeOffset().getNanos());
        }
      }
    }
  }
}

Node.js

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const inputUri = 'gs://cloud-samples-data/video/googlework_short.mp4';

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

// Instantiates a client
const client = new Video.VideoIntelligenceServiceClient();

// Performs asynchronous video annotation for logo recognition on a file hosted in GCS.
async function detectLogoGcs() {
  // Build the request with the input uri and logo recognition feature.
  const request = {
    inputUri: inputUri,
    features: ['LOGO_RECOGNITION'],
  };

  // Make the asynchronous request
  const [operation] = await client.annotateVideo(request);

  // Wait for the results
  const [response] = await operation.promise();

  // Get the first response, since we sent only one video.
  const annotationResult = response.annotationResults[0];
  for (const logoRecognitionAnnotation of annotationResult.logoRecognitionAnnotations) {
    const entity = logoRecognitionAnnotation.entity;
    // Opaque entity ID. Some IDs may be available in
    // [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).
    console.log(`Entity Id: ${entity.entityId}`);
    console.log(`Description: ${entity.description}`);

    // All logo tracks where the recognized logo appears.
    // Each track corresponds to one logo instance appearing in consecutive frames.
    for (const track of logoRecognitionAnnotation.tracks) {
      console.log(
        `\n\tStart Time Offset: ${track.segment.startTimeOffset.seconds}.${track.segment.startTimeOffset.nanos}`
      );
      console.log(
        `\tEnd Time Offset: ${track.segment.endTimeOffset.seconds}.${track.segment.endTimeOffset.nanos}`
      );
      console.log(`\tConfidence: ${track.confidence}`);

      // The object with timestamp and attributes per frame in the track.
      for (const timestampedObject of track.timestampedObjects) {
        // Normalized Bounding box in a frame, where the object is located.
        const normalizedBoundingBox = timestampedObject.normalizedBoundingBox;
        console.log(`\n\t\tLeft: ${normalizedBoundingBox.left}`);
        console.log(`\t\tTop: ${normalizedBoundingBox.top}`);
        console.log(`\t\tRight: ${normalizedBoundingBox.right}`);
        console.log(`\t\tBottom: ${normalizedBoundingBox.bottom}`);
        // Optional. The attributes of the object in the bounding box.
        for (const attribute of timestampedObject.attributes) {
          console.log(`\n\t\t\tName: ${attribute.name}`);
          console.log(`\t\t\tConfidence: ${attribute.confidence}`);
          console.log(`\t\t\tValue: ${attribute.value}`);
        }
      }

      // Optional. Attributes in the track level.
      for (const trackAttribute of track.attributes) {
        console.log(`\n\t\tName: ${trackAttribute.name}`);
        console.log(`\t\tConfidence: ${trackAttribute.confidence}`);
        console.log(`\t\tValue: ${trackAttribute.value}`);
      }
    }

    // All video segments where the recognized logo appears.
    // There might be multiple instances of the same logo class appearing in one VideoSegment.
    for (const segment of logoRecognitionAnnotation.segments) {
      console.log(
        `\n\tStart Time Offset: ${segment.startTimeOffset.seconds}.${segment.startTimeOffset.nanos}`
      );
      console.log(
        `\tEnd Time Offset: ${segment.endTimeOffset.seconds}.${segment.endTimeOffset.nanos}`
      );
    }
  }
}

detectLogoGcs();

Python

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


from google.cloud import videointelligence


def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):
    client = videointelligence.VideoIntelligenceServiceClient()

    features = [videointelligence.Feature.LOGO_RECOGNITION]

    operation = client.annotate_video(
        request={"features": features, "input_uri": input_uri}
    )

    print("Waiting for operation to complete...")
    response = operation.result()

    # Get the first response, since we sent only one video.
    annotation_result = response.annotation_results[0]

    # Annotations for list of logos detected, tracked and recognized in video.
    for logo_recognition_annotation in annotation_result.logo_recognition_annotations:
        entity = logo_recognition_annotation.entity

        # Opaque entity ID. Some IDs may be available in [Google Knowledge Graph
        # Search API](https://developers.google.com/knowledge-graph/).
        print("Entity Id : {}".format(entity.entity_id))

        print("Description : {}".format(entity.description))

        # All logo tracks where the recognized logo appears. Each track corresponds
        # to one logo instance appearing in consecutive frames.
        for track in logo_recognition_annotation.tracks:
            # Video segment of a track.
            print(
                "\n\tStart Time Offset : {}.{}".format(
                    track.segment.start_time_offset.seconds,
                    track.segment.start_time_offset.microseconds * 1000,
                )
            )
            print(
                "\tEnd Time Offset : {}.{}".format(
                    track.segment.end_time_offset.seconds,
                    track.segment.end_time_offset.microseconds * 1000,
                )
            )
            print("\tConfidence : {}".format(track.confidence))

            # The object with timestamp and attributes per frame in the track.
            for timestamped_object in track.timestamped_objects:
                # Normalized Bounding box in a frame, where the object is located.
                normalized_bounding_box = timestamped_object.normalized_bounding_box
                print("\n\t\tLeft : {}".format(normalized_bounding_box.left))
                print("\t\tTop : {}".format(normalized_bounding_box.top))
                print("\t\tRight : {}".format(normalized_bounding_box.right))
                print("\t\tBottom : {}".format(normalized_bounding_box.bottom))

                # Optional. The attributes of the object in the bounding box.
                for attribute in timestamped_object.attributes:
                    print("\n\t\t\tName : {}".format(attribute.name))
                    print("\t\t\tConfidence : {}".format(attribute.confidence))
                    print("\t\t\tValue : {}".format(attribute.value))

            # Optional. Attributes in the track level.
            for track_attribute in track.attributes:
                print("\n\t\tName : {}".format(track_attribute.name))
                print("\t\tConfidence : {}".format(track_attribute.confidence))
                print("\t\tValue : {}".format(track_attribute.value))

        # All video segments where the recognized logo appears. There might be
        # multiple instances of the same logo class appearing in one VideoSegment.
        for segment in logo_recognition_annotation.segments:
            print(
                "\n\tStart Time Offset : {}.{}".format(
                    segment.start_time_offset.seconds,
                    segment.start_time_offset.microseconds * 1000,
                )
            )
            print(
                "\tEnd Time Offset : {}.{}".format(
                    segment.end_time_offset.seconds,
                    segment.end_time_offset.microseconds * 1000,
                )
            )

Idiomas adicionales

C# Sigue las Instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita Documentación de referencia de Video Intelligence para .NET

PHP: Sigue las Instrucciones de configuración de PHP en la página de bibliotecas cliente y, luego, visita Documentación de referencia de Video Intelligence para PHP

Ruby: Sigue las instrucciones de configuración de Ruby en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Video Intelligence para Ruby.

Anota un video local

En la siguiente muestra de código, se muestra cómo detectar logotipos en un archivo de video local.

REST

Envía una solicitud de anotación de video

Para realizar una anotación en un archivo de video local, asegúrate de codificar el contenido del archivo de video en Base64. Incluye el contenido codificado en Base64 en el campo inputContent de la solicitud. Para obtener información sobre cómo codificar en Base64 el contenido de un archivo de video, consulta Codificación en Base64.

A continuación, se muestra cómo enviar una solicitud videos:annotate al método . En el ejemplo, se usa el token de acceso correspondiente a la configuración de una cuenta de servicio para el proyecto con Google Cloud CLI. Si deseas obtener instrucciones para instalar Google Cloud CLI, configurar un proyecto con una cuenta de servicio y conseguir un token de acceso, consulta la guía de inicio rápido de la API de Video Intelligence.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • "inputContent": BASE64_ENCODED_CONTENT
    Por ejemplo:
    "UklGRg41AwBBVkkgTElTVAwBAABoZHJsYXZpaDgAAAA1ggAAxPMBAAAAAAAQCAA..."
  • LANGUAGE_CODE: Consulta los idiomas compatibles (Opcional)
  • PROJECT_NUMBER: Es el identificador numérico del proyecto de Google Cloud.

Método HTTP y URL:

POST https://videointelligence.googleapis.com/v1/videos:annotate

Cuerpo JSON de la solicitud:

{
  "inputContent": "BASE64_ENCODED_CONTENT",
  "features": ["LOGO_RECOGNITION"],
  "videoContext": {
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/operations/OPERATION_ID"
}

Si la respuesta es correcta, la API de Video Intelligence muestra name para tu operación. A continuación, se muestra un ejemplo de la respuesta, en la que project-number es el número de tu proyecto y operation-id es el ID de la operación de larga duración creada para la solicitud.

  • OPERATION_ID: se proporciona en la respuesta cuando iniciaste la operación, por ejemplo 12345...

Obtén resultados de anotaciones

Para recuperar el resultado de la operación, realiza una solicitud GET con el nombre de la operación que se muestra en la llamada a videos:annotate, como se muestra en el siguiente ejemplo.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_NUMBER: Es el identificador numérico del proyecto de Google Cloud.

Método HTTP y URL:

GET https://videointelligence.googleapis.com/v1/OPERATION_NAME

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Las anotaciones de detección de texto se muestran como una lista textAnnotations. Nota: El campo done se muestra solo cuando su valor es True. No se incluye en las respuestas para las que no se completó la operación.

Go

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	video "cloud.google.com/go/videointelligence/apiv1"
	videopb "cloud.google.com/go/videointelligence/apiv1/videointelligencepb"
	"github.com/golang/protobuf/ptypes"
)

// logoDetection analyzes a video and extracts logos with their bounding boxes.
func logoDetection(w io.Writer, filename string) error {
	// filename := "../testdata/googlework_short.mp4"

	ctx := context.Background()

	// Creates a client.
	client, err := video.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("video.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*180)
	defer cancel()

	fileBytes, err := os.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("os.ReadFile: %w", err)
	}

	op, err := client.AnnotateVideo(ctx, &videopb.AnnotateVideoRequest{
		InputContent: fileBytes,
		Features: []videopb.Feature{
			videopb.Feature_LOGO_RECOGNITION,
		},
	})
	if err != nil {
		return fmt.Errorf("AnnotateVideo: %w", err)
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %w", err)
	}

	// Only one video was processed, so get the first result.
	result := resp.GetAnnotationResults()[0]

	// Annotations for list of logos detected, tracked and recognized in video.
	for _, annotation := range result.LogoRecognitionAnnotations {
		fmt.Fprintf(w, "Description: %q\n", annotation.Entity.GetDescription())
		// Opaque entity ID. Some IDs may be available in Google Knowledge
		// Graph Search API (https://developers.google.com/knowledge-graph/).
		if len(annotation.Entity.EntityId) > 0 {
			fmt.Fprintf(w, "\tEntity ID: %q\n", annotation.Entity.GetEntityId())
		}

		// All logo tracks where the recognized logo appears. Each track
		// corresponds to one logo instance appearing in consecutive frames.
		for _, track := range annotation.Tracks {
			// Video segment of a track.
			segment := track.GetSegment()
			start, _ := ptypes.Duration(segment.GetStartTimeOffset())
			end, _ := ptypes.Duration(segment.GetEndTimeOffset())
			fmt.Fprintf(w, "\tSegment: %v to %v\n", start, end)
			fmt.Fprintf(w, "\tConfidence: %f\n", track.GetConfidence())

			// The object with timestamp and attributes per frame in the track.
			for _, timestampedObject := range track.TimestampedObjects {
				// Normalized Bounding box in a frame, where the object is
				// located.
				box := timestampedObject.GetNormalizedBoundingBox()
				fmt.Fprintf(w, "\tBounding box position:\n")
				fmt.Fprintf(w, "\t\tleft  : %f\n", box.GetLeft())
				fmt.Fprintf(w, "\t\ttop   : %f\n", box.GetTop())
				fmt.Fprintf(w, "\t\tright : %f\n", box.GetRight())
				fmt.Fprintf(w, "\t\tbottom: %f\n", box.GetBottom())

				// Optional. The attributes of the object in the bounding box.
				for _, attribute := range timestampedObject.Attributes {
					fmt.Fprintf(w, "\t\t\tName: %q\n", attribute.GetName())
					fmt.Fprintf(w, "\t\t\tConfidence: %f\n", attribute.GetConfidence())
					fmt.Fprintf(w, "\t\t\tValue: %q\n", attribute.GetValue())
				}
			}

			// Optional. Attributes in the track level.
			for _, trackAttribute := range track.Attributes {
				fmt.Fprintf(w, "\t\tName: %q\n", trackAttribute.GetName())
				fmt.Fprintf(w, "\t\tConfidence: %f\n", trackAttribute.GetConfidence())
				fmt.Fprintf(w, "\t\tValue: %q\n", trackAttribute.GetValue())
			}
		}

		// All video segments where the recognized logo appears. There might be
		// multiple instances of the same logo class appearing in one VideoSegment.
		for _, segment := range annotation.Segments {
			start, _ := ptypes.Duration(segment.GetStartTimeOffset())
			end, _ := ptypes.Duration(segment.GetEndTimeOffset())
			fmt.Fprintf(w, "\tSegment: %v to %v\n", start, end)
		}
	}

	return nil
}

Java

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.videointelligence.v1.AnnotateVideoProgress;
import com.google.cloud.videointelligence.v1.AnnotateVideoRequest;
import com.google.cloud.videointelligence.v1.AnnotateVideoResponse;
import com.google.cloud.videointelligence.v1.DetectedAttribute;
import com.google.cloud.videointelligence.v1.Entity;
import com.google.cloud.videointelligence.v1.Feature;
import com.google.cloud.videointelligence.v1.LogoRecognitionAnnotation;
import com.google.cloud.videointelligence.v1.NormalizedBoundingBox;
import com.google.cloud.videointelligence.v1.TimestampedObject;
import com.google.cloud.videointelligence.v1.Track;
import com.google.cloud.videointelligence.v1.VideoAnnotationResults;
import com.google.cloud.videointelligence.v1.VideoIntelligenceServiceClient;
import com.google.cloud.videointelligence.v1.VideoSegment;
import com.google.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class LogoDetection {

  public static void detectLogo() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String localFilePath = "path/to/your/video.mp4";
    detectLogo(localFilePath);
  }

  public static void detectLogo(String filePath)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (VideoIntelligenceServiceClient client = VideoIntelligenceServiceClient.create()) {
      // Read file
      Path path = Paths.get(filePath);
      byte[] data = Files.readAllBytes(path);
      // Create the request
      AnnotateVideoRequest request =
          AnnotateVideoRequest.newBuilder()
              .setInputContent(ByteString.copyFrom(data))
              .addFeatures(Feature.LOGO_RECOGNITION)
              .build();

      // asynchronously perform object tracking on videos
      OperationFuture<AnnotateVideoResponse, AnnotateVideoProgress> future =
          client.annotateVideoAsync(request);

      System.out.println("Waiting for operation to complete...");
      // The first result is retrieved because a single video was processed.
      AnnotateVideoResponse response = future.get(300, TimeUnit.SECONDS);
      VideoAnnotationResults annotationResult = response.getAnnotationResults(0);

      // Annotations for list of logos detected, tracked and recognized in video.
      for (LogoRecognitionAnnotation logoRecognitionAnnotation :
          annotationResult.getLogoRecognitionAnnotationsList()) {
        Entity entity = logoRecognitionAnnotation.getEntity();
        // Opaque entity ID. Some IDs may be available in
        // [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).
        System.out.printf("Entity Id : %s\n", entity.getEntityId());
        System.out.printf("Description : %s\n", entity.getDescription());
        // All logo tracks where the recognized logo appears. Each track corresponds to one logo
        // instance appearing in consecutive frames.
        for (Track track : logoRecognitionAnnotation.getTracksList()) {

          // Video segment of a track.
          Duration startTimeOffset = track.getSegment().getStartTimeOffset();
          System.out.printf(
              "\n\tStart Time Offset: %s.%s\n",
              startTimeOffset.getSeconds(), startTimeOffset.getNanos());
          Duration endTimeOffset = track.getSegment().getEndTimeOffset();
          System.out.printf(
              "\tEnd Time Offset: %s.%s\n", endTimeOffset.getSeconds(), endTimeOffset.getNanos());
          System.out.printf("\tConfidence: %s\n", track.getConfidence());

          // The object with timestamp and attributes per frame in the track.
          for (TimestampedObject timestampedObject : track.getTimestampedObjectsList()) {

            // Normalized Bounding box in a frame, where the object is located.
            NormalizedBoundingBox normalizedBoundingBox =
                timestampedObject.getNormalizedBoundingBox();
            System.out.printf("\n\t\tLeft: %s\n", normalizedBoundingBox.getLeft());
            System.out.printf("\t\tTop: %s\n", normalizedBoundingBox.getTop());
            System.out.printf("\t\tRight: %s\n", normalizedBoundingBox.getRight());
            System.out.printf("\t\tBottom: %s\n", normalizedBoundingBox.getBottom());

            // Optional. The attributes of the object in the bounding box.
            for (DetectedAttribute attribute : timestampedObject.getAttributesList()) {
              System.out.printf("\n\t\t\tName: %s\n", attribute.getName());
              System.out.printf("\t\t\tConfidence: %s\n", attribute.getConfidence());
              System.out.printf("\t\t\tValue: %s\n", attribute.getValue());
            }
          }

          // Optional. Attributes in the track level.
          for (DetectedAttribute trackAttribute : track.getAttributesList()) {
            System.out.printf("\n\t\tName : %s\n", trackAttribute.getName());
            System.out.printf("\t\tConfidence : %s\n", trackAttribute.getConfidence());
            System.out.printf("\t\tValue : %s\n", trackAttribute.getValue());
          }
        }

        // All video segments where the recognized logo appears. There might be multiple instances
        // of the same logo class appearing in one VideoSegment.
        for (VideoSegment segment : logoRecognitionAnnotation.getSegmentsList()) {
          System.out.printf(
              "\n\tStart Time Offset : %s.%s\n",
              segment.getStartTimeOffset().getSeconds(), segment.getStartTimeOffset().getNanos());
          System.out.printf(
              "\tEnd Time Offset : %s.%s\n",
              segment.getEndTimeOffset().getSeconds(), segment.getEndTimeOffset().getNanos());
        }
      }
    }
  }
}

Node.js

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const localFilePath = 'path/to/your/video.mp4'

// Imports the Google Cloud client libraries
const Video = require('@google-cloud/video-intelligence');
const fs = require('fs');

// Instantiates a client
const client = new Video.VideoIntelligenceServiceClient();

// Performs asynchronous video annotation for logo recognition on a file.
async function detectLogo() {
  const inputContent = fs.readFileSync(localFilePath).toString('base64');

  // Build the request with the input content and logo recognition feature.
  const request = {
    inputContent: inputContent,
    features: ['LOGO_RECOGNITION'],
  };

  // Make the asynchronous request
  const [operation] = await client.annotateVideo(request);

  // Wait for the results
  const [response] = await operation.promise();

  // Get the first response, since we sent only one video.
  const annotationResult = response.annotationResults[0];
  for (const logoRecognitionAnnotation of annotationResult.logoRecognitionAnnotations) {
    const entity = logoRecognitionAnnotation.entity;
    // Opaque entity ID. Some IDs may be available in
    // [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).
    console.log(`Entity Id: ${entity.entityId}`);
    console.log(`Description: ${entity.description}`);

    // All logo tracks where the recognized logo appears.
    // Each track corresponds to one logo instance appearing in consecutive frames.
    for (const track of logoRecognitionAnnotation.tracks) {
      console.log(
        `\n\tStart Time Offset: ${track.segment.startTimeOffset.seconds}.${track.segment.startTimeOffset.nanos}`
      );
      console.log(
        `\tEnd Time Offset: ${track.segment.endTimeOffset.seconds}.${track.segment.endTimeOffset.nanos}`
      );
      console.log(`\tConfidence: ${track.confidence}`);

      // The object with timestamp and attributes per frame in the track.
      for (const timestampedObject of track.timestampedObjects) {
        // Normalized Bounding box in a frame, where the object is located.
        const normalizedBoundingBox = timestampedObject.normalizedBoundingBox;
        console.log(`\n\t\tLeft: ${normalizedBoundingBox.left}`);
        console.log(`\t\tTop: ${normalizedBoundingBox.top}`);
        console.log(`\t\tRight: ${normalizedBoundingBox.right}`);
        console.log(`\t\tBottom: ${normalizedBoundingBox.bottom}`);
        // Optional. The attributes of the object in the bounding box.
        for (const attribute of timestampedObject.attributes) {
          console.log(`\n\t\t\tName: ${attribute.name}`);
          console.log(`\t\t\tConfidence: ${attribute.confidence}`);
          console.log(`\t\t\tValue: ${attribute.value}`);
        }
      }

      // Optional. Attributes in the track level.
      for (const trackAttribute of track.attributes) {
        console.log(`\n\t\tName: ${trackAttribute.name}`);
        console.log(`\t\tConfidence: ${trackAttribute.confidence}`);
        console.log(`\t\tValue: ${trackAttribute.value}`);
      }
    }

    // All video segments where the recognized logo appears.
    // There might be multiple instances of the same logo class appearing in one VideoSegment.
    for (const segment of logoRecognitionAnnotation.segments) {
      console.log(
        `\n\tStart Time Offset: ${segment.startTimeOffset.seconds}.${segment.startTimeOffset.nanos}`
      );
      console.log(
        `\tEnd Time Offset: ${segment.endTimeOffset.seconds}.${segment.endTimeOffset.nanos}`
      );
    }
  }
}

detectLogo();

Python

Para autenticarte en Video Intelligence, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import io

from google.cloud import videointelligence


def detect_logo(local_file_path="path/to/your/video.mp4"):
    """Performs asynchronous video annotation for logo recognition on a local file."""

    client = videointelligence.VideoIntelligenceServiceClient()

    with io.open(local_file_path, "rb") as f:
        input_content = f.read()
    features = [videointelligence.Feature.LOGO_RECOGNITION]

    operation = client.annotate_video(
        request={"features": features, "input_content": input_content}
    )

    print("Waiting for operation to complete...")
    response = operation.result()

    # Get the first response, since we sent only one video.
    annotation_result = response.annotation_results[0]

    # Annotations for list of logos detected, tracked and recognized in video.
    for logo_recognition_annotation in annotation_result.logo_recognition_annotations:
        entity = logo_recognition_annotation.entity

        # Opaque entity ID. Some IDs may be available in [Google Knowledge Graph
        # Search API](https://developers.google.com/knowledge-graph/).
        print("Entity Id : {}".format(entity.entity_id))

        print("Description : {}".format(entity.description))

        # All logo tracks where the recognized logo appears. Each track corresponds
        # to one logo instance appearing in consecutive frames.
        for track in logo_recognition_annotation.tracks:
            # Video segment of a track.
            print(
                "\n\tStart Time Offset : {}.{}".format(
                    track.segment.start_time_offset.seconds,
                    track.segment.start_time_offset.microseconds * 1000,
                )
            )
            print(
                "\tEnd Time Offset : {}.{}".format(
                    track.segment.end_time_offset.seconds,
                    track.segment.end_time_offset.microseconds * 1000,
                )
            )
            print("\tConfidence : {}".format(track.confidence))

            # The object with timestamp and attributes per frame in the track.
            for timestamped_object in track.timestamped_objects:
                # Normalized Bounding box in a frame, where the object is located.
                normalized_bounding_box = timestamped_object.normalized_bounding_box
                print("\n\t\tLeft : {}".format(normalized_bounding_box.left))
                print("\t\tTop : {}".format(normalized_bounding_box.top))
                print("\t\tRight : {}".format(normalized_bounding_box.right))
                print("\t\tBottom : {}".format(normalized_bounding_box.bottom))

                # Optional. The attributes of the object in the bounding box.
                for attribute in timestamped_object.attributes:
                    print("\n\t\t\tName : {}".format(attribute.name))
                    print("\t\t\tConfidence : {}".format(attribute.confidence))
                    print("\t\t\tValue : {}".format(attribute.value))

            # Optional. Attributes in the track level.
            for track_attribute in track.attributes:
                print("\n\t\tName : {}".format(track_attribute.name))
                print("\t\tConfidence : {}".format(track_attribute.confidence))
                print("\t\tValue : {}".format(track_attribute.value))

        # All video segments where the recognized logo appears. There might be
        # multiple instances of the same logo class appearing in one VideoSegment.
        for segment in logo_recognition_annotation.segments:
            print(
                "\n\tStart Time Offset : {}.{}".format(
                    segment.start_time_offset.seconds,
                    segment.start_time_offset.microseconds * 1000,
                )
            )
            print(
                "\tEnd Time Offset : {}.{}".format(
                    segment.end_time_offset.seconds,
                    segment.end_time_offset.microseconds * 1000,
                )
            )

Idiomas adicionales

C# Sigue las Instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita Documentación de referencia de Video Intelligence para .NET

PHP: Sigue las instrucciones de configuración de PHP en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Video Intelligence para PHP.

Ruby: Sigue las Instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita Documentación de referencia de Video Intelligence para Ruby.