Referenzbilder und Indexierung erstellen

Referenzbilder sind Bilder mit verschiedenen Ansichten Ihrer Artikel. Hierbei gelten folgende Empfehlungen:

  • Die Datei darf maximal 20 MB groß sein.
  • Überlegen Sie, welche Perspektiven das Produkt auf natürliche Weise hervorheben und in welchen Perspektiven die relevanten optischen Informationen enthalten sind.
  • Erstellen Sie Referenzbilder, die fehlende Perspektiven ergänzen. Wenn Sie beispielsweise nur Bilder vom rechten Schuh haben, stellen Sie diese für den linken Schuh gespiegelt bereit.
  • Laden Sie das Bild mit der höchsten Auflösung hoch.
  • Präsentieren Sie das Produkt vor einem weißen Hintergrund.
  • Konvertieren Sie PNGs mit transparentem Hintergrund in einen soliden Hintergrund.

Bilder müssen in einem Google Cloud Storage-Bucket gespeichert sein. Wenn Sie die Anfrage zur Bilderstellung mit einem API-Schlüssel authentifizieren, muss der Bucket öffentlich sein. Wenn Sie für die Authentifizierung ein Dienstkonto verwenden, muss dieses Dienstkonto Lesezugriff auf den Bucket haben.

Einzelnes Referenzbild erstellen

Sie können einem bestehenden Produkt ein Referenzbild hinzufügen. Mit diesem Bild können Sie dann nach dem Produkt zu suchen.

Befehlszeile

Senden Sie eine POST-Anfrage an den folgenden URI, um ein Referenzbild zu erstellen.
  • Ersetzen Sie project-id durch die ID Ihres Google Cloud Platform-Projekts (GCP).
  • Ersetzen Sie location-id durch eine gültige Standortkennung. Gültige Standortkennungen sind us-west1, us-east1, europe-west1 und asia-east1.
  • Ersetzen Sie product-id durch die ID des Produkts, mit dem das Referenzbild verknüpft werden soll.
curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/products/product-id/referenceImages -d '{
  'uri': 'gs://bucket/path/to/red-shoe.jpg',
  'boundingPolys': [
    {
      'vertices': [
        {
          'x': 44,
          'y': 252
        },
        {
          'x': 44,
          'y': 1351
        },
        {
          'x': 1161,
          'y': 252
        },
        {
          'x': 1161,
          'y': 1351
        }
      ]
    }
  ]
}
Das Feld boundingPolys ist optional. Wenn im Feld nichts angegeben wird, leitet der Dienst die Begrenzungen für das Bild ab.

C#

private static int CreateReferenceImage(CreateReferenceImageOptions opts)
{
    var client = ProductSearchClient.Create();
    var request = new CreateReferenceImageRequest
    {
        // Get the full path of the product.
        ParentAsProductName = new ProductName(opts.ProjectID,
                                              opts.ComputeRegion,
                                              opts.ProductID),
        ReferenceImageId = opts.ReferenceImageID,
        // Create a reference image.
        ReferenceImage = new ReferenceImage
        {
            Uri = opts.ReferenceImageURI
        }
    };

    var referenceImage = client.CreateReferenceImage(request);

    Console.WriteLine($"Reference image name: {referenceImage.Name}");
    Console.WriteLine($"Reference image URI: {referenceImage.Uri}");

    return 0;
}

Go


import (
	"context"
	"fmt"
	"io"

	vision "cloud.google.com/go/vision/apiv1"
	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
)

// createReferenceImage creates a reference image for a product.
func createReferenceImage(w io.Writer, projectID string, location string, productID string, referenceImageID string, gcsURI string) error {
	ctx := context.Background()
	c, err := vision.NewProductSearchClient(ctx)
	if err != nil {
		return fmt.Errorf("NewProductSearchClient: %v", err)
	}

	req := &visionpb.CreateReferenceImageRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s/products/%s", projectID, location, productID),
		ReferenceImage: &visionpb.ReferenceImage{
			Uri: gcsURI,
		},
		ReferenceImageId: referenceImageID,
	}

	resp, err := c.CreateReferenceImage(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateReferenceImage: %v", err)
	}

	fmt.Fprintf(w, "Reference image name: %s\n", resp.Name)
	fmt.Fprintf(w, "Reference image uri: %s\n", resp.Uri)

	return nil
}

