google-cloud-vision 0.21.1 → 0.22.0

data/lib/google/cloud/vision/v1/doc/google/protobuf/any.rb

@@ -0,0 +1,104 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Google
+  module Protobuf
+    # +Any+ contains an arbitrary serialized protocol buffer message along with a
+    # URL that describes the type of the serialized message.
+    #
+    # Protobuf library provides support to pack/unpack Any values in the form
+    # of utility functions or additional generated methods of the Any type.
+    #
+    # Example 1: Pack and unpack a message in C++.
+    #
+    #     Foo foo = ...;
+    #     Any any;
+    #     any.PackFrom(foo);
+    #     ...
+    #     if (any.UnpackTo(&foo)) {
+    #       ...
+    #     }
+    #
+    # Example 2: Pack and unpack a message in Java.
+    #
+    #     Foo foo = ...;
+    #     Any any = Any.pack(foo);
+    #     ...
+    #     if (any.is(Foo.class)) {
+    #       foo = any.unpack(Foo.class);
+    #     }
+    #
+    # The pack methods provided by protobuf library will by default use
+    # 'type.googleapis.com/full.type.name' as the type URL and the unpack
+    # methods only use the fully qualified type name after the last '/'
+    # in the type URL, for example "foo.bar.com/x/y.z" will yield type
+    # name "y.z".
+    #
+    #
+    # = JSON
+    #
+    # The JSON representation of an +Any+ value uses the regular
+    # representation of the deserialized, embedded message, with an
+    # additional field +@type+ which contains the type URL. Example:
+    #
+    #     package google.profile;
+    #     message Person {
+    #       string first_name = 1;
+    #       string last_name = 2;
+    #     }
+    #
+    #     {
+    #       "@type": "type.googleapis.com/google.profile.Person",
+    #       "firstName": <string>,
+    #       "lastName": <string>
+    #     }
+    #
+    # If the embedded message type is well-known and has a custom JSON
+    # representation, that representation will be embedded adding a field
+    # +value+ which holds the custom JSON in addition to the +@type+
+    # field. Example (for message Google::Protobuf::Duration):
+    #
+    #     {
+    #       "@type": "type.googleapis.com/google.protobuf.Duration",
+    #       "value": "1.212s"
+    #     }
+    # @!attribute [rw] type_url
+    #   @return [String]
+    #     A URL/resource name whose content describes the type of the
+    #     serialized protocol buffer message.
+    #
+    #     For URLs which use the schema +http+, +https+, or no schema, the
+    #     following restrictions and interpretations apply:
+    #
+    #     * If no schema is provided, +https+ is assumed.
+    #     * The last segment of the URL's path must represent the fully
+    #       qualified name of the type (as in +path/google.protobuf.Duration+).
+    #       The name should be in a canonical form (e.g., leading "." is
+    #       not accepted).
+    #     * An HTTP GET on the URL must yield a Google::Protobuf::Type
+    #       value in binary format, or produce an error.
+    #     * Applications are allowed to cache lookup results based on the
+    #       URL, or have them precompiled into a binary to avoid any
+    #       lookup. Therefore, binary compatibility needs to be preserved
+    #       on changes to types. (Use versioned type names to manage
+    #       breaking changes.)
+    #
+    #     Schemas other than +http+, +https+ (or the empty schema) might be
+    #     used with implementation specific semantics.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     Must be a valid serialized protocol buffer of the above specified type.
+    class Any; end
+  end
+end

data/lib/google/cloud/vision/v1/doc/google/protobuf/wrappers.rb

@@ -0,0 +1,89 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Google
+  module Protobuf
+    # Wrapper message for +double+.
+    #
+    # The JSON representation for +DoubleValue+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Float]
+    #     The double value.
+    class DoubleValue; end
+
+    # Wrapper message for +float+.
+    #
+    # The JSON representation for +FloatValue+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Float]
+    #     The float value.
+    class FloatValue; end
+
+    # Wrapper message for +int64+.
+    #
+    # The JSON representation for +Int64Value+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The int64 value.
+    class Int64Value; end
+
+    # Wrapper message for +uint64+.
+    #
+    # The JSON representation for +UInt64Value+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The uint64 value.
+    class UInt64Value; end
+
+    # Wrapper message for +int32+.
+    #
+    # The JSON representation for +Int32Value+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The int32 value.
+    class Int32Value; end
+
+    # Wrapper message for +uint32+.
+    #
+    # The JSON representation for +UInt32Value+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The uint32 value.
+    class UInt32Value; end
+
+    # Wrapper message for +bool+.
+    #
+    # The JSON representation for +BoolValue+ is JSON +true+ and +false+.
+    # @!attribute [rw] value
+    #   @return [true, false]
+    #     The bool value.
+    class BoolValue; end
+
+    # Wrapper message for +string+.
+    #
+    # The JSON representation for +StringValue+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     The string value.
+    class StringValue; end
+
+    # Wrapper message for +bytes+.
+    #
+    # The JSON representation for +BytesValue+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     The bytes value.
+    class BytesValue; end
+  end
+end

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

@@ -0,0 +1,83 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Google
+  module Rpc
+    # The +Status+ type defines a logical error model that is suitable for different
+    # programming environments, including REST APIs and RPC APIs. It is used by
+    # {gRPC}[https://github.com/grpc]. The error model is designed to be:
+    #
+    # - Simple to use and understand for most users
+    # - Flexible enough to meet unexpected needs
+    #
+    # = Overview
+    #
+    # The +Status+ message contains three pieces of data: error code, error message,
+    # and error details. The error code should be an enum value of
+    # Google::Rpc::Code, but it may accept additional error codes if needed.  The
+    # error message should be a developer-facing English message that helps
+    # developers *understand* and *resolve* the error. If a localized user-facing
+    # error message is needed, put the localized message in the error details or
+    # localize it in the client. The optional error details may contain arbitrary
+    # information about the error. There is a predefined set of error detail types
+    # in the package +google.rpc+ which 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 purpose.
+    #
+    # - Batch operations. If a client uses batch request and batch response, the
+    #     +Status+ message should be used directly inside batch response, one for
+    #     each error sub-response.
+    #
+    # - Asynchronous operations. If an API call embeds asynchronous operation
+    #     results in its response, the status of those operations should be
+    #     represented directly using the +Status+ message.
+    #
+    # - Logging. If some API errors are stored in logs, the message +Status+ could
+    #     be used directly after any stripping needed for security/privacy reasons.
+    # @!attribute [rw] code
+    #   @return [Integer]
+    #     The status code, which should be an enum value of Google::Rpc::Code.
+    # @!attribute [rw] message
+    #   @return [String]
+    #     A developer-facing error message, which should be in English. Any
+    #     user-facing error message should be localized and sent in the
+    #     Google::Rpc::Status#details field, or localized by the client.
+    # @!attribute [rw] details
+    #   @return [Array<Google::Protobuf::Any>]
+    #     A list of messages that carry the error details.  There will be a
+    #     common set of message types for APIs to use.
+    class Status; end
+  end
+end

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

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

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

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