La fonctionnalité de recherche de produits est en mode maintenance. Pour bénéficier d'une meilleure évolutivité et des mêmes fonctionnalités qu'avec la recherche de produits, utilisez l'entrepôt Vision.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Détecter des logos dans un fichier image Cloud Storage

Lancez une détection de logos dans un fichier image stocké dans Cloud Storage.

En savoir plus

Pour obtenir une documentation détaillée incluant cet exemple de code, consultez la page suivante :

Exemple de code

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour la recherche de produits de l'API Vision, consultez la page Bibliothèques clientes de la recherche de produits de l'API Vision. Pour en savoir plus, consultez la documentation de référence sur les API de la recherche de produits de l'API Vision pour Go.

Pour vous authentifier auprès de la recherche de produits de l'API Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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

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

	image := &visionpb.Image{
		Source: &visionpb.ImageSource{
			// Use GcsImageUri for gs:// links
			// Use ImageUri for public https:// links
			GcsImageUri: file,
		},
	}

	feature := &visionpb.Feature{
		Type:       visionpb.Feature_LOGO_DETECTION,
		MaxResults: 10,
	}

	request := &visionpb.BatchAnnotateImagesRequest{
		Requests: []*visionpb.AnnotateImageRequest{
			{
				Image:    image,
				Features: []*visionpb.Feature{feature},
			},
		},
	}

	response, err := client.BatchAnnotateImages(ctx, request)
	if err != nil {
		return err
	}

	for _, resp := range response.Responses {
		if resp.Error != nil {
			fmt.Fprintf(w, "Error: %v\n", resp.Error)
			continue
		}
		if len(resp.LogoAnnotations) == 0 {
			fmt.Fprintln(w, "No logos found.")
		} else {
			fmt.Fprintln(w, "Logos:")
			for _, annotation := range resp.LogoAnnotations {
				fmt.Fprintln(w, annotation.Description)
			}
		}
	}

	return nil
}

Java


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.Image;
import com.google.cloud.vision.v1.ImageAnnotatorClient;
import com.google.cloud.vision.v1.ImageSource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DetectLogosGcs {

  public static void detectLogosGcs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String filePath = "gs://your-gcs-bucket/path/to/image/file.jpg";
    detectLogosGcs(filePath);
  }

  // Detects logos in the specified remote image on Google Cloud Storage.
  public static void detectLogosGcs(String gcsPath) throws 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(Feature.Type.LOGO_DETECTION).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
        for (EntityAnnotation annotation : res.getLogoAnnotationsList()) {
          System.out.println(annotation.getDescription());
        }
      }
    }
  }
}

Node.js

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

const request = {
  requests: [
    {
      image: {
        source: {
          imageUri: `gs://${bucketName}/${fileName}`,
        },
      },
      features: [
        {
          type: 'LOGO_DETECTION',
        },
      ],
    },
  ],
};

// Performs logo detection on the gcs file
const [response] = await client.batchAnnotateImages(request);

response.responses.forEach(res => {
  if (res.logoAnnotations) {
    console.log('Logos:');
    res.logoAnnotations.forEach(logo => console.log(logo));
  }

  if (res.error) {
    console.error(` - Error: ${res.error.message}`);
  }
});

PHP

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\Client\ImageAnnotatorClient;

/**
 * @param string $path GCS path to the image, e.g. "gs://path/to/your/image.jpg"
 */
function detect_logo_gcs(string $path)
{
    $imageAnnotator = new ImageAnnotatorClient();

    # annotate the image
    $response = $imageAnnotator->logoDetection($path);
    $logos = $response->getLogoAnnotations();

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

    $imageAnnotator->close();
}

Python

def detect_logos_uri(uri):
    """Detects logos in the file located in Google Cloud Storage or on the Web."""
    from google.cloud import vision

    client = vision.ImageAnnotatorClient()
    image = vision.Image()
    image.source.image_uri = uri

    request = {
        "image": image,
        "features": [{"type_": vision.Feature.Type.LOGO_DETECTION}],
    }

    response = client.annotate_image(request=request)

    logos = response.logo_annotations
    print("Logos:")

    for logo in logos:
        print(logo.description)

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

Étape suivante

Pour rechercher et filtrer des exemples de code pour d'autres produits Google Cloud , consultez l'explorateur d'exemplesGoogle Cloud .

Détecter des logos dans un fichier image Cloud Storage Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.