class Google::Cloud::Vision::V1::ImageAnnotator::Client

Client for the ImageAnnotator service.

Service that performs Google Cloud Vision API detection tasks over client images, such as face, landmark, logo, label, and text detection. The ImageAnnotator service returns detected entities from the images.

Attributes

image_annotator_stub[R]

@private

operations_client[R]

Get the associated client for long-running operations.

@return [::Google::Cloud::Vision::V1::ImageAnnotator::Operations]

Public Class Methods

configure() { |configure| ... } click to toggle source

Configure the ImageAnnotator Client class.

See {::Google::Cloud::Vision::V1::ImageAnnotator::Client::Configuration} for a description of the configuration fields.

@example

# Modify the configuration for all ImageAnnotator clients
::Google::Cloud::Vision::V1::ImageAnnotator::Client.configure do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 58
def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "Vision", "V1"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config.rpcs.batch_annotate_images.timeout = 600.0
    default_config.rpcs.batch_annotate_images.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.batch_annotate_files.timeout = 600.0
    default_config.rpcs.batch_annotate_files.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.async_batch_annotate_images.timeout = 600.0
    default_config.rpcs.async_batch_annotate_images.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.async_batch_annotate_files.timeout = 600.0
    default_config.rpcs.async_batch_annotate_files.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config
  end
  yield @configure if block_given?
  @configure
end
new() { |config| ... } click to toggle source

Create a new ImageAnnotator client object.

@example

# Create a client using the default configuration
client = ::Google::Cloud::Vision::V1::ImageAnnotator::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::Vision::V1::ImageAnnotator::Client.new do |config|
  config.timeout = 10.0
end

@yield [config] Configure the ImageAnnotator client. @yieldparam config [Client::Configuration]

# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 131
def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/cloud/vision/v1/image_annotator_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&
                           !@config.endpoint.split(".").first.include?("-")
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @operations_client = Operations.new do |config|
    config.credentials = credentials
    config.endpoint = @config.endpoint
  end

  @image_annotator_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::Vision::V1::ImageAnnotator::Stub,
    credentials:  credentials,
    endpoint:     @config.endpoint,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors
  )
end

Public Instance Methods

async_batch_annotate_files(request, options = nil) { |response, operation| ... } click to toggle source

