google-cloud-vision 0.31.0 → 0.32.0

data/lib/google/cloud/vision/v1p3beta1/doc/google/rpc/status.rb

@@ -0,0 +1,84 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Rpc
+    # The `Status` type defines a logical error model that is suitable for different
+    # programming environments, including REST APIs and RPC APIs. It is used by
+    # [gRPC](https://github.com/grpc). The error model is designed to be:
+    #
+    # * Simple to use and understand for most users
+    # * Flexible enough to meet unexpected needs
+    #
+    # = Overview
+    #
+    # The `Status` message contains three pieces of data: error code, error message,
+    # and error details. The error code should be an enum value of
+    # {Google::Rpc::Code}, but it may accept additional error codes if needed.  The
+    # error message should be a developer-facing English message that helps
+    # developers *understand* and *resolve* the error. If a localized user-facing
+    # error message is needed, put the localized message in the error details or
+    # localize it in the client. The optional error details may contain arbitrary
+    # information about the error. There is a predefined set of error detail types
+    # in the package `google.rpc` that can be used for common error conditions.
+    #
+    # = Language mapping
+    #
+    # The `Status` message is the logical representation of the error model, but it
+    # is not necessarily the actual wire format. When the `Status` message is
+    # exposed in different client libraries and different wire protocols, it can be
+    # mapped differently. For example, it will likely be mapped to some exceptions
+    # in Java, but more likely mapped to some error codes in C.
+    #
+    # = Other uses
+    #
+    # The error model and the `Status` message can be used in a variety of
+    # environments, either with or without APIs, to provide a
+    # consistent developer experience across different environments.
+    #
+    # Example uses of this error model include:
+    #
+    # * Partial errors. If a service needs to return partial errors to the client,
+    #   it may embed the `Status` in the normal response to indicate the partial
+    #   errors.
+    #
+    # * Workflow errors. A typical workflow has multiple steps. Each step may
+    #   have a `Status` message for error reporting.
+    #
+    # * Batch operations. If a client uses batch request and batch response, the
+    #   `Status` message should be used directly inside batch response, one for
+    #   each error sub-response.
+    #
+    # * Asynchronous operations. If an API call embeds asynchronous operation
+    #   results in its response, the status of those operations should be
+    #   represented directly using the `Status` message.
+    #
+    # * Logging. If some API errors are stored in logs, the message `Status` could
+    #   be used directly after any stripping needed for security/privacy reasons.
+    # @!attribute [rw] code
+    #   @return [Integer]
+    #     The status code, which should be an enum value of {Google::Rpc::Code}.
+    # @!attribute [rw] message
+    #   @return [String]
+    #     A developer-facing error message, which should be in English. Any
+    #     user-facing error message should be localized and sent in the
+    #     {Google::Rpc::Status#details} field, or localized by the client.
+    # @!attribute [rw] details
+    #   @return [Array<Google::Protobuf::Any>]
+    #     A list of messages that carry the error details.  There is a common set of
+    #     message types for APIs to use.
+    class Status; end
+  end
+end

data/lib/google/cloud/vision/v1p3beta1/doc/google/type/color.rb

