| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // source: google/cloud/vision/v1p3beta1/image_annotator.proto |
| |
| package vision // import "google.golang.org/genproto/googleapis/cloud/vision/v1p3beta1" |
| |
| import proto "github.com/golang/protobuf/proto" |
| import fmt "fmt" |
| import math "math" |
| import timestamp "github.com/golang/protobuf/ptypes/timestamp" |
| import _ "google.golang.org/genproto/googleapis/api/annotations" |
| import longrunning "google.golang.org/genproto/googleapis/longrunning" |
| import status "google.golang.org/genproto/googleapis/rpc/status" |
| import color "google.golang.org/genproto/googleapis/type/color" |
| import latlng "google.golang.org/genproto/googleapis/type/latlng" |
| |
| import ( |
| context "golang.org/x/net/context" |
| grpc "google.golang.org/grpc" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the proto package it is being compiled against. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package |
| |
| // A bucketized representation of likelihood, which is intended to give clients |
| // highly stable results across model upgrades. |
| type Likelihood int32 |
| |
| const ( |
| // Unknown likelihood. |
| Likelihood_UNKNOWN Likelihood = 0 |
| // It is very unlikely that the image belongs to the specified vertical. |
| Likelihood_VERY_UNLIKELY Likelihood = 1 |
| // It is unlikely that the image belongs to the specified vertical. |
| Likelihood_UNLIKELY Likelihood = 2 |
| // It is possible that the image belongs to the specified vertical. |
| Likelihood_POSSIBLE Likelihood = 3 |
| // It is likely that the image belongs to the specified vertical. |
| Likelihood_LIKELY Likelihood = 4 |
| // It is very likely that the image belongs to the specified vertical. |
| Likelihood_VERY_LIKELY Likelihood = 5 |
| ) |
| |
| var Likelihood_name = map[int32]string{ |
| 0: "UNKNOWN", |
| 1: "VERY_UNLIKELY", |
| 2: "UNLIKELY", |
| 3: "POSSIBLE", |
| 4: "LIKELY", |
| 5: "VERY_LIKELY", |
| } |
| var Likelihood_value = map[string]int32{ |
| "UNKNOWN": 0, |
| "VERY_UNLIKELY": 1, |
| "UNLIKELY": 2, |
| "POSSIBLE": 3, |
| "LIKELY": 4, |
| "VERY_LIKELY": 5, |
| } |
| |
| func (x Likelihood) String() string { |
| return proto.EnumName(Likelihood_name, int32(x)) |
| } |
| func (Likelihood) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{0} |
| } |
| |
| // Type of Google Cloud Vision API feature to be extracted. |
| type Feature_Type int32 |
| |
| const ( |
| // Unspecified feature type. |
| Feature_TYPE_UNSPECIFIED Feature_Type = 0 |
| // Run face detection. |
| Feature_FACE_DETECTION Feature_Type = 1 |
| // Run landmark detection. |
| Feature_LANDMARK_DETECTION Feature_Type = 2 |
| // Run logo detection. |
| Feature_LOGO_DETECTION Feature_Type = 3 |
| // Run label detection. |
| Feature_LABEL_DETECTION Feature_Type = 4 |
| // Run text detection / optical character recognition (OCR). Text detection |
| // is optimized for areas of text within a larger image; if the image is |
| // a document, use `DOCUMENT_TEXT_DETECTION` instead. |
| Feature_TEXT_DETECTION Feature_Type = 5 |
| // Run dense text document OCR. Takes precedence when both |
| // `DOCUMENT_TEXT_DETECTION` and `TEXT_DETECTION` are present. |
| Feature_DOCUMENT_TEXT_DETECTION Feature_Type = 11 |
| // Run Safe Search to detect potentially unsafe |
| // or undesirable content. |
| Feature_SAFE_SEARCH_DETECTION Feature_Type = 6 |
| // Compute a set of image properties, such as the |
| // image's dominant colors. |
| Feature_IMAGE_PROPERTIES Feature_Type = 7 |
| // Run crop hints. |
| Feature_CROP_HINTS Feature_Type = 9 |
| // Run web detection. |
| Feature_WEB_DETECTION Feature_Type = 10 |
| // Run Product Search. |
| Feature_PRODUCT_SEARCH Feature_Type = 12 |
| // Run localizer for object detection. |
| Feature_OBJECT_LOCALIZATION Feature_Type = 19 |
| ) |
| |
| var Feature_Type_name = map[int32]string{ |
| 0: "TYPE_UNSPECIFIED", |
| 1: "FACE_DETECTION", |
| 2: "LANDMARK_DETECTION", |
| 3: "LOGO_DETECTION", |
| 4: "LABEL_DETECTION", |
| 5: "TEXT_DETECTION", |
| 11: "DOCUMENT_TEXT_DETECTION", |
| 6: "SAFE_SEARCH_DETECTION", |
| 7: "IMAGE_PROPERTIES", |
| 9: "CROP_HINTS", |
| 10: "WEB_DETECTION", |
| 12: "PRODUCT_SEARCH", |
| 19: "OBJECT_LOCALIZATION", |
| } |
| var Feature_Type_value = map[string]int32{ |
| "TYPE_UNSPECIFIED": 0, |
| "FACE_DETECTION": 1, |
| "LANDMARK_DETECTION": 2, |
| "LOGO_DETECTION": 3, |
| "LABEL_DETECTION": 4, |
| "TEXT_DETECTION": 5, |
| "DOCUMENT_TEXT_DETECTION": 11, |
| "SAFE_SEARCH_DETECTION": 6, |
| "IMAGE_PROPERTIES": 7, |
| "CROP_HINTS": 9, |
| "WEB_DETECTION": 10, |
| "PRODUCT_SEARCH": 12, |
| "OBJECT_LOCALIZATION": 19, |
| } |
| |
| func (x Feature_Type) String() string { |
| return proto.EnumName(Feature_Type_name, int32(x)) |
| } |
| func (Feature_Type) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{0, 0} |
| } |
| |
| // Face landmark (feature) type. |
| // Left and right are defined from the vantage of the viewer of the image |
| // without considering mirror projections typical of photos. So, `LEFT_EYE`, |
| // typically, is the person's right eye. |
| type FaceAnnotation_Landmark_Type int32 |
| |
| const ( |
| // Unknown face landmark detected. Should not be filled. |
| FaceAnnotation_Landmark_UNKNOWN_LANDMARK FaceAnnotation_Landmark_Type = 0 |
| // Left eye. |
| FaceAnnotation_Landmark_LEFT_EYE FaceAnnotation_Landmark_Type = 1 |
| // Right eye. |
| FaceAnnotation_Landmark_RIGHT_EYE FaceAnnotation_Landmark_Type = 2 |
| // Left of left eyebrow. |
| FaceAnnotation_Landmark_LEFT_OF_LEFT_EYEBROW FaceAnnotation_Landmark_Type = 3 |
| // Right of left eyebrow. |
| FaceAnnotation_Landmark_RIGHT_OF_LEFT_EYEBROW FaceAnnotation_Landmark_Type = 4 |
| // Left of right eyebrow. |
| FaceAnnotation_Landmark_LEFT_OF_RIGHT_EYEBROW FaceAnnotation_Landmark_Type = 5 |
| // Right of right eyebrow. |
| FaceAnnotation_Landmark_RIGHT_OF_RIGHT_EYEBROW FaceAnnotation_Landmark_Type = 6 |
| // Midpoint between eyes. |
| FaceAnnotation_Landmark_MIDPOINT_BETWEEN_EYES FaceAnnotation_Landmark_Type = 7 |
| // Nose tip. |
| FaceAnnotation_Landmark_NOSE_TIP FaceAnnotation_Landmark_Type = 8 |
| // Upper lip. |
| FaceAnnotation_Landmark_UPPER_LIP FaceAnnotation_Landmark_Type = 9 |
| // Lower lip. |
| FaceAnnotation_Landmark_LOWER_LIP FaceAnnotation_Landmark_Type = 10 |
| // Mouth left. |
| FaceAnnotation_Landmark_MOUTH_LEFT FaceAnnotation_Landmark_Type = 11 |
| // Mouth right. |
| FaceAnnotation_Landmark_MOUTH_RIGHT FaceAnnotation_Landmark_Type = 12 |
| // Mouth center. |
| FaceAnnotation_Landmark_MOUTH_CENTER FaceAnnotation_Landmark_Type = 13 |
| // Nose, bottom right. |
| FaceAnnotation_Landmark_NOSE_BOTTOM_RIGHT FaceAnnotation_Landmark_Type = 14 |
| // Nose, bottom left. |
| FaceAnnotation_Landmark_NOSE_BOTTOM_LEFT FaceAnnotation_Landmark_Type = 15 |
| // Nose, bottom center. |
| FaceAnnotation_Landmark_NOSE_BOTTOM_CENTER FaceAnnotation_Landmark_Type = 16 |
| // Left eye, top boundary. |
| FaceAnnotation_Landmark_LEFT_EYE_TOP_BOUNDARY FaceAnnotation_Landmark_Type = 17 |
| // Left eye, right corner. |
| FaceAnnotation_Landmark_LEFT_EYE_RIGHT_CORNER FaceAnnotation_Landmark_Type = 18 |
| // Left eye, bottom boundary. |
| FaceAnnotation_Landmark_LEFT_EYE_BOTTOM_BOUNDARY FaceAnnotation_Landmark_Type = 19 |
| // Left eye, left corner. |
| FaceAnnotation_Landmark_LEFT_EYE_LEFT_CORNER FaceAnnotation_Landmark_Type = 20 |
| // Right eye, top boundary. |
| FaceAnnotation_Landmark_RIGHT_EYE_TOP_BOUNDARY FaceAnnotation_Landmark_Type = 21 |
| // Right eye, right corner. |
| FaceAnnotation_Landmark_RIGHT_EYE_RIGHT_CORNER FaceAnnotation_Landmark_Type = 22 |
| // Right eye, bottom boundary. |
| FaceAnnotation_Landmark_RIGHT_EYE_BOTTOM_BOUNDARY FaceAnnotation_Landmark_Type = 23 |
| // Right eye, left corner. |
| FaceAnnotation_Landmark_RIGHT_EYE_LEFT_CORNER FaceAnnotation_Landmark_Type = 24 |
| // Left eyebrow, upper midpoint. |
| FaceAnnotation_Landmark_LEFT_EYEBROW_UPPER_MIDPOINT FaceAnnotation_Landmark_Type = 25 |
| // Right eyebrow, upper midpoint. |
| FaceAnnotation_Landmark_RIGHT_EYEBROW_UPPER_MIDPOINT FaceAnnotation_Landmark_Type = 26 |
| // Left ear tragion. |
| FaceAnnotation_Landmark_LEFT_EAR_TRAGION FaceAnnotation_Landmark_Type = 27 |
| // Right ear tragion. |
| FaceAnnotation_Landmark_RIGHT_EAR_TRAGION FaceAnnotation_Landmark_Type = 28 |
| // Left eye pupil. |
| FaceAnnotation_Landmark_LEFT_EYE_PUPIL FaceAnnotation_Landmark_Type = 29 |
| // Right eye pupil. |
| FaceAnnotation_Landmark_RIGHT_EYE_PUPIL FaceAnnotation_Landmark_Type = 30 |
| // Forehead glabella. |
| FaceAnnotation_Landmark_FOREHEAD_GLABELLA FaceAnnotation_Landmark_Type = 31 |
| // Chin gnathion. |
| FaceAnnotation_Landmark_CHIN_GNATHION FaceAnnotation_Landmark_Type = 32 |
| // Chin left gonion. |
| FaceAnnotation_Landmark_CHIN_LEFT_GONION FaceAnnotation_Landmark_Type = 33 |
| // Chin right gonion. |
| FaceAnnotation_Landmark_CHIN_RIGHT_GONION FaceAnnotation_Landmark_Type = 34 |
| ) |
| |
| var FaceAnnotation_Landmark_Type_name = map[int32]string{ |
| 0: "UNKNOWN_LANDMARK", |
| 1: "LEFT_EYE", |
| 2: "RIGHT_EYE", |
| 3: "LEFT_OF_LEFT_EYEBROW", |
| 4: "RIGHT_OF_LEFT_EYEBROW", |
| 5: "LEFT_OF_RIGHT_EYEBROW", |
| 6: "RIGHT_OF_RIGHT_EYEBROW", |
| 7: "MIDPOINT_BETWEEN_EYES", |
| 8: "NOSE_TIP", |
| 9: "UPPER_LIP", |
| 10: "LOWER_LIP", |
| 11: "MOUTH_LEFT", |
| 12: "MOUTH_RIGHT", |
| 13: "MOUTH_CENTER", |
| 14: "NOSE_BOTTOM_RIGHT", |
| 15: "NOSE_BOTTOM_LEFT", |
| 16: "NOSE_BOTTOM_CENTER", |
| 17: "LEFT_EYE_TOP_BOUNDARY", |
| 18: "LEFT_EYE_RIGHT_CORNER", |
| 19: "LEFT_EYE_BOTTOM_BOUNDARY", |
| 20: "LEFT_EYE_LEFT_CORNER", |
| 21: "RIGHT_EYE_TOP_BOUNDARY", |
| 22: "RIGHT_EYE_RIGHT_CORNER", |
| 23: "RIGHT_EYE_BOTTOM_BOUNDARY", |
| 24: "RIGHT_EYE_LEFT_CORNER", |
| 25: "LEFT_EYEBROW_UPPER_MIDPOINT", |
| 26: "RIGHT_EYEBROW_UPPER_MIDPOINT", |
| 27: "LEFT_EAR_TRAGION", |
| 28: "RIGHT_EAR_TRAGION", |
| 29: "LEFT_EYE_PUPIL", |
| 30: "RIGHT_EYE_PUPIL", |
| 31: "FOREHEAD_GLABELLA", |
| 32: "CHIN_GNATHION", |
| 33: "CHIN_LEFT_GONION", |
| 34: "CHIN_RIGHT_GONION", |
| } |
| var FaceAnnotation_Landmark_Type_value = map[string]int32{ |
| "UNKNOWN_LANDMARK": 0, |
| "LEFT_EYE": 1, |
| "RIGHT_EYE": 2, |
| "LEFT_OF_LEFT_EYEBROW": 3, |
| "RIGHT_OF_LEFT_EYEBROW": 4, |
| "LEFT_OF_RIGHT_EYEBROW": 5, |
| "RIGHT_OF_RIGHT_EYEBROW": 6, |
| "MIDPOINT_BETWEEN_EYES": 7, |
| "NOSE_TIP": 8, |
| "UPPER_LIP": 9, |
| "LOWER_LIP": 10, |
| "MOUTH_LEFT": 11, |
| "MOUTH_RIGHT": 12, |
| "MOUTH_CENTER": 13, |
| "NOSE_BOTTOM_RIGHT": 14, |
| "NOSE_BOTTOM_LEFT": 15, |
| "NOSE_BOTTOM_CENTER": 16, |
| "LEFT_EYE_TOP_BOUNDARY": 17, |
| "LEFT_EYE_RIGHT_CORNER": 18, |
| "LEFT_EYE_BOTTOM_BOUNDARY": 19, |
| "LEFT_EYE_LEFT_CORNER": 20, |
| "RIGHT_EYE_TOP_BOUNDARY": 21, |
| "RIGHT_EYE_RIGHT_CORNER": 22, |
| "RIGHT_EYE_BOTTOM_BOUNDARY": 23, |
| "RIGHT_EYE_LEFT_CORNER": 24, |
| "LEFT_EYEBROW_UPPER_MIDPOINT": 25, |
| "RIGHT_EYEBROW_UPPER_MIDPOINT": 26, |
| "LEFT_EAR_TRAGION": 27, |
| "RIGHT_EAR_TRAGION": 28, |
| "LEFT_EYE_PUPIL": 29, |
| "RIGHT_EYE_PUPIL": 30, |
| "FOREHEAD_GLABELLA": 31, |
| "CHIN_GNATHION": 32, |
| "CHIN_LEFT_GONION": 33, |
| "CHIN_RIGHT_GONION": 34, |
| } |
| |
| func (x FaceAnnotation_Landmark_Type) String() string { |
| return proto.EnumName(FaceAnnotation_Landmark_Type_name, int32(x)) |
| } |
| func (FaceAnnotation_Landmark_Type) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{3, 0, 0} |
| } |
| |
| // Batch operation states. |
| type OperationMetadata_State int32 |
| |
| const ( |
| // Invalid. |
| OperationMetadata_STATE_UNSPECIFIED OperationMetadata_State = 0 |
| // Request is received. |
| OperationMetadata_CREATED OperationMetadata_State = 1 |
| // Request is actively being processed. |
| OperationMetadata_RUNNING OperationMetadata_State = 2 |
| // The batch processing is done. |
| OperationMetadata_DONE OperationMetadata_State = 3 |
| // The batch processing was cancelled. |
| OperationMetadata_CANCELLED OperationMetadata_State = 4 |
| ) |
| |
| var OperationMetadata_State_name = map[int32]string{ |
| 0: "STATE_UNSPECIFIED", |
| 1: "CREATED", |
| 2: "RUNNING", |
| 3: "DONE", |
| 4: "CANCELLED", |
| } |
| var OperationMetadata_State_value = map[string]int32{ |
| "STATE_UNSPECIFIED": 0, |
| "CREATED": 1, |
| "RUNNING": 2, |
| "DONE": 3, |
| "CANCELLED": 4, |
| } |
| |
| func (x OperationMetadata_State) String() string { |
| return proto.EnumName(OperationMetadata_State_name, int32(x)) |
| } |
| func (OperationMetadata_State) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{32, 0} |
| } |
| |
| // The type of Google Cloud Vision API detection to perform, and the maximum |
| // number of results to return for that type. Multiple `Feature` objects can |
| // be specified in the `features` list. |
| type Feature struct { |
| // The feature type. |
| Type Feature_Type `protobuf:"varint,1,opt,name=type,proto3,enum=google.cloud.vision.v1p3beta1.Feature_Type" json:"type,omitempty"` |
| // Maximum number of results of this type. Does not apply to |
| // `TEXT_DETECTION`, `DOCUMENT_TEXT_DETECTION`, or `CROP_HINTS`. |
| MaxResults int32 `protobuf:"varint,2,opt,name=max_results,json=maxResults,proto3" json:"max_results,omitempty"` |
| // Model to use for the feature. |
| // Supported values: "builtin/stable" (the default if unset) and |
| // "builtin/latest". |
| Model string `protobuf:"bytes,3,opt,name=model,proto3" json:"model,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Feature) Reset() { *m = Feature{} } |
| func (m *Feature) String() string { return proto.CompactTextString(m) } |
| func (*Feature) ProtoMessage() {} |
| func (*Feature) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{0} |
| } |
| func (m *Feature) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Feature.Unmarshal(m, b) |
| } |
| func (m *Feature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Feature.Marshal(b, m, deterministic) |
| } |
| func (dst *Feature) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Feature.Merge(dst, src) |
| } |
| func (m *Feature) XXX_Size() int { |
| return xxx_messageInfo_Feature.Size(m) |
| } |
| func (m *Feature) XXX_DiscardUnknown() { |
| xxx_messageInfo_Feature.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Feature proto.InternalMessageInfo |
| |
| func (m *Feature) GetType() Feature_Type { |
| if m != nil { |
| return m.Type |
| } |
| return Feature_TYPE_UNSPECIFIED |
| } |
| |
| func (m *Feature) GetMaxResults() int32 { |
| if m != nil { |
| return m.MaxResults |
| } |
| return 0 |
| } |
| |
| func (m *Feature) GetModel() string { |
| if m != nil { |
| return m.Model |
| } |
| return "" |
| } |
| |
| // External image source (Google Cloud Storage or web URL image location). |
| type ImageSource struct { |
| // **Use `image_uri` instead.** |
| // |
| // The Google Cloud Storage URI of the form |
| // `gs://bucket_name/object_name`. Object versioning is not supported. See |
| // [Google Cloud Storage Request |
| // URIs](https://cloud.google.com/storage/docs/reference-uris) for more info. |
| GcsImageUri string `protobuf:"bytes,1,opt,name=gcs_image_uri,json=gcsImageUri,proto3" json:"gcs_image_uri,omitempty"` |
| // The URI of the source image. Can be either: |
| // |
| // 1. A Google Cloud Storage URI of the form |
| // `gs://bucket_name/object_name`. Object versioning is not supported. See |
| // [Google Cloud Storage Request |
| // URIs](https://cloud.google.com/storage/docs/reference-uris) for more |
| // info. |
| // |
| // 2. A publicly-accessible image HTTP/HTTPS URL. When fetching images from |
| // HTTP/HTTPS URLs, Google cannot guarantee that the request will be |
| // completed. Your request may fail if the specified host denies the |
| // request (e.g. due to request throttling or DOS prevention), or if Google |
| // throttles requests to the site for abuse prevention. You should not |
| // depend on externally-hosted images for production applications. |
| // |
| // When both `gcs_image_uri` and `image_uri` are specified, `image_uri` takes |
| // precedence. |
| ImageUri string `protobuf:"bytes,2,opt,name=image_uri,json=imageUri,proto3" json:"image_uri,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ImageSource) Reset() { *m = ImageSource{} } |
| func (m *ImageSource) String() string { return proto.CompactTextString(m) } |
| func (*ImageSource) ProtoMessage() {} |
| func (*ImageSource) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{1} |
| } |
| func (m *ImageSource) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ImageSource.Unmarshal(m, b) |
| } |
| func (m *ImageSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ImageSource.Marshal(b, m, deterministic) |
| } |
| func (dst *ImageSource) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ImageSource.Merge(dst, src) |
| } |
| func (m *ImageSource) XXX_Size() int { |
| return xxx_messageInfo_ImageSource.Size(m) |
| } |
| func (m *ImageSource) XXX_DiscardUnknown() { |
| xxx_messageInfo_ImageSource.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ImageSource proto.InternalMessageInfo |
| |
| func (m *ImageSource) GetGcsImageUri() string { |
| if m != nil { |
| return m.GcsImageUri |
| } |
| return "" |
| } |
| |
| func (m *ImageSource) GetImageUri() string { |
| if m != nil { |
| return m.ImageUri |
| } |
| return "" |
| } |
| |
| // Client image to perform Google Cloud Vision API tasks over. |
| type Image struct { |
| // Image content, represented as a stream of bytes. |
| // Note: As with all `bytes` fields, protobuffers use a pure binary |
| // representation, whereas JSON representations use base64. |
| Content []byte `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` |
| // Google Cloud Storage image location, or publicly-accessible image |
| // URL. If both `content` and `source` are provided for an image, `content` |
| // takes precedence and is used to perform the image annotation request. |
| Source *ImageSource `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Image) Reset() { *m = Image{} } |
| func (m *Image) String() string { return proto.CompactTextString(m) } |
| func (*Image) ProtoMessage() {} |
| func (*Image) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{2} |
| } |
| func (m *Image) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Image.Unmarshal(m, b) |
| } |
| func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Image.Marshal(b, m, deterministic) |
| } |
| func (dst *Image) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Image.Merge(dst, src) |
| } |
| func (m *Image) XXX_Size() int { |
| return xxx_messageInfo_Image.Size(m) |
| } |
| func (m *Image) XXX_DiscardUnknown() { |
| xxx_messageInfo_Image.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Image proto.InternalMessageInfo |
| |
| func (m *Image) GetContent() []byte { |
| if m != nil { |
| return m.Content |
| } |
| return nil |
| } |
| |
| func (m *Image) GetSource() *ImageSource { |
| if m != nil { |
| return m.Source |
| } |
| return nil |
| } |
| |
| // A face annotation object contains the results of face detection. |
| type FaceAnnotation struct { |
| // The bounding polygon around the face. The coordinates of the bounding box |
| // are in the original image's scale, as returned in `ImageParams`. |
| // The bounding box is computed to "frame" the face in accordance with human |
| // expectations. It is based on the landmarker results. |
| // Note that one or more x and/or y coordinates may not be generated in the |
| // `BoundingPoly` (the polygon will be unbounded) if only a partial face |
| // appears in the image to be annotated. |
| BoundingPoly *BoundingPoly `protobuf:"bytes,1,opt,name=bounding_poly,json=boundingPoly,proto3" json:"bounding_poly,omitempty"` |
| // The `fd_bounding_poly` bounding polygon is tighter than the |
| // `boundingPoly`, and encloses only the skin part of the face. Typically, it |
| // is used to eliminate the face from any image analysis that detects the |
| // "amount of skin" visible in an image. It is not based on the |
| // landmarker results, only on the initial face detection, hence |
| // the <code>fd</code> (face detection) prefix. |
| FdBoundingPoly *BoundingPoly `protobuf:"bytes,2,opt,name=fd_bounding_poly,json=fdBoundingPoly,proto3" json:"fd_bounding_poly,omitempty"` |
| // Detected face landmarks. |
| Landmarks []*FaceAnnotation_Landmark `protobuf:"bytes,3,rep,name=landmarks,proto3" json:"landmarks,omitempty"` |
| // 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]. |
| RollAngle float32 `protobuf:"fixed32,4,opt,name=roll_angle,json=rollAngle,proto3" json:"roll_angle,omitempty"` |
| // 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]. |
| PanAngle float32 `protobuf:"fixed32,5,opt,name=pan_angle,json=panAngle,proto3" json:"pan_angle,omitempty"` |
| // Pitch angle, which indicates the upwards/downwards angle that the face is |
| // pointing relative to the image's horizontal plane. Range [-180,180]. |
| TiltAngle float32 `protobuf:"fixed32,6,opt,name=tilt_angle,json=tiltAngle,proto3" json:"tilt_angle,omitempty"` |
| // Detection confidence. Range [0, 1]. |
| DetectionConfidence float32 `protobuf:"fixed32,7,opt,name=detection_confidence,json=detectionConfidence,proto3" json:"detection_confidence,omitempty"` |
| // Face landmarking confidence. Range [0, 1]. |
| LandmarkingConfidence float32 `protobuf:"fixed32,8,opt,name=landmarking_confidence,json=landmarkingConfidence,proto3" json:"landmarking_confidence,omitempty"` |
| // Joy likelihood. |
| JoyLikelihood Likelihood `protobuf:"varint,9,opt,name=joy_likelihood,json=joyLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"joy_likelihood,omitempty"` |
| // Sorrow likelihood. |
| SorrowLikelihood Likelihood `protobuf:"varint,10,opt,name=sorrow_likelihood,json=sorrowLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"sorrow_likelihood,omitempty"` |
| // Anger likelihood. |
| AngerLikelihood Likelihood `protobuf:"varint,11,opt,name=anger_likelihood,json=angerLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"anger_likelihood,omitempty"` |
| // Surprise likelihood. |
| SurpriseLikelihood Likelihood `protobuf:"varint,12,opt,name=surprise_likelihood,json=surpriseLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"surprise_likelihood,omitempty"` |
| // Under-exposed likelihood. |
| UnderExposedLikelihood Likelihood `protobuf:"varint,13,opt,name=under_exposed_likelihood,json=underExposedLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"under_exposed_likelihood,omitempty"` |
| // Blurred likelihood. |
| BlurredLikelihood Likelihood `protobuf:"varint,14,opt,name=blurred_likelihood,json=blurredLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"blurred_likelihood,omitempty"` |
| // Headwear likelihood. |
| HeadwearLikelihood Likelihood `protobuf:"varint,15,opt,name=headwear_likelihood,json=headwearLikelihood,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"headwear_likelihood,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *FaceAnnotation) Reset() { *m = FaceAnnotation{} } |
| func (m *FaceAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*FaceAnnotation) ProtoMessage() {} |
| func (*FaceAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{3} |
| } |
| func (m *FaceAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_FaceAnnotation.Unmarshal(m, b) |
| } |
| func (m *FaceAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_FaceAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *FaceAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FaceAnnotation.Merge(dst, src) |
| } |
| func (m *FaceAnnotation) XXX_Size() int { |
| return xxx_messageInfo_FaceAnnotation.Size(m) |
| } |
| func (m *FaceAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_FaceAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FaceAnnotation proto.InternalMessageInfo |
| |
| func (m *FaceAnnotation) GetBoundingPoly() *BoundingPoly { |
| if m != nil { |
| return m.BoundingPoly |
| } |
| return nil |
| } |
| |
| func (m *FaceAnnotation) GetFdBoundingPoly() *BoundingPoly { |
| if m != nil { |
| return m.FdBoundingPoly |
| } |
| return nil |
| } |
| |
| func (m *FaceAnnotation) GetLandmarks() []*FaceAnnotation_Landmark { |
| if m != nil { |
| return m.Landmarks |
| } |
| return nil |
| } |
| |
| func (m *FaceAnnotation) GetRollAngle() float32 { |
| if m != nil { |
| return m.RollAngle |
| } |
| return 0 |
| } |
| |
| func (m *FaceAnnotation) GetPanAngle() float32 { |
| if m != nil { |
| return m.PanAngle |
| } |
| return 0 |
| } |
| |
| func (m *FaceAnnotation) GetTiltAngle() float32 { |
| if m != nil { |
| return m.TiltAngle |
| } |
| return 0 |
| } |
| |
| func (m *FaceAnnotation) GetDetectionConfidence() float32 { |
| if m != nil { |
| return m.DetectionConfidence |
| } |
| return 0 |
| } |
| |
| func (m *FaceAnnotation) GetLandmarkingConfidence() float32 { |
| if m != nil { |
| return m.LandmarkingConfidence |
| } |
| return 0 |
| } |
| |
| func (m *FaceAnnotation) GetJoyLikelihood() Likelihood { |
| if m != nil { |
| return m.JoyLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetSorrowLikelihood() Likelihood { |
| if m != nil { |
| return m.SorrowLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetAngerLikelihood() Likelihood { |
| if m != nil { |
| return m.AngerLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetSurpriseLikelihood() Likelihood { |
| if m != nil { |
| return m.SurpriseLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetUnderExposedLikelihood() Likelihood { |
| if m != nil { |
| return m.UnderExposedLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetBlurredLikelihood() Likelihood { |
| if m != nil { |
| return m.BlurredLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *FaceAnnotation) GetHeadwearLikelihood() Likelihood { |
| if m != nil { |
| return m.HeadwearLikelihood |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| // A face-specific landmark (for example, a face feature). |
| type FaceAnnotation_Landmark struct { |
| // Face landmark type. |
| Type FaceAnnotation_Landmark_Type `protobuf:"varint,3,opt,name=type,proto3,enum=google.cloud.vision.v1p3beta1.FaceAnnotation_Landmark_Type" json:"type,omitempty"` |
| // Face landmark position. |
| Position *Position `protobuf:"bytes,4,opt,name=position,proto3" json:"position,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *FaceAnnotation_Landmark) Reset() { *m = FaceAnnotation_Landmark{} } |
| func (m *FaceAnnotation_Landmark) String() string { return proto.CompactTextString(m) } |
| func (*FaceAnnotation_Landmark) ProtoMessage() {} |
| func (*FaceAnnotation_Landmark) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{3, 0} |
| } |
| func (m *FaceAnnotation_Landmark) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_FaceAnnotation_Landmark.Unmarshal(m, b) |
| } |
| func (m *FaceAnnotation_Landmark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_FaceAnnotation_Landmark.Marshal(b, m, deterministic) |
| } |
| func (dst *FaceAnnotation_Landmark) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FaceAnnotation_Landmark.Merge(dst, src) |
| } |
| func (m *FaceAnnotation_Landmark) XXX_Size() int { |
| return xxx_messageInfo_FaceAnnotation_Landmark.Size(m) |
| } |
| func (m *FaceAnnotation_Landmark) XXX_DiscardUnknown() { |
| xxx_messageInfo_FaceAnnotation_Landmark.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FaceAnnotation_Landmark proto.InternalMessageInfo |
| |
| func (m *FaceAnnotation_Landmark) GetType() FaceAnnotation_Landmark_Type { |
| if m != nil { |
| return m.Type |
| } |
| return FaceAnnotation_Landmark_UNKNOWN_LANDMARK |
| } |
| |
| func (m *FaceAnnotation_Landmark) GetPosition() *Position { |
| if m != nil { |
| return m.Position |
| } |
| return nil |
| } |
| |
| // Detected entity location information. |
| type LocationInfo struct { |
| // lat/long location coordinates. |
| LatLng *latlng.LatLng `protobuf:"bytes,1,opt,name=lat_lng,json=latLng,proto3" json:"lat_lng,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *LocationInfo) Reset() { *m = LocationInfo{} } |
| func (m *LocationInfo) String() string { return proto.CompactTextString(m) } |
| func (*LocationInfo) ProtoMessage() {} |
| func (*LocationInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{4} |
| } |
| func (m *LocationInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_LocationInfo.Unmarshal(m, b) |
| } |
| func (m *LocationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_LocationInfo.Marshal(b, m, deterministic) |
| } |
| func (dst *LocationInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_LocationInfo.Merge(dst, src) |
| } |
| func (m *LocationInfo) XXX_Size() int { |
| return xxx_messageInfo_LocationInfo.Size(m) |
| } |
| func (m *LocationInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_LocationInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_LocationInfo proto.InternalMessageInfo |
| |
| func (m *LocationInfo) GetLatLng() *latlng.LatLng { |
| if m != nil { |
| return m.LatLng |
| } |
| return nil |
| } |
| |
| // A `Property` consists of a user-supplied name/value pair. |
| type Property struct { |
| // Name of the property. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| // Value of the property. |
| Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
| // Value of numeric properties. |
| Uint64Value uint64 `protobuf:"varint,3,opt,name=uint64_value,json=uint64Value,proto3" json:"uint64_value,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Property) Reset() { *m = Property{} } |
| func (m *Property) String() string { return proto.CompactTextString(m) } |
| func (*Property) ProtoMessage() {} |
| func (*Property) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{5} |
| } |
| func (m *Property) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Property.Unmarshal(m, b) |
| } |
| func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Property.Marshal(b, m, deterministic) |
| } |
| func (dst *Property) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Property.Merge(dst, src) |
| } |
| func (m *Property) XXX_Size() int { |
| return xxx_messageInfo_Property.Size(m) |
| } |
| func (m *Property) XXX_DiscardUnknown() { |
| xxx_messageInfo_Property.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Property proto.InternalMessageInfo |
| |
| func (m *Property) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| func (m *Property) GetValue() string { |
| if m != nil { |
| return m.Value |
| } |
| return "" |
| } |
| |
| func (m *Property) GetUint64Value() uint64 { |
| if m != nil { |
| return m.Uint64Value |
| } |
| return 0 |
| } |
| |
| // Set of detected entity features. |
| type EntityAnnotation struct { |
| // Opaque entity ID. Some IDs may be available in |
| // [Google Knowledge Graph Search |
| // API](https://developers.google.com/knowledge-graph/). |
| Mid string `protobuf:"bytes,1,opt,name=mid,proto3" json:"mid,omitempty"` |
| // The language code for the locale in which the entity textual |
| // `description` is expressed. |
| Locale string `protobuf:"bytes,2,opt,name=locale,proto3" json:"locale,omitempty"` |
| // Entity textual description, expressed in its `locale` language. |
| Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` |
| // Overall score of the result. Range [0, 1]. |
| Score float32 `protobuf:"fixed32,4,opt,name=score,proto3" json:"score,omitempty"` |
| // **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]. |
| Confidence float32 `protobuf:"fixed32,5,opt,name=confidence,proto3" json:"confidence,omitempty"` |
| // 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]. |
| Topicality float32 `protobuf:"fixed32,6,opt,name=topicality,proto3" json:"topicality,omitempty"` |
| // Image region to which this entity belongs. Not produced |
| // for `LABEL_DETECTION` features. |
| BoundingPoly *BoundingPoly `protobuf:"bytes,7,opt,name=bounding_poly,json=boundingPoly,proto3" json:"bounding_poly,omitempty"` |
| // 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. |
| Locations []*LocationInfo `protobuf:"bytes,8,rep,name=locations,proto3" json:"locations,omitempty"` |
| // Some entities may have optional user-supplied `Property` (name/value) |
| // fields, such a score or string that qualifies the entity. |
| Properties []*Property `protobuf:"bytes,9,rep,name=properties,proto3" json:"properties,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *EntityAnnotation) Reset() { *m = EntityAnnotation{} } |
| func (m *EntityAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*EntityAnnotation) ProtoMessage() {} |
| func (*EntityAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{6} |
| } |
| func (m *EntityAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_EntityAnnotation.Unmarshal(m, b) |
| } |
| func (m *EntityAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_EntityAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *EntityAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_EntityAnnotation.Merge(dst, src) |
| } |
| func (m *EntityAnnotation) XXX_Size() int { |
| return xxx_messageInfo_EntityAnnotation.Size(m) |
| } |
| func (m *EntityAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_EntityAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_EntityAnnotation proto.InternalMessageInfo |
| |
| func (m *EntityAnnotation) GetMid() string { |
| if m != nil { |
| return m.Mid |
| } |
| return "" |
| } |
| |
| func (m *EntityAnnotation) GetLocale() string { |
| if m != nil { |
| return m.Locale |
| } |
| return "" |
| } |
| |
| func (m *EntityAnnotation) GetDescription() string { |
| if m != nil { |
| return m.Description |
| } |
| return "" |
| } |
| |
| func (m *EntityAnnotation) GetScore() float32 { |
| if m != nil { |
| return m.Score |
| } |
| return 0 |
| } |
| |
| func (m *EntityAnnotation) GetConfidence() float32 { |
| if m != nil { |
| return m.Confidence |
| } |
| return 0 |
| } |
| |
| func (m *EntityAnnotation) GetTopicality() float32 { |
| if m != nil { |
| return m.Topicality |
| } |
| return 0 |
| } |
| |
| func (m *EntityAnnotation) GetBoundingPoly() *BoundingPoly { |
| if m != nil { |
| return m.BoundingPoly |
| } |
| return nil |
| } |
| |
| func (m *EntityAnnotation) GetLocations() []*LocationInfo { |
| if m != nil { |
| return m.Locations |
| } |
| return nil |
| } |
| |
| func (m *EntityAnnotation) GetProperties() []*Property { |
| if m != nil { |
| return m.Properties |
| } |
| return nil |
| } |
| |
| // Set of detected objects with bounding boxes. |
| type LocalizedObjectAnnotation struct { |
| // Object ID that should align with EntityAnnotation mid. |
| Mid string `protobuf:"bytes,1,opt,name=mid,proto3" json:"mid,omitempty"` |
| // 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. |
| LanguageCode string `protobuf:"bytes,2,opt,name=language_code,json=languageCode,proto3" json:"language_code,omitempty"` |
| // Object name, expressed in its `language_code` language. |
| Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` |
| // Score of the result. Range [0, 1]. |
| Score float32 `protobuf:"fixed32,4,opt,name=score,proto3" json:"score,omitempty"` |
| // Image region to which this object belongs. This must be populated. |
| BoundingPoly *BoundingPoly `protobuf:"bytes,5,opt,name=bounding_poly,json=boundingPoly,proto3" json:"bounding_poly,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *LocalizedObjectAnnotation) Reset() { *m = LocalizedObjectAnnotation{} } |
| func (m *LocalizedObjectAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*LocalizedObjectAnnotation) ProtoMessage() {} |
| func (*LocalizedObjectAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{7} |
| } |
| func (m *LocalizedObjectAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_LocalizedObjectAnnotation.Unmarshal(m, b) |
| } |
| func (m *LocalizedObjectAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_LocalizedObjectAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *LocalizedObjectAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_LocalizedObjectAnnotation.Merge(dst, src) |
| } |
| func (m *LocalizedObjectAnnotation) XXX_Size() int { |
| return xxx_messageInfo_LocalizedObjectAnnotation.Size(m) |
| } |
| func (m *LocalizedObjectAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_LocalizedObjectAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_LocalizedObjectAnnotation proto.InternalMessageInfo |
| |
| func (m *LocalizedObjectAnnotation) GetMid() string { |
| if m != nil { |
| return m.Mid |
| } |
| return "" |
| } |
| |
| func (m *LocalizedObjectAnnotation) GetLanguageCode() string { |
| if m != nil { |
| return m.LanguageCode |
| } |
| return "" |
| } |
| |
| func (m *LocalizedObjectAnnotation) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| func (m *LocalizedObjectAnnotation) GetScore() float32 { |
| if m != nil { |
| return m.Score |
| } |
| return 0 |
| } |
| |
| func (m *LocalizedObjectAnnotation) GetBoundingPoly() *BoundingPoly { |
| if m != nil { |
| return m.BoundingPoly |
| } |
| return nil |
| } |
| |
| // Set of features pertaining to the image, computed by computer vision |
| // methods over safe-search verticals (for example, adult, spoof, medical, |
| // violence). |
| type SafeSearchAnnotation struct { |
| // Represents the adult content likelihood for the image. Adult content may |
| // contain elements such as nudity, pornographic images or cartoons, or |
| // sexual activities. |
| Adult Likelihood `protobuf:"varint,1,opt,name=adult,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"adult,omitempty"` |
| // Spoof likelihood. The likelihood that an modification |
| // was made to the image's canonical version to make it appear |
| // funny or offensive. |
| Spoof Likelihood `protobuf:"varint,2,opt,name=spoof,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"spoof,omitempty"` |
| // Likelihood that this is a medical image. |
| Medical Likelihood `protobuf:"varint,3,opt,name=medical,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"medical,omitempty"` |
| // Likelihood that this image contains violent content. |
| Violence Likelihood `protobuf:"varint,4,opt,name=violence,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"violence,omitempty"` |
| // 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. |
| Racy Likelihood `protobuf:"varint,9,opt,name=racy,proto3,enum=google.cloud.vision.v1p3beta1.Likelihood" json:"racy,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *SafeSearchAnnotation) Reset() { *m = SafeSearchAnnotation{} } |
| func (m *SafeSearchAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*SafeSearchAnnotation) ProtoMessage() {} |
| func (*SafeSearchAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{8} |
| } |
| func (m *SafeSearchAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_SafeSearchAnnotation.Unmarshal(m, b) |
| } |
| func (m *SafeSearchAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_SafeSearchAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *SafeSearchAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SafeSearchAnnotation.Merge(dst, src) |
| } |
| func (m *SafeSearchAnnotation) XXX_Size() int { |
| return xxx_messageInfo_SafeSearchAnnotation.Size(m) |
| } |
| func (m *SafeSearchAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_SafeSearchAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SafeSearchAnnotation proto.InternalMessageInfo |
| |
| func (m *SafeSearchAnnotation) GetAdult() Likelihood { |
| if m != nil { |
| return m.Adult |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *SafeSearchAnnotation) GetSpoof() Likelihood { |
| if m != nil { |
| return m.Spoof |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *SafeSearchAnnotation) GetMedical() Likelihood { |
| if m != nil { |
| return m.Medical |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *SafeSearchAnnotation) GetViolence() Likelihood { |
| if m != nil { |
| return m.Violence |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| func (m *SafeSearchAnnotation) GetRacy() Likelihood { |
| if m != nil { |
| return m.Racy |
| } |
| return Likelihood_UNKNOWN |
| } |
| |
| // Rectangle determined by min and max `LatLng` pairs. |
| type LatLongRect struct { |
| // Min lat/long pair. |
| MinLatLng *latlng.LatLng `protobuf:"bytes,1,opt,name=min_lat_lng,json=minLatLng,proto3" json:"min_lat_lng,omitempty"` |
| // Max lat/long pair. |
| MaxLatLng *latlng.LatLng `protobuf:"bytes,2,opt,name=max_lat_lng,json=maxLatLng,proto3" json:"max_lat_lng,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *LatLongRect) Reset() { *m = LatLongRect{} } |
| func (m *LatLongRect) String() string { return proto.CompactTextString(m) } |
| func (*LatLongRect) ProtoMessage() {} |
| func (*LatLongRect) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{9} |
| } |
| func (m *LatLongRect) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_LatLongRect.Unmarshal(m, b) |
| } |
| func (m *LatLongRect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_LatLongRect.Marshal(b, m, deterministic) |
| } |
| func (dst *LatLongRect) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_LatLongRect.Merge(dst, src) |
| } |
| func (m *LatLongRect) XXX_Size() int { |
| return xxx_messageInfo_LatLongRect.Size(m) |
| } |
| func (m *LatLongRect) XXX_DiscardUnknown() { |
| xxx_messageInfo_LatLongRect.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_LatLongRect proto.InternalMessageInfo |
| |
| func (m *LatLongRect) GetMinLatLng() *latlng.LatLng { |
| if m != nil { |
| return m.MinLatLng |
| } |
| return nil |
| } |
| |
| func (m *LatLongRect) GetMaxLatLng() *latlng.LatLng { |
| if m != nil { |
| return m.MaxLatLng |
| } |
| return nil |
| } |
| |
| // Color information consists of RGB channels, score, and the fraction of |
| // the image that the color occupies in the image. |
| type ColorInfo struct { |
| // RGB components of the color. |
| Color *color.Color `protobuf:"bytes,1,opt,name=color,proto3" json:"color,omitempty"` |
| // Image-specific score for this color. Value in range [0, 1]. |
| Score float32 `protobuf:"fixed32,2,opt,name=score,proto3" json:"score,omitempty"` |
| // The fraction of pixels the color occupies in the image. |
| // Value in range [0, 1]. |
| PixelFraction float32 `protobuf:"fixed32,3,opt,name=pixel_fraction,json=pixelFraction,proto3" json:"pixel_fraction,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ColorInfo) Reset() { *m = ColorInfo{} } |
| func (m *ColorInfo) String() string { return proto.CompactTextString(m) } |
| func (*ColorInfo) ProtoMessage() {} |
| func (*ColorInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{10} |
| } |
| func (m *ColorInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ColorInfo.Unmarshal(m, b) |
| } |
| func (m *ColorInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ColorInfo.Marshal(b, m, deterministic) |
| } |
| func (dst *ColorInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ColorInfo.Merge(dst, src) |
| } |
| func (m *ColorInfo) XXX_Size() int { |
| return xxx_messageInfo_ColorInfo.Size(m) |
| } |
| func (m *ColorInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_ColorInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ColorInfo proto.InternalMessageInfo |
| |
| func (m *ColorInfo) GetColor() *color.Color { |
| if m != nil { |
| return m.Color |
| } |
| return nil |
| } |
| |
| func (m *ColorInfo) GetScore() float32 { |
| if m != nil { |
| return m.Score |
| } |
| return 0 |
| } |
| |
| func (m *ColorInfo) GetPixelFraction() float32 { |
| if m != nil { |
| return m.PixelFraction |
| } |
| return 0 |
| } |
| |
| // Set of dominant colors and their corresponding scores. |
| type DominantColorsAnnotation struct { |
| // RGB color values with their score and pixel fraction. |
| Colors []*ColorInfo `protobuf:"bytes,1,rep,name=colors,proto3" json:"colors,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *DominantColorsAnnotation) Reset() { *m = DominantColorsAnnotation{} } |
| func (m *DominantColorsAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*DominantColorsAnnotation) ProtoMessage() {} |
| func (*DominantColorsAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{11} |
| } |
| func (m *DominantColorsAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_DominantColorsAnnotation.Unmarshal(m, b) |
| } |
| func (m *DominantColorsAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_DominantColorsAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *DominantColorsAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DominantColorsAnnotation.Merge(dst, src) |
| } |
| func (m *DominantColorsAnnotation) XXX_Size() int { |
| return xxx_messageInfo_DominantColorsAnnotation.Size(m) |
| } |
| func (m *DominantColorsAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_DominantColorsAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DominantColorsAnnotation proto.InternalMessageInfo |
| |
| func (m *DominantColorsAnnotation) GetColors() []*ColorInfo { |
| if m != nil { |
| return m.Colors |
| } |
| return nil |
| } |
| |
| // Stores image properties, such as dominant colors. |
| type ImageProperties struct { |
| // If present, dominant colors completed successfully. |
| DominantColors *DominantColorsAnnotation `protobuf:"bytes,1,opt,name=dominant_colors,json=dominantColors,proto3" json:"dominant_colors,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ImageProperties) Reset() { *m = ImageProperties{} } |
| func (m *ImageProperties) String() string { return proto.CompactTextString(m) } |
| func (*ImageProperties) ProtoMessage() {} |
| func (*ImageProperties) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{12} |
| } |
| func (m *ImageProperties) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ImageProperties.Unmarshal(m, b) |
| } |
| func (m *ImageProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ImageProperties.Marshal(b, m, deterministic) |
| } |
| func (dst *ImageProperties) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ImageProperties.Merge(dst, src) |
| } |
| func (m *ImageProperties) XXX_Size() int { |
| return xxx_messageInfo_ImageProperties.Size(m) |
| } |
| func (m *ImageProperties) XXX_DiscardUnknown() { |
| xxx_messageInfo_ImageProperties.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ImageProperties proto.InternalMessageInfo |
| |
| func (m *ImageProperties) GetDominantColors() *DominantColorsAnnotation { |
| if m != nil { |
| return m.DominantColors |
| } |
| return nil |
| } |
| |
| // Single crop hint that is used to generate a new crop when serving an image. |
| type CropHint struct { |
| // The bounding polygon for the crop region. The coordinates of the bounding |
| // box are in the original image's scale, as returned in `ImageParams`. |
| BoundingPoly *BoundingPoly `protobuf:"bytes,1,opt,name=bounding_poly,json=boundingPoly,proto3" json:"bounding_poly,omitempty"` |
| // Confidence of this being a salient region. Range [0, 1]. |
| Confidence float32 `protobuf:"fixed32,2,opt,name=confidence,proto3" json:"confidence,omitempty"` |
| // Fraction of importance of this salient region with respect to the original |
| // image. |
| ImportanceFraction float32 `protobuf:"fixed32,3,opt,name=importance_fraction,json=importanceFraction,proto3" json:"importance_fraction,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CropHint) Reset() { *m = CropHint{} } |
| func (m *CropHint) String() string { return proto.CompactTextString(m) } |
| func (*CropHint) ProtoMessage() {} |
| func (*CropHint) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{13} |
| } |
| func (m *CropHint) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CropHint.Unmarshal(m, b) |
| } |
| func (m *CropHint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CropHint.Marshal(b, m, deterministic) |
| } |
| func (dst *CropHint) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CropHint.Merge(dst, src) |
| } |
| func (m *CropHint) XXX_Size() int { |
| return xxx_messageInfo_CropHint.Size(m) |
| } |
| func (m *CropHint) XXX_DiscardUnknown() { |
| xxx_messageInfo_CropHint.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CropHint proto.InternalMessageInfo |
| |
| func (m *CropHint) GetBoundingPoly() *BoundingPoly { |
| if m != nil { |
| return m.BoundingPoly |
| } |
| return nil |
| } |
| |
| func (m *CropHint) GetConfidence() float32 { |
| if m != nil { |
| return m.Confidence |
| } |
| return 0 |
| } |
| |
| func (m *CropHint) GetImportanceFraction() float32 { |
| if m != nil { |
| return m.ImportanceFraction |
| } |
| return 0 |
| } |
| |
| // Set of crop hints that are used to generate new crops when serving images. |
| type CropHintsAnnotation struct { |
| // Crop hint results. |
| CropHints []*CropHint `protobuf:"bytes,1,rep,name=crop_hints,json=cropHints,proto3" json:"crop_hints,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CropHintsAnnotation) Reset() { *m = CropHintsAnnotation{} } |
| func (m *CropHintsAnnotation) String() string { return proto.CompactTextString(m) } |
| func (*CropHintsAnnotation) ProtoMessage() {} |
| func (*CropHintsAnnotation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{14} |
| } |
| func (m *CropHintsAnnotation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CropHintsAnnotation.Unmarshal(m, b) |
| } |
| func (m *CropHintsAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CropHintsAnnotation.Marshal(b, m, deterministic) |
| } |
| func (dst *CropHintsAnnotation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CropHintsAnnotation.Merge(dst, src) |
| } |
| func (m *CropHintsAnnotation) XXX_Size() int { |
| return xxx_messageInfo_CropHintsAnnotation.Size(m) |
| } |
| func (m *CropHintsAnnotation) XXX_DiscardUnknown() { |
| xxx_messageInfo_CropHintsAnnotation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CropHintsAnnotation proto.InternalMessageInfo |
| |
| func (m *CropHintsAnnotation) GetCropHints() []*CropHint { |
| if m != nil { |
| return m.CropHints |
| } |
| return nil |
| } |
| |
| // Parameters for crop hints annotation request. |
| type CropHintsParams struct { |
| // Aspect ratios in floats, representing the ratio of the width to the height |
| // of the image. For example, if the desired aspect ratio is 4/3, the |
| // corresponding float value should be 1.33333. If not specified, the |
| // best possible crop is returned. The number of provided aspect ratios is |
| // limited to a maximum of 16; any aspect ratios provided after the 16th are |
| // ignored. |
| AspectRatios []float32 `protobuf:"fixed32,1,rep,packed,name=aspect_ratios,json=aspectRatios,proto3" json:"aspect_ratios,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CropHintsParams) Reset() { *m = CropHintsParams{} } |
| func (m *CropHintsParams) String() string { return proto.CompactTextString(m) } |
| func (*CropHintsParams) ProtoMessage() {} |
| func (*CropHintsParams) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{15} |
| } |
| func (m *CropHintsParams) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CropHintsParams.Unmarshal(m, b) |
| } |
| func (m *CropHintsParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CropHintsParams.Marshal(b, m, deterministic) |
| } |
| func (dst *CropHintsParams) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CropHintsParams.Merge(dst, src) |
| } |
| func (m *CropHintsParams) XXX_Size() int { |
| return xxx_messageInfo_CropHintsParams.Size(m) |
| } |
| func (m *CropHintsParams) XXX_DiscardUnknown() { |
| xxx_messageInfo_CropHintsParams.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CropHintsParams proto.InternalMessageInfo |
| |
| func (m *CropHintsParams) GetAspectRatios() []float32 { |
| if m != nil { |
| return m.AspectRatios |
| } |
| return nil |
| } |
| |
| // Parameters for web detection request. |
| type WebDetectionParams struct { |
| // Whether to include results derived from the geo information in the image. |
| IncludeGeoResults bool `protobuf:"varint,2,opt,name=include_geo_results,json=includeGeoResults,proto3" json:"include_geo_results,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *WebDetectionParams) Reset() { *m = WebDetectionParams{} } |
| func (m *WebDetectionParams) String() string { return proto.CompactTextString(m) } |
| func (*WebDetectionParams) ProtoMessage() {} |
| func (*WebDetectionParams) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{16} |
| } |
| func (m *WebDetectionParams) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_WebDetectionParams.Unmarshal(m, b) |
| } |
| func (m *WebDetectionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_WebDetectionParams.Marshal(b, m, deterministic) |
| } |
| func (dst *WebDetectionParams) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_WebDetectionParams.Merge(dst, src) |
| } |
| func (m *WebDetectionParams) XXX_Size() int { |
| return xxx_messageInfo_WebDetectionParams.Size(m) |
| } |
| func (m *WebDetectionParams) XXX_DiscardUnknown() { |
| xxx_messageInfo_WebDetectionParams.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_WebDetectionParams proto.InternalMessageInfo |
| |
| func (m *WebDetectionParams) GetIncludeGeoResults() bool { |
| if m != nil { |
| return m.IncludeGeoResults |
| } |
| return false |
| } |
| |
| // Image context and/or feature-specific parameters. |
| type ImageContext struct { |
| // Not used. |
| LatLongRect *LatLongRect `protobuf:"bytes,1,opt,name=lat_long_rect,json=latLongRect,proto3" json:"lat_long_rect,omitempty"` |
| // List of languages to use for TEXT_DETECTION. In most cases, an empty value |
| // yields the best results since it enables automatic language detection. For |
| // languages based on the Latin alphabet, setting `language_hints` is not |
| // needed. In rare cases, when the language of the text in the image is known, |
| // setting a hint will help get better results (although it will be a |
| // significant hindrance if the hint is wrong). Text detection returns an |
| // error if one or more of the specified languages is not one of the |
| // [supported languages](/vision/docs/languages). |
| LanguageHints []string `protobuf:"bytes,2,rep,name=language_hints,json=languageHints,proto3" json:"language_hints,omitempty"` |
| // Parameters for crop hints annotation request. |
| CropHintsParams *CropHintsParams `protobuf:"bytes,4,opt,name=crop_hints_params,json=cropHintsParams,proto3" json:"crop_hints_params,omitempty"` |
| // Parameters for product search. |
| ProductSearchParams *ProductSearchParams `protobuf:"bytes,5,opt,name=product_search_params,json=productSearchParams,proto3" json:"product_search_params,omitempty"` |
| // Parameters for web detection. |
| WebDetectionParams *WebDetectionParams `protobuf:"bytes,6,opt,name=web_detection_params,json=webDetectionParams,proto3" json:"web_detection_params,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ImageContext) Reset() { *m = ImageContext{} } |
| func (m *ImageContext) String() string { return proto.CompactTextString(m) } |
| func (*ImageContext) ProtoMessage() {} |
| func (*ImageContext) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{17} |
| } |
| func (m *ImageContext) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ImageContext.Unmarshal(m, b) |
| } |
| func (m *ImageContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ImageContext.Marshal(b, m, deterministic) |
| } |
| func (dst *ImageContext) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ImageContext.Merge(dst, src) |
| } |
| func (m *ImageContext) XXX_Size() int { |
| return xxx_messageInfo_ImageContext.Size(m) |
| } |
| func (m *ImageContext) XXX_DiscardUnknown() { |
| xxx_messageInfo_ImageContext.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ImageContext proto.InternalMessageInfo |
| |
| func (m *ImageContext) GetLatLongRect() *LatLongRect { |
| if m != nil { |
| return m.LatLongRect |
| } |
| return nil |
| } |
| |
| func (m *ImageContext) GetLanguageHints() []string { |
| if m != nil { |
| return m.LanguageHints |
| } |
| return nil |
| } |
| |
| func (m *ImageContext) GetCropHintsParams() *CropHintsParams { |
| if m != nil { |
| return m.CropHintsParams |
| } |
| return nil |
| } |
| |
| func (m *ImageContext) GetProductSearchParams() *ProductSearchParams { |
| if m != nil { |
| return m.ProductSearchParams |
| } |
| return nil |
| } |
| |
| func (m *ImageContext) GetWebDetectionParams() *WebDetectionParams { |
| if m != nil { |
| return m.WebDetectionParams |
| } |
| return nil |
| } |
| |
| // Request for performing Google Cloud Vision API tasks over a user-provided |
| // image, with user-requested features. |
| type AnnotateImageRequest struct { |
| // The image to be processed. |
| Image *Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` |
| // Requested features. |
| Features []*Feature `protobuf:"bytes,2,rep,name=features,proto3" json:"features,omitempty"` |
| // Additional context that may accompany the image. |
| ImageContext *ImageContext `protobuf:"bytes,3,opt,name=image_context,json=imageContext,proto3" json:"image_context,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AnnotateImageRequest) Reset() { *m = AnnotateImageRequest{} } |
| func (m *AnnotateImageRequest) String() string { return proto.CompactTextString(m) } |
| func (*AnnotateImageRequest) ProtoMessage() {} |
| func (*AnnotateImageRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{18} |
| } |
| func (m *AnnotateImageRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AnnotateImageRequest.Unmarshal(m, b) |
| } |
| func (m *AnnotateImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AnnotateImageRequest.Marshal(b, m, deterministic) |
| } |
| func (dst *AnnotateImageRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AnnotateImageRequest.Merge(dst, src) |
| } |
| func (m *AnnotateImageRequest) XXX_Size() int { |
| return xxx_messageInfo_AnnotateImageRequest.Size(m) |
| } |
| func (m *AnnotateImageRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_AnnotateImageRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AnnotateImageRequest proto.InternalMessageInfo |
| |
| func (m *AnnotateImageRequest) GetImage() *Image { |
| if m != nil { |
| return m.Image |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageRequest) GetFeatures() []*Feature { |
| if m != nil { |
| return m.Features |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageRequest) GetImageContext() *ImageContext { |
| if m != nil { |
| return m.ImageContext |
| } |
| return nil |
| } |
| |
| // If an image was produced from a file (e.g. a PDF), this message gives |
| // information about the source of that image. |
| type ImageAnnotationContext struct { |
| // The URI of the file used to produce the image. |
| Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` |
| // If the file was a PDF or TIFF, this field gives the page number within |
| // the file used to produce the image. |
| PageNumber int32 `protobuf:"varint,2,opt,name=page_number,json=pageNumber,proto3" json:"page_number,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ImageAnnotationContext) Reset() { *m = ImageAnnotationContext{} } |
| func (m *ImageAnnotationContext) String() string { return proto.CompactTextString(m) } |
| func (*ImageAnnotationContext) ProtoMessage() {} |
| func (*ImageAnnotationContext) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{19} |
| } |
| func (m *ImageAnnotationContext) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ImageAnnotationContext.Unmarshal(m, b) |
| } |
| func (m *ImageAnnotationContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ImageAnnotationContext.Marshal(b, m, deterministic) |
| } |
| func (dst *ImageAnnotationContext) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ImageAnnotationContext.Merge(dst, src) |
| } |
| func (m *ImageAnnotationContext) XXX_Size() int { |
| return xxx_messageInfo_ImageAnnotationContext.Size(m) |
| } |
| func (m *ImageAnnotationContext) XXX_DiscardUnknown() { |
| xxx_messageInfo_ImageAnnotationContext.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ImageAnnotationContext proto.InternalMessageInfo |
| |
| func (m *ImageAnnotationContext) GetUri() string { |
| if m != nil { |
| return m.Uri |
| } |
| return "" |
| } |
| |
| func (m *ImageAnnotationContext) GetPageNumber() int32 { |
| if m != nil { |
| return m.PageNumber |
| } |
| return 0 |
| } |
| |
| // Response to an image annotation request. |
| type AnnotateImageResponse struct { |
| // If present, face detection has completed successfully. |
| FaceAnnotations []*FaceAnnotation `protobuf:"bytes,1,rep,name=face_annotations,json=faceAnnotations,proto3" json:"face_annotations,omitempty"` |
| // If present, landmark detection has completed successfully. |
| LandmarkAnnotations []*EntityAnnotation `protobuf:"bytes,2,rep,name=landmark_annotations,json=landmarkAnnotations,proto3" json:"landmark_annotations,omitempty"` |
| // If present, logo detection has completed successfully. |
| LogoAnnotations []*EntityAnnotation `protobuf:"bytes,3,rep,name=logo_annotations,json=logoAnnotations,proto3" json:"logo_annotations,omitempty"` |
| // If present, label detection has completed successfully. |
| LabelAnnotations []*EntityAnnotation `protobuf:"bytes,4,rep,name=label_annotations,json=labelAnnotations,proto3" json:"label_annotations,omitempty"` |
| // If present, localized object detection has completed successfully. |
| // This will be sorted descending by confidence score. |
| LocalizedObjectAnnotations []*LocalizedObjectAnnotation `protobuf:"bytes,22,rep,name=localized_object_annotations,json=localizedObjectAnnotations,proto3" json:"localized_object_annotations,omitempty"` |
| // If present, text (OCR) detection has completed successfully. |
| TextAnnotations []*EntityAnnotation `protobuf:"bytes,5,rep,name=text_annotations,json=textAnnotations,proto3" json:"text_annotations,omitempty"` |
| // If present, text (OCR) detection or document (OCR) text detection has |
| // completed successfully. |
| // This annotation provides the structural hierarchy for the OCR detected |
| // text. |
| FullTextAnnotation *TextAnnotation `protobuf:"bytes,12,opt,name=full_text_annotation,json=fullTextAnnotation,proto3" json:"full_text_annotation,omitempty"` |
| // If present, safe-search annotation has completed successfully. |
| SafeSearchAnnotation *SafeSearchAnnotation `protobuf:"bytes,6,opt,name=safe_search_annotation,json=safeSearchAnnotation,proto3" json:"safe_search_annotation,omitempty"` |
| // If present, image properties were extracted successfully. |
| ImagePropertiesAnnotation *ImageProperties `protobuf:"bytes,8,opt,name=image_properties_annotation,json=imagePropertiesAnnotation,proto3" json:"image_properties_annotation,omitempty"` |
| // If present, crop hints have completed successfully. |
| CropHintsAnnotation *CropHintsAnnotation `protobuf:"bytes,11,opt,name=crop_hints_annotation,json=cropHintsAnnotation,proto3" json:"crop_hints_annotation,omitempty"` |
| // If present, web detection has completed successfully. |
| WebDetection *WebDetection `protobuf:"bytes,13,opt,name=web_detection,json=webDetection,proto3" json:"web_detection,omitempty"` |
| // If present, product search has completed successfully. |
| ProductSearchResults *ProductSearchResults `protobuf:"bytes,14,opt,name=product_search_results,json=productSearchResults,proto3" json:"product_search_results,omitempty"` |
| // If set, represents the error message for the operation. |
| // Note that filled-in image annotations are guaranteed to be |
| // correct, even when `error` is set. |
| Error *status.Status `protobuf:"bytes,9,opt,name=error,proto3" json:"error,omitempty"` |
| // If present, contextual information is needed to understand where this image |
| // comes from. |
| Context *ImageAnnotationContext `protobuf:"bytes,21,opt,name=context,proto3" json:"context,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AnnotateImageResponse) Reset() { *m = AnnotateImageResponse{} } |
| func (m *AnnotateImageResponse) String() string { return proto.CompactTextString(m) } |
| func (*AnnotateImageResponse) ProtoMessage() {} |
| func (*AnnotateImageResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{20} |
| } |
| func (m *AnnotateImageResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AnnotateImageResponse.Unmarshal(m, b) |
| } |
| func (m *AnnotateImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AnnotateImageResponse.Marshal(b, m, deterministic) |
| } |
| func (dst *AnnotateImageResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AnnotateImageResponse.Merge(dst, src) |
| } |
| func (m *AnnotateImageResponse) XXX_Size() int { |
| return xxx_messageInfo_AnnotateImageResponse.Size(m) |
| } |
| func (m *AnnotateImageResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_AnnotateImageResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AnnotateImageResponse proto.InternalMessageInfo |
| |
| func (m *AnnotateImageResponse) GetFaceAnnotations() []*FaceAnnotation { |
| if m != nil { |
| return m.FaceAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetLandmarkAnnotations() []*EntityAnnotation { |
| if m != nil { |
| return m.LandmarkAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetLogoAnnotations() []*EntityAnnotation { |
| if m != nil { |
| return m.LogoAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetLabelAnnotations() []*EntityAnnotation { |
| if m != nil { |
| return m.LabelAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetLocalizedObjectAnnotations() []*LocalizedObjectAnnotation { |
| if m != nil { |
| return m.LocalizedObjectAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetTextAnnotations() []*EntityAnnotation { |
| if m != nil { |
| return m.TextAnnotations |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetFullTextAnnotation() *TextAnnotation { |
| if m != nil { |
| return m.FullTextAnnotation |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetSafeSearchAnnotation() *SafeSearchAnnotation { |
| if m != nil { |
| return m.SafeSearchAnnotation |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetImagePropertiesAnnotation() *ImageProperties { |
| if m != nil { |
| return m.ImagePropertiesAnnotation |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetCropHintsAnnotation() *CropHintsAnnotation { |
| if m != nil { |
| return m.CropHintsAnnotation |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetWebDetection() *WebDetection { |
| if m != nil { |
| return m.WebDetection |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetProductSearchResults() *ProductSearchResults { |
| if m != nil { |
| return m.ProductSearchResults |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetError() *status.Status { |
| if m != nil { |
| return m.Error |
| } |
| return nil |
| } |
| |
| func (m *AnnotateImageResponse) GetContext() *ImageAnnotationContext { |
| if m != nil { |
| return m.Context |
| } |
| return nil |
| } |
| |
| // Response to a single file annotation request. A file may contain one or more |
| // images, which individually have their own responses. |
| type AnnotateFileResponse struct { |
| // Information about the file for which this response is generated. |
| InputConfig *InputConfig `protobuf:"bytes,1,opt,name=input_config,json=inputConfig,proto3" json:"input_config,omitempty"` |
| // Individual responses to images found within the file. |
| Responses []*AnnotateImageResponse `protobuf:"bytes,2,rep,name=responses,proto3" json:"responses,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AnnotateFileResponse) Reset() { *m = AnnotateFileResponse{} } |
| func (m *AnnotateFileResponse) String() string { return proto.CompactTextString(m) } |
| func (*AnnotateFileResponse) ProtoMessage() {} |
| func (*AnnotateFileResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{21} |
| } |
| func (m *AnnotateFileResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AnnotateFileResponse.Unmarshal(m, b) |
| } |
| func (m *AnnotateFileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AnnotateFileResponse.Marshal(b, m, deterministic) |
| } |
| func (dst *AnnotateFileResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AnnotateFileResponse.Merge(dst, src) |
| } |
| func (m *AnnotateFileResponse) XXX_Size() int { |
| return xxx_messageInfo_AnnotateFileResponse.Size(m) |
| } |
| func (m *AnnotateFileResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_AnnotateFileResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AnnotateFileResponse proto.InternalMessageInfo |
| |
| func (m *AnnotateFileResponse) GetInputConfig() *InputConfig { |
| if m != nil { |
| return m.InputConfig |
| } |
| return nil |
| } |
| |
| func (m *AnnotateFileResponse) GetResponses() []*AnnotateImageResponse { |
| if m != nil { |
| return m.Responses |
| } |
| return nil |
| } |
| |
| // Multiple image annotation requests are batched into a single service call. |
| type BatchAnnotateImagesRequest struct { |
| // Individual image annotation requests for this batch. |
| Requests []*AnnotateImageRequest `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BatchAnnotateImagesRequest) Reset() { *m = BatchAnnotateImagesRequest{} } |
| func (m *BatchAnnotateImagesRequest) String() string { return proto.CompactTextString(m) } |
| func (*BatchAnnotateImagesRequest) ProtoMessage() {} |
| func (*BatchAnnotateImagesRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{22} |
| } |
| func (m *BatchAnnotateImagesRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BatchAnnotateImagesRequest.Unmarshal(m, b) |
| } |
| func (m *BatchAnnotateImagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BatchAnnotateImagesRequest.Marshal(b, m, deterministic) |
| } |
| func (dst *BatchAnnotateImagesRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BatchAnnotateImagesRequest.Merge(dst, src) |
| } |
| func (m *BatchAnnotateImagesRequest) XXX_Size() int { |
| return xxx_messageInfo_BatchAnnotateImagesRequest.Size(m) |
| } |
| func (m *BatchAnnotateImagesRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_BatchAnnotateImagesRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BatchAnnotateImagesRequest proto.InternalMessageInfo |
| |
| func (m *BatchAnnotateImagesRequest) GetRequests() []*AnnotateImageRequest { |
| if m != nil { |
| return m.Requests |
| } |
| return nil |
| } |
| |
| // Response to a batch image annotation request. |
| type BatchAnnotateImagesResponse struct { |
| // Individual responses to image annotation requests within the batch. |
| Responses []*AnnotateImageResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BatchAnnotateImagesResponse) Reset() { *m = BatchAnnotateImagesResponse{} } |
| func (m *BatchAnnotateImagesResponse) String() string { return proto.CompactTextString(m) } |
| func (*BatchAnnotateImagesResponse) ProtoMessage() {} |
| func (*BatchAnnotateImagesResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{23} |
| } |
| func (m *BatchAnnotateImagesResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BatchAnnotateImagesResponse.Unmarshal(m, b) |
| } |
| func (m *BatchAnnotateImagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BatchAnnotateImagesResponse.Marshal(b, m, deterministic) |
| } |
| func (dst *BatchAnnotateImagesResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BatchAnnotateImagesResponse.Merge(dst, src) |
| } |
| func (m *BatchAnnotateImagesResponse) XXX_Size() int { |
| return xxx_messageInfo_BatchAnnotateImagesResponse.Size(m) |
| } |
| func (m *BatchAnnotateImagesResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_BatchAnnotateImagesResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BatchAnnotateImagesResponse proto.InternalMessageInfo |
| |
| func (m *BatchAnnotateImagesResponse) GetResponses() []*AnnotateImageResponse { |
| if m != nil { |
| return m.Responses |
| } |
| return nil |
| } |
| |
| // An offline file annotation request. |
| type AsyncAnnotateFileRequest struct { |
| // Required. Information about the input file. |
| InputConfig *InputConfig `protobuf:"bytes,1,opt,name=input_config,json=inputConfig,proto3" json:"input_config,omitempty"` |
| // Required. Requested features. |
| Features []*Feature `protobuf:"bytes,2,rep,name=features,proto3" json:"features,omitempty"` |
| // Additional context that may accompany the image(s) in the file. |
| ImageContext *ImageContext `protobuf:"bytes,3,opt,name=image_context,json=imageContext,proto3" json:"image_context,omitempty"` |
| // Required. The desired output location and metadata (e.g. format). |
| OutputConfig *OutputConfig `protobuf:"bytes,4,opt,name=output_config,json=outputConfig,proto3" json:"output_config,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AsyncAnnotateFileRequest) Reset() { *m = AsyncAnnotateFileRequest{} } |
| func (m *AsyncAnnotateFileRequest) String() string { return proto.CompactTextString(m) } |
| func (*AsyncAnnotateFileRequest) ProtoMessage() {} |
| func (*AsyncAnnotateFileRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{24} |
| } |
| func (m *AsyncAnnotateFileRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AsyncAnnotateFileRequest.Unmarshal(m, b) |
| } |
| func (m *AsyncAnnotateFileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AsyncAnnotateFileRequest.Marshal(b, m, deterministic) |
| } |
| func (dst *AsyncAnnotateFileRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AsyncAnnotateFileRequest.Merge(dst, src) |
| } |
| func (m *AsyncAnnotateFileRequest) XXX_Size() int { |
| return xxx_messageInfo_AsyncAnnotateFileRequest.Size(m) |
| } |
| func (m *AsyncAnnotateFileRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_AsyncAnnotateFileRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AsyncAnnotateFileRequest proto.InternalMessageInfo |
| |
| func (m *AsyncAnnotateFileRequest) GetInputConfig() *InputConfig { |
| if m != nil { |
| return m.InputConfig |
| } |
| return nil |
| } |
| |
| func (m *AsyncAnnotateFileRequest) GetFeatures() []*Feature { |
| if m != nil { |
| return m.Features |
| } |
| return nil |
| } |
| |
| func (m *AsyncAnnotateFileRequest) GetImageContext() *ImageContext { |
| if m != nil { |
| return m.ImageContext |
| } |
| return nil |
| } |
| |
| func (m *AsyncAnnotateFileRequest) GetOutputConfig() *OutputConfig { |
| if m != nil { |
| return m.OutputConfig |
| } |
| return nil |
| } |
| |
| // The response for a single offline file annotation request. |
| type AsyncAnnotateFileResponse struct { |
| // The output location and metadata from AsyncAnnotateFileRequest. |
| OutputConfig *OutputConfig `protobuf:"bytes,1,opt,name=output_config,json=outputConfig,proto3" json:"output_config,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AsyncAnnotateFileResponse) Reset() { *m = AsyncAnnotateFileResponse{} } |
| func (m *AsyncAnnotateFileResponse) String() string { return proto.CompactTextString(m) } |
| func (*AsyncAnnotateFileResponse) ProtoMessage() {} |
| func (*AsyncAnnotateFileResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{25} |
| } |
| func (m *AsyncAnnotateFileResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AsyncAnnotateFileResponse.Unmarshal(m, b) |
| } |
| func (m *AsyncAnnotateFileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AsyncAnnotateFileResponse.Marshal(b, m, deterministic) |
| } |
| func (dst *AsyncAnnotateFileResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AsyncAnnotateFileResponse.Merge(dst, src) |
| } |
| func (m *AsyncAnnotateFileResponse) XXX_Size() int { |
| return xxx_messageInfo_AsyncAnnotateFileResponse.Size(m) |
| } |
| func (m *AsyncAnnotateFileResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_AsyncAnnotateFileResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AsyncAnnotateFileResponse proto.InternalMessageInfo |
| |
| func (m *AsyncAnnotateFileResponse) GetOutputConfig() *OutputConfig { |
| if m != nil { |
| return m.OutputConfig |
| } |
| return nil |
| } |
| |
| // Multiple async file annotation requests are batched into a single service |
| // call. |
| type AsyncBatchAnnotateFilesRequest struct { |
| // Individual async file annotation requests for this batch. |
| Requests []*AsyncAnnotateFileRequest `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AsyncBatchAnnotateFilesRequest) Reset() { *m = AsyncBatchAnnotateFilesRequest{} } |
| func (m *AsyncBatchAnnotateFilesRequest) String() string { return proto.CompactTextString(m) } |
| func (*AsyncBatchAnnotateFilesRequest) ProtoMessage() {} |
| func (*AsyncBatchAnnotateFilesRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{26} |
| } |
| func (m *AsyncBatchAnnotateFilesRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesRequest.Unmarshal(m, b) |
| } |
| func (m *AsyncBatchAnnotateFilesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesRequest.Marshal(b, m, deterministic) |
| } |
| func (dst *AsyncBatchAnnotateFilesRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AsyncBatchAnnotateFilesRequest.Merge(dst, src) |
| } |
| func (m *AsyncBatchAnnotateFilesRequest) XXX_Size() int { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesRequest.Size(m) |
| } |
| func (m *AsyncBatchAnnotateFilesRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_AsyncBatchAnnotateFilesRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AsyncBatchAnnotateFilesRequest proto.InternalMessageInfo |
| |
| func (m *AsyncBatchAnnotateFilesRequest) GetRequests() []*AsyncAnnotateFileRequest { |
| if m != nil { |
| return m.Requests |
| } |
| return nil |
| } |
| |
| // Response to an async batch file annotation request. |
| type AsyncBatchAnnotateFilesResponse struct { |
| // The list of file annotation responses, one for each request in |
| // AsyncBatchAnnotateFilesRequest. |
| Responses []*AsyncAnnotateFileResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AsyncBatchAnnotateFilesResponse) Reset() { *m = AsyncBatchAnnotateFilesResponse{} } |
| func (m *AsyncBatchAnnotateFilesResponse) String() string { return proto.CompactTextString(m) } |
| func (*AsyncBatchAnnotateFilesResponse) ProtoMessage() {} |
| func (*AsyncBatchAnnotateFilesResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{27} |
| } |
| func (m *AsyncBatchAnnotateFilesResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesResponse.Unmarshal(m, b) |
| } |
| func (m *AsyncBatchAnnotateFilesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesResponse.Marshal(b, m, deterministic) |
| } |
| func (dst *AsyncBatchAnnotateFilesResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AsyncBatchAnnotateFilesResponse.Merge(dst, src) |
| } |
| func (m *AsyncBatchAnnotateFilesResponse) XXX_Size() int { |
| return xxx_messageInfo_AsyncBatchAnnotateFilesResponse.Size(m) |
| } |
| func (m *AsyncBatchAnnotateFilesResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_AsyncBatchAnnotateFilesResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AsyncBatchAnnotateFilesResponse proto.InternalMessageInfo |
| |
| func (m *AsyncBatchAnnotateFilesResponse) GetResponses() []*AsyncAnnotateFileResponse { |
| if m != nil { |
| return m.Responses |
| } |
| return nil |
| } |
| |
| // The desired input location and metadata. |
| type InputConfig struct { |
| // The Google Cloud Storage location to read the input from. |
| GcsSource *GcsSource `protobuf:"bytes,1,opt,name=gcs_source,json=gcsSource,proto3" json:"gcs_source,omitempty"` |
| // The type of the file. Currently only "application/pdf" and "image/tiff" |
| // are supported. Wildcards are not supported. |
| MimeType string `protobuf:"bytes,2,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *InputConfig) Reset() { *m = InputConfig{} } |
| func (m *InputConfig) String() string { return proto.CompactTextString(m) } |
| func (*InputConfig) ProtoMessage() {} |
| func (*InputConfig) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{28} |
| } |
| func (m *InputConfig) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_InputConfig.Unmarshal(m, b) |
| } |
| func (m *InputConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_InputConfig.Marshal(b, m, deterministic) |
| } |
| func (dst *InputConfig) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_InputConfig.Merge(dst, src) |
| } |
| func (m *InputConfig) XXX_Size() int { |
| return xxx_messageInfo_InputConfig.Size(m) |
| } |
| func (m *InputConfig) XXX_DiscardUnknown() { |
| xxx_messageInfo_InputConfig.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_InputConfig proto.InternalMessageInfo |
| |
| func (m *InputConfig) GetGcsSource() *GcsSource { |
| if m != nil { |
| return m.GcsSource |
| } |
| return nil |
| } |
| |
| func (m *InputConfig) GetMimeType() string { |
| if m != nil { |
| return m.MimeType |
| } |
| return "" |
| } |
| |
| // The desired output location and metadata. |
| type OutputConfig struct { |
| // The Google Cloud Storage location to write the output(s) to. |
| GcsDestination *GcsDestination `protobuf:"bytes,1,opt,name=gcs_destination,json=gcsDestination,proto3" json:"gcs_destination,omitempty"` |
| // 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. |
| BatchSize int32 `protobuf:"varint,2,opt,name=batch_size,json=batchSize,proto3" json:"batch_size,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *OutputConfig) Reset() { *m = OutputConfig{} } |
| func (m *OutputConfig) String() string { return proto.CompactTextString(m) } |
| func (*OutputConfig) ProtoMessage() {} |
| func (*OutputConfig) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{29} |
| } |
| func (m *OutputConfig) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_OutputConfig.Unmarshal(m, b) |
| } |
| func (m *OutputConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_OutputConfig.Marshal(b, m, deterministic) |
| } |
| func (dst *OutputConfig) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OutputConfig.Merge(dst, src) |
| } |
| func (m *OutputConfig) XXX_Size() int { |
| return xxx_messageInfo_OutputConfig.Size(m) |
| } |
| func (m *OutputConfig) XXX_DiscardUnknown() { |
| xxx_messageInfo_OutputConfig.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OutputConfig proto.InternalMessageInfo |
| |
| func (m *OutputConfig) GetGcsDestination() *GcsDestination { |
| if m != nil { |
| return m.GcsDestination |
| } |
| return nil |
| } |
| |
| func (m *OutputConfig) GetBatchSize() int32 { |
| if m != nil { |
| return m.BatchSize |
| } |
| return 0 |
| } |
| |
| // The Google Cloud Storage location where the input will be read from. |
| type GcsSource struct { |
| // Google Cloud Storage URI for the input file. This must only be a |
| // Google Cloud Storage object. Wildcards are not currently supported. |
| Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *GcsSource) Reset() { *m = GcsSource{} } |
| func (m *GcsSource) String() string { return proto.CompactTextString(m) } |
| func (*GcsSource) ProtoMessage() {} |
| func (*GcsSource) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{30} |
| } |
| func (m *GcsSource) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_GcsSource.Unmarshal(m, b) |
| } |
| func (m *GcsSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_GcsSource.Marshal(b, m, deterministic) |
| } |
| func (dst *GcsSource) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_GcsSource.Merge(dst, src) |
| } |
| func (m *GcsSource) XXX_Size() int { |
| return xxx_messageInfo_GcsSource.Size(m) |
| } |
| func (m *GcsSource) XXX_DiscardUnknown() { |
| xxx_messageInfo_GcsSource.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_GcsSource proto.InternalMessageInfo |
| |
| func (m *GcsSource) GetUri() string { |
| if m != nil { |
| return m.Uri |
| } |
| return "" |
| } |
| |
| // The Google Cloud Storage location where the output will be written to. |
| type GcsDestination struct { |
| // Google Cloud Storage URI where the results will be stored. Results will |
| // be in JSON format and preceded by its corresponding input URI. This field |
| // can either represent a single file, or a prefix for multiple outputs. |
| // Prefixes must end in a `/`. |
| // |
| // Examples: |
| // |
| // * File: gs://bucket-name/filename.json |
| // * Prefix: gs://bucket-name/prefix/here/ |
| // * File: gs://bucket-name/prefix/here |
| // |
| // 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. |
| Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *GcsDestination) Reset() { *m = GcsDestination{} } |
| func (m *GcsDestination) String() string { return proto.CompactTextString(m) } |
| func (*GcsDestination) ProtoMessage() {} |
| func (*GcsDestination) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{31} |
| } |
| func (m *GcsDestination) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_GcsDestination.Unmarshal(m, b) |
| } |
| func (m *GcsDestination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_GcsDestination.Marshal(b, m, deterministic) |
| } |
| func (dst *GcsDestination) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_GcsDestination.Merge(dst, src) |
| } |
| func (m *GcsDestination) XXX_Size() int { |
| return xxx_messageInfo_GcsDestination.Size(m) |
| } |
| func (m *GcsDestination) XXX_DiscardUnknown() { |
| xxx_messageInfo_GcsDestination.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_GcsDestination proto.InternalMessageInfo |
| |
| func (m *GcsDestination) GetUri() string { |
| if m != nil { |
| return m.Uri |
| } |
| return "" |
| } |
| |
| // Contains metadata for the BatchAnnotateImages operation. |
| type OperationMetadata struct { |
| // Current state of the batch operation. |
| State OperationMetadata_State `protobuf:"varint,1,opt,name=state,proto3,enum=google.cloud.vision.v1p3beta1.OperationMetadata_State" json:"state,omitempty"` |
| // The time when the batch request was received. |
| CreateTime *timestamp.Timestamp `protobuf:"bytes,5,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"` |
| // The time when the operation result was last updated. |
| UpdateTime *timestamp.Timestamp `protobuf:"bytes,6,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *OperationMetadata) Reset() { *m = OperationMetadata{} } |
| func (m *OperationMetadata) String() string { return proto.CompactTextString(m) } |
| func (*OperationMetadata) ProtoMessage() {} |
| func (*OperationMetadata) Descriptor() ([]byte, []int) { |
| return fileDescriptor_image_annotator_a0c5dd8c15adca67, []int{32} |
| } |
| func (m *OperationMetadata) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_OperationMetadata.Unmarshal(m, b) |
| } |
| func (m *OperationMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_OperationMetadata.Marshal(b, m, deterministic) |
| } |
| func (dst *OperationMetadata) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OperationMetadata.Merge(dst, src) |
| } |
| func (m *OperationMetadata) XXX_Size() int { |
| return xxx_messageInfo_OperationMetadata.Size(m) |
| } |
| func (m *OperationMetadata) XXX_DiscardUnknown() { |
| xxx_messageInfo_OperationMetadata.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OperationMetadata proto.InternalMessageInfo |
| |
| func (m *OperationMetadata) GetState() OperationMetadata_State { |
| if m != nil { |
| return m.State |
| } |
| return OperationMetadata_STATE_UNSPECIFIED |
| } |
| |
| func (m *OperationMetadata) GetCreateTime() *timestamp.Timestamp { |
| if m != nil { |
| return m.CreateTime |
| } |
| return nil |
| } |
| |
| func (m *OperationMetadata) GetUpdateTime() *timestamp.Timestamp { |
| if m != nil { |
| return m.UpdateTime |
| } |
| return nil |
| } |
| |
| func init() { |
| proto.RegisterType((*Feature)(nil), "google.cloud.vision.v1p3beta1.Feature") |
| proto.RegisterType((*ImageSource)(nil), "google.cloud.vision.v1p3beta1.ImageSource") |
| proto.RegisterType((*Image)(nil), "google.cloud.vision.v1p3beta1.Image") |
| proto.RegisterType((*FaceAnnotation)(nil), "google.cloud.vision.v1p3beta1.FaceAnnotation") |
| proto.RegisterType((*FaceAnnotation_Landmark)(nil), "google.cloud.vision.v1p3beta1.FaceAnnotation.Landmark") |
| proto.RegisterType((*LocationInfo)(nil), "google.cloud.vision.v1p3beta1.LocationInfo") |
| proto.RegisterType((*Property)(nil), "google.cloud.vision.v1p3beta1.Property") |
| proto.RegisterType((*EntityAnnotation)(nil), "google.cloud.vision.v1p3beta1.EntityAnnotation") |
| proto.RegisterType((*LocalizedObjectAnnotation)(nil), "google.cloud.vision.v1p3beta1.LocalizedObjectAnnotation") |
| proto.RegisterType((*SafeSearchAnnotation)(nil), "google.cloud.vision.v1p3beta1.SafeSearchAnnotation") |
| proto.RegisterType((*LatLongRect)(nil), "google.cloud.vision.v1p3beta1.LatLongRect") |
| proto.RegisterType((*ColorInfo)(nil), "google.cloud.vision.v1p3beta1.ColorInfo") |
| proto.RegisterType((*DominantColorsAnnotation)(nil), "google.cloud.vision.v1p3beta1.DominantColorsAnnotation") |
| proto.RegisterType((*ImageProperties)(nil), "google.cloud.vision.v1p3beta1.ImageProperties") |
| proto.RegisterType((*CropHint)(nil), "google.cloud.vision.v1p3beta1.CropHint") |
| proto.RegisterType((*CropHintsAnnotation)(nil), "google.cloud.vision.v1p3beta1.CropHintsAnnotation") |
| proto.RegisterType((*CropHintsParams)(nil), "google.cloud.vision.v1p3beta1.CropHintsParams") |
| proto.RegisterType((*WebDetectionParams)(nil), "google.cloud.vision.v1p3beta1.WebDetectionParams") |
| proto.RegisterType((*ImageContext)(nil), "google.cloud.vision.v1p3beta1.ImageContext") |
| proto.RegisterType((*AnnotateImageRequest)(nil), "google.cloud.vision.v1p3beta1.AnnotateImageRequest") |
| proto.RegisterType((*ImageAnnotationContext)(nil), "google.cloud.vision.v1p3beta1.ImageAnnotationContext") |
| proto.RegisterType((*AnnotateImageResponse)(nil), "google.cloud.vision.v1p3beta1.AnnotateImageResponse") |
| proto.RegisterType((*AnnotateFileResponse)(nil), "google.cloud.vision.v1p3beta1.AnnotateFileResponse") |
| proto.RegisterType((*BatchAnnotateImagesRequest)(nil), "google.cloud.vision.v1p3beta1.BatchAnnotateImagesRequest") |
| proto.RegisterType((*BatchAnnotateImagesResponse)(nil), "google.cloud.vision.v1p3beta1.BatchAnnotateImagesResponse") |
| proto.RegisterType((*AsyncAnnotateFileRequest)(nil), "google.cloud.vision.v1p3beta1.AsyncAnnotateFileRequest") |
| proto.RegisterType((*AsyncAnnotateFileResponse)(nil), "google.cloud.vision.v1p3beta1.AsyncAnnotateFileResponse") |
| proto.RegisterType((*AsyncBatchAnnotateFilesRequest)(nil), "google.cloud.vision.v1p3beta1.AsyncBatchAnnotateFilesRequest") |
| proto.RegisterType((*AsyncBatchAnnotateFilesResponse)(nil), "google.cloud.vision.v1p3beta1.AsyncBatchAnnotateFilesResponse") |
| proto.RegisterType((*InputConfig)(nil), "google.cloud.vision.v1p3beta1.InputConfig") |
| proto.RegisterType((*OutputConfig)(nil), "google.cloud.vision.v1p3beta1.OutputConfig") |
| proto.RegisterType((*GcsSource)(nil), "google.cloud.vision.v1p3beta1.GcsSource") |
| proto.RegisterType((*GcsDestination)(nil), "google.cloud.vision.v1p3beta1.GcsDestination") |
| proto.RegisterType((*OperationMetadata)(nil), "google.cloud.vision.v1p3beta1.OperationMetadata") |
| proto.RegisterEnum("google.cloud.vision.v1p3beta1.Likelihood", Likelihood_name, Likelihood_value) |
| proto.RegisterEnum("google.cloud.vision.v1p3beta1.Feature_Type", Feature_Type_name, Feature_Type_value) |
| proto.RegisterEnum("google.cloud.vision.v1p3beta1.FaceAnnotation_Landmark_Type", FaceAnnotation_Landmark_Type_name, FaceAnnotation_Landmark_Type_value) |
| proto.RegisterEnum("google.cloud.vision.v1p3beta1.OperationMetadata_State", OperationMetadata_State_name, OperationMetadata_State_value) |
| } |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ context.Context |
| var _ grpc.ClientConn |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the grpc package it is being compiled against. |
| const _ = grpc.SupportPackageIsVersion4 |
| |
| // ImageAnnotatorClient is the client API for ImageAnnotator service. |
| // |
| // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. |
| type ImageAnnotatorClient interface { |
| // Run image detection and annotation for a batch of images. |
| BatchAnnotateImages(ctx context.Context, in *BatchAnnotateImagesRequest, opts ...grpc.CallOption) (*BatchAnnotateImagesResponse, error) |
| // Run asynchronous image detection and annotation for a list of generic |
| // files, such as PDF files, which may contain multiple pages and multiple |
| // images per page. Progress and results can be retrieved through the |
| // `google.longrunning.Operations` interface. |
| // `Operation.metadata` contains `OperationMetadata` (metadata). |
| // `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results). |
| AsyncBatchAnnotateFiles(ctx context.Context, in *AsyncBatchAnnotateFilesRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) |
| } |
| |
| type imageAnnotatorClient struct { |
| cc *grpc.ClientConn |
| } |
| |
| func NewImageAnnotatorClient(cc *grpc.ClientConn) ImageAnnotatorClient { |
| return &imageAnnotatorClient{cc} |
| } |
| |
| func (c *imageAnnotatorClient) BatchAnnotateImages(ctx context.Context, in *BatchAnnotateImagesRequest, opts ...grpc.CallOption) (*BatchAnnotateImagesResponse, error) { |
| out := new(BatchAnnotateImagesResponse) |
| err := c.cc.Invoke(ctx, "/google.cloud.vision.v1p3beta1.ImageAnnotator/BatchAnnotateImages", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *imageAnnotatorClient) AsyncBatchAnnotateFiles(ctx context.Context, in *AsyncBatchAnnotateFilesRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) { |
| out := new(longrunning.Operation) |
| err := c.cc.Invoke(ctx, "/google.cloud.vision.v1p3beta1.ImageAnnotator/AsyncBatchAnnotateFiles", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| // ImageAnnotatorServer is the server API for ImageAnnotator service. |
| type ImageAnnotatorServer interface { |
| // Run image detection and annotation for a batch of images. |
| BatchAnnotateImages(context.Context, *BatchAnnotateImagesRequest) (*BatchAnnotateImagesResponse, error) |
| // Run asynchronous image detection and annotation for a list of generic |
| // files, such as PDF files, which may contain multiple pages and multiple |
| // images per page. Progress and results can be retrieved through the |
| // `google.longrunning.Operations` interface. |
| // `Operation.metadata` contains `OperationMetadata` (metadata). |
| // `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results). |
| AsyncBatchAnnotateFiles(context.Context, *AsyncBatchAnnotateFilesRequest) (*longrunning.Operation, error) |
| } |
| |
| func RegisterImageAnnotatorServer(s *grpc.Server, srv ImageAnnotatorServer) { |
| s.RegisterService(&_ImageAnnotator_serviceDesc, srv) |
| } |
| |
| func _ImageAnnotator_BatchAnnotateImages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(BatchAnnotateImagesRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(ImageAnnotatorServer).BatchAnnotateImages(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/google.cloud.vision.v1p3beta1.ImageAnnotator/BatchAnnotateImages", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(ImageAnnotatorServer).BatchAnnotateImages(ctx, req.(*BatchAnnotateImagesRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _ImageAnnotator_AsyncBatchAnnotateFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(AsyncBatchAnnotateFilesRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(ImageAnnotatorServer).AsyncBatchAnnotateFiles(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/google.cloud.vision.v1p3beta1.ImageAnnotator/AsyncBatchAnnotateFiles", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(ImageAnnotatorServer).AsyncBatchAnnotateFiles(ctx, req.(*AsyncBatchAnnotateFilesRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| var _ImageAnnotator_serviceDesc = grpc.ServiceDesc{ |
| ServiceName: "google.cloud.vision.v1p3beta1.ImageAnnotator", |
| HandlerType: (*ImageAnnotatorServer)(nil), |
| Methods: []grpc.MethodDesc{ |
| { |
| MethodName: "BatchAnnotateImages", |
| Handler: _ImageAnnotator_BatchAnnotateImages_Handler, |
| }, |
| { |
| MethodName: "AsyncBatchAnnotateFiles", |
| Handler: _ImageAnnotator_AsyncBatchAnnotateFiles_Handler, |
| }, |
| }, |
| Streams: []grpc.StreamDesc{}, |
| Metadata: "google/cloud/vision/v1p3beta1/image_annotator.proto", |
| } |
| |
| func init() { |
| proto.RegisterFile("google/cloud/vision/v1p3beta1/image_annotator.proto", fileDescriptor_image_annotator_a0c5dd8c15adca67) |
| } |
| |
| var fileDescriptor_image_annotator_a0c5dd8c15adca67 = []byte{ |
| // 3065 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcf, 0x73, 0xdb, 0xc6, |
| 0xf5, 0x0f, 0xa9, 0x5f, 0xe4, 0x23, 0x25, 0x41, 0xab, 0x1f, 0xa6, 0x65, 0x2b, 0x56, 0x90, 0x6f, |
| 0xbe, 0x5f, 0x7d, 0xdd, 0x54, 0x1a, 0xcb, 0x49, 0x9a, 0x3a, 0xcd, 0xa4, 0x14, 0x05, 0x49, 0xac, |
| 0x29, 0x82, 0x5d, 0x41, 0x76, 0xec, 0x49, 0x07, 0x85, 0xc0, 0x25, 0x8d, 0x04, 0xc4, 0x22, 0x00, |
| 0x68, 0x4b, 0x3e, 0x66, 0xa6, 0x7f, 0x41, 0x6f, 0xbd, 0x76, 0x3a, 0x39, 0x35, 0x97, 0xf6, 0xd2, |
| 0x73, 0xef, 0x9d, 0xe9, 0xf4, 0xd0, 0x3f, 0xa0, 0x3d, 0xf4, 0xd8, 0x63, 0x8f, 0x9d, 0x5d, 0x2c, |
| 0xc0, 0x05, 0x29, 0x99, 0xa2, 0x93, 0xce, 0xf4, 0x44, 0xec, 0x7b, 0xfb, 0xf9, 0xbc, 0xdd, 0xf7, |
| 0x76, 0xdf, 0x3e, 0x2c, 0x08, 0xf7, 0xbb, 0x94, 0x76, 0x5d, 0xb2, 0x63, 0xbb, 0xb4, 0xdf, 0xde, |
| 0x79, 0xee, 0x84, 0x0e, 0xf5, 0x76, 0x9e, 0xdf, 0xf3, 0xef, 0x9f, 0x91, 0xc8, 0xba, 0xb7, 0xe3, |
| 0xf4, 0xac, 0x2e, 0x31, 0x2d, 0xcf, 0xa3, 0x91, 0x15, 0xd1, 0x60, 0xdb, 0x0f, 0x68, 0x44, 0xd1, |
| 0x46, 0x0c, 0xda, 0xe6, 0xa0, 0xed, 0x18, 0xb4, 0x9d, 0x82, 0xd6, 0x6f, 0x0b, 0x4e, 0xcb, 0x77, |
| 0x76, 0x04, 0xd4, 0xa1, 0x5e, 0x18, 0x83, 0xd7, 0xdf, 0x7d, 0xb5, 0xc5, 0x2e, 0xa1, 0x3d, 0x12, |
| 0x05, 0x17, 0xa2, 0xf7, 0xee, 0xab, 0x7b, 0xfb, 0x01, 0x6d, 0xf7, 0xed, 0xc8, 0x0c, 0x89, 0x15, |
| 0xd8, 0xcf, 0x04, 0x66, 0xcc, 0x9c, 0x22, 0x72, 0x1e, 0x99, 0x83, 0x71, 0x09, 0xd0, 0xbd, 0x57, |
| 0x83, 0x5e, 0x90, 0x33, 0xb3, 0x4d, 0x22, 0x62, 0x4b, 0x90, 0xb7, 0x05, 0xc4, 0xa5, 0x5e, 0x37, |
| 0xe8, 0x7b, 0x9e, 0xe3, 0x75, 0x77, 0xa8, 0x4f, 0x82, 0xcc, 0x74, 0xef, 0x88, 0x4e, 0xbc, 0x75, |
| 0xd6, 0xef, 0xec, 0x44, 0x4e, 0x8f, 0x84, 0x91, 0xd5, 0xf3, 0x45, 0x87, 0x1b, 0xa2, 0x43, 0xe0, |
| 0xdb, 0x3b, 0x61, 0x64, 0x45, 0xfd, 0x70, 0x48, 0x11, 0x5d, 0xf8, 0x64, 0xc7, 0xa6, 0x6e, 0xe2, |
| 0xfe, 0xf5, 0x8a, 0xac, 0x70, 0xad, 0xc8, 0xf5, 0xba, 0xb1, 0x46, 0xfd, 0x7a, 0x0a, 0xe6, 0x0e, |
| 0x88, 0x15, 0xf5, 0x03, 0x82, 0x3e, 0x81, 0x69, 0xd6, 0xa1, 0x92, 0xdb, 0xcc, 0x6d, 0x2d, 0xec, |
| 0x7e, 0x6f, 0xfb, 0x95, 0x31, 0xdb, 0x16, 0xa8, 0x6d, 0xe3, 0xc2, 0x27, 0x98, 0x03, 0xd1, 0x1d, |
| 0x28, 0xf5, 0xac, 0x73, 0x33, 0x20, 0x61, 0xdf, 0x8d, 0xc2, 0x4a, 0x7e, 0x33, 0xb7, 0x35, 0x83, |
| 0xa1, 0x67, 0x9d, 0xe3, 0x58, 0x82, 0x56, 0x60, 0xa6, 0x47, 0xdb, 0xc4, 0xad, 0x4c, 0x6d, 0xe6, |
| 0xb6, 0x8a, 0x38, 0x6e, 0xa8, 0xbf, 0xce, 0xc3, 0x34, 0x63, 0x41, 0x2b, 0xa0, 0x18, 0x4f, 0x5a, |
| 0x9a, 0x79, 0xda, 0x3c, 0x69, 0x69, 0xb5, 0xfa, 0x41, 0x5d, 0xdb, 0x57, 0xde, 0x40, 0x08, 0x16, |
| 0x0e, 0xaa, 0x35, 0xcd, 0xdc, 0xd7, 0x0c, 0xad, 0x66, 0xd4, 0xf5, 0xa6, 0x92, 0x43, 0x6b, 0x80, |
| 0x1a, 0xd5, 0xe6, 0xfe, 0x71, 0x15, 0x3f, 0x94, 0xe4, 0x79, 0xd6, 0xb7, 0xa1, 0x1f, 0xea, 0x92, |
| 0x6c, 0x0a, 0x2d, 0xc3, 0x62, 0xa3, 0xba, 0xa7, 0x35, 0x24, 0xe1, 0x34, 0xeb, 0x68, 0x68, 0x9f, |
| 0x1a, 0x92, 0x6c, 0x06, 0xdd, 0x82, 0x1b, 0xfb, 0x7a, 0xed, 0xf4, 0x58, 0x6b, 0x1a, 0xe6, 0x90, |
| 0xb2, 0x84, 0x6e, 0xc2, 0xea, 0x49, 0xf5, 0x40, 0x33, 0x4f, 0xb4, 0x2a, 0xae, 0x1d, 0x49, 0xaa, |
| 0x59, 0x36, 0xec, 0xfa, 0x71, 0xf5, 0x50, 0x33, 0x5b, 0x58, 0x6f, 0x69, 0xd8, 0xa8, 0x6b, 0x27, |
| 0xca, 0x1c, 0x5a, 0x00, 0xa8, 0x61, 0xbd, 0x65, 0x1e, 0xd5, 0x9b, 0xc6, 0x89, 0x52, 0x44, 0x4b, |
| 0x30, 0xff, 0x58, 0xdb, 0x93, 0x80, 0xc0, 0x06, 0xd1, 0xc2, 0xfa, 0xfe, 0x69, 0xcd, 0x10, 0xb4, |
| 0x4a, 0x19, 0xdd, 0x80, 0x65, 0x7d, 0xef, 0x27, 0x5a, 0xcd, 0x30, 0x1b, 0x7a, 0xad, 0xda, 0xa8, |
| 0x3f, 0xad, 0xf2, 0xce, 0xcb, 0x6a, 0x13, 0x4a, 0x75, 0xb6, 0xb7, 0x4e, 0x68, 0x3f, 0xb0, 0x09, |
| 0x52, 0x61, 0xbe, 0x6b, 0x87, 0x66, 0xbc, 0xdd, 0xfa, 0x81, 0xc3, 0xa3, 0x56, 0xc4, 0xa5, 0xae, |
| 0x1d, 0xf2, 0x6e, 0xa7, 0x81, 0x83, 0x6e, 0x41, 0x71, 0xa0, 0xcf, 0x73, 0x7d, 0xc1, 0x11, 0x4a, |
| 0x95, 0xc0, 0x0c, 0xef, 0x88, 0x2a, 0x30, 0x67, 0x53, 0x2f, 0x22, 0x5e, 0xc4, 0x39, 0xca, 0x38, |
| 0x69, 0xa2, 0x3d, 0x98, 0x0d, 0xb9, 0x35, 0x0e, 0x2e, 0xed, 0xde, 0x1d, 0xb3, 0x24, 0xa4, 0xf1, |
| 0x61, 0x81, 0x54, 0x7f, 0xa3, 0xc0, 0xc2, 0x81, 0x65, 0x93, 0x6a, 0xba, 0x7d, 0x50, 0x0b, 0xe6, |
| 0xcf, 0x68, 0xdf, 0x6b, 0x3b, 0x5e, 0xd7, 0xf4, 0xa9, 0x7b, 0xc1, 0xcd, 0x96, 0xc6, 0x2e, 0xb8, |
| 0x3d, 0x81, 0x69, 0x51, 0xf7, 0x02, 0x97, 0xcf, 0xa4, 0x16, 0x3a, 0x05, 0xa5, 0xd3, 0x36, 0xb3, |
| 0xa4, 0xf9, 0xc9, 0x49, 0x17, 0x3a, 0x6d, 0xb9, 0x8d, 0x0c, 0x28, 0xba, 0x96, 0xd7, 0xee, 0x59, |
| 0xc1, 0x17, 0x61, 0x65, 0x6a, 0x73, 0x6a, 0xab, 0xb4, 0xfb, 0xc1, 0xb8, 0x5d, 0x91, 0x99, 0xea, |
| 0x76, 0x43, 0xc0, 0xf1, 0x80, 0x08, 0x6d, 0x00, 0x04, 0xd4, 0x75, 0x4d, 0xcb, 0xeb, 0xba, 0xa4, |
| 0x32, 0xbd, 0x99, 0xdb, 0xca, 0xe3, 0x22, 0x93, 0x54, 0x99, 0x80, 0x05, 0xcd, 0xb7, 0x3c, 0xa1, |
| 0x9d, 0xe1, 0xda, 0x82, 0x6f, 0x79, 0xb1, 0x72, 0x03, 0x20, 0x72, 0xdc, 0x48, 0x68, 0x67, 0x63, |
| 0x2c, 0x93, 0xc4, 0xea, 0x7b, 0xb0, 0x92, 0xa6, 0x1c, 0xd3, 0xa6, 0x5e, 0xc7, 0x69, 0x13, 0xcf, |
| 0x26, 0x95, 0x39, 0xde, 0x71, 0x39, 0xd5, 0xd5, 0x52, 0x15, 0x7a, 0x1f, 0xd6, 0x92, 0xa1, 0x31, |
| 0xd7, 0x49, 0xa0, 0x02, 0x07, 0xad, 0x4a, 0x5a, 0x09, 0xd6, 0x82, 0x85, 0xcf, 0xe9, 0x85, 0xe9, |
| 0x3a, 0x5f, 0x10, 0xd7, 0x79, 0x46, 0x69, 0xbb, 0x52, 0xe4, 0x59, 0xe3, 0xff, 0xc7, 0xf8, 0xa7, |
| 0x91, 0x02, 0xf0, 0xfc, 0xe7, 0xf4, 0x62, 0xd0, 0x44, 0x8f, 0x60, 0x29, 0xa4, 0x41, 0x40, 0x5f, |
| 0xc8, 0xa4, 0x30, 0x29, 0xa9, 0x12, 0x73, 0x48, 0xbc, 0x06, 0x28, 0x96, 0xd7, 0x25, 0x81, 0x4c, |
| 0x5b, 0x9a, 0x94, 0x76, 0x91, 0x53, 0x48, 0xac, 0x4f, 0x61, 0x39, 0xec, 0x07, 0x7e, 0xe0, 0x84, |
| 0x44, 0x26, 0x2e, 0x4f, 0x4a, 0x8c, 0x12, 0x16, 0x89, 0xdb, 0x86, 0x4a, 0xdf, 0x6b, 0x93, 0xc0, |
| 0x24, 0xe7, 0x3e, 0x0d, 0x49, 0x5b, 0x36, 0x30, 0x3f, 0xa9, 0x81, 0x35, 0x4e, 0xa5, 0xc5, 0x4c, |
| 0x92, 0x91, 0x4f, 0x01, 0x9d, 0xb9, 0xfd, 0x20, 0xc8, 0xd2, 0x2f, 0x4c, 0x4a, 0xbf, 0x24, 0x48, |
| 0xb2, 0xae, 0x79, 0x46, 0xac, 0xf6, 0x0b, 0x62, 0x65, 0x7c, 0xbe, 0x38, 0xb1, 0x6b, 0x12, 0x96, |
| 0x81, 0x6c, 0xfd, 0xaf, 0x73, 0x50, 0x48, 0xf6, 0x14, 0xd2, 0xc5, 0x79, 0x35, 0xc5, 0x99, 0x3f, |
| 0x7a, 0xbd, 0x9d, 0x29, 0x9f, 0x5f, 0x35, 0x28, 0xf8, 0x34, 0x74, 0x98, 0x9e, 0xef, 0xcb, 0xd2, |
| 0xee, 0xff, 0x8d, 0x21, 0x6d, 0x89, 0xee, 0x38, 0x05, 0xaa, 0xbf, 0x9f, 0x1d, 0x9c, 0x66, 0xa7, |
| 0xcd, 0x87, 0x4d, 0xfd, 0x71, 0xd3, 0x4c, 0xce, 0x2a, 0xe5, 0x0d, 0x54, 0x86, 0x42, 0x43, 0x3b, |
| 0x30, 0x4c, 0xed, 0x89, 0xa6, 0xe4, 0xd0, 0x3c, 0x14, 0x71, 0xfd, 0xf0, 0x28, 0x6e, 0xe6, 0x51, |
| 0x05, 0x56, 0xb8, 0x52, 0x3f, 0x30, 0x93, 0x4e, 0x7b, 0x58, 0x7f, 0xac, 0x4c, 0xb1, 0xe3, 0x27, |
| 0xee, 0x38, 0xac, 0x9a, 0x66, 0xaa, 0x04, 0x94, 0x72, 0x71, 0xd5, 0x0c, 0x5a, 0x87, 0xb5, 0x14, |
| 0x95, 0xd5, 0xcd, 0x32, 0xd8, 0x71, 0x7d, 0xbf, 0xa5, 0xd7, 0x9b, 0x86, 0xb9, 0xa7, 0x19, 0x8f, |
| 0x35, 0xad, 0xc9, 0xb4, 0xec, 0xe8, 0x2a, 0x43, 0xa1, 0xa9, 0x9f, 0x68, 0xa6, 0x51, 0x6f, 0x29, |
| 0x05, 0x36, 0xc6, 0xd3, 0x56, 0x4b, 0xc3, 0x66, 0xa3, 0xde, 0x52, 0x8a, 0xac, 0xd9, 0xd0, 0x1f, |
| 0x8b, 0x26, 0xb0, 0x63, 0xee, 0x58, 0x3f, 0x35, 0x8e, 0xf8, 0xa8, 0x94, 0x12, 0x5a, 0x84, 0x52, |
| 0xdc, 0xe6, 0xf6, 0x94, 0x32, 0x52, 0xa0, 0x1c, 0x0b, 0x6a, 0x5a, 0xd3, 0xd0, 0xb0, 0x32, 0x8f, |
| 0x56, 0x61, 0x89, 0xd3, 0xef, 0xe9, 0x86, 0xa1, 0x1f, 0x8b, 0x8e, 0x0b, 0xcc, 0x5f, 0xb2, 0x98, |
| 0xf3, 0x2d, 0xb2, 0x93, 0x5e, 0x96, 0x0a, 0x12, 0x25, 0x9d, 0xb5, 0xf6, 0x44, 0x33, 0x0d, 0xbd, |
| 0x65, 0xee, 0xe9, 0xa7, 0xcd, 0xfd, 0x2a, 0x7e, 0xa2, 0x2c, 0x65, 0x54, 0xf1, 0xac, 0x6b, 0x3a, |
| 0x6e, 0x6a, 0x58, 0x41, 0xe8, 0x36, 0x54, 0x52, 0x95, 0x60, 0x4c, 0x81, 0xcb, 0xa9, 0xfb, 0x99, |
| 0x96, 0x3f, 0x08, 0xdc, 0xca, 0xc0, 0x91, 0x23, 0xe6, 0x56, 0xb3, 0xba, 0x8c, 0xbd, 0x35, 0xb4, |
| 0x01, 0x37, 0x07, 0xba, 0x61, 0x83, 0x37, 0x06, 0x51, 0x1d, 0xb6, 0x58, 0x41, 0x77, 0xe0, 0x96, |
| 0x1c, 0x67, 0x33, 0x0e, 0x41, 0x12, 0x31, 0xe5, 0x26, 0xda, 0x84, 0xdb, 0x99, 0x90, 0x0e, 0xf7, |
| 0x58, 0x67, 0x0e, 0x8d, 0x29, 0xaa, 0xd8, 0x34, 0x70, 0xf5, 0x90, 0xd5, 0x11, 0xb7, 0x98, 0xf7, |
| 0x05, 0x4e, 0x12, 0xdf, 0xe6, 0x95, 0x53, 0x32, 0xf7, 0xd6, 0x69, 0xab, 0xde, 0x50, 0x36, 0x58, |
| 0xe5, 0x34, 0x18, 0x5e, 0x2c, 0x7c, 0x93, 0xe1, 0x0f, 0x74, 0xac, 0x1d, 0x69, 0xd5, 0x7d, 0xf3, |
| 0x90, 0x17, 0x56, 0x8d, 0xaa, 0x72, 0x87, 0x95, 0x37, 0xb5, 0xa3, 0x7a, 0xd3, 0x3c, 0x6c, 0x56, |
| 0x8d, 0x23, 0x46, 0xb9, 0xc9, 0xec, 0x73, 0x11, 0xe7, 0x3d, 0xd4, 0x9b, 0x4c, 0xfa, 0x16, 0xc3, |
| 0x73, 0x69, 0xcc, 0x2c, 0xc4, 0xaa, 0xfa, 0x23, 0x28, 0x37, 0xa8, 0xcd, 0xf7, 0x66, 0xdd, 0xeb, |
| 0x50, 0xf4, 0x2e, 0xcc, 0xb9, 0x56, 0x64, 0xba, 0x5e, 0x57, 0x94, 0x07, 0xcb, 0xc9, 0x56, 0x64, |
| 0x5b, 0x75, 0xbb, 0x61, 0x45, 0x0d, 0xaf, 0x8b, 0x67, 0x5d, 0xfe, 0xab, 0x3e, 0x86, 0x42, 0x2b, |
| 0x60, 0x95, 0x74, 0x74, 0x81, 0x10, 0x4c, 0x7b, 0x56, 0x8f, 0x88, 0x82, 0x88, 0x3f, 0xb3, 0xc2, |
| 0xf3, 0xb9, 0xe5, 0xf6, 0x89, 0xa8, 0x82, 0xe2, 0x06, 0x7a, 0x0b, 0xca, 0x7d, 0xc7, 0x8b, 0x3e, |
| 0x78, 0xcf, 0x8c, 0x95, 0x2c, 0x91, 0x4c, 0xe3, 0x52, 0x2c, 0x7b, 0xc4, 0x44, 0xea, 0xaf, 0xa6, |
| 0x40, 0xd1, 0xbc, 0xc8, 0x89, 0x2e, 0xa4, 0x02, 0x46, 0x81, 0xa9, 0x9e, 0xd3, 0x16, 0x06, 0xd8, |
| 0x23, 0x5a, 0x83, 0x59, 0x97, 0xda, 0x96, 0x9b, 0x18, 0x10, 0x2d, 0xb4, 0x09, 0xa5, 0x36, 0x09, |
| 0xed, 0xc0, 0xf1, 0x79, 0x52, 0x89, 0xcb, 0x5e, 0x59, 0xc4, 0x46, 0x16, 0xda, 0x34, 0x48, 0x0a, |
| 0x81, 0xb8, 0x81, 0xde, 0x04, 0x90, 0x4e, 0xe2, 0xb8, 0x0a, 0x90, 0x24, 0x4c, 0x1f, 0x51, 0xdf, |
| 0xb1, 0x2d, 0xd7, 0x89, 0x2e, 0x44, 0x1d, 0x20, 0x49, 0x46, 0x4b, 0xac, 0xb9, 0x6f, 0x5b, 0x62, |
| 0xd5, 0xa1, 0xe8, 0x8a, 0xf8, 0x84, 0x95, 0x02, 0xaf, 0x85, 0xc6, 0xb1, 0xc9, 0xf1, 0xc4, 0x03, |
| 0x34, 0x3a, 0x04, 0xf0, 0xe3, 0x60, 0x39, 0x24, 0xac, 0x14, 0x39, 0xd7, 0xd8, 0x44, 0x2b, 0xa2, |
| 0x8b, 0x25, 0xa8, 0xfa, 0xa7, 0x1c, 0xdc, 0x64, 0x46, 0x5c, 0xe7, 0x25, 0x69, 0xeb, 0x67, 0x9f, |
| 0x13, 0x3b, 0x7a, 0x65, 0x94, 0xde, 0x86, 0x79, 0xd7, 0xf2, 0xba, 0x7d, 0x56, 0x12, 0xdb, 0xb4, |
| 0x9d, 0x04, 0xab, 0x9c, 0x08, 0x6b, 0xb4, 0x4d, 0xd2, 0xe5, 0x33, 0x95, 0x5d, 0x3e, 0x97, 0x04, |
| 0x69, 0xc4, 0xc9, 0x33, 0xdf, 0xd2, 0xc9, 0xea, 0xdf, 0xf2, 0xb0, 0x72, 0x62, 0x75, 0xc8, 0x09, |
| 0x7f, 0x39, 0x95, 0xe6, 0xf2, 0x09, 0xcc, 0x58, 0xed, 0xbe, 0x1b, 0x89, 0x77, 0xb3, 0x09, 0x4e, |
| 0xd1, 0x18, 0xc7, 0x08, 0x42, 0x9f, 0xd2, 0x0e, 0x9f, 0xf2, 0x64, 0x04, 0x1c, 0x87, 0x6a, 0x30, |
| 0xd7, 0x23, 0x6d, 0xb6, 0xbe, 0xc4, 0x79, 0x3b, 0x01, 0x45, 0x82, 0x44, 0x1a, 0x14, 0x9e, 0x3b, |
| 0xd4, 0xe5, 0x8b, 0x7a, 0x7a, 0x52, 0x96, 0x14, 0x8a, 0x3e, 0x86, 0xe9, 0xc0, 0xb2, 0x2f, 0x26, |
| 0x2f, 0x39, 0x39, 0x4c, 0x7d, 0x01, 0x25, 0x96, 0x3e, 0xa8, 0xd7, 0xc5, 0xc4, 0x8e, 0xd0, 0x7d, |
| 0x28, 0xf5, 0x1c, 0xcf, 0xbc, 0x46, 0xb6, 0x29, 0xf6, 0x1c, 0x2f, 0x7e, 0xe4, 0x20, 0xeb, 0x3c, |
| 0x05, 0xe5, 0x5f, 0x05, 0xb2, 0xce, 0xe3, 0x47, 0x35, 0x80, 0x62, 0x8d, 0xbd, 0x95, 0xf3, 0x04, |
| 0xb7, 0x05, 0x33, 0xfc, 0x15, 0x5d, 0x18, 0x44, 0x19, 0x2c, 0xef, 0x86, 0xe3, 0x0e, 0x83, 0xd5, |
| 0x97, 0x97, 0x57, 0xdf, 0x3b, 0xb0, 0xe0, 0x3b, 0xe7, 0xc4, 0x35, 0x3b, 0x81, 0x65, 0xa7, 0xd9, |
| 0x25, 0x8f, 0xe7, 0xb9, 0xf4, 0x40, 0x08, 0xd5, 0xcf, 0xa0, 0xb2, 0x4f, 0x7b, 0x8e, 0x67, 0x79, |
| 0x11, 0x27, 0x0d, 0xa5, 0x55, 0xf5, 0x63, 0x98, 0xe5, 0x16, 0xc2, 0x4a, 0x8e, 0x6f, 0xc2, 0xad, |
| 0x31, 0x9e, 0x4c, 0x07, 0x8f, 0x05, 0x4e, 0x0d, 0x61, 0x91, 0xbf, 0xf4, 0xb5, 0xd2, 0x4d, 0x89, |
| 0x7e, 0x0e, 0x8b, 0x6d, 0x61, 0xd0, 0x4c, 0xd9, 0xd9, 0x0c, 0x7f, 0x30, 0x86, 0xfd, 0xaa, 0x61, |
| 0xe2, 0x85, 0x76, 0x46, 0xa3, 0xfe, 0x36, 0x07, 0x85, 0x5a, 0x40, 0xfd, 0x23, 0xc7, 0x8b, 0xfe, |
| 0x03, 0x2f, 0x93, 0xd9, 0xdc, 0x9b, 0x1f, 0xc9, 0xbd, 0x3b, 0xb0, 0xec, 0xf4, 0x7c, 0x1a, 0x44, |
| 0x96, 0x67, 0x93, 0x61, 0xef, 0xa3, 0x81, 0x2a, 0x0d, 0xc1, 0xcf, 0x60, 0x39, 0x19, 0xae, 0xec, |
| 0xfd, 0x03, 0x00, 0x3b, 0xa0, 0xbe, 0xf9, 0x8c, 0xc9, 0x45, 0x04, 0xc6, 0xa5, 0xc1, 0x84, 0x07, |
| 0x17, 0xed, 0x84, 0x51, 0xfd, 0x00, 0x16, 0x53, 0xfa, 0x96, 0x15, 0x58, 0xbd, 0x90, 0x25, 0x3a, |
| 0x2b, 0xf4, 0x89, 0x1d, 0x99, 0xfc, 0x6a, 0x29, 0x66, 0xcf, 0xe3, 0x72, 0x2c, 0xc4, 0x5c, 0xa6, |
| 0xee, 0x03, 0x7a, 0x4c, 0xce, 0xf6, 0x93, 0x77, 0x42, 0x01, 0xdd, 0x86, 0x65, 0xc7, 0xb3, 0xdd, |
| 0x7e, 0x9b, 0x98, 0x5d, 0x42, 0x33, 0x77, 0x39, 0x05, 0xbc, 0x24, 0x54, 0x87, 0x84, 0x8a, 0x2b, |
| 0x1d, 0xf5, 0x9b, 0x29, 0x28, 0xf3, 0x25, 0x50, 0xa3, 0x5e, 0x44, 0xce, 0x23, 0xd4, 0x64, 0x49, |
| 0x36, 0x32, 0x5d, 0xea, 0x75, 0xcd, 0x80, 0xd8, 0x91, 0x08, 0xc8, 0xb8, 0xbb, 0x03, 0x69, 0x47, |
| 0xe2, 0x92, 0x2b, 0x6d, 0xcf, 0x77, 0x60, 0x21, 0x4d, 0xda, 0xb1, 0xab, 0xf2, 0x9b, 0x53, 0x5b, |
| 0x45, 0x9c, 0xa6, 0x72, 0x3e, 0x71, 0xf4, 0x14, 0x96, 0x06, 0xde, 0x34, 0x7d, 0x3e, 0x19, 0x51, |
| 0xc4, 0x6f, 0x5f, 0xd3, 0xa9, 0xc2, 0x7b, 0x78, 0xd1, 0x1e, 0x72, 0x67, 0x07, 0x56, 0xb3, 0xd7, |
| 0x86, 0x09, 0x7f, 0x9c, 0xf0, 0x77, 0xc7, 0x9f, 0x5d, 0x0c, 0x1b, 0x27, 0x75, 0x61, 0x63, 0xd9, |
| 0x1f, 0x15, 0x22, 0x1b, 0x56, 0x32, 0xb7, 0x86, 0x89, 0x99, 0x59, 0x6e, 0xe6, 0xde, 0x18, 0x33, |
| 0xa3, 0xc1, 0xc4, 0xe8, 0xc5, 0x88, 0x4c, 0xfd, 0x47, 0x0e, 0x56, 0xc4, 0x2a, 0x24, 0x3c, 0x70, |
| 0x98, 0x7c, 0xd9, 0x27, 0x61, 0x84, 0x1e, 0xc0, 0x0c, 0xbf, 0x1c, 0x12, 0x01, 0xfb, 0x9f, 0xeb, |
| 0x5c, 0xf6, 0xe0, 0x18, 0x82, 0xf6, 0xa0, 0xd0, 0x89, 0xef, 0x03, 0xe3, 0xf0, 0x94, 0x76, 0xff, |
| 0xf7, 0x7a, 0xd7, 0x87, 0x38, 0xc5, 0xb1, 0x9d, 0x1c, 0xdf, 0x56, 0xd9, 0xf1, 0x4a, 0xe2, 0x3b, |
| 0x6a, 0xfc, 0x4e, 0x96, 0x17, 0x1f, 0x2e, 0x3b, 0x52, 0x4b, 0x7d, 0x08, 0x6b, 0x5c, 0x3b, 0xd8, |
| 0x74, 0xc9, 0x22, 0x55, 0x60, 0x6a, 0x70, 0x67, 0xc6, 0x1e, 0xd1, 0x1d, 0x28, 0xf9, 0xcc, 0xb8, |
| 0xd7, 0xef, 0x9d, 0x91, 0x20, 0xb9, 0xbb, 0x64, 0xa2, 0x26, 0x97, 0xa8, 0x7f, 0x04, 0x58, 0x1d, |
| 0xf2, 0x5b, 0xe8, 0x53, 0x2f, 0x24, 0xe8, 0x53, 0x50, 0x3a, 0x96, 0x4d, 0xa4, 0x1b, 0xe2, 0x64, |
| 0x3b, 0x7f, 0x7f, 0xa2, 0x77, 0x52, 0xbc, 0xd8, 0xc9, 0xb4, 0x43, 0x74, 0x06, 0x2b, 0xc9, 0xf5, |
| 0x4b, 0x86, 0x3d, 0x76, 0xf1, 0xce, 0x18, 0xf6, 0xe1, 0xba, 0x15, 0x2f, 0x27, 0x64, 0xb2, 0x8d, |
| 0xa7, 0xa0, 0xb8, 0xb4, 0x4b, 0x33, 0xfc, 0x53, 0xaf, 0xc7, 0xbf, 0xc8, 0x88, 0x64, 0xee, 0xcf, |
| 0x60, 0xc9, 0xb5, 0xce, 0x88, 0x9b, 0x21, 0x9f, 0x7e, 0x3d, 0x72, 0x85, 0x33, 0xc9, 0xec, 0x2f, |
| 0xe1, 0xb6, 0x9b, 0x54, 0x7f, 0x26, 0xe5, 0xe5, 0x5f, 0xc6, 0xd0, 0x1a, 0x37, 0xf4, 0xe1, 0x35, |
| 0xaa, 0xd4, 0x4b, 0x0b, 0x48, 0xbc, 0xee, 0x5e, 0xa5, 0xe2, 0x5e, 0x1b, 0xfa, 0x2a, 0xc0, 0xb2, |
| 0xc1, 0xeb, 0x79, 0x8d, 0x11, 0xc9, 0xdc, 0x26, 0xac, 0x74, 0xfa, 0xae, 0x6b, 0x0e, 0x19, 0xe0, |
| 0x97, 0x4b, 0xe3, 0xd7, 0x94, 0x91, 0x61, 0xc3, 0x88, 0x51, 0x65, 0x65, 0xc8, 0x81, 0xb5, 0xd0, |
| 0xea, 0x90, 0x24, 0x99, 0x49, 0x26, 0xe2, 0x4c, 0x73, 0x7f, 0x8c, 0x89, 0xcb, 0x4a, 0x54, 0xbc, |
| 0x12, 0x5e, 0x56, 0xb8, 0x7a, 0x70, 0x2b, 0xde, 0xd4, 0x83, 0xb2, 0x5d, 0xb6, 0x57, 0xb8, 0x56, |
| 0x82, 0x1e, 0x2a, 0x31, 0xf0, 0x4d, 0x27, 0x2b, 0x90, 0xec, 0x75, 0x60, 0x55, 0x3a, 0x06, 0x24, |
| 0x4b, 0xa5, 0x6b, 0xa5, 0xea, 0x4b, 0xce, 0x69, 0xbc, 0x6c, 0x5f, 0x72, 0x78, 0xb7, 0x60, 0x3e, |
| 0x93, 0xaa, 0xf9, 0xc5, 0xdc, 0xf8, 0x64, 0x25, 0xe7, 0x68, 0x5c, 0x96, 0xb3, 0x33, 0x0b, 0xca, |
| 0xd0, 0x21, 0x93, 0x9c, 0xbd, 0x0b, 0xd7, 0x0a, 0x4a, 0xe6, 0x94, 0x11, 0xa7, 0x33, 0x5e, 0xf1, |
| 0x2f, 0x91, 0xb2, 0xd2, 0x93, 0x04, 0x01, 0x0d, 0x78, 0x01, 0x2d, 0x95, 0x9e, 0x81, 0x6f, 0x6f, |
| 0x9f, 0xf0, 0x0f, 0x4a, 0x38, 0xee, 0x80, 0x74, 0xf1, 0x6d, 0xe0, 0x3c, 0xaa, 0xac, 0xf2, 0xbe, |
| 0xef, 0x5f, 0x27, 0x54, 0x23, 0xf9, 0x16, 0x27, 0x2c, 0xea, 0x1f, 0xa4, 0xd3, 0xe7, 0xc0, 0x71, |
| 0x07, 0x49, 0xf4, 0x18, 0xca, 0x8e, 0xe7, 0xf7, 0xa3, 0xf8, 0x06, 0xba, 0x7b, 0xcd, 0xaa, 0xa1, |
| 0xce, 0x20, 0xfc, 0x5a, 0xba, 0x8b, 0x4b, 0xce, 0xa0, 0x81, 0x30, 0x14, 0x03, 0x41, 0x9d, 0xa4, |
| 0xcb, 0xf7, 0xc6, 0x70, 0x5d, 0x9a, 0xdc, 0xf1, 0x80, 0x46, 0xed, 0xc1, 0xfa, 0x9e, 0x15, 0xa5, |
| 0xcb, 0x3b, 0xee, 0x18, 0x26, 0xc7, 0xa7, 0x0e, 0x85, 0x20, 0x7e, 0x4c, 0xb2, 0xff, 0xfd, 0xc9, |
| 0x0c, 0x72, 0x2c, 0x4e, 0x49, 0xd4, 0x2f, 0xe1, 0xd6, 0xa5, 0xe6, 0x84, 0xc3, 0x32, 0x33, 0xcc, |
| 0x7d, 0x37, 0x33, 0xfc, 0x73, 0x1e, 0x2a, 0xd5, 0xf0, 0xc2, 0xb3, 0xb3, 0x21, 0x8a, 0x27, 0xf8, |
| 0x1d, 0x47, 0xe8, 0xbf, 0xb2, 0x64, 0x60, 0x8c, 0xb4, 0x1f, 0x49, 0xb3, 0x9c, 0xbe, 0x16, 0xa3, |
| 0xce, 0x31, 0x62, 0x9a, 0x65, 0x2a, 0xb5, 0xd4, 0x1e, 0xdc, 0xbc, 0xc4, 0xa5, 0x22, 0x88, 0x23, |
| 0xe6, 0x72, 0xdf, 0xd6, 0x5c, 0x1f, 0xde, 0xe4, 0xe6, 0x32, 0x4b, 0x87, 0xd9, 0x4c, 0x17, 0xea, |
| 0xc9, 0xc8, 0x42, 0x1d, 0xf7, 0x66, 0x76, 0xd5, 0x92, 0x90, 0x16, 0xeb, 0x05, 0xdc, 0xb9, 0xd2, |
| 0xac, 0x98, 0xeb, 0xa3, 0xd1, 0x05, 0xfb, 0xe1, 0xe4, 0x86, 0x47, 0x17, 0x6d, 0x08, 0x25, 0x69, |
| 0x91, 0xa1, 0x43, 0x80, 0xae, 0x1d, 0x9a, 0xe2, 0xc3, 0x65, 0xec, 0xcf, 0x71, 0x2f, 0xb6, 0x87, |
| 0x76, 0x28, 0x3e, 0x5b, 0x16, 0xbb, 0xc9, 0x23, 0xba, 0x05, 0xc5, 0x9e, 0xd3, 0x23, 0x26, 0xff, |
| 0xc6, 0x20, 0xbe, 0x9e, 0x32, 0x81, 0x71, 0xe1, 0x13, 0xf5, 0x17, 0x39, 0x28, 0xcb, 0x51, 0x40, |
| 0x8f, 0x60, 0x91, 0x99, 0x6d, 0x93, 0x30, 0x72, 0xbc, 0xf8, 0xc8, 0xc9, 0x5d, 0xeb, 0xbc, 0x3e, |
| 0xb4, 0xc3, 0xfd, 0x01, 0x08, 0x2f, 0x74, 0x33, 0x6d, 0xb4, 0x01, 0x70, 0xc6, 0x7c, 0x6a, 0x86, |
| 0xce, 0x4b, 0x22, 0xca, 0xd2, 0x22, 0x97, 0x9c, 0x38, 0x2f, 0x89, 0xba, 0x01, 0xc5, 0x74, 0xf0, |
| 0xa3, 0x55, 0xad, 0xaa, 0xc2, 0x42, 0x96, 0xff, 0x92, 0x3e, 0xdf, 0xe4, 0x61, 0x49, 0x4f, 0xfe, |
| 0x84, 0x70, 0x4c, 0x22, 0xab, 0x6d, 0x45, 0x16, 0x6a, 0xc0, 0x4c, 0xc8, 0xbc, 0x2e, 0x6e, 0x9c, |
| 0xc6, 0x7d, 0xf7, 0x1c, 0x21, 0xe0, 0x07, 0x09, 0xc1, 0x31, 0x09, 0xfa, 0x08, 0x4a, 0x76, 0x40, |
| 0xac, 0x88, 0x98, 0x91, 0xd3, 0x23, 0xe2, 0xbd, 0x69, 0x3d, 0xe1, 0x4c, 0xfe, 0xe9, 0xb0, 0x6d, |
| 0x24, 0xff, 0x74, 0xc0, 0x10, 0x77, 0x67, 0x02, 0x06, 0xee, 0xfb, 0xed, 0x14, 0x3c, 0x3b, 0x1e, |
| 0x1c, 0x77, 0x67, 0x02, 0xf5, 0xa7, 0x30, 0xc3, 0x47, 0x82, 0x56, 0x61, 0xe9, 0xc4, 0xa8, 0x1a, |
| 0xc3, 0xff, 0x2e, 0x28, 0xc1, 0x5c, 0x0d, 0x6b, 0x55, 0x43, 0xdb, 0x57, 0x72, 0xac, 0x81, 0x4f, |
| 0x9b, 0xcd, 0x7a, 0xf3, 0x50, 0xc9, 0xa3, 0x02, 0x4c, 0xef, 0xeb, 0x4d, 0x4d, 0x99, 0x42, 0xf3, |
| 0x50, 0xac, 0x55, 0x9b, 0x35, 0xad, 0xd1, 0xd0, 0xf6, 0x95, 0xe9, 0xbb, 0x04, 0x40, 0xfa, 0xdc, |
| 0x55, 0x82, 0x39, 0xf1, 0x99, 0x47, 0x79, 0x03, 0x2d, 0xc1, 0xfc, 0x23, 0x0d, 0x3f, 0x31, 0x4f, |
| 0x9b, 0x8d, 0xfa, 0x43, 0xad, 0xf1, 0x44, 0xc9, 0xa1, 0x32, 0x14, 0xd2, 0x56, 0x9e, 0xb5, 0x5a, |
| 0xfa, 0xc9, 0x49, 0x7d, 0xaf, 0xc1, 0x88, 0x01, 0x66, 0x85, 0x66, 0x1a, 0x2d, 0x42, 0x89, 0x43, |
| 0x85, 0x60, 0x66, 0xf7, 0x9f, 0x79, 0x58, 0x90, 0x8f, 0x53, 0x1a, 0xa0, 0xdf, 0xe5, 0x60, 0xf9, |
| 0x92, 0x33, 0x01, 0xfd, 0x70, 0xdc, 0x6d, 0xc7, 0x95, 0xc7, 0xd6, 0xfa, 0x83, 0xd7, 0x81, 0xc6, |
| 0x5b, 0x4f, 0x7d, 0xe7, 0xab, 0xbf, 0xfc, 0xfd, 0x97, 0xf9, 0x3b, 0xea, 0xfa, 0xf0, 0xff, 0x7f, |
| 0xc2, 0x07, 0xa2, 0xf2, 0x22, 0x0f, 0x72, 0x77, 0xd1, 0xd7, 0x39, 0xb8, 0x71, 0x45, 0x72, 0x40, |
| 0x1f, 0x5f, 0x27, 0x03, 0x5c, 0x99, 0xcb, 0xd6, 0x37, 0x12, 0xb8, 0xf4, 0x8f, 0x9a, 0xc1, 0x5a, |
| 0x54, 0xb7, 0xf9, 0x00, 0xb7, 0xd4, 0xb7, 0xa5, 0x01, 0x76, 0x18, 0xfe, 0x81, 0x35, 0xc2, 0xfb, |
| 0x20, 0x77, 0x77, 0xef, 0xab, 0x1c, 0xbc, 0x65, 0xd3, 0xde, 0xab, 0xc7, 0xb4, 0xb7, 0x9c, 0x8d, |
| 0x4a, 0x8b, 0x2d, 0xc0, 0x56, 0xee, 0x69, 0x4d, 0xa0, 0xba, 0xd4, 0xb5, 0xbc, 0xee, 0x36, 0x0d, |
| 0xba, 0x3b, 0x5d, 0xe2, 0xf1, 0xe5, 0xb9, 0x13, 0xab, 0x2c, 0xdf, 0x09, 0xaf, 0xf8, 0xbb, 0xd0, |
| 0x47, 0xb1, 0xe0, 0x5f, 0xb9, 0xdc, 0xd9, 0x2c, 0x87, 0xdc, 0xff, 0x77, 0x00, 0x00, 0x00, 0xff, |
| 0xff, 0xeb, 0x48, 0xba, 0xeb, 0x69, 0x25, 0x00, 0x00, |
| } |