Run asynchronous image detection and annotation for a list of generic files, such as PDF files, which may contain multiple pages and multiple images per page. Progress and results can be retrieved through the `google.longrunning.Operations` interface. `Operation.metadata` contains `OperationMetadata` (metadata). `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results).

@overload async_batch_annotate_files(request, options = nil)

Pass arguments to `async_batch_annotate_files` via a request object, either of type
{::Google::Cloud::Vision::V1::AsyncBatchAnnotateFilesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Vision::V1::AsyncBatchAnnotateFilesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload async_batch_annotate_files(requests: nil, parent: nil)

Pass arguments to `async_batch_annotate_files` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param requests [::Array<::Google::Cloud::Vision::V1::AsyncAnnotateFileRequest, ::Hash>]
  Required. Individual async file annotation requests for this batch.
@param parent [::String]
  Optional. Target project and location to make a call.

  Format: `projects/{project-id}/locations/{location-id}`.

  If no parent is specified, a region will be chosen automatically.

  Supported location-ids:
      `us`: USA country only,
      `asia`: East asia areas, like Japan, Taiwan,
      `eu`: The European Union.

  Example: `projects/project-A/locations/eu`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

@example Basic example

require "google/cloud/vision/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::Vision::V1::AsyncBatchAnnotateFilesRequest.new

# Call the async_batch_annotate_files method.
result = client.async_batch_annotate_files request

# The returned object is of type Gapic::Operation. You can use this
# object to check the status of an operation, cancel it, or wait
# for results. Here is how to block until completion:
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "Error!"
end
# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 545
def async_batch_annotate_files request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Vision::V1::AsyncBatchAnnotateFilesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.async_batch_annotate_files.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Vision::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  options.apply_defaults timeout:      @config.rpcs.async_batch_annotate_files.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.async_batch_annotate_files.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @image_annotator_stub.call_rpc :async_batch_annotate_files, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
async_batch_annotate_images(request, options = nil) { |response, operation| ... } click to toggle source

Run asynchronous image detection and annotation for a list of images.

Progress and results can be retrieved through the `google.longrunning.Operations` interface. `Operation.metadata` contains `OperationMetadata` (metadata). `Operation.response` contains `AsyncBatchAnnotateImagesResponse` (results).

This service will write image annotation outputs to json files in customer GCS bucket, each json file containing BatchAnnotateImagesResponse proto.

@overload async_batch_annotate_images(request, options = nil)

Pass arguments to `async_batch_annotate_images` via a request object, either of type
{::Google::Cloud::Vision::V1::AsyncBatchAnnotateImagesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Vision::V1::AsyncBatchAnnotateImagesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload async_batch_annotate_images(requests: nil, output_config: nil, parent: nil)

Pass arguments to `async_batch_annotate_images` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param requests [::Array<::Google::Cloud::Vision::V1::AnnotateImageRequest, ::Hash>]
  Required. Individual image annotation requests for this batch.
@param output_config [::Google::Cloud::Vision::V1::OutputConfig, ::Hash]
  Required. The desired output location and metadata (e.g. format).
@param parent [::String]
  Optional. Target project and location to make a call.

  Format: `projects/{project-id}/locations/{location-id}`.

  If no parent is specified, a region will be chosen automatically.

  Supported location-ids:
      `us`: USA country only,
      `asia`: East asia areas, like Japan, Taiwan,
      `eu`: The European Union.

  Example: `projects/project-A/locations/eu`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

@example Basic example

require "google/cloud/vision/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::Vision::V1::AsyncBatchAnnotateImagesRequest.new

# Call the async_batch_annotate_images method.
result = client.async_batch_annotate_images request

# The returned object is of type Gapic::Operation. You can use this
# object to check the status of an operation, cancel it, or wait
# for results. Here is how to block until completion:
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "Error!"
end
# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 442
def async_batch_annotate_images request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Vision::V1::AsyncBatchAnnotateImagesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.async_batch_annotate_images.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Vision::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  options.apply_defaults timeout:      @config.rpcs.async_batch_annotate_images.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.async_batch_annotate_images.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @image_annotator_stub.call_rpc :async_batch_annotate_images, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
batch_annotate_files(request, options = nil) { |response, operation| ... } click to toggle source

Service that performs image detection and annotation for a batch of files. Now only “application/pdf”, “image/tiff” and “image/gif” are supported.

This service will extract at most 5 (customers can specify which 5 in AnnotateFileRequest.pages) frames (gif) or pages (pdf or tiff) from each file provided and perform detection and annotation for each image extracted.

@overload batch_annotate_files(request, options = nil)

Pass arguments to `batch_annotate_files` via a request object, either of type
{::Google::Cloud::Vision::V1::BatchAnnotateFilesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Vision::V1::BatchAnnotateFilesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload batch_annotate_files(requests: nil, parent: nil)

Pass arguments to `batch_annotate_files` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param requests [::Array<::Google::Cloud::Vision::V1::AnnotateFileRequest, ::Hash>]
  Required. The list of file annotation requests. Right now we support only
  one AnnotateFileRequest in BatchAnnotateFilesRequest.
@param parent [::String]
  Optional. Target project and location to make a call.

  Format: `projects/{project-id}/locations/{location-id}`.

  If no parent is specified, a region will be chosen automatically.

  Supported location-ids:
      `us`: USA country only,
      `asia`: East asia areas, like Japan, Taiwan,
      `eu`: The European Union.

  Example: `projects/project-A/locations/eu`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Vision::V1::BatchAnnotateFilesResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Vision::V1::BatchAnnotateFilesResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

@example Basic example

require "google/cloud/vision/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::Vision::V1::BatchAnnotateFilesRequest.new

# Call the batch_annotate_files method.
result = client.batch_annotate_files request

# The returned object is of type Google::Cloud::Vision::V1::BatchAnnotateFilesResponse.
p result
# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 335
def batch_annotate_files request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Vision::V1::BatchAnnotateFilesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.batch_annotate_files.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Vision::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  options.apply_defaults timeout:      @config.rpcs.batch_annotate_files.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.batch_annotate_files.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @image_annotator_stub.call_rpc :batch_annotate_files, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
batch_annotate_images(request, options = nil) { |response, operation| ... } click to toggle source

Run image detection and annotation for a batch of images.

@overload batch_annotate_images(request, options = nil)

Pass arguments to `batch_annotate_images` via a request object, either of type
{::Google::Cloud::Vision::V1::BatchAnnotateImagesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Vision::V1::BatchAnnotateImagesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload batch_annotate_images(requests: nil, parent: nil)

Pass arguments to `batch_annotate_images` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param requests [::Array<::Google::Cloud::Vision::V1::AnnotateImageRequest, ::Hash>]
  Required. Individual image annotation requests for this batch.
@param parent [::String]
  Optional. Target project and location to make a call.

  Format: `projects/{project-id}/locations/{location-id}`.

  If no parent is specified, a region will be chosen automatically.

  Supported location-ids:
      `us`: USA country only,
      `asia`: East asia areas, like Japan, Taiwan,
      `eu`: The European Union.

  Example: `projects/project-A/locations/eu`.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Vision::V1::BatchAnnotateImagesResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

@example Basic example

require "google/cloud/vision/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::Vision::V1::BatchAnnotateImagesRequest.new

# Call the batch_annotate_images method.
result = client.batch_annotate_images request

# The returned object is of type Google::Cloud::Vision::V1::BatchAnnotateImagesResponse.
p result
# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 238
def batch_annotate_images request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Vision::V1::BatchAnnotateImagesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.batch_annotate_images.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Vision::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  options.apply_defaults timeout:      @config.rpcs.batch_annotate_images.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.batch_annotate_images.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @image_annotator_stub.call_rpc :batch_annotate_images, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
configure() { |config| ... } click to toggle source

Configure the ImageAnnotator Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on {Client.configure}.

See {::Google::Cloud::Vision::V1::ImageAnnotator::Client::Configuration} for a description of the configuration fields.

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/vision/v1/image_annotator/client.rb, line 110
def configure
  yield @config if block_given?
  @config
end
crop_hints_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type CROP_HINTS.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.crop_hints_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 73
def crop_hints_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :CROP_HINTS, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
document_text_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type DOCUMENT_TEXT_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.document_text_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 171
def document_text_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :DOCUMENT_TEXT_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
face_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type FACE_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.face_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 269
def face_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :FACE_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
image_properties_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type IMAGE_PROPERTIES.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.image_properties_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 367
def image_properties_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :IMAGE_PROPERTIES, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
label_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type LABEL_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.label_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 465
def label_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :LABEL_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
landmark_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type LANDMARK_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.landmark_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 563
def landmark_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :LANDMARK_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
logo_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type LOGO_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.logo_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 661
def logo_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :LOGO_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
object_localization_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type OBJECT_LOCALIZATION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.object_localization_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 759
def object_localization_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :OBJECT_LOCALIZATION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
product_search_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type PRODUCT_SEARCH.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.product_search_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 857
def product_search_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :PRODUCT_SEARCH, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
safe_search_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type SAFE_SEARCH_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.safe_search_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 955
def safe_search_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :SAFE_SEARCH_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
text_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type TEXT_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.text_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 1053
def text_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :TEXT_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end
web_detection(\ images: [], image: nil, max_results: 10, options: nil, async: false, mime_type: nil, batch_size: 10, destination: nil, image_context: nil, &block) click to toggle source

Detect features of type WEB_DETECTION.

@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 [Gapic::CallOptions]

Optional. Overrides the default settings for this call, e.g,
timeout, retries, etc.

@param async [Boolean]

Optional. Defaults to `false`. If `false`, performs the request
synchronously, returning a `BatchAnnotateImagesResponse`. If `true`,
performs the request asynchronously, returning a `Gapic::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]