@@ -0,0 +1,156 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Type
+    # Represents a color in the RGBA color space. This representation is designed
+    # for simplicity of conversion to/from color representations in various
+    # languages over compactness; for example, the fields of this representation
+    # can be trivially provided to the constructor of "java.awt.Color" in Java; it
+    # can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha"
+    # method in iOS; and, with just a little work, it can be easily formatted into
+    # a CSS "rgba()" string in JavaScript, as well. Here are some examples:
+    #
+    # Example (Java):
+    #
+    #      import com.google.type.Color;
+    #
+    #      // ...
+    #      public static java.awt.Color fromProto(Color protocolor) {
+    #        float alpha = protocolor.hasAlpha()
+    #            ? protocolor.getAlpha().getValue()
+    #            : 1.0;
+    #
+    #        return new java.awt.Color(
+    #            protocolor.getRed(),
+    #            protocolor.getGreen(),
+    #            protocolor.getBlue(),
+    #            alpha);
+    #      }
+    #
+    #      public static Color toProto(java.awt.Color color) {
+    #        float red = (float) color.getRed();
+    #        float green = (float) color.getGreen();
+    #        float blue = (float) color.getBlue();
+    #        float denominator = 255.0;
+    #        Color.Builder resultBuilder =
+    #            Color
+    #                .newBuilder()
+    #                .setRed(red / denominator)
+    #                .setGreen(green / denominator)
+    #                .setBlue(blue / denominator);
+    #        int alpha = color.getAlpha();
+    #        if (alpha != 255) {
+    #          result.setAlpha(
+    #              FloatValue
+    #                  .newBuilder()
+    #                  .setValue(((float) alpha) / denominator)
+    #                  .build());
+    #        }
+    #        return resultBuilder.build();
+    #      }
+    #      // ...
+    #
+    # Example (iOS / Obj-C):
+    #
+    #      // ...
+    #      static UIColor* fromProto(Color* protocolor) {
+    #         float red = [protocolor red];
+    #         float green = [protocolor green];
+    #         float blue = [protocolor blue];
+    #         FloatValue* alpha_wrapper = [protocolor alpha];
+    #         float alpha = 1.0;
+    #         if (alpha_wrapper != nil) {
+    #           alpha = [alpha_wrapper value];
+    #         }
+    #         return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
+    #      }
+    #
+    #      static Color* toProto(UIColor* color) {
+    #          CGFloat red, green, blue, alpha;
+    #          if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
+    #            return nil;
+    #          }
+    #          Color* result = [Color alloc] init];
+    #          [result setRed:red];
+    #          [result setGreen:green];
+    #          [result setBlue:blue];
+    #          if (alpha <= 0.9999) {
+    #            [result setAlpha:floatWrapperWithValue(alpha)];
+    #          }
+    #          [result autorelease];
+    #          return result;
+    #     }
+    #     // ...
+    #
+    #  Example (JavaScript):
+    #
+    #     // ...
+    #
+    #     var protoToCssColor = function(rgb_color) {
+    #        var redFrac = rgb_color.red || 0.0;
+    #        var greenFrac = rgb_color.green || 0.0;
+    #        var blueFrac = rgb_color.blue || 0.0;
+    #        var red = Math.floor(redFrac * 255);
+    #        var green = Math.floor(greenFrac * 255);
+    #        var blue = Math.floor(blueFrac * 255);
+    #
+    #        if (!('alpha' in rgb_color)) {
+    #           return rgbToCssColor_(red, green, blue);
+    #        }
+    #
+    #        var alphaFrac = rgb_color.alpha.value || 0.0;
+    #        var rgbParams = [red, green, blue].join(',');
+    #        return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
+    #     };
+    #
+    #     var rgbToCssColor_ = function(red, green, blue) {
+    #       var rgbNumber = new Number((red << 16) | (green << 8) | blue);
+    #       var hexString = rgbNumber.toString(16);
+    #       var missingZeros = 6 - hexString.length;
+    #       var resultBuilder = ['#'];
+    #       for (var i = 0; i < missingZeros; i++) {
+    #          resultBuilder.push('0');
+    #       }
+    #       resultBuilder.push(hexString);
+    #       return resultBuilder.join('');
+    #     };
+    #
+    #     // ...
+    # @!attribute [rw] red
+    #   @return [Float]
+    #     The amount of red in the color as a value in the interval [0, 1].
+    # @!attribute [rw] green
+    #   @return [Float]
+    #     The amount of green in the color as a value in the interval [0, 1].
+    # @!attribute [rw] blue
+    #   @return [Float]
+    #     The amount of blue in the color as a value in the interval [0, 1].
+    # @!attribute [rw] alpha
+    #   @return [Google::Protobuf::FloatValue]
+    #     The fraction of this color that should be applied to the pixel. That is,
+    #     the final pixel color is defined by the equation:
+    #
+    #       pixel color = alpha * (this color) + (1.0 - alpha) * (background color)
+    #
+    #     This means that a value of 1.0 corresponds to a solid color, whereas
+    #     a value of 0.0 corresponds to a completely transparent color. This
+    #     uses a wrapper message rather than a simple float scalar so that it is
+    #     possible to distinguish between a default value and the value being unset.
+    #     If omitted, this color object is to be rendered as a solid color
+    #     (as if the alpha value had been explicitly given with a value of 1.0).
+    class Color; end
+  end
+end

data/lib/google/cloud/vision/v1p3beta1/doc/google/type/latlng.rb

