Batch image annotation offline

importcom.google.cloud.vision.v1.AnnotateImageRequest ;
importcom.google.cloud.vision.v1.AsyncBatchAnnotateImagesRequest ;
importcom.google.cloud.vision.v1.AsyncBatchAnnotateImagesResponse ;
importcom.google.cloud.vision.v1.Feature ;
importcom.google.cloud.vision.v1.GcsDestination ;
importcom.google.cloud.vision.v1.Image ;
importcom.google.cloud.vision.v1.ImageAnnotatorClient ;
importcom.google.cloud.vision.v1.ImageSource ;
importcom.google.cloud.vision.v1.OutputConfig ;
importjava.io.IOException;
importjava.util.concurrent.ExecutionException;
publicclass AsyncBatchAnnotateImages{
publicstaticvoidasyncBatchAnnotateImages()
throwsInterruptedException,ExecutionException,IOException{
StringinputImageUri="gs://cloud-samples-data/vision/label/wakeupcat.jpg";
StringoutputUri="gs://YOUR_BUCKET_ID/path/to/save/results/";
asyncBatchAnnotateImages(inputImageUri,outputUri);
}
publicstaticvoidasyncBatchAnnotateImages(StringinputImageUri,StringoutputUri)
throwsIOException,ExecutionException,InterruptedException{
// 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 imageAnnotatorClient=ImageAnnotatorClient .create()){
// You can send multiple images to be annotated, this sample demonstrates how to do this with
// one image. If you want to use multiple images, you have to create a `AnnotateImageRequest`
// object for each image that you want annotated.
// First specify where the vision api can find the image
ImageSource source=ImageSource .newBuilder().setImageUri (inputImageUri).build();
Image image=Image .newBuilder().setSource (source).build();
// Set the type of annotation you want to perform on the image
// https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type
Feature feature=Feature .newBuilder().setType(Feature .Type.LABEL_DETECTION).build();
// Build the request object for that one image. Note: for additional images you have to create
// additional `AnnotateImageRequest` objects and store them in a list to be used below.
AnnotateImageRequest imageRequest=
AnnotateImageRequest .newBuilder().setImage(image).addFeatures(feature).build();
// Set where to store the results for the images that will be annotated.
GcsDestination gcsDestination=GcsDestination .newBuilder().setUri(outputUri).build();
OutputConfig outputConfig=
OutputConfig .newBuilder()
.setGcsDestination (gcsDestination)
.setBatchSize (2)// The max number of responses to output in each JSON file
.build();
// Add each `AnnotateImageRequest` object to the batch request and add the output config.
AsyncBatchAnnotateImagesRequest request=
AsyncBatchAnnotateImagesRequest .newBuilder()
.addRequests(imageRequest)
.setOutputConfig(outputConfig)
.build();
// Make the asynchronous batch request.
AsyncBatchAnnotateImagesResponse response=
imageAnnotatorClient.asyncBatchAnnotateImagesAsync (request).get();
// The output is written to GCS with the provided output_uri as prefix
StringgcsOutputUri=response.getOutputConfig ().getGcsDestination().getUri();
System.out.format("Output written to GCS with prefix: %s%n",gcsOutputUri);
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const inputImageUri = 'gs://cloud-samples-data/vision/label/wakeupcat.jpg';
// const outputUri = 'gs://YOUR_BUCKET_ID/path/to/save/results/';
// Imports the Google Cloud client libraries
const{ImageAnnotatorClient}=require('@google-cloud/vision').v1;
// Instantiates a client
constclient=newImageAnnotatorClient ();
// You can send multiple images to be annotated, this sample demonstrates how to do this with
// one image. If you want to use multiple images, you have to create a request object for each image that you want annotated.
asyncfunctionasyncBatchAnnotateImages(){
// Set the type of annotation you want to perform on the image
// https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type
constfeatures=[{type:'LABEL_DETECTION'}];
// Build the image request object for that one image. Note: for additional images you have to create
// additional image request objects and store them in a list to be used below.
constimageRequest={
image:{
source:{
imageUri:inputImageUri,
},
},
features:features,
};
// Set where to store the results for the images that will be annotated.
constoutputConfig={
gcsDestination:{
uri:outputUri,
},
batchSize:2,// The max number of responses to output in each JSON file
};
// Add each image request object to the batch request and add the output config.
constrequest={
requests:[
imageRequest,// add additional request objects here
],
outputConfig,
};
// Make the asynchronous batch request.
const[operation]=awaitclient.asyncBatchAnnotateImages(request);
// Wait for the operation to complete
const[filesResponse]=awaitoperation.promise();
// The output is written to GCS with the provided output_uri as prefix
constdestinationUri=filesResponse.outputConfig.gcsDestination.uri;
console.log(`Output written to GCS with prefix: ${destinationUri}`);
}
asyncBatchAnnotateImages();

fromgoogle.cloudimport vision_v1
defsample_async_batch_annotate_images(
 input_image_uri="gs://cloud-samples-data/vision/label/wakeupcat.jpg",
 output_uri="gs://your-bucket/prefix/",
):
"""Perform async batch image annotation."""
 client = vision_v1 .ImageAnnotatorClient ()
 source = {"image_uri": input_image_uri}
 image = {"source": source}
 features = [
 {"type_": vision_v1 .Feature .Type.LABEL_DETECTION},
 {"type_": vision_v1 .Feature .Type.IMAGE_PROPERTIES},
 ]
 # Each requests element corresponds to a single image. To annotate more
 # images, create a request element for each image and add it to
 # the array of requests
 requests = [{"image": image, "features": features}]
 gcs_destination = {"uri": output_uri}
 # The max number of responses to output in each JSON file
 batch_size = 2
 output_config = {"gcs_destination": gcs_destination, "batch_size": batch_size}
 operation = client.async_batch_annotate_images (
 requests=requests, output_config=output_config
 )
 print("Waiting for operation to complete...")
 response = operation.result(90)
 # The output is written to GCS with the provided output_uri as prefix
 gcs_output_uri = response.output_config.gcs_destination.uri
 print(f"Output written to GCS with prefix: {gcs_output_uri}")