A Google Cloud Storage location for storing the output. Required
only if async is `true`.

@param image_context [Hash]

Optional. Image context and/or feature-specific parameters.

@yield [result, operation] Access the result along with the RPC operation @yieldparam result [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse, Gapic::Operation] @yieldparam operation [GRPC::ActiveCall::Operation]

@return [Google::Cloud::Vision::V1::BatchAnnotateImagesResponse] if async is `false`. @return [Gapic::Operation] if async is `true`.

@raise [Google::Cloud::Error] if the RPC is aborted.

@example

require "google/cloud/vision/v1"

image_annotator_client = Google::Cloud::Vision::V1::ImageAnnotator::Client.new

response = image_annotator_client.web_detection image: "path/to/image.png"
response.responses.each do |res|
  puts res
end
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 1151
def web_detection \
    images: [],
    image: nil,
    max_results: 10,
    options: nil,
    async: false,
    mime_type: nil,
    batch_size: 10,
    destination: nil,
    image_context: nil,
    &block

  feature = { type: :WEB_DETECTION, 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|
    request = { image: img, features: [feature] }
    request[:image_context] = image_context if image_context
    request
  end
  batch_request = { requests: requests }

  if async
    requests.map! do |request|
      {
        input_config:  {
          gcs_source: {
            uri: request[:image][:source][:gcs_image_uri]
          },
          mime_type:  mime_type
        },
        features:      request[:features],
        output_config: {
          gcs_destination: {
            uri: destination
          },
          batch_size:      batch_size
        }
      }
    end
    async_batch_annotate_files batch_request, options, &block
  else
    batch_annotate_images batch_request, options, &block
  end
end

Private Instance Methods

normalize_image(image) click to toggle source
# File lib/google/cloud/vision/v1/image_annotator/helpers.rb, line 1203
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, "Image must be a filepath, url, or IO object" unless formatted_image
  formatted_image
end