@@ -0,0 +1,65 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Type
+    # An object representing a latitude/longitude pair. This is expressed as a pair
+    # of doubles representing degrees latitude and degrees longitude. Unless
+    # specified otherwise, this must conform to the
+    # <a href="http://www.unoosa.org/pdf/icg/2012/template/WGS_84.pdf">WGS84
+    # standard</a>. Values must be within normalized ranges.
+    #
+    # Example of normalization code in Python:
+    #
+    #     def NormalizeLongitude(longitude):
+    #       """Wraps decimal degrees longitude to [-180.0, 180.0]."""
+    #       q, r = divmod(longitude, 360.0)
+    #       if r > 180.0 or (r == 180.0 and q <= -1.0):
+    #         return r - 360.0
+    #       return r
+    #
+    #     def NormalizeLatLng(latitude, longitude):
+    #       """Wraps decimal degrees latitude and longitude to
+    #       [-90.0, 90.0] and [-180.0, 180.0], respectively."""
+    #       r = latitude % 360.0
+    #       if r <= 90.0:
+    #         return r, NormalizeLongitude(longitude)
+    #       elif r >= 270.0:
+    #         return r - 360, NormalizeLongitude(longitude)
+    #       else:
+    #         return 180 - r, NormalizeLongitude(longitude + 180.0)
+    #
+    #     assert 180.0 == NormalizeLongitude(180.0)
+    #     assert -180.0 == NormalizeLongitude(-180.0)
+    #     assert -179.0 == NormalizeLongitude(181.0)
+    #     assert (0.0, 0.0) == NormalizeLatLng(360.0, 0.0)
+    #     assert (0.0, 0.0) == NormalizeLatLng(-360.0, 0.0)
+    #     assert (85.0, 180.0) == NormalizeLatLng(95.0, 0.0)
+    #     assert (-85.0, -170.0) == NormalizeLatLng(-95.0, 10.0)
+    #     assert (90.0, 10.0) == NormalizeLatLng(90.0, 10.0)
+    #     assert (-90.0, -10.0) == NormalizeLatLng(-90.0, -10.0)
+    #     assert (0.0, -170.0) == NormalizeLatLng(-180.0, 10.0)
+    #     assert (0.0, -170.0) == NormalizeLatLng(180.0, 10.0)
+    #     assert (-90.0, 10.0) == NormalizeLatLng(270.0, 10.0)
+    #     assert (90.0, 10.0) == NormalizeLatLng(-270.0, 10.0)
+    # @!attribute [rw] latitude
+    #   @return [Float]
+    #     The latitude in degrees. It must be in the range [-90.0, +90.0].
+    # @!attribute [rw] longitude
+    #   @return [Float]
+    #     The longitude in degrees. It must be in the range [-180.0, +180.0].
+    class LatLng; end
+  end
+end

data/lib/google/cloud/vision/v1p3beta1/geometry_pb.rb

@@ -0,0 +1,43 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: google/cloud/vision/v1p3beta1/geometry.proto
+
+
+require 'google/protobuf'
+
+require 'google/api/annotations_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "google.cloud.vision.v1p3beta1.Vertex" do
+    optional :x, :int32, 1
+    optional :y, :int32, 2
+  end
+  add_message "google.cloud.vision.v1p3beta1.NormalizedVertex" do
+    optional :x, :float, 1
+    optional :y, :float, 2
+  end
+  add_message "google.cloud.vision.v1p3beta1.BoundingPoly" do
+    repeated :vertices, :message, 1, "google.cloud.vision.v1p3beta1.Vertex"
+    repeated :normalized_vertices, :message, 2, "google.cloud.vision.v1p3beta1.NormalizedVertex"
+  end
+  add_message "google.cloud.vision.v1p3beta1.NormalizedBoundingPoly" do
+    repeated :vertices, :message, 1, "google.cloud.vision.v1p3beta1.NormalizedVertex"
+  end
+  add_message "google.cloud.vision.v1p3beta1.Position" do
+    optional :x, :float, 1
+    optional :y, :float, 2
+    optional :z, :float, 3
+  end
+end
+
+module Google
+  module Cloud
+    module Vision
+      module V1p3beta1
+        Vertex = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.cloud.vision.v1p3beta1.Vertex").msgclass
+        NormalizedVertex = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.cloud.vision.v1p3beta1.NormalizedVertex").msgclass
+        BoundingPoly = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.cloud.vision.v1p3beta1.BoundingPoly").msgclass
+        NormalizedBoundingPoly = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.cloud.vision.v1p3beta1.NormalizedBoundingPoly").msgclass
+        Position = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.cloud.vision.v1p3beta1.Position").msgclass
+      end
+    end
+  end
+end