Java

/**
 * Create a reference image.
 *
 * @param projectId - Id of the project.
 * @param computeRegion - Region name.
 * @param productId - Id of the product.
 * @param referenceImageId - Id of the image.
 * @param gcsUri - Google Cloud Storage path of the input image.
 * @throws IOException - on I/O errors.
 */
public static void createReferenceImage(
    String projectId,
    String computeRegion,
    String productId,
    String referenceImageId,
    String gcsUri)
    throws IOException {
  try (ProductSearchClient client = ProductSearchClient.create()) {

    // Get the full path of the product.
    String formattedParent =
        ProductSearchClient.formatProductName(projectId, computeRegion, productId);
    // Create a reference image.
    ReferenceImage referenceImage = ReferenceImage.newBuilder().setUri(gcsUri).build();

    ReferenceImage image =
        client.createReferenceImage(formattedParent, referenceImage, referenceImageId);
    // Display the reference image information.
    System.out.println(String.format("Reference image name: %s", image.getName()));
    System.out.println(String.format("Reference image uri: %s", image.getUri()));
  }
}

Node.js


const vision = require('@google-cloud/vision');

const client = new vision.ProductSearchClient();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const projectId = 'Your Google Cloud project Id';
// const location = 'A compute region name';
// const productId = 'Id of the product';
// const referenceImageId = 'Id of the reference image';
// const gcsUri = 'Google Cloud Storage path of the input image';

const formattedParent = client.productPath(projectId, location, productId);

const referenceImage = {
  uri: gcsUri,
};

const request = {
  parent: formattedParent,
  referenceImage: referenceImage,
  referenceImageId: referenceImageId,
};

const [response] = await client.createReferenceImage(request);
console.log(`response.name: ${response.name}`);
console.log(`response.uri: ${response.uri}`);

PHP

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ProductSearchClient;
use Google\Cloud\Vision\V1\ReferenceImage;

/**
 * Create a reference image
 *
 * @param string $projectId Your Google Cloud project ID
 * @param string $location Google Cloud compute region name
 * @param string $productId ID of the product
 * @param string $referenceImageId ID of the reference image
 * @param string $gcsUri Google Cloud Storage path of the input image
 */
function product_image_create($projectId, $location, $productId, $referenceImageId, $gcsUri)
{
    $client = new ProductSearchClient();

    # get the name of the product.
    $productPath = $client->productName($projectId, $location, $productId);

    # create a reference image.
    $referenceImage = (new ReferenceImage())
        ->setUri($gcsUri);

    # the response is the reference image with `name` populated.
    $image = $client->createReferenceImage($productPath, $referenceImage, ['referenceImageId' => $referenceImageId]);

    # display the reference image information
    printf('Reference image name: %s' . PHP_EOL, $image->getName());
    printf('Reference image uri: %s' . PHP_EOL, $image->getUri());

    $client->close();
}

Python

from google.cloud import vision

def create_reference_image(
        project_id, location, product_id, reference_image_id, gcs_uri):
    """Create a reference image.
    Args:
        project_id: Id of the project.
        location: A compute region name.
        product_id: Id of the product.
        reference_image_id: Id of the reference image.
        gcs_uri: Google Cloud Storage path of the input image.
    """
    client = vision.ProductSearchClient()

    # Get the full path of the product.
    product_path = client.product_path(
        project=project_id, location=location, product=product_id)

    # Create a reference image.
    reference_image = vision.types.ReferenceImage(uri=gcs_uri)

    # The response is the reference image with `name` populated.
    image = client.create_reference_image(
        parent=product_path,
        reference_image=reference_image,
        reference_image_id=reference_image_id)

    # Display the reference image information.
    print('Reference image name: {}'.format(image.name))
    print('Reference image uri: {}'.format(image.uri))

