generated/google/apis/vision_v1/classes.rb in google-api-client-0.29.1 vs generated/google/apis/vision_v1/classes.rb in google-api-client-0.29.2

- old
+ new

@@ -41,10 +41,56 @@ def update!(**args) @product = args[:product] if args.key?(:product) end end + # A request to annotate one single file, e.g. a PDF, TIFF or GIF file. + class AnnotateFileRequest + include Google::Apis::Core::Hashable + + # Required. Requested features. + # Corresponds to the JSON property `features` + # @return [Array<Google::Apis::VisionV1::Feature>] + attr_accessor :features + + # Image context and/or feature-specific parameters. + # Corresponds to the JSON property `imageContext` + # @return [Google::Apis::VisionV1::ImageContext] + attr_accessor :image_context + + # The desired input location and metadata. + # Corresponds to the JSON property `inputConfig` + # @return [Google::Apis::VisionV1::InputConfig] + attr_accessor :input_config + + # Pages of the file to perform image annotation. + # Pages starts from 1, we assume the first page of the file is page 1. + # At most 5 pages are supported per request. Pages can be negative. + # Page 1 means the first page. + # Page 2 means the second page. + # Page -1 means the last page. + # Page -2 means the second to the last page. + # If the file is GIF instead of PDF or TIFF, page refers to GIF frames. + # If this field is empty, by default the service performs image annotation + # for the first 5 pages of the file. + # Corresponds to the JSON property `pages` + # @return [Array<Fixnum>] + attr_accessor :pages + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @features = args[:features] if args.key?(:features) + @image_context = args[:image_context] if args.key?(:image_context) + @input_config = args[:input_config] if args.key?(:input_config) + @pages = args[:pages] if args.key?(:pages) + end + end + # Response to a single file annotation request. A file may contain one or more # images, which individually have their own responses. class AnnotateFileResponse include Google::Apis::Core::Hashable @@ -56,18 +102,24 @@ # Individual responses to images found within the file. # Corresponds to the JSON property `responses` # @return [Array<Google::Apis::VisionV1::AnnotateImageResponse>] attr_accessor :responses + # This field gives the total number of pages in the file. + # Corresponds to the JSON property `totalPages` + # @return [Fixnum] + attr_accessor :total_pages + def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @input_config = args[:input_config] if args.key?(:input_config) @responses = args[:responses] if args.key?(:responses) + @total_pages = args[:total_pages] if args.key?(:total_pages) end end # Request for performing Google Cloud Vision API tasks over a user-provided # image, with user-requested features, and with context information. @@ -340,10 +392,94 @@ def update!(**args) @responses = args[:responses] if args.key?(:responses) end end + # Request for async image annotation for a list of images. + class AsyncBatchAnnotateImagesRequest + include Google::Apis::Core::Hashable + + # The desired output location and metadata. + # Corresponds to the JSON property `outputConfig` + # @return [Google::Apis::VisionV1::OutputConfig] + attr_accessor :output_config + + # Individual image annotation requests for this batch. + # Corresponds to the JSON property `requests` + # @return [Array<Google::Apis::VisionV1::AnnotateImageRequest>] + attr_accessor :requests + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @output_config = args[:output_config] if args.key?(:output_config) + @requests = args[:requests] if args.key?(:requests) + end + end + + # Response to an async batch image annotation request. + class AsyncBatchAnnotateImagesResponse + include Google::Apis::Core::Hashable + + # The desired output location and metadata. + # Corresponds to the JSON property `outputConfig` + # @return [Google::Apis::VisionV1::OutputConfig] + attr_accessor :output_config + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @output_config = args[:output_config] if args.key?(:output_config) + end + end + + # A list of requests to annotate files using the BatchAnnotateFiles API. + class BatchAnnotateFilesRequest + include Google::Apis::Core::Hashable + + # The list of file annotation requests. Right now we support only one + # AnnotateFileRequest in BatchAnnotateFilesRequest. + # Corresponds to the JSON property `requests` + # @return [Array<Google::Apis::VisionV1::AnnotateFileRequest>] + attr_accessor :requests + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @requests = args[:requests] if args.key?(:requests) + end + end + + # A list of file annotation responses. + class BatchAnnotateFilesResponse + include Google::Apis::Core::Hashable + + # The list of file annotation responses, each response corresponding to each + # AnnotateFileRequest in BatchAnnotateFilesRequest. + # Corresponds to the JSON property `responses` + # @return [Array<Google::Apis::VisionV1::AnnotateFileResponse>] + attr_accessor :responses + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @responses = args[:responses] if args.key?(:responses) + end + end + # Multiple image annotation requests are batched into a single service call. class BatchAnnotateImagesRequest include Google::Apis::Core::Hashable # Individual image annotation requests for this batch. @@ -1239,18 +1375,24 @@ # Individual responses to images found within the file. # Corresponds to the JSON property `responses` # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p1beta1AnnotateImageResponse>] attr_accessor :responses + # This field gives the total number of pages in the file. + # Corresponds to the JSON property `totalPages` + # @return [Fixnum] + attr_accessor :total_pages + def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @input_config = args[:input_config] if args.key?(:input_config) @responses = args[:responses] if args.key?(:responses) + @total_pages = args[:total_pages] if args.key?(:total_pages) end end # Response to an image annotation request. class GoogleCloudVisionV1p1beta1AnnotateImageResponse @@ -2031,10 +2173,20 @@ # The desired input location and metadata. class GoogleCloudVisionV1p1beta1InputConfig include Google::Apis::Core::Hashable + # File content, represented as a stream of bytes. + # Note: As with all `bytes` fields, protobuffers use a pure binary + # representation, whereas JSON representations use base64. + # Currently, this field only works for BatchAnnotateFiles requests. It does + # not work for AsyncBatchAnnotateFiles requests. + # Corresponds to the JSON property `content` + # NOTE: Values are automatically base64 encoded/decoded in the client library. + # @return [String] + attr_accessor :content + # The Google Cloud Storage location where the input will be read from. # Corresponds to the JSON property `gcsSource` # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p1beta1GcsSource] attr_accessor :gcs_source @@ -2048,10 +2200,11 @@ update!(**args) end # Update properties of this object def update!(**args) + @content = args[:content] if args.key?(:content) @gcs_source = args[:gcs_source] if args.key?(:gcs_source) @mime_type = args[:mime_type] if args.key?(:mime_type) end end @@ -2997,18 +3150,24 @@ # Individual responses to images found within the file. # Corresponds to the JSON property `responses` # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p2beta1AnnotateImageResponse>] attr_accessor :responses + # This field gives the total number of pages in the file. + # Corresponds to the JSON property `totalPages` + # @return [Fixnum] + attr_accessor :total_pages + def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @input_config = args[:input_config] if args.key?(:input_config) @responses = args[:responses] if args.key?(:responses) + @total_pages = args[:total_pages] if args.key?(:total_pages) end end # Response to an image annotation request. class GoogleCloudVisionV1p2beta1AnnotateImageResponse @@ -3789,10 +3948,20 @@ # The desired input location and metadata. class GoogleCloudVisionV1p2beta1InputConfig include Google::Apis::Core::Hashable + # File content, represented as a stream of bytes. + # Note: As with all `bytes` fields, protobuffers use a pure binary + # representation, whereas JSON representations use base64. + # Currently, this field only works for BatchAnnotateFiles requests. It does + # not work for AsyncBatchAnnotateFiles requests. + # Corresponds to the JSON property `content` + # NOTE: Values are automatically base64 encoded/decoded in the client library. + # @return [String] + attr_accessor :content + # The Google Cloud Storage location where the input will be read from. # Corresponds to the JSON property `gcsSource` # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p2beta1GcsSource] attr_accessor :gcs_source @@ -3806,10 +3975,11 @@ update!(**args) end # Update properties of this object def update!(**args) + @content = args[:content] if args.key?(:content) @gcs_source = args[:gcs_source] if args.key?(:gcs_source) @mime_type = args[:mime_type] if args.key?(:mime_type) end end @@ -4755,18 +4925,24 @@ # Individual responses to images found within the file. # Corresponds to the JSON property `responses` # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p3beta1AnnotateImageResponse>] attr_accessor :responses + # This field gives the total number of pages in the file. + # Corresponds to the JSON property `totalPages` + # @return [Fixnum] + attr_accessor :total_pages + def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @input_config = args[:input_config] if args.key?(:input_config) @responses = args[:responses] if args.key?(:responses) + @total_pages = args[:total_pages] if args.key?(:total_pages) end end # Response to an image annotation request. class GoogleCloudVisionV1p3beta1AnnotateImageResponse @@ -5613,10 +5789,20 @@ # The desired input location and metadata. class GoogleCloudVisionV1p3beta1InputConfig include Google::Apis::Core::Hashable + # File content, represented as a stream of bytes. + # Note: As with all `bytes` fields, protobuffers use a pure binary + # representation, whereas JSON representations use base64. + # Currently, this field only works for BatchAnnotateFiles requests. It does + # not work for AsyncBatchAnnotateFiles requests. + # Corresponds to the JSON property `content` + # NOTE: Values are automatically base64 encoded/decoded in the client library. + # @return [String] + attr_accessor :content + # The Google Cloud Storage location where the input will be read from. # Corresponds to the JSON property `gcsSource` # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p3beta1GcsSource] attr_accessor :gcs_source @@ -5630,10 +5816,11 @@ update!(**args) end # Update properties of this object def update!(**args) + @content = args[:content] if args.key?(:content) @gcs_source = args[:gcs_source] if args.key?(:gcs_source) @mime_type = args[:mime_type] if args.key?(:mime_type) end end @@ -8532,12 +8719,2113 @@ @property = args[:property] if args.key?(:property) @symbols = args[:symbols] if args.key?(:symbols) end end + # Response to a single file annotation request. A file may contain one or more + # images, which individually have their own responses. + class GoogleCloudVisionV1p5beta1AnnotateFileResponse + include Google::Apis::Core::Hashable + + # The desired input location and metadata. + # Corresponds to the JSON property `inputConfig` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1InputConfig] + attr_accessor :input_config + + # Individual responses to images found within the file. + # Corresponds to the JSON property `responses` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1AnnotateImageResponse>] + attr_accessor :responses + + # This field gives the total number of pages in the file. + # Corresponds to the JSON property `totalPages` + # @return [Fixnum] + attr_accessor :total_pages + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @input_config = args[:input_config] if args.key?(:input_config) + @responses = args[:responses] if args.key?(:responses) + @total_pages = args[:total_pages] if args.key?(:total_pages) + end + end + + # Response to an image annotation request. + class GoogleCloudVisionV1p5beta1AnnotateImageResponse + include Google::Apis::Core::Hashable + + # If an image was produced from a file (e.g. a PDF), this message gives + # information about the source of that image. + # Corresponds to the JSON property `context` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ImageAnnotationContext] + attr_accessor :context + + # Set of crop hints that are used to generate new crops when serving images. + # Corresponds to the JSON property `cropHintsAnnotation` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1CropHintsAnnotation] + attr_accessor :crop_hints_annotation + + # 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. + # Corresponds to the JSON property `error` + # @return [Google::Apis::VisionV1::Status] + attr_accessor :error + + # If present, face detection has completed successfully. + # Corresponds to the JSON property `faceAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1FaceAnnotation>] + attr_accessor :face_annotations + + # TextAnnotation contains a structured representation of OCR extracted text. + # The hierarchy of an OCR extracted text structure is like this: + # TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol + # Each structural component, starting from Page, may further have their own + # properties. Properties describe detected languages, breaks etc.. Please refer + # to the TextAnnotation.TextProperty message definition below for more + # detail. + # Corresponds to the JSON property `fullTextAnnotation` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotation] + attr_accessor :full_text_annotation + + # Stores image properties, such as dominant colors. + # Corresponds to the JSON property `imagePropertiesAnnotation` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ImageProperties] + attr_accessor :image_properties_annotation + + # If present, label detection has completed successfully. + # Corresponds to the JSON property `labelAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1EntityAnnotation>] + attr_accessor :label_annotations + + # If present, landmark detection has completed successfully. + # Corresponds to the JSON property `landmarkAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1EntityAnnotation>] + attr_accessor :landmark_annotations + + # If present, localized object detection has completed successfully. + # This will be sorted descending by confidence score. + # Corresponds to the JSON property `localizedObjectAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1LocalizedObjectAnnotation>] + attr_accessor :localized_object_annotations + + # If present, logo detection has completed successfully. + # Corresponds to the JSON property `logoAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1EntityAnnotation>] + attr_accessor :logo_annotations + + # Results for a product search request. + # Corresponds to the JSON property `productSearchResults` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ProductSearchResults] + attr_accessor :product_search_results + + # Set of features pertaining to the image, computed by computer vision + # methods over safe-search verticals (for example, adult, spoof, medical, + # violence). + # Corresponds to the JSON property `safeSearchAnnotation` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1SafeSearchAnnotation] + attr_accessor :safe_search_annotation + + # If present, text (OCR) detection has completed successfully. + # Corresponds to the JSON property `textAnnotations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1EntityAnnotation>] + attr_accessor :text_annotations + + # Relevant information for the image from the Internet. + # Corresponds to the JSON property `webDetection` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetection] + attr_accessor :web_detection + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @context = args[:context] if args.key?(:context) + @crop_hints_annotation = args[:crop_hints_annotation] if args.key?(:crop_hints_annotation) + @error = args[:error] if args.key?(:error) + @face_annotations = args[:face_annotations] if args.key?(:face_annotations) + @full_text_annotation = args[:full_text_annotation] if args.key?(:full_text_annotation) + @image_properties_annotation = args[:image_properties_annotation] if args.key?(:image_properties_annotation) + @label_annotations = args[:label_annotations] if args.key?(:label_annotations) + @landmark_annotations = args[:landmark_annotations] if args.key?(:landmark_annotations) + @localized_object_annotations = args[:localized_object_annotations] if args.key?(:localized_object_annotations) + @logo_annotations = args[:logo_annotations] if args.key?(:logo_annotations) + @product_search_results = args[:product_search_results] if args.key?(:product_search_results) + @safe_search_annotation = args[:safe_search_annotation] if args.key?(:safe_search_annotation) + @text_annotations = args[:text_annotations] if args.key?(:text_annotations) + @web_detection = args[:web_detection] if args.key?(:web_detection) + end + end + + # The response for a single offline file annotation request. + class GoogleCloudVisionV1p5beta1AsyncAnnotateFileResponse + include Google::Apis::Core::Hashable + + # The desired output location and metadata. + # Corresponds to the JSON property `outputConfig` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1OutputConfig] + attr_accessor :output_config + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @output_config = args[:output_config] if args.key?(:output_config) + end + end + + # Response to an async batch file annotation request. + class GoogleCloudVisionV1p5beta1AsyncBatchAnnotateFilesResponse + include Google::Apis::Core::Hashable + + # The list of file annotation responses, one for each request in + # AsyncBatchAnnotateFilesRequest. + # Corresponds to the JSON property `responses` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1AsyncAnnotateFileResponse>] + attr_accessor :responses + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @responses = args[:responses] if args.key?(:responses) + end + end + + # Response to an async batch image annotation request. + class GoogleCloudVisionV1p5beta1AsyncBatchAnnotateImagesResponse + include Google::Apis::Core::Hashable + + # The desired output location and metadata. + # Corresponds to the JSON property `outputConfig` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1OutputConfig] + attr_accessor :output_config + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @output_config = args[:output_config] if args.key?(:output_config) + end + end + + # A list of file annotation responses. + class GoogleCloudVisionV1p5beta1BatchAnnotateFilesResponse + include Google::Apis::Core::Hashable + + # The list of file annotation responses, each response corresponding to each + # AnnotateFileRequest in BatchAnnotateFilesRequest. + # Corresponds to the JSON property `responses` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1AnnotateFileResponse>] + attr_accessor :responses + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @responses = args[:responses] if args.key?(:responses) + end + end + + # Metadata for the batch operations such as the current state. + # This is included in the `metadata` field of the `Operation` returned by the + # `GetOperation` call of the `google::longrunning::Operations` service. + class GoogleCloudVisionV1p5beta1BatchOperationMetadata + include Google::Apis::Core::Hashable + + # The time when the batch request is finished and + # google.longrunning.Operation.done is set to true. + # Corresponds to the JSON property `endTime` + # @return [String] + attr_accessor :end_time + + # The current state of the batch operation. + # Corresponds to the JSON property `state` + # @return [String] + attr_accessor :state + + # The time when the batch request was submitted to the server. + # Corresponds to the JSON property `submitTime` + # @return [String] + attr_accessor :submit_time + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @end_time = args[:end_time] if args.key?(:end_time) + @state = args[:state] if args.key?(:state) + @submit_time = args[:submit_time] if args.key?(:submit_time) + end + end + + # Logical element on the page. + class GoogleCloudVisionV1p5beta1Block + include Google::Apis::Core::Hashable + + # Detected block type (text, image etc) for this block. + # Corresponds to the JSON property `blockType` + # @return [String] + attr_accessor :block_type + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingBox` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_box + + # Confidence of the OCR results on the block. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # Proto for a key value pair. + # Corresponds to the JSON property `keyValuePair` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1KeyValuePair] + attr_accessor :key_value_pair + + # All UTF-8 text detected in this block. This field is by default not + # returned unless specified in TextDetectionParams.block_filter or + # DocumentParsingParams.block_filter. + # Corresponds to the JSON property `mergedText` + # @return [String] + attr_accessor :merged_text + + # List of paragraphs in this block (if this blocks is of type text). + # Corresponds to the JSON property `paragraphs` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Paragraph>] + attr_accessor :paragraphs + + # Additional information detected on the structural component. + # Corresponds to the JSON property `property` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationTextProperty] + attr_accessor :property + + # A table representation similar to HTML table structure. + # Corresponds to the JSON property `table` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Table] + attr_accessor :table + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @block_type = args[:block_type] if args.key?(:block_type) + @bounding_box = args[:bounding_box] if args.key?(:bounding_box) + @confidence = args[:confidence] if args.key?(:confidence) + @key_value_pair = args[:key_value_pair] if args.key?(:key_value_pair) + @merged_text = args[:merged_text] if args.key?(:merged_text) + @paragraphs = args[:paragraphs] if args.key?(:paragraphs) + @property = args[:property] if args.key?(:property) + @table = args[:table] if args.key?(:table) + end + end + + # A bounding polygon for the detected image annotation. + class GoogleCloudVisionV1p5beta1BoundingPoly + include Google::Apis::Core::Hashable + + # The bounding polygon normalized vertices. + # Corresponds to the JSON property `normalizedVertices` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1NormalizedVertex>] + attr_accessor :normalized_vertices + + # The bounding polygon vertices. + # Corresponds to the JSON property `vertices` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Vertex>] + attr_accessor :vertices + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @normalized_vertices = args[:normalized_vertices] if args.key?(:normalized_vertices) + @vertices = args[:vertices] if args.key?(:vertices) + end + end + + # Color information consists of RGB channels, score, and the fraction of + # the image that the color occupies in the image. + class GoogleCloudVisionV1p5beta1ColorInfo + include Google::Apis::Core::Hashable + + # 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. + # Note: this proto does not carry information about the absolute color space + # that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB, + # DCI-P3, BT.2020, etc.). By default, applications SHOULD assume the sRGB color + # space. + # 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(''); + # `; + # // ... + # Corresponds to the JSON property `color` + # @return [Google::Apis::VisionV1::Color] + attr_accessor :color + + # The fraction of pixels the color occupies in the image. + # Value in range [0, 1]. + # Corresponds to the JSON property `pixelFraction` + # @return [Float] + attr_accessor :pixel_fraction + + # Image-specific score for this color. Value in range [0, 1]. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @color = args[:color] if args.key?(:color) + @pixel_fraction = args[:pixel_fraction] if args.key?(:pixel_fraction) + @score = args[:score] if args.key?(:score) + end + end + + # Single crop hint that is used to generate a new crop when serving an image. + class GoogleCloudVisionV1p5beta1CropHint + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_poly + + # Confidence of this being a salient region. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # Fraction of importance of this salient region with respect to the original + # image. + # Corresponds to the JSON property `importanceFraction` + # @return [Float] + attr_accessor :importance_fraction + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_poly = args[:bounding_poly] if args.key?(:bounding_poly) + @confidence = args[:confidence] if args.key?(:confidence) + @importance_fraction = args[:importance_fraction] if args.key?(:importance_fraction) + end + end + + # Set of crop hints that are used to generate new crops when serving images. + class GoogleCloudVisionV1p5beta1CropHintsAnnotation + include Google::Apis::Core::Hashable + + # Crop hint results. + # Corresponds to the JSON property `cropHints` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1CropHint>] + attr_accessor :crop_hints + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @crop_hints = args[:crop_hints] if args.key?(:crop_hints) + end + end + + # Set of dominant colors and their corresponding scores. + class GoogleCloudVisionV1p5beta1DominantColorsAnnotation + include Google::Apis::Core::Hashable + + # RGB color values with their score and pixel fraction. + # Corresponds to the JSON property `colors` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ColorInfo>] + attr_accessor :colors + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @colors = args[:colors] if args.key?(:colors) + end + end + + # Set of detected entity features. + class GoogleCloudVisionV1p5beta1EntityAnnotation + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_poly + + # **Deprecated. Use `score` instead.** + # The accuracy of the entity detection in an image. + # For example, for an image in which the "Eiffel Tower" entity is detected, + # this field represents the confidence that there is a tower in the query + # image. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # Entity textual description, expressed in its `locale` language. + # Corresponds to the JSON property `description` + # @return [String] + attr_accessor :description + + # The language code for the locale in which the entity textual + # `description` is expressed. + # Corresponds to the JSON property `locale` + # @return [String] + attr_accessor :locale + + # The location information for the detected entity. Multiple + # `LocationInfo` elements can be present because one location may + # indicate the location of the scene in the image, and another location + # may indicate the location of the place where the image was taken. + # Location information is usually present for landmarks. + # Corresponds to the JSON property `locations` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1LocationInfo>] + attr_accessor :locations + + # Opaque entity ID. Some IDs may be available in + # [Google Knowledge Graph Search + # API](https://developers.google.com/knowledge-graph/). + # Corresponds to the JSON property `mid` + # @return [String] + attr_accessor :mid + + # Some entities may have optional user-supplied `Property` (name/value) + # fields, such a score or string that qualifies the entity. + # Corresponds to the JSON property `properties` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Property>] + attr_accessor :properties + + # Overall score of the result. Range [0, 1]. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + # The relevancy of the ICA (Image Content Annotation) label to the + # image. For example, the relevancy of "tower" is likely higher to an image + # containing the detected "Eiffel Tower" than to an image containing a + # detected distant towering building, even though the confidence that + # there is a tower in each image may be the same. Range [0, 1]. + # Corresponds to the JSON property `topicality` + # @return [Float] + attr_accessor :topicality + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_poly = args[:bounding_poly] if args.key?(:bounding_poly) + @confidence = args[:confidence] if args.key?(:confidence) + @description = args[:description] if args.key?(:description) + @locale = args[:locale] if args.key?(:locale) + @locations = args[:locations] if args.key?(:locations) + @mid = args[:mid] if args.key?(:mid) + @properties = args[:properties] if args.key?(:properties) + @score = args[:score] if args.key?(:score) + @topicality = args[:topicality] if args.key?(:topicality) + end + end + + # A face annotation object contains the results of face detection. + class GoogleCloudVisionV1p5beta1FaceAnnotation + include Google::Apis::Core::Hashable + + # Anger likelihood. + # Corresponds to the JSON property `angerLikelihood` + # @return [String] + attr_accessor :anger_likelihood + + # Blurred likelihood. + # Corresponds to the JSON property `blurredLikelihood` + # @return [String] + attr_accessor :blurred_likelihood + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_poly + + # Detection confidence. Range [0, 1]. + # Corresponds to the JSON property `detectionConfidence` + # @return [Float] + attr_accessor :detection_confidence + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `fdBoundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :fd_bounding_poly + + # Headwear likelihood. + # Corresponds to the JSON property `headwearLikelihood` + # @return [String] + attr_accessor :headwear_likelihood + + # Joy likelihood. + # Corresponds to the JSON property `joyLikelihood` + # @return [String] + attr_accessor :joy_likelihood + + # Face landmarking confidence. Range [0, 1]. + # Corresponds to the JSON property `landmarkingConfidence` + # @return [Float] + attr_accessor :landmarking_confidence + + # Detected face landmarks. + # Corresponds to the JSON property `landmarks` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1FaceAnnotationLandmark>] + attr_accessor :landmarks + + # Yaw angle, which indicates the leftward/rightward angle that the face is + # pointing relative to the vertical plane perpendicular to the image. Range + # [-180,180]. + # Corresponds to the JSON property `panAngle` + # @return [Float] + attr_accessor :pan_angle + + # Roll angle, which indicates the amount of clockwise/anti-clockwise rotation + # of the face relative to the image vertical about the axis perpendicular to + # the face. Range [-180,180]. + # Corresponds to the JSON property `rollAngle` + # @return [Float] + attr_accessor :roll_angle + + # Sorrow likelihood. + # Corresponds to the JSON property `sorrowLikelihood` + # @return [String] + attr_accessor :sorrow_likelihood + + # Surprise likelihood. + # Corresponds to the JSON property `surpriseLikelihood` + # @return [String] + attr_accessor :surprise_likelihood + + # Pitch angle, which indicates the upwards/downwards angle that the face is + # pointing relative to the image's horizontal plane. Range [-180,180]. + # Corresponds to the JSON property `tiltAngle` + # @return [Float] + attr_accessor :tilt_angle + + # Under-exposed likelihood. + # Corresponds to the JSON property `underExposedLikelihood` + # @return [String] + attr_accessor :under_exposed_likelihood + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @anger_likelihood = args[:anger_likelihood] if args.key?(:anger_likelihood) + @blurred_likelihood = args[:blurred_likelihood] if args.key?(:blurred_likelihood) + @bounding_poly = args[:bounding_poly] if args.key?(:bounding_poly) + @detection_confidence = args[:detection_confidence] if args.key?(:detection_confidence) + @fd_bounding_poly = args[:fd_bounding_poly] if args.key?(:fd_bounding_poly) + @headwear_likelihood = args[:headwear_likelihood] if args.key?(:headwear_likelihood) + @joy_likelihood = args[:joy_likelihood] if args.key?(:joy_likelihood) + @landmarking_confidence = args[:landmarking_confidence] if args.key?(:landmarking_confidence) + @landmarks = args[:landmarks] if args.key?(:landmarks) + @pan_angle = args[:pan_angle] if args.key?(:pan_angle) + @roll_angle = args[:roll_angle] if args.key?(:roll_angle) + @sorrow_likelihood = args[:sorrow_likelihood] if args.key?(:sorrow_likelihood) + @surprise_likelihood = args[:surprise_likelihood] if args.key?(:surprise_likelihood) + @tilt_angle = args[:tilt_angle] if args.key?(:tilt_angle) + @under_exposed_likelihood = args[:under_exposed_likelihood] if args.key?(:under_exposed_likelihood) + end + end + + # A face-specific landmark (for example, a face feature). + class GoogleCloudVisionV1p5beta1FaceAnnotationLandmark + include Google::Apis::Core::Hashable + + # A 3D position in the image, used primarily for Face detection landmarks. + # A valid Position must have both x and y coordinates. + # The position coordinates are in the same scale as the original image. + # Corresponds to the JSON property `position` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Position] + attr_accessor :position + + # Face landmark type. + # Corresponds to the JSON property `type` + # @return [String] + attr_accessor :type + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @position = args[:position] if args.key?(:position) + @type = args[:type] if args.key?(:type) + end + end + + # The Google Cloud Storage location where the output will be written to. + class GoogleCloudVisionV1p5beta1GcsDestination + include Google::Apis::Core::Hashable + + # Google Cloud Storage URI prefix where the results will be stored. Results + # will be in JSON format and preceded by its corresponding input URI prefix. + # This field can either represent a gcs file prefix or gcs directory. In + # either case, the uri should be unique because in order to get all of the + # output files, you will need to do a wildcard gcs search on the uri prefix + # you provide. + # Examples: + # * File Prefix: gs://bucket-name/here/filenameprefix The output files + # will be created in gs://bucket-name/here/ and the names of the + # output files will begin with "filenameprefix". + # * Directory Prefix: gs://bucket-name/some/location/ The output files + # will be created in gs://bucket-name/some/location/ and the names of the + # output files could be anything because there was no filename prefix + # specified. + # If multiple outputs, each response is still AnnotateFileResponse, each of + # which contains some subset of the full list of AnnotateImageResponse. + # Multiple outputs can happen if, for example, the output JSON is too large + # and overflows into multiple sharded files. + # Corresponds to the JSON property `uri` + # @return [String] + attr_accessor :uri + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @uri = args[:uri] if args.key?(:uri) + end + end + + # The Google Cloud Storage location where the input will be read from. + class GoogleCloudVisionV1p5beta1GcsSource + include Google::Apis::Core::Hashable + + # Google Cloud Storage URI for the input file. This must only be a + # Google Cloud Storage object. Wildcards are not currently supported. + # Corresponds to the JSON property `uri` + # @return [String] + attr_accessor :uri + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @uri = args[:uri] if args.key?(:uri) + end + end + + # If an image was produced from a file (e.g. a PDF), this message gives + # information about the source of that image. + class GoogleCloudVisionV1p5beta1ImageAnnotationContext + include Google::Apis::Core::Hashable + + # If the file was a PDF or TIFF, this field gives the page number within + # the file used to produce the image. + # Corresponds to the JSON property `pageNumber` + # @return [Fixnum] + attr_accessor :page_number + + # The URI of the file used to produce the image. + # Corresponds to the JSON property `uri` + # @return [String] + attr_accessor :uri + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @page_number = args[:page_number] if args.key?(:page_number) + @uri = args[:uri] if args.key?(:uri) + end + end + + # Stores image properties, such as dominant colors. + class GoogleCloudVisionV1p5beta1ImageProperties + include Google::Apis::Core::Hashable + + # Set of dominant colors and their corresponding scores. + # Corresponds to the JSON property `dominantColors` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1DominantColorsAnnotation] + attr_accessor :dominant_colors + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @dominant_colors = args[:dominant_colors] if args.key?(:dominant_colors) + end + end + + # Response message for the `ImportProductSets` method. + # This message is returned by the + # google.longrunning.Operations.GetOperation method in the returned + # google.longrunning.Operation.response field. + class GoogleCloudVisionV1p5beta1ImportProductSetsResponse + include Google::Apis::Core::Hashable + + # The list of reference_images that are imported successfully. + # Corresponds to the JSON property `referenceImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ReferenceImage>] + attr_accessor :reference_images + + # The rpc status for each ImportProductSet request, including both successes + # and errors. + # The number of statuses here matches the number of lines in the csv file, + # and statuses[i] stores the success or failure status of processing the i-th + # line of the csv, starting from line 0. + # Corresponds to the JSON property `statuses` + # @return [Array<Google::Apis::VisionV1::Status>] + attr_accessor :statuses + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @reference_images = args[:reference_images] if args.key?(:reference_images) + @statuses = args[:statuses] if args.key?(:statuses) + end + end + + # The desired input location and metadata. + class GoogleCloudVisionV1p5beta1InputConfig + include Google::Apis::Core::Hashable + + # File content, represented as a stream of bytes. + # Note: As with all `bytes` fields, protobuffers use a pure binary + # representation, whereas JSON representations use base64. + # Currently, this field only works for BatchAnnotateFiles requests. It does + # not work for AsyncBatchAnnotateFiles requests. + # Corresponds to the JSON property `content` + # NOTE: Values are automatically base64 encoded/decoded in the client library. + # @return [String] + attr_accessor :content + + # The Google Cloud Storage location where the input will be read from. + # Corresponds to the JSON property `gcsSource` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1GcsSource] + attr_accessor :gcs_source + + # The type of the file. Currently only "application/pdf" and "image/tiff" + # are supported. Wildcards are not supported. + # Corresponds to the JSON property `mimeType` + # @return [String] + attr_accessor :mime_type + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @content = args[:content] if args.key?(:content) + @gcs_source = args[:gcs_source] if args.key?(:gcs_source) + @mime_type = args[:mime_type] if args.key?(:mime_type) + end + end + + # Proto for a key value pair. + class GoogleCloudVisionV1p5beta1KeyValuePair + include Google::Apis::Core::Hashable + + # The key string value. + # Corresponds to the JSON property `key` + # @return [String] + attr_accessor :key + + # Logical element on the page. + # Corresponds to the JSON property `keyBlock` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Block] + attr_accessor :key_block + + # Optional. The translation of key text if the text is not in English. + # Corresponds to the JSON property `normalizedKey` + # @return [String] + attr_accessor :normalized_key + + # Logical element on the page. + # Corresponds to the JSON property `valueBlock` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Block] + attr_accessor :value_block + + # Type of the value. Valid strings are the following: + # "generic" - For generic text that is mapped to a value. + # "number" - for numeric types + # "id" - for generic identifiers. + # "currency" - for currency values. + # "date" - for dates. + # "time" - for time and duration values. + # "date_range" - for date ranges. + # "address" - for address values (can be long). + # "person" - for names of people or other personal identifiers. + # "phone" - for phone numbers. + # Corresponds to the JSON property `valueType` + # @return [String] + attr_accessor :value_type + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @key = args[:key] if args.key?(:key) + @key_block = args[:key_block] if args.key?(:key_block) + @normalized_key = args[:normalized_key] if args.key?(:normalized_key) + @value_block = args[:value_block] if args.key?(:value_block) + @value_type = args[:value_type] if args.key?(:value_type) + end + end + + # Set of detected objects with bounding boxes. + class GoogleCloudVisionV1p5beta1LocalizedObjectAnnotation + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_poly + + # The BCP-47 language code, such as "en-US" or "sr-Latn". For more + # information, see + # http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. + # Corresponds to the JSON property `languageCode` + # @return [String] + attr_accessor :language_code + + # Object ID that should align with EntityAnnotation mid. + # Corresponds to the JSON property `mid` + # @return [String] + attr_accessor :mid + + # Object name, expressed in its `language_code` language. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # Score of the result. Range [0, 1]. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_poly = args[:bounding_poly] if args.key?(:bounding_poly) + @language_code = args[:language_code] if args.key?(:language_code) + @mid = args[:mid] if args.key?(:mid) + @name = args[:name] if args.key?(:name) + @score = args[:score] if args.key?(:score) + end + end + + # Detected entity location information. + class GoogleCloudVisionV1p5beta1LocationInfo + include Google::Apis::Core::Hashable + + # 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. + # Corresponds to the JSON property `latLng` + # @return [Google::Apis::VisionV1::LatLng] + attr_accessor :lat_lng + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @lat_lng = args[:lat_lng] if args.key?(:lat_lng) + end + end + + # A vertex represents a 2D point in the image. + # NOTE: the normalized vertex coordinates are relative to the original image + # and range from 0 to 1. + class GoogleCloudVisionV1p5beta1NormalizedVertex + include Google::Apis::Core::Hashable + + # X coordinate. + # Corresponds to the JSON property `x` + # @return [Float] + attr_accessor :x + + # Y coordinate. + # Corresponds to the JSON property `y` + # @return [Float] + attr_accessor :y + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @x = args[:x] if args.key?(:x) + @y = args[:y] if args.key?(:y) + end + end + + # Contains metadata for the BatchAnnotateImages operation. + class GoogleCloudVisionV1p5beta1OperationMetadata + include Google::Apis::Core::Hashable + + # The time when the batch request was received. + # Corresponds to the JSON property `createTime` + # @return [String] + attr_accessor :create_time + + # Current state of the batch operation. + # Corresponds to the JSON property `state` + # @return [String] + attr_accessor :state + + # The time when the operation result was last updated. + # Corresponds to the JSON property `updateTime` + # @return [String] + attr_accessor :update_time + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @create_time = args[:create_time] if args.key?(:create_time) + @state = args[:state] if args.key?(:state) + @update_time = args[:update_time] if args.key?(:update_time) + end + end + + # The desired output location and metadata. + class GoogleCloudVisionV1p5beta1OutputConfig + include Google::Apis::Core::Hashable + + # The max number of response protos to put into each output JSON file on + # Google Cloud Storage. + # The valid range is [1, 100]. If not specified, the default value is 20. + # For example, for one pdf file with 100 pages, 100 response protos will + # be generated. If `batch_size` = 20, then 5 json files each + # containing 20 response protos will be written under the prefix + # `gcs_destination`.`uri`. + # Currently, batch_size only applies to GcsDestination, with potential future + # support for other output configurations. + # Corresponds to the JSON property `batchSize` + # @return [Fixnum] + attr_accessor :batch_size + + # The Google Cloud Storage location where the output will be written to. + # Corresponds to the JSON property `gcsDestination` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1GcsDestination] + attr_accessor :gcs_destination + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @batch_size = args[:batch_size] if args.key?(:batch_size) + @gcs_destination = args[:gcs_destination] if args.key?(:gcs_destination) + end + end + + # Detected page from OCR. + class GoogleCloudVisionV1p5beta1Page + include Google::Apis::Core::Hashable + + # List of blocks of text, images etc on this page. + # Corresponds to the JSON property `blocks` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Block>] + attr_accessor :blocks + + # Confidence of the OCR results on the page. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # Page height. For PDFs the unit is points. For images (including + # TIFFs) the unit is pixels. + # Corresponds to the JSON property `height` + # @return [Fixnum] + attr_accessor :height + + # All UTF-8 text detected in this page. This field is by default not + # returned unless specified in TextDetectionParams.page_filter. + # Corresponds to the JSON property `mergedText` + # @return [String] + attr_accessor :merged_text + + # Additional information detected on the structural component. + # Corresponds to the JSON property `property` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationTextProperty] + attr_accessor :property + + # Page width. For PDFs the unit is points. For images (including + # TIFFs) the unit is pixels. + # Corresponds to the JSON property `width` + # @return [Fixnum] + attr_accessor :width + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @blocks = args[:blocks] if args.key?(:blocks) + @confidence = args[:confidence] if args.key?(:confidence) + @height = args[:height] if args.key?(:height) + @merged_text = args[:merged_text] if args.key?(:merged_text) + @property = args[:property] if args.key?(:property) + @width = args[:width] if args.key?(:width) + end + end + + # Structural unit of text representing a number of words in certain order. + class GoogleCloudVisionV1p5beta1Paragraph + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingBox` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_box + + # Confidence of the OCR results for the paragraph. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # All UTF-8 text detected in this paragraph. This field is by default not + # returned unless specified in + # TextDetectionParams.paragraph_filter. + # Corresponds to the JSON property `mergedText` + # @return [String] + attr_accessor :merged_text + + # Additional information detected on the structural component. + # Corresponds to the JSON property `property` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationTextProperty] + attr_accessor :property + + # List of words in this paragraph. + # Corresponds to the JSON property `words` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Word>] + attr_accessor :words + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_box = args[:bounding_box] if args.key?(:bounding_box) + @confidence = args[:confidence] if args.key?(:confidence) + @merged_text = args[:merged_text] if args.key?(:merged_text) + @property = args[:property] if args.key?(:property) + @words = args[:words] if args.key?(:words) + end + end + + # A 3D position in the image, used primarily for Face detection landmarks. + # A valid Position must have both x and y coordinates. + # The position coordinates are in the same scale as the original image. + class GoogleCloudVisionV1p5beta1Position + include Google::Apis::Core::Hashable + + # X coordinate. + # Corresponds to the JSON property `x` + # @return [Float] + attr_accessor :x + + # Y coordinate. + # Corresponds to the JSON property `y` + # @return [Float] + attr_accessor :y + + # Z coordinate (or depth). + # Corresponds to the JSON property `z` + # @return [Float] + attr_accessor :z + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @x = args[:x] if args.key?(:x) + @y = args[:y] if args.key?(:y) + @z = args[:z] if args.key?(:z) + end + end + + # A Product contains ReferenceImages. + class GoogleCloudVisionV1p5beta1Product + include Google::Apis::Core::Hashable + + # User-provided metadata to be stored with this product. Must be at most 4096 + # characters long. + # Corresponds to the JSON property `description` + # @return [String] + attr_accessor :description + + # The user-provided name for this Product. Must not be empty. Must be at most + # 4096 characters long. + # Corresponds to the JSON property `displayName` + # @return [String] + attr_accessor :display_name + + # The resource name of the product. + # Format is: + # `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`. + # This field is ignored when creating a product. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # The category for the product identified by the reference image. This should + # be either "homegoods", "apparel", or "toys". + # This field is immutable. + # Corresponds to the JSON property `productCategory` + # @return [String] + attr_accessor :product_category + + # Key-value pairs that can be attached to a product. At query time, + # constraints can be specified based on the product_labels. + # Note that integer values can be provided as strings, e.g. "1199". Only + # strings with integer values can match a range-based restriction which is + # to be supported soon. + # Multiple values can be assigned to the same key. One product may have up to + # 100 product_labels. + # Corresponds to the JSON property `productLabels` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ProductKeyValue>] + attr_accessor :product_labels + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @description = args[:description] if args.key?(:description) + @display_name = args[:display_name] if args.key?(:display_name) + @name = args[:name] if args.key?(:name) + @product_category = args[:product_category] if args.key?(:product_category) + @product_labels = args[:product_labels] if args.key?(:product_labels) + end + end + + # A product label represented as a key-value pair. + class GoogleCloudVisionV1p5beta1ProductKeyValue + include Google::Apis::Core::Hashable + + # The key of the label attached to the product. Cannot be empty and cannot + # exceed 128 bytes. + # Corresponds to the JSON property `key` + # @return [String] + attr_accessor :key + + # The value of the label attached to the product. Cannot be empty and + # cannot exceed 128 bytes. + # Corresponds to the JSON property `value` + # @return [String] + attr_accessor :value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @key = args[:key] if args.key?(:key) + @value = args[:value] if args.key?(:value) + end + end + + # Results for a product search request. + class GoogleCloudVisionV1p5beta1ProductSearchResults + include Google::Apis::Core::Hashable + + # Timestamp of the index which provided these results. Products added to the + # product set and products removed from the product set after this time are + # not reflected in the current results. + # Corresponds to the JSON property `indexTime` + # @return [String] + attr_accessor :index_time + + # List of results grouped by products detected in the query image. Each entry + # corresponds to one bounding polygon in the query image, and contains the + # matching products specific to that region. There may be duplicate product + # matches in the union of all the per-product results. + # Corresponds to the JSON property `productGroupedResults` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ProductSearchResultsGroupedResult>] + attr_accessor :product_grouped_results + + # List of results, one for each product match. + # Corresponds to the JSON property `results` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ProductSearchResultsResult>] + attr_accessor :results + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @index_time = args[:index_time] if args.key?(:index_time) + @product_grouped_results = args[:product_grouped_results] if args.key?(:product_grouped_results) + @results = args[:results] if args.key?(:results) + end + end + # Information about the products similar to a single product in a query # image. + class GoogleCloudVisionV1p5beta1ProductSearchResultsGroupedResult + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingPoly` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_poly + + # List of results, one for each product match. + # Corresponds to the JSON property `results` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1ProductSearchResultsResult>] + attr_accessor :results + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_poly = args[:bounding_poly] if args.key?(:bounding_poly) + @results = args[:results] if args.key?(:results) + end + end + + # Information about a product. + class GoogleCloudVisionV1p5beta1ProductSearchResultsResult + include Google::Apis::Core::Hashable + + # The resource name of the image from the product that is the closest match + # to the query. + # Corresponds to the JSON property `image` + # @return [String] + attr_accessor :image + + # A Product contains ReferenceImages. + # Corresponds to the JSON property `product` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Product] + attr_accessor :product + + # A confidence level on the match, ranging from 0 (no confidence) to + # 1 (full confidence). + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @image = args[:image] if args.key?(:image) + @product = args[:product] if args.key?(:product) + @score = args[:score] if args.key?(:score) + end + end + + # A `Property` consists of a user-supplied name/value pair. + class GoogleCloudVisionV1p5beta1Property + include Google::Apis::Core::Hashable + + # Name of the property. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # Value of numeric properties. + # Corresponds to the JSON property `uint64Value` + # @return [Fixnum] + attr_accessor :uint64_value + + # Value of the property. + # Corresponds to the JSON property `value` + # @return [String] + attr_accessor :value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @name = args[:name] if args.key?(:name) + @uint64_value = args[:uint64_value] if args.key?(:uint64_value) + @value = args[:value] if args.key?(:value) + end + end + + # A `ReferenceImage` represents a product image and its associated metadata, + # such as bounding boxes. + class GoogleCloudVisionV1p5beta1ReferenceImage + include Google::Apis::Core::Hashable + + # Bounding polygons around the areas of interest in the reference image. + # Optional. If this field is empty, the system will try to detect regions of + # interest. At most 10 bounding polygons will be used. + # The provided shape is converted into a non-rotated rectangle. Once + # converted, the small edge of the rectangle must be greater than or equal + # to 300 pixels. The aspect ratio must be 1:4 or less (i.e. 1:3 is ok; 1:5 + # is not). + # Corresponds to the JSON property `boundingPolys` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly>] + attr_accessor :bounding_polys + + # The resource name of the reference image. + # Format is: + # `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID/referenceImages/ + # IMAGE_ID`. + # This field is ignored when creating a reference image. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # The Google Cloud Storage URI of the reference image. + # The URI must start with `gs://`. + # Required. + # Corresponds to the JSON property `uri` + # @return [String] + attr_accessor :uri + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_polys = args[:bounding_polys] if args.key?(:bounding_polys) + @name = args[:name] if args.key?(:name) + @uri = args[:uri] if args.key?(:uri) + end + end + + # Set of features pertaining to the image, computed by computer vision + # methods over safe-search verticals (for example, adult, spoof, medical, + # violence). + class GoogleCloudVisionV1p5beta1SafeSearchAnnotation + include Google::Apis::Core::Hashable + + # Represents the adult content likelihood for the image. Adult content may + # contain elements such as nudity, pornographic images or cartoons, or + # sexual activities. + # Corresponds to the JSON property `adult` + # @return [String] + attr_accessor :adult + + # Likelihood that this is a medical image. + # Corresponds to the JSON property `medical` + # @return [String] + attr_accessor :medical + + # Likelihood that the request image contains racy content. Racy content may + # include (but is not limited to) skimpy or sheer clothing, strategically + # covered nudity, lewd or provocative poses, or close-ups of sensitive + # body areas. + # Corresponds to the JSON property `racy` + # @return [String] + attr_accessor :racy + + # Spoof likelihood. The likelihood that an modification + # was made to the image's canonical version to make it appear + # funny or offensive. + # Corresponds to the JSON property `spoof` + # @return [String] + attr_accessor :spoof + + # Likelihood that this image contains violent content. + # Corresponds to the JSON property `violence` + # @return [String] + attr_accessor :violence + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @adult = args[:adult] if args.key?(:adult) + @medical = args[:medical] if args.key?(:medical) + @racy = args[:racy] if args.key?(:racy) + @spoof = args[:spoof] if args.key?(:spoof) + @violence = args[:violence] if args.key?(:violence) + end + end + + # A single symbol representation. + class GoogleCloudVisionV1p5beta1Symbol + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingBox` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_box + + # Confidence of the OCR results for the symbol. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # Additional information detected on the structural component. + # Corresponds to the JSON property `property` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationTextProperty] + attr_accessor :property + + # The actual UTF-8 representation of the symbol. + # Corresponds to the JSON property `text` + # @return [String] + attr_accessor :text + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_box = args[:bounding_box] if args.key?(:bounding_box) + @confidence = args[:confidence] if args.key?(:confidence) + @property = args[:property] if args.key?(:property) + @text = args[:text] if args.key?(:text) + end + end + + # A table representation similar to HTML table structure. + class GoogleCloudVisionV1p5beta1Table + include Google::Apis::Core::Hashable + + # Body rows of the table + # Corresponds to the JSON property `bodyRows` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TableTableRow>] + attr_accessor :body_rows + + # Header rows of the table + # Corresponds to the JSON property `headerRows` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TableTableRow>] + attr_accessor :header_rows + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @body_rows = args[:body_rows] if args.key?(:body_rows) + @header_rows = args[:header_rows] if args.key?(:header_rows) + end + end + + # A cell representation inside of tables. + class GoogleCloudVisionV1p5beta1TableTableCell + include Google::Apis::Core::Hashable + + # How many columns this cell spans. + # Corresponds to the JSON property `colSpan` + # @return [Fixnum] + attr_accessor :col_span + + # How many rows this cell spans. + # Corresponds to the JSON property `rowSpan` + # @return [Fixnum] + attr_accessor :row_span + + # The merged text value of this cell, omitting any deeper structural + # information unlike `text_block`. This is useful for simple cells. + # Corresponds to the JSON property `text` + # @return [String] + attr_accessor :text + + # Logical element on the page. + # Corresponds to the JSON property `textBlock` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Block] + attr_accessor :text_block + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @col_span = args[:col_span] if args.key?(:col_span) + @row_span = args[:row_span] if args.key?(:row_span) + @text = args[:text] if args.key?(:text) + @text_block = args[:text_block] if args.key?(:text_block) + end + end + + # A row of table cells. + class GoogleCloudVisionV1p5beta1TableTableRow + include Google::Apis::Core::Hashable + + # Cells that make up this row. + # Corresponds to the JSON property `cells` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TableTableCell>] + attr_accessor :cells + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @cells = args[:cells] if args.key?(:cells) + end + end + + # TextAnnotation contains a structured representation of OCR extracted text. + # The hierarchy of an OCR extracted text structure is like this: + # TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol + # Each structural component, starting from Page, may further have their own + # properties. Properties describe detected languages, breaks etc.. Please refer + # to the TextAnnotation.TextProperty message definition below for more + # detail. + class GoogleCloudVisionV1p5beta1TextAnnotation + include Google::Apis::Core::Hashable + + # List of pages detected by OCR. + # Corresponds to the JSON property `pages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Page>] + attr_accessor :pages + + # UTF-8 text detected on the pages. + # Corresponds to the JSON property `text` + # @return [String] + attr_accessor :text + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @pages = args[:pages] if args.key?(:pages) + @text = args[:text] if args.key?(:text) + end + end + + # Detected start or end of a structural component. + class GoogleCloudVisionV1p5beta1TextAnnotationDetectedBreak + include Google::Apis::Core::Hashable + + # True if break prepends the element. + # Corresponds to the JSON property `isPrefix` + # @return [Boolean] + attr_accessor :is_prefix + alias_method :is_prefix?, :is_prefix + + # Detected break type. + # Corresponds to the JSON property `type` + # @return [String] + attr_accessor :type + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @is_prefix = args[:is_prefix] if args.key?(:is_prefix) + @type = args[:type] if args.key?(:type) + end + end + + # Detected language for a structural component. + class GoogleCloudVisionV1p5beta1TextAnnotationDetectedLanguage + include Google::Apis::Core::Hashable + + # Confidence of detected language. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # The BCP-47 language code, such as "en-US" or "sr-Latn". For more + # information, see + # http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. + # Corresponds to the JSON property `languageCode` + # @return [String] + attr_accessor :language_code + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @confidence = args[:confidence] if args.key?(:confidence) + @language_code = args[:language_code] if args.key?(:language_code) + end + end + + # Additional information detected on the structural component. + class GoogleCloudVisionV1p5beta1TextAnnotationTextProperty + include Google::Apis::Core::Hashable + + # Detected start or end of a structural component. + # Corresponds to the JSON property `detectedBreak` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationDetectedBreak] + attr_accessor :detected_break + + # A list of detected languages together with confidence. + # Corresponds to the JSON property `detectedLanguages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationDetectedLanguage>] + attr_accessor :detected_languages + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @detected_break = args[:detected_break] if args.key?(:detected_break) + @detected_languages = args[:detected_languages] if args.key?(:detected_languages) + end + end + + # A vertex represents a 2D point in the image. + # NOTE: the vertex coordinates are in the same scale as the original image. + class GoogleCloudVisionV1p5beta1Vertex + include Google::Apis::Core::Hashable + + # X coordinate. + # Corresponds to the JSON property `x` + # @return [Fixnum] + attr_accessor :x + + # Y coordinate. + # Corresponds to the JSON property `y` + # @return [Fixnum] + attr_accessor :y + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @x = args[:x] if args.key?(:x) + @y = args[:y] if args.key?(:y) + end + end + + # Relevant information for the image from the Internet. + class GoogleCloudVisionV1p5beta1WebDetection + include Google::Apis::Core::Hashable + + # The service's best guess as to the topic of the request image. + # Inferred from similar images on the open web. + # Corresponds to the JSON property `bestGuessLabels` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebLabel>] + attr_accessor :best_guess_labels + + # Fully matching images from the Internet. + # Can include resized copies of the query image. + # Corresponds to the JSON property `fullMatchingImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebImage>] + attr_accessor :full_matching_images + + # Web pages containing the matching images from the Internet. + # Corresponds to the JSON property `pagesWithMatchingImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebPage>] + attr_accessor :pages_with_matching_images + + # Partial matching images from the Internet. + # Those images are similar enough to share some key-point features. For + # example an original image will likely have partial matching for its crops. + # Corresponds to the JSON property `partialMatchingImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebImage>] + attr_accessor :partial_matching_images + + # The visually similar image results. + # Corresponds to the JSON property `visuallySimilarImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebImage>] + attr_accessor :visually_similar_images + + # Deduced entities from similar images on the Internet. + # Corresponds to the JSON property `webEntities` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebEntity>] + attr_accessor :web_entities + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @best_guess_labels = args[:best_guess_labels] if args.key?(:best_guess_labels) + @full_matching_images = args[:full_matching_images] if args.key?(:full_matching_images) + @pages_with_matching_images = args[:pages_with_matching_images] if args.key?(:pages_with_matching_images) + @partial_matching_images = args[:partial_matching_images] if args.key?(:partial_matching_images) + @visually_similar_images = args[:visually_similar_images] if args.key?(:visually_similar_images) + @web_entities = args[:web_entities] if args.key?(:web_entities) + end + end + + # Entity deduced from similar images on the Internet. + class GoogleCloudVisionV1p5beta1WebDetectionWebEntity + include Google::Apis::Core::Hashable + + # Canonical description of the entity, in English. + # Corresponds to the JSON property `description` + # @return [String] + attr_accessor :description + + # Opaque entity ID. + # Corresponds to the JSON property `entityId` + # @return [String] + attr_accessor :entity_id + + # Overall relevancy score for the entity. + # Not normalized and not comparable across different image queries. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @description = args[:description] if args.key?(:description) + @entity_id = args[:entity_id] if args.key?(:entity_id) + @score = args[:score] if args.key?(:score) + end + end + + # Metadata for online images. + class GoogleCloudVisionV1p5beta1WebDetectionWebImage + include Google::Apis::Core::Hashable + + # (Deprecated) Overall relevancy score for the image. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + # The result image URL. + # Corresponds to the JSON property `url` + # @return [String] + attr_accessor :url + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @score = args[:score] if args.key?(:score) + @url = args[:url] if args.key?(:url) + end + end + + # Label to provide extra metadata for the web detection. + class GoogleCloudVisionV1p5beta1WebDetectionWebLabel + include Google::Apis::Core::Hashable + + # Label for extra metadata. + # Corresponds to the JSON property `label` + # @return [String] + attr_accessor :label + + # The BCP-47 language code for `label`, such as "en-US" or "sr-Latn". + # For more information, see + # http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. + # Corresponds to the JSON property `languageCode` + # @return [String] + attr_accessor :language_code + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @label = args[:label] if args.key?(:label) + @language_code = args[:language_code] if args.key?(:language_code) + end + end + + # Metadata for web pages. + class GoogleCloudVisionV1p5beta1WebDetectionWebPage + include Google::Apis::Core::Hashable + + # Fully matching images on the page. + # Can include resized copies of the query image. + # Corresponds to the JSON property `fullMatchingImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebImage>] + attr_accessor :full_matching_images + + # Title for the web page, may contain HTML markups. + # Corresponds to the JSON property `pageTitle` + # @return [String] + attr_accessor :page_title + + # Partial matching images on the page. + # Those images are similar enough to share some key-point features. For + # example an original image will likely have partial matching for its + # crops. + # Corresponds to the JSON property `partialMatchingImages` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1WebDetectionWebImage>] + attr_accessor :partial_matching_images + + # (Deprecated) Overall relevancy score for the web page. + # Corresponds to the JSON property `score` + # @return [Float] + attr_accessor :score + + # The result web page URL. + # Corresponds to the JSON property `url` + # @return [String] + attr_accessor :url + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @full_matching_images = args[:full_matching_images] if args.key?(:full_matching_images) + @page_title = args[:page_title] if args.key?(:page_title) + @partial_matching_images = args[:partial_matching_images] if args.key?(:partial_matching_images) + @score = args[:score] if args.key?(:score) + @url = args[:url] if args.key?(:url) + end + end + + # A word representation. + class GoogleCloudVisionV1p5beta1Word + include Google::Apis::Core::Hashable + + # A bounding polygon for the detected image annotation. + # Corresponds to the JSON property `boundingBox` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1BoundingPoly] + attr_accessor :bounding_box + + # Confidence of the OCR results for the word. Range [0, 1]. + # Corresponds to the JSON property `confidence` + # @return [Float] + attr_accessor :confidence + + # All UTF-8 text detected in this word. This field is by default not + # returned unless specified in TextDetectionParams.word_filter. + # Corresponds to the JSON property `mergedText` + # @return [String] + attr_accessor :merged_text + + # Additional information detected on the structural component. + # Corresponds to the JSON property `property` + # @return [Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1TextAnnotationTextProperty] + attr_accessor :property + + # List of symbols in the word. + # The order of the symbols follows the natural reading order. + # Corresponds to the JSON property `symbols` + # @return [Array<Google::Apis::VisionV1::GoogleCloudVisionV1p5beta1Symbol>] + attr_accessor :symbols + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounding_box = args[:bounding_box] if args.key?(:bounding_box) + @confidence = args[:confidence] if args.key?(:confidence) + @merged_text = args[:merged_text] if args.key?(:merged_text) + @property = args[:property] if args.key?(:property) + @symbols = args[:symbols] if args.key?(:symbols) + end + end + + # Information about the products similar to a single product in a query + # image. class GroupedResult include Google::Apis::Core::Hashable # A bounding polygon for the detected image annotation. # Corresponds to the JSON property `boundingPoly` @@ -8865,10 +11153,20 @@ # The desired input location and metadata. class InputConfig include Google::Apis::Core::Hashable + # File content, represented as a stream of bytes. + # Note: As with all `bytes` fields, protobuffers use a pure binary + # representation, whereas JSON representations use base64. + # Currently, this field only works for BatchAnnotateFiles requests. It does + # not work for AsyncBatchAnnotateFiles requests. + # Corresponds to the JSON property `content` + # NOTE: Values are automatically base64 encoded/decoded in the client library. + # @return [String] + attr_accessor :content + # The Google Cloud Storage location where the input will be read from. # Corresponds to the JSON property `gcsSource` # @return [Google::Apis::VisionV1::GcsSource] attr_accessor :gcs_source @@ -8882,10 +11180,11 @@ update!(**args) end # Update properties of this object def update!(**args) + @content = args[:content] if args.key?(:content) @gcs_source = args[:gcs_source] if args.key?(:gcs_source) @mime_type = args[:mime_type] if args.key?(:mime_type) end end @@ -9298,10 +11597,10 @@ # @return [Hash<String,Object>] attr_accessor :metadata # The server-assigned name, which is only unique within the same service that # originally returns it. If you use the default HTTP mapping, the - # `name` should have the format of `operations/some/unique/name`. + # `name` should be a resource name ending with `operations/`unique_id``. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # The normal response of the operation in case of success. If the original