data/lib/google/cloud/vision/v1p3beta1/helpers.rb

@@ -0,0 +1,972 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# # limitations under the License.
+
+
+require "uri"
+
+module Google
+  module Cloud
+    module Vision
+      module V1p3beta1
+        class ImageAnnotatorClient
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.face_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def face_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :FACE_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.landmark_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def landmark_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :LANDMARK_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.logo_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def logo_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :LOGO_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.label_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def label_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :LABEL_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.text_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def text_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :TEXT_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.document_text_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def document_text_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :DOCUMENT_TEXT_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.safe_search_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def safe_search_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :SAFE_SEARCH_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.image_properties_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def image_properties_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :IMAGE_PROPERTIES }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.crop_hints_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def crop_hints_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :CROP_HINTS }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.product_search_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def product_search_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :PRODUCT_SEARCH }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.object_localization_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def object_localization_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :OBJECT_LOCALIZATION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          # @param images [Array<String>, Array<File>]
+          #   An array containing files, file paths, io objects, image urls, or Google Cloud Storage urls. Can be used with or instead of image.
+          # @param image [File, String]
+          #   A file, file path, io object, url pointing to an image, or Google Cloud Storage url. Can be used with or instead of images.
+          # @param max_results [Integer]
+          #   Optional. Defaults to 10.
+          # @param options [Google::Gax::CallOptions]
+          #   Optional. Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @param async [Boolean]
+          #   Optional. Defaults to false. Specifies whether to preform the request synchronously and return a 
+          #   BatchAnnotateImagesResponse instance or to return a Google::Gax::Operation.
+          # @param mime_type [String]
+          #   Required only if async is true.
+          # @param batch_size [Integer]
+          #   Optional. Defaults to 10. When async is true, this specifies the number of input files per output json.
+          # @param destination [String]
+          #   Required only if async is true. A Google Cloud Storage location for storing the output.
+          # @yield [result, operation] Access the result along with the RPC operation
+          # @yieldparam result [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse]
+          # @yieldparam operation [GRPC::ActiveCall::Operation]
+          # @return [Google::Cloud::Vision::V1p3beta1::BatchAnnotateImagesResponse, Google::Gax::Operation]
+          # @example
+          #   require "google/cloud/vision"
+          #
+          #   image_annotator_client = Google::Cloud::Vision::ImageAnnotator.new(version: :v1p3beta1)
+          #
+          #   response = image_annotator_client.web_detection image: "path\to\image.png"
+          #   response.responses.each do |res|
+          #     puts res
+          #   end
+
+          def web_detection \
+            images: [], 
+            image: nil,
+            max_results: 10,
+            options: nil,
+            async: false,
+            mime_type: nil,
+            batch_size: 10,
+            destination: nil,
+            &blk
+
+            feature = { type: :WEB_DETECTION }
+            feature[:max_results] = max_results
+            images << image if image
+
+            formatted_images = images.map do |img|
+              formatted_image = normalize_image img
+              formatted_image[:mime_type] = mime_type if mime_type
+              formatted_image
+            end
+
+            requests = formatted_images.map do |img|
+              {
+                image: img,
+                features: [feature]
+              }
+            end
+
+            if async
+              requests.map! do |request|
+                {
+                  input_config: request[:image],
+                  features: request[:features],
+                  output_config: {
+                    gcs_destination: destination,
+                    batch_size: batch_size
+                  }
+                }
+              end
+              async_batch_annotate_files requests, options
+            else
+              batch_annotate_images requests, options, &blk
+            end
+          end
+
+          private
+
+          def normalize_image image
+            formatted_image =
+              if image.respond_to? :binmode
+                { content: image.binmode.read }
+              elsif image.is_a? String
+                if File.file? image
+                  { content: File.binread(image) }
+                elsif image =~ URI::DEFAULT_PARSER.make_regexp
+                  if URI(image).scheme == "gs"
+                    { source: { gcs_image_uri: image } }
+                  else
+                    { source: { image_uri: image } }
+                  end
+                end
+              end
+            raise TypeError.new("Image must be a filepath, url, or IO object") unless formatted_image
+            formatted_image
+          end
+        end
+      end
+    end
+  end
+end