Ruby

require "google/cloud/vision"

def product_search_create_reference_image(
  project_id = "your-project-id",
  location   = "us-west1",
  product_id = "your-product-id"
)
  client = Google::Cloud::Vision::ProductSearch.new

  product_path    = client.product_path project_id, location, product_id
  reference_image = {
    uri: "gs://cloud-samples-data/vision/product_search/shoes_1.jpg"
  }

  reference_image = client.create_reference_image product_path, reference_image

  puts "Added reference image to #{product_id}."
  puts "Reference image name: #{reference_image.name}"
  puts "Reference image uri: #{reference_image.uri}"
end

Mehrere Referenzbilder mit Bulk-Import erstellen

Sie können auch Referenzbilder gleichzeitig mit einer Produktgruppe und mehreren Produkten erstellen.

Mehrere Referenzbilder gleichzeitig erstellen Sie, indem Sie den Speicherort einer CSV-Datei in Google Cloud Storage an die Methode import übergeben. Daher müssen sich die CSV-Datei und die Bilder, auf die sie verweist, in einem Google Cloud Storage-Bucket befinden.

Wenn Sie Ihre Bulk-Importanfrage mit einem API-Schlüssel authentifizieren, muss diese CSV-Quelldatei öffentlich sein.

Wenn Sie sich mit einem Dienstkonto authentifizieren, muss dieses Dienstkonto Lesezugriff auf die CSV-Quelldatei haben.

CSV-Format

image-uri,[image-id],product-set-id,product-id,product-category,[product-display-name],[label(s)],[bounding-poly]

Ausführliche Informationen zum Formatieren von CSV finden Sie im Hilfethema zum CSV-Format.

Anfrage für die Bulk-Erstellung

Befehlszeile

Senden Sie eine POST-Anfrage an den folgenden URI, um Produkte in Ihre Produktgruppe zu importieren.
  • Ersetzen Sie project-id durch die ID Ihres Google Cloud Platform-Projekts (GCP).
  • Ersetzen Sie location-id durch eine gültige Standortkennung.Gültige Standortkennungen sind us-west1, us-east1, europe-west1 und asia-east1.
curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
"https://vision.googleapis.com/v1/projects/$PROJECT_ID/locations/$LOCATION_ID/productSets:import" -d '{
  "inputConfig": {
    "gcsSource": {
      "csvFileUri": "gs://bucket/path/to/file.csv"
    }
  }
}'
Eine erfolgreiche Antwort enthält ein lang laufendes Vorgangsobjekt:
{
  "name": "locations/location-id/operations/operation-id"
}
Rufen Sie den Endpunkt operations auf und übergeben Sie die vom Aufruf zurückgegebene operation-id an die Methode import, um den Status des Vorgangs abzufragen. Ersetzen Sie location-id durch die Standort-ID aus dem Aufruf der Methode import.
curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/locations/location-id/operations/operation-id
Die Antwort sieht in etwa so aus:
{
  "name": "locations/us-west1/operations/eea5667a0ed419d8",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.BatchOperationMetadata",
    "state": "SUCCESSFUL",
    "endTime": "2018-04-18T21:45:14.926185506Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.ImportProductSetsResponse",
    "referenceImages": [
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_kids_01/referenceImages/17196263426604931544-0",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_kids_01.jpg"
      },
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_kids_02/referenceImages/17196263426604931544-1",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_kids_02.jpg"
      },
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_kids_04/referenceImages/17196263426604931544-2",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_kids_04.jpg"
      },
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_kids_05/referenceImages/17196263426604931544-3",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_kids_05.jpg"
      },
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_women_05/referenceImages/17196263426604931544-4",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_women_05.jpg"
      },
      {
        "name": "projects/media-demo-service/locations/us-west1/products/160421_women_07/referenceImages/17196263426604931544-5",
        "uri": "gs://cloud-ml-api-e2e-testing/vision/product_search/client-lib/160421_women_07.jpg"
      }
    ],
    "statuses": [
      {},
      {},
      {},
      {},
      {},
      {}
    ]
  }
}

C#

private static int ImportProductSet(ImportProductSetOptions opts)
{
    var client = ProductSearchClient.Create();
    var request = new ImportProductSetsRequest
    {
        // A resource that represents Google Cloud Platform location.
        ParentAsLocationName = new LocationName(opts.ProjectID,
                                                opts.ComputeRegion),

        // Set the input configuration along with Google Cloud Storage URI
        InputConfig = new ImportProductSetsInputConfig
        {
            GcsSource = new ImportProductSetsGcsSource
            {
                CsvFileUri = opts.GcsUri
            }
        }
    };
    var response = client.ImportProductSets(request);

    // Synchronous check of operation status
    var completedResponse = response.PollUntilCompleted();

    if (completedResponse.IsCompleted)
    {
        var result = completedResponse.Result;

        foreach (var status in result.Statuses)
        {
            // Check status of reference image.
            // `0` is the code for OK in google.rpc.Code.
            if (status.Code == 0)
            {
                Console.WriteLine(result.ReferenceImages);
            }
            else
            {
                Console.WriteLine("No reference images.");
            }
        }
    }

    return 0;
}

Go



import (
	"context"
	"fmt"
	"io"

	vision "cloud.google.com/go/vision/apiv1"
	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
)

// importProductSets creates a product set using information in a csv file on GCS.
func importProductSets(w io.Writer, projectID string, location string, gcsURI string) error {
	ctx := context.Background()
	c, err := vision.NewProductSearchClient(ctx)
	if err != nil {
		return fmt.Errorf("NewProductSearchClient: %v", err)
	}

	req := &visionpb.ImportProductSetsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		InputConfig: &visionpb.ImportProductSetsInputConfig{
			Source: &visionpb.ImportProductSetsInputConfig_GcsSource{
				GcsSource: &visionpb.ImportProductSetsGcsSource{
					CsvFileUri: gcsURI,
				},
			},
		},
	}

	op, err := c.ImportProductSets(ctx, req)
	if err != nil {
		return fmt.Errorf("ImportProductSets: %v", err)
	}

	fmt.Fprintf(w, "Processing operation name: %s\n", op.Name())

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

	fmt.Fprintf(w, "processing done.\n")

	for i, status := range resp.Statuses {
		// `0` is the coee for OK in google.rpc.code
		fmt.Fprintf(w, "Status of processing line %d of the csv: %d\n", i, status.Code)

		if status.Code == 0 {
			fmt.Fprintf(w, "Reference image name: %s\n", resp.ReferenceImages[i].Name)
		} else {
			fmt.Fprintf(w, "Status code not OK: %s\n", status.Message)
		}
	}

	return nil
}

Java

/**
 * Import images of different products in the product set.
 *
 * @param projectId - Id of the project.
 * @param computeRegion - Region name.
 * @param gcsUri - Google Cloud Storage URI.Target files must be in Product Search CSV format.
 * @throws Exception - on client errors.
 */
public static void importProductSets(String projectId, String computeRegion, String gcsUri)
    throws Exception {
  try (ProductSearchClient client = ProductSearchClient.create()) {

    // A resource that represents Google Cloud Platform location.
    String formattedParent = ProductSearchClient.formatLocationName(projectId, computeRegion);
    Builder gcsSource = ImportProductSetsGcsSource.newBuilder().setCsvFileUri(gcsUri);

    // Set the input configuration along with Google Cloud Storage URI
    ImportProductSetsInputConfig inputConfig =
        ImportProductSetsInputConfig.newBuilder().setGcsSource(gcsSource).build();

    // Import the product sets from the input URI.
    OperationFuture<ImportProductSetsResponse, BatchOperationMetadata> response =
        client.importProductSetsAsync(formattedParent, inputConfig);

    System.out.println(String.format("Processing operation name: %s", response.getName()));
    ImportProductSetsResponse results = response.get();
    System.out.println("Processing done.");
    System.out.println("Results of the processing:");

    for (int i = 0; i < results.getStatusesCount(); i++) {
      System.out.println(
          String.format(
              "Status of processing line %s of the csv: %s", i, results.getStatuses(i)));
      // Check the status of reference image.
      if (results.getStatuses(i).getCode() == 0) {
        ReferenceImage referenceImage = results.getReferenceImages(i);
        System.out.println(referenceImage);
      } else {
        System.out.println("No reference image.");
      }
    }
  }
}

Node.js

async function importProductSets(projectId, location, gcsUri) {
  // Imports the Google Cloud client library
  const vision = require('@google-cloud/vision');
  // Creates a client
  const client = new vision.ProductSearchClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = 'Your Google Cloud project Id';
  // const location = 'A compute region name';
  // const gcsUri = 'Google Cloud Storage path of the input image'';

  // A resource that represents Google Cloud Platform location.
  const projectLocation = client.locationPath(projectId, location);

  // Set the input configuration along with Google Cloud Storage URI
  const inputConfig = {
    gcsSource: {
      csvFileUri: gcsUri,
    },
  };

  // Import the product sets from the input URI.
  const [response, operation] = await client.importProductSets({
    parent: projectLocation,
    inputConfig: inputConfig,
  });

  console.log('Processing operation name: ', operation.name);

  // synchronous check of operation status
  const [result] = await response.promise();
  console.log('Processing done.');
  console.log('Results of the processing:');

  for (const i in result.statuses) {
    console.log('Status of processing ', i, 'of the csv:', result.statuses[i]);

    // Check the status of reference image
    if (result.statuses[i].code === 0) {
      console.log(result.referenceImages[i]);
    } else {
      console.log('No reference image.');
    }
  }

PHP

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ProductSearchClient;
use Google\Cloud\Vision\V1\ImportProductSetsGcsSource;
use Google\Cloud\Vision\V1\ImportProductSetsInputConfig;

/**
 * Import images of different products in the product set.
 *
 * @param string $projectId Your Google Cloud Project ID
 * @param string $location Google Cloud compute region name
 * @param string $gcsUri Google Cloud Storage URI
 */
function product_set_import($projectId, $location, $gcsUri)
{
    $client = new ProductSearchClient();

    # a resource that represents Google Cloud Platform location.
    $locationPath = $client->locationName($projectId, $location);

    # set the input configuration along with Google Cloud Storage URI
    $gcsSource = (new ImportProductSetsGcsSource())
        ->setCsvFileUri($gcsUri);
    $inputConfig = (new ImportProductSetsInputConfig())
        ->setGcsSource($gcsSource);

    # import the product sets from the input URI
    $operation = $client->importProductSets($locationPath, $inputConfig);
    $operationName = $operation->getName();
    printf('Processing operation name: %s' . PHP_EOL, $operationName);

    $operation->pollUntilComplete();
    print('Processing done.' . PHP_EOL);

    if ($result = $operation->getResult()) {
        $referenceImages = $result->getReferenceImages();

        foreach ($result->getStatuses() as $count => $status) {
            printf('Status of processing line %d of the csv: ' . PHP_EOL, $count);
            # check the status of reference image
            # `0` is the code for OK in google.rpc.Code.
            if ($status->getCode() == 0) {
                $referenceImage = $referenceImages[$count];
                printf('name: %s' . PHP_EOL, $referenceImage->getName());
                printf('uri: %s' . PHP_EOL, $referenceImage->getUri());
            } else {
                printf('Status code not OK: %s' . PHP_EOL, $status->getMessage());
            }
        }
        print('IMPORTANT: You will need to wait up to 30 minutes for indexing to complete' . PHP_EOL);
    } else {
        printf('Error: %s' . PHP_EOL, $operation->getError()->getMessage());
    }

    $client->close();
}

Python

def import_product_sets(project_id, location, gcs_uri):
    """Import images of different products in the product set.
    Args:
        project_id: Id of the project.
        location: A compute region name.
        gcs_uri: Google Cloud Storage URI.
            Target files must be in Product Search CSV format.
    """
    client = vision.ProductSearchClient()

    # A resource that represents Google Cloud Platform location.
    location_path = client.location_path(
        project=project_id, location=location)

    # Set the input configuration along with Google Cloud Storage URI
    gcs_source = vision.types.ImportProductSetsGcsSource(
        csv_file_uri=gcs_uri)
    input_config = vision.types.ImportProductSetsInputConfig(
        gcs_source=gcs_source)

    # Import the product sets from the input URI.
    response = client.import_product_sets(
        parent=location_path, input_config=input_config)

    print('Processing operation name: {}'.format(response.operation.name))
    # synchronous check of operation status
    result = response.result()
    print('Processing done.')

    for i, status in enumerate(result.statuses):
        print('Status of processing line {} of the csv: {}'.format(
            i, status))
        # Check the status of reference image
        # `0` is the code for OK in google.rpc.Code.
        if status.code == 0:
            reference_image = result.reference_images[i]
            print(reference_image)
        else:
            print('Status code not OK: {}'.format(status.message))

Ruby

require "google/cloud/vision"

def product_search_import_product_sets(
  project_id = "your-project-id",
  location   = "us-west1"
)
  client = Google::Cloud::Vision::ProductSearch.new

  # A resource that represents Google Cloud Platform location.
  location_path = client.location_path project_id, location

  # Set the input configuration along with Google Cloud Storage URI
  input_config = {
    gcs_source: {
      csv_file_uri: "gs://cloud-samples-data/vision/product_search/product_sets.csv"
    }
  }

  # Import the product sets from the input URI.
  operation = client.import_product_sets(location_path, input_config)
  puts "Processing operation name: #{operation.name}"
  operation.wait_until_done!  # Waits for the operation to complete

  puts "Processing done."

  result = operation.response
  result.statuses.each_with_index do |status, index|
    puts "Status of processing line #{index} of the csv: #{status.code}"

    # Check the status of reference image
    # `0` is the code for OK in google.rpc.Code.
    if status.code == 0
      reference_image = result.reference_images[index]
      puts reference_image.uri
    else
      puts "Status code not OK: #{status.message}"
    end
  end
end

Beim Import können unter anderem die folgenden Fehler auftreten:

  • The number of columns in the csv line should be 8: Wenn Sie keinen Begrenzungsrahmen angeben, muss die Zeile mit einem Komma enden. Beispiel:
    "gs://example-reference-images/10002-002/10002-002_B.jpg","sample-set","sample-product-123","apparel",,
  • Image not found: Der Google Cloud Storage-URI verweist auf keine Bilddatei.
  • Access denied: Bild- oder CSV-Datei haben nicht die erforderlichen Berechtigungen. Der Zugriff auf Bilddateien muss über die für die Anfrage verwendete Authentifizierungsmethode möglich sein. Wenn Sie sich mit einem API-Schlüssel authentifizieren, müssen Ihre CSV-Dateien öffentlich zugänglich sein.

Indexierung

Der Index für die Produktsuche wird alle 30 Minuten aktualisiert. Wenn Bilder hinzugefügt oder gelöscht werden, spiegelt sich die Änderung erst nach der nächsten Aktualisierung des Index in den Antworten der Produktsuche wider.

Überprüfen Sie das Feld indexTime einer Produktgruppe, um sicherzustellen, dass die Indexierung erfolgreich abgeschlossen wurde.

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

Produktsuche der Cloud Vision API