mirror of
https://github.com/genuinetools/reg.git
synced 2024-09-19 16:51:01 -04:00
2701 lines
112 KiB
Go
2701 lines
112 KiB
Go
|
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||
|
// source: google/cloud/vision/v1/image_annotator.proto
|
||
|
|
||
|
package vision // import "google.golang.org/genproto/googleapis/cloud/vision/v1"
|
||
|
|
||
|
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_aa4dfcf881de3ecf, []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
|
||
|
)
|
||
|
|
||
|
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",
|
||
|
}
|
||
|
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,
|
||
|
}
|
||
|
|
||
|
func (x Feature_Type) String() string {
|
||
|
return proto.EnumName(Feature_Type_name, int32(x))
|
||
|
}
|
||
|
func (Feature_Type) EnumDescriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_image_annotator_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []int{31, 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.v1.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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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.v1.Likelihood" json:"joy_likelihood,omitempty"`
|
||
|
// Sorrow likelihood.
|
||
|
SorrowLikelihood Likelihood `protobuf:"varint,10,opt,name=sorrow_likelihood,json=sorrowLikelihood,proto3,enum=google.cloud.vision.v1.Likelihood" json:"sorrow_likelihood,omitempty"`
|
||
|
// Anger likelihood.
|
||
|
AngerLikelihood Likelihood `protobuf:"varint,11,opt,name=anger_likelihood,json=angerLikelihood,proto3,enum=google.cloud.vision.v1.Likelihood" json:"anger_likelihood,omitempty"`
|
||
|
// Surprise likelihood.
|
||
|
SurpriseLikelihood Likelihood `protobuf:"varint,12,opt,name=surprise_likelihood,json=surpriseLikelihood,proto3,enum=google.cloud.vision.v1.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.v1.Likelihood" json:"under_exposed_likelihood,omitempty"`
|
||
|
// Blurred likelihood.
|
||
|
BlurredLikelihood Likelihood `protobuf:"varint,14,opt,name=blurred_likelihood,json=blurredLikelihood,proto3,enum=google.cloud.vision.v1.Likelihood" json:"blurred_likelihood,omitempty"`
|
||
|
// Headwear likelihood.
|
||
|
HeadwearLikelihood Likelihood `protobuf:"varint,15,opt,name=headwear_likelihood,json=headwearLikelihood,proto3,enum=google.cloud.vision.v1.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_aa4dfcf881de3ecf, []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.v1.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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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_aa4dfcf881de3ecf, []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 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.v1.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.v1.Likelihood" json:"spoof,omitempty"`
|
||
|
// Likelihood that this is a medical image.
|
||
|
Medical Likelihood `protobuf:"varint,3,opt,name=medical,proto3,enum=google.cloud.vision.v1.Likelihood" json:"medical,omitempty"`
|
||
|
// Likelihood that this image contains violent content.
|
||
|
Violence Likelihood `protobuf:"varint,4,opt,name=violence,proto3,enum=google.cloud.vision.v1.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.v1.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_aa4dfcf881de3ecf, []int{7}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{8}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{9}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{10}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{11}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{12}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{13}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{14}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{15}
|
||
|
}
|
||
|
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 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_aa4dfcf881de3ecf, []int{16}
|
||
|
}
|
||
|
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) 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_aa4dfcf881de3ecf, []int{17}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{18}
|
||
|
}
|
||
|
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, 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 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_aa4dfcf881de3ecf, []int{19}
|
||
|
}
|
||
|
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) 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) 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_aa4dfcf881de3ecf, []int{20}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{21}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{22}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{23}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{24}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{25}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{26}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{27}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{28}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{29}
|
||
|
}
|
||
|
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_aa4dfcf881de3ecf, []int{30}
|
||
|
}
|
||
|
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.v1.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_aa4dfcf881de3ecf, []int{31}
|
||
|
}
|
||
|
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.v1.Feature")
|
||
|
proto.RegisterType((*ImageSource)(nil), "google.cloud.vision.v1.ImageSource")
|
||
|
proto.RegisterType((*Image)(nil), "google.cloud.vision.v1.Image")
|
||
|
proto.RegisterType((*FaceAnnotation)(nil), "google.cloud.vision.v1.FaceAnnotation")
|
||
|
proto.RegisterType((*FaceAnnotation_Landmark)(nil), "google.cloud.vision.v1.FaceAnnotation.Landmark")
|
||
|
proto.RegisterType((*LocationInfo)(nil), "google.cloud.vision.v1.LocationInfo")
|
||
|
proto.RegisterType((*Property)(nil), "google.cloud.vision.v1.Property")
|
||
|
proto.RegisterType((*EntityAnnotation)(nil), "google.cloud.vision.v1.EntityAnnotation")
|
||
|
proto.RegisterType((*SafeSearchAnnotation)(nil), "google.cloud.vision.v1.SafeSearchAnnotation")
|
||
|
proto.RegisterType((*LatLongRect)(nil), "google.cloud.vision.v1.LatLongRect")
|
||
|
proto.RegisterType((*ColorInfo)(nil), "google.cloud.vision.v1.ColorInfo")
|
||
|
proto.RegisterType((*DominantColorsAnnotation)(nil), "google.cloud.vision.v1.DominantColorsAnnotation")
|
||
|
proto.RegisterType((*ImageProperties)(nil), "google.cloud.vision.v1.ImageProperties")
|
||
|
proto.RegisterType((*CropHint)(nil), "google.cloud.vision.v1.CropHint")
|
||
|
proto.RegisterType((*CropHintsAnnotation)(nil), "google.cloud.vision.v1.CropHintsAnnotation")
|
||
|
proto.RegisterType((*CropHintsParams)(nil), "google.cloud.vision.v1.CropHintsParams")
|
||
|
proto.RegisterType((*WebDetectionParams)(nil), "google.cloud.vision.v1.WebDetectionParams")
|
||
|
proto.RegisterType((*ImageContext)(nil), "google.cloud.vision.v1.ImageContext")
|
||
|
proto.RegisterType((*AnnotateImageRequest)(nil), "google.cloud.vision.v1.AnnotateImageRequest")
|
||
|
proto.RegisterType((*ImageAnnotationContext)(nil), "google.cloud.vision.v1.ImageAnnotationContext")
|
||
|
proto.RegisterType((*AnnotateImageResponse)(nil), "google.cloud.vision.v1.AnnotateImageResponse")
|
||
|
proto.RegisterType((*AnnotateFileResponse)(nil), "google.cloud.vision.v1.AnnotateFileResponse")
|
||
|
proto.RegisterType((*BatchAnnotateImagesRequest)(nil), "google.cloud.vision.v1.BatchAnnotateImagesRequest")
|
||
|
proto.RegisterType((*BatchAnnotateImagesResponse)(nil), "google.cloud.vision.v1.BatchAnnotateImagesResponse")
|
||
|
proto.RegisterType((*AsyncAnnotateFileRequest)(nil), "google.cloud.vision.v1.AsyncAnnotateFileRequest")
|
||
|
proto.RegisterType((*AsyncAnnotateFileResponse)(nil), "google.cloud.vision.v1.AsyncAnnotateFileResponse")
|
||
|
proto.RegisterType((*AsyncBatchAnnotateFilesRequest)(nil), "google.cloud.vision.v1.AsyncBatchAnnotateFilesRequest")
|
||
|
proto.RegisterType((*AsyncBatchAnnotateFilesResponse)(nil), "google.cloud.vision.v1.AsyncBatchAnnotateFilesResponse")
|
||
|
proto.RegisterType((*InputConfig)(nil), "google.cloud.vision.v1.InputConfig")
|
||
|
proto.RegisterType((*OutputConfig)(nil), "google.cloud.vision.v1.OutputConfig")
|
||
|
proto.RegisterType((*GcsSource)(nil), "google.cloud.vision.v1.GcsSource")
|
||
|
proto.RegisterType((*GcsDestination)(nil), "google.cloud.vision.v1.GcsDestination")
|
||
|
proto.RegisterType((*OperationMetadata)(nil), "google.cloud.vision.v1.OperationMetadata")
|
||
|
proto.RegisterEnum("google.cloud.vision.v1.Likelihood", Likelihood_name, Likelihood_value)
|
||
|
proto.RegisterEnum("google.cloud.vision.v1.Feature_Type", Feature_Type_name, Feature_Type_value)
|
||
|
proto.RegisterEnum("google.cloud.vision.v1.FaceAnnotation_Landmark_Type", FaceAnnotation_Landmark_Type_name, FaceAnnotation_Landmark_Type_value)
|
||
|
proto.RegisterEnum("google.cloud.vision.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/image_annotator.proto",
|
||
|
}
|
||
|
|
||
|
func init() {
|
||
|
proto.RegisterFile("google/cloud/vision/v1/image_annotator.proto", fileDescriptor_image_annotator_aa4dfcf881de3ecf)
|
||
|
}
|
||
|
|
||
|
var fileDescriptor_image_annotator_aa4dfcf881de3ecf = []byte{
|
||
|
// 2892 bytes of a gzipped FileDescriptorProto
|
||
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x48,
|
||
|
0x15, 0x5f, 0x3b, 0x4e, 0x62, 0x3f, 0x3b, 0x89, 0xd2, 0xf9, 0x18, 0x4f, 0xe6, 0x2b, 0xa3, 0x65,
|
||
|
0xd9, 0xd4, 0x30, 0x24, 0x4c, 0x76, 0x99, 0x5a, 0x66, 0xa6, 0x00, 0xc7, 0x51, 0x12, 0xd7, 0x38,
|
||
|
0xb6, 0xb7, 0xed, 0xcc, 0x6c, 0x60, 0x0b, 0x95, 0x22, 0xb7, 0x35, 0xda, 0x95, 0x25, 0x21, 0xc9,
|
||
|
0x33, 0xc9, 0x52, 0xc5, 0x81, 0x2a, 0xce, 0x1c, 0x38, 0x71, 0xe1, 0xc0, 0x01, 0x0e, 0x9c, 0xa8,
|
||
|
0x82, 0x3b, 0x57, 0x0e, 0x1c, 0xa8, 0xfd, 0x17, 0xf8, 0x0f, 0xa8, 0xa2, 0x38, 0x52, 0xfd, 0x21,
|
||
|
0xb9, 0xe5, 0x44, 0x99, 0x64, 0xd9, 0x03, 0xa7, 0xb8, 0xdf, 0x7b, 0xbf, 0xdf, 0xeb, 0x7e, 0xdd,
|
||
|
0xaf, 0xfb, 0x75, 0x2b, 0xf0, 0xd0, 0xf2, 0x3c, 0xcb, 0x21, 0x5b, 0xa6, 0xe3, 0x8d, 0xfa, 0x5b,
|
||
|
0xaf, 0xed, 0xd0, 0xf6, 0xdc, 0xad, 0xd7, 0x8f, 0xb6, 0xec, 0xa1, 0x61, 0x11, 0xdd, 0x70, 0x5d,
|
||
|
0x2f, 0x32, 0x22, 0x2f, 0xd8, 0xf4, 0x03, 0x2f, 0xf2, 0xd0, 0x2a, 0xb7, 0xde, 0x64, 0xd6, 0x9b,
|
||
|
0xdc, 0x7a, 0xf3, 0xf5, 0xa3, 0xb5, 0xdb, 0x82, 0xc5, 0xf0, 0xed, 0x2d, 0x81, 0xb1, 0x3d, 0x37,
|
||
|
0xe4, 0xa8, 0xb5, 0xf7, 0x32, 0x7c, 0x58, 0xc4, 0x1b, 0x92, 0x28, 0x38, 0x13, 0x66, 0x59, 0x5d,
|
||
|
0x89, 0xc8, 0x69, 0xa4, 0x8f, 0x59, 0x85, 0xf5, 0x83, 0x0c, 0xeb, 0x37, 0xe4, 0x44, 0xef, 0x93,
|
||
|
0x88, 0x98, 0x92, 0xed, 0xbb, 0xc2, 0xd6, 0xf1, 0x5c, 0x2b, 0x18, 0xb9, 0xae, 0xed, 0x5a, 0x5b,
|
||
|
0x9e, 0x4f, 0x82, 0x54, 0x2f, 0xef, 0x09, 0x23, 0xd6, 0x3a, 0x19, 0x0d, 0xb6, 0x22, 0x7b, 0x48,
|
||
|
0xc2, 0xc8, 0x18, 0xfa, 0xc2, 0xe0, 0x86, 0x30, 0x08, 0x7c, 0x73, 0x2b, 0x8c, 0x8c, 0x68, 0x14,
|
||
|
0x4e, 0x28, 0xa2, 0x33, 0x9f, 0x6c, 0x99, 0x9e, 0x13, 0x87, 0x6b, 0xad, 0x2a, 0x2b, 0x1c, 0x23,
|
||
|
0x72, 0x5c, 0x8b, 0x6b, 0xd4, 0x7f, 0xe5, 0x61, 0x76, 0x8f, 0x18, 0xd1, 0x28, 0x20, 0xe8, 0x23,
|
||
|
0x28, 0x50, 0x83, 0x6a, 0x6e, 0x3d, 0xb7, 0x31, 0xbf, 0xfd, 0x8d, 0xcd, 0x8b, 0x63, 0xbc, 0x29,
|
||
|
0xcc, 0x37, 0x7b, 0x67, 0x3e, 0xc1, 0x0c, 0x81, 0xee, 0x41, 0x79, 0x68, 0x9c, 0xea, 0x01, 0x09,
|
||
|
0x47, 0x4e, 0x14, 0x56, 0xf3, 0xeb, 0xb9, 0x8d, 0x69, 0x0c, 0x43, 0xe3, 0x14, 0x73, 0x09, 0x5a,
|
||
|
0x86, 0xe9, 0xa1, 0xd7, 0x27, 0x4e, 0x75, 0x6a, 0x3d, 0xb7, 0x51, 0xc2, 0xbc, 0xa1, 0xfe, 0x3b,
|
||
|
0x07, 0x05, 0xca, 0x82, 0x96, 0x41, 0xe9, 0x1d, 0x77, 0x34, 0xfd, 0xa8, 0xd5, 0xed, 0x68, 0xf5,
|
||
|
0xc6, 0x5e, 0x43, 0xdb, 0x55, 0xde, 0x41, 0x08, 0xe6, 0xf7, 0x6a, 0x75, 0x4d, 0xdf, 0xd5, 0x7a,
|
||
|
0x5a, 0xbd, 0xd7, 0x68, 0xb7, 0x94, 0x1c, 0x5a, 0x05, 0xd4, 0xac, 0xb5, 0x76, 0x0f, 0x6b, 0xf8,
|
||
|
0xb9, 0x24, 0xcf, 0x53, 0xdb, 0x66, 0x7b, 0xbf, 0x2d, 0xc9, 0xa6, 0xd0, 0x12, 0x2c, 0x34, 0x6b,
|
||
|
0x3b, 0x5a, 0x53, 0x12, 0x16, 0xa8, 0x61, 0x4f, 0xfb, 0xa4, 0x27, 0xc9, 0xa6, 0xd1, 0x2d, 0xb8,
|
||
|
0xb1, 0xdb, 0xae, 0x1f, 0x1d, 0x6a, 0xad, 0x9e, 0x3e, 0xa1, 0x2c, 0xa3, 0x9b, 0xb0, 0xd2, 0xad,
|
||
|
0xed, 0x69, 0x7a, 0x57, 0xab, 0xe1, 0xfa, 0x81, 0xa4, 0x9a, 0xa1, 0xdd, 0x6e, 0x1c, 0xd6, 0xf6,
|
||
|
0x35, 0xbd, 0x83, 0xdb, 0x1d, 0x0d, 0xf7, 0x1a, 0x5a, 0x57, 0x99, 0x45, 0xf3, 0x00, 0x75, 0xdc,
|
||
|
0xee, 0xe8, 0x07, 0x8d, 0x56, 0xaf, 0xab, 0x94, 0xd0, 0x22, 0xcc, 0xbd, 0xd4, 0x76, 0x24, 0x20,
|
||
|
0xa8, 0x2d, 0x28, 0x37, 0xe8, 0xba, 0xee, 0x7a, 0xa3, 0xc0, 0x24, 0x48, 0x85, 0x39, 0xcb, 0x0c,
|
||
|
0x75, 0xbe, 0xd4, 0x47, 0x81, 0xcd, 0x66, 0xa0, 0x84, 0xcb, 0x96, 0x19, 0x32, 0xb3, 0xa3, 0xc0,
|
||
|
0x46, 0xb7, 0xa0, 0x34, 0xd6, 0xe7, 0x99, 0xbe, 0x68, 0x0b, 0xa5, 0xfa, 0x13, 0x98, 0x66, 0x86,
|
||
|
0xa8, 0x0a, 0xb3, 0xa6, 0xe7, 0x46, 0xc4, 0x8d, 0x18, 0x47, 0x05, 0xc7, 0x4d, 0xf4, 0x14, 0x66,
|
||
|
0x42, 0xe6, 0x8d, 0x81, 0xcb, 0xdb, 0xef, 0x66, 0x4d, 0xaf, 0xd4, 0x31, 0x2c, 0x20, 0xea, 0x3f,
|
||
|
0x16, 0x60, 0x7e, 0xcf, 0x30, 0x49, 0x2d, 0x59, 0xfc, 0xa8, 0x01, 0x73, 0x27, 0xde, 0xc8, 0xed,
|
||
|
0xdb, 0xae, 0xa5, 0xfb, 0x9e, 0x73, 0xc6, 0xfc, 0x95, 0xb3, 0x57, 0xcd, 0x8e, 0x30, 0xee, 0x78,
|
||
|
0xce, 0x19, 0xae, 0x9c, 0x48, 0x2d, 0xd4, 0x02, 0x65, 0xd0, 0xd7, 0xd3, 0x6c, 0xf9, 0x6b, 0xb0,
|
||
|
0xcd, 0x0f, 0xfa, 0x72, 0x1b, 0x1d, 0x42, 0xc9, 0x31, 0xdc, 0xfe, 0xd0, 0x08, 0x3e, 0x0f, 0xab,
|
||
|
0x53, 0xeb, 0x53, 0x1b, 0xe5, 0xed, 0xad, 0xcc, 0xc5, 0x9c, 0x1a, 0xd5, 0x66, 0x53, 0xe0, 0xf0,
|
||
|
0x98, 0x01, 0xdd, 0x01, 0x08, 0x3c, 0xc7, 0xd1, 0x0d, 0xd7, 0x72, 0x48, 0xb5, 0xb0, 0x9e, 0xdb,
|
||
|
0xc8, 0xe3, 0x12, 0x95, 0xd4, 0xa8, 0x80, 0x4e, 0x8c, 0x6f, 0xb8, 0x42, 0x3b, 0xcd, 0xb4, 0x45,
|
||
|
0xdf, 0x70, 0xb9, 0xf2, 0x0e, 0x40, 0x64, 0x3b, 0x91, 0xd0, 0xce, 0x70, 0x2c, 0x95, 0x70, 0xf5,
|
||
|
0x23, 0x58, 0x4e, 0xb6, 0x08, 0xdd, 0xf4, 0xdc, 0x81, 0xdd, 0x27, 0xae, 0x49, 0xaa, 0xb3, 0xcc,
|
||
|
0x70, 0x29, 0xd1, 0xd5, 0x13, 0x15, 0xfa, 0x2e, 0xac, 0xc6, 0x5d, 0xa3, 0xc1, 0x92, 0x40, 0x45,
|
||
|
0x06, 0x5a, 0x91, 0xb4, 0x12, 0xac, 0x01, 0xf3, 0x9f, 0x79, 0x67, 0xba, 0x63, 0x7f, 0x4e, 0x1c,
|
||
|
0xfb, 0x95, 0xe7, 0xf5, 0xab, 0x25, 0x96, 0xe5, 0x6a, 0x56, 0x60, 0x9a, 0x89, 0x25, 0x9e, 0xfb,
|
||
|
0xcc, 0x3b, 0x1b, 0x37, 0x51, 0x1b, 0x16, 0x43, 0x2f, 0x08, 0xbc, 0x37, 0x32, 0x1b, 0x5c, 0x99,
|
||
|
0x4d, 0xe1, 0x60, 0x89, 0xf0, 0x10, 0x14, 0xc3, 0xb5, 0x48, 0x20, 0xf3, 0x95, 0xaf, 0xcc, 0xb7,
|
||
|
0xc0, 0xb0, 0x12, 0x5d, 0x17, 0x96, 0xc2, 0x51, 0xe0, 0x07, 0x76, 0x48, 0x64, 0xc6, 0xca, 0x95,
|
||
|
0x19, 0x51, 0x0c, 0x97, 0x48, 0x3f, 0x85, 0xea, 0xc8, 0xed, 0x93, 0x40, 0x27, 0xa7, 0xbe, 0x17,
|
||
|
0x92, 0xbe, 0xcc, 0x3c, 0x77, 0x65, 0xe6, 0x55, 0xc6, 0xa1, 0x71, 0x0a, 0x89, 0xfd, 0x63, 0x40,
|
||
|
0x27, 0xce, 0x28, 0x08, 0xd2, 0xbc, 0xf3, 0x57, 0xe6, 0x5d, 0x14, 0xe8, 0x74, 0x14, 0x5e, 0x11,
|
||
|
0xa3, 0xff, 0x86, 0x18, 0xa9, 0xb8, 0x2e, 0x5c, 0x3d, 0x0a, 0x31, 0x7c, 0x2c, 0x5b, 0xfb, 0xdb,
|
||
|
0x2c, 0x14, 0xe3, 0x14, 0x41, 0x07, 0xe2, 0xb8, 0x98, 0x62, 0x94, 0x1f, 0x5e, 0x33, 0xc3, 0xe4,
|
||
|
0xe3, 0xe3, 0x19, 0x14, 0x7d, 0x2f, 0xb4, 0xa9, 0x9e, 0xe5, 0x57, 0x79, 0x7b, 0x3d, 0x8b, 0xad,
|
||
|
0x23, 0xec, 0x70, 0x82, 0x50, 0xff, 0x3c, 0x33, 0x3e, 0x45, 0x8e, 0x5a, 0xcf, 0x5b, 0xed, 0x97,
|
||
|
0x2d, 0x3d, 0x3e, 0x23, 0x94, 0x77, 0x50, 0x05, 0x8a, 0x4d, 0x6d, 0xaf, 0xa7, 0x6b, 0xc7, 0x9a,
|
||
|
0x92, 0x43, 0x73, 0x50, 0xc2, 0x8d, 0xfd, 0x03, 0xde, 0xcc, 0xa3, 0x2a, 0x2c, 0x33, 0x65, 0x7b,
|
||
|
0x4f, 0x8f, 0x8d, 0x76, 0x70, 0xfb, 0xa5, 0x32, 0x45, 0xb7, 0x7d, 0x6e, 0x38, 0xa9, 0x2a, 0x50,
|
||
|
0x55, 0x0c, 0x4a, 0xb8, 0x98, 0x6a, 0x1a, 0xad, 0xc1, 0x6a, 0x82, 0x4a, 0xeb, 0x66, 0x28, 0xec,
|
||
|
0xb0, 0xb1, 0xdb, 0x69, 0x37, 0x5a, 0x3d, 0x7d, 0x47, 0xeb, 0xbd, 0xd4, 0xb4, 0x16, 0xd5, 0xd2,
|
||
|
0x23, 0xa3, 0x02, 0xc5, 0x56, 0xbb, 0xab, 0xe9, 0xbd, 0x46, 0x47, 0x29, 0xd2, 0x3e, 0x1e, 0x75,
|
||
|
0x3a, 0x1a, 0xd6, 0x9b, 0x8d, 0x8e, 0x52, 0xa2, 0xcd, 0x66, 0xfb, 0xa5, 0x68, 0x02, 0x3d, 0x5e,
|
||
|
0x0e, 0xdb, 0x47, 0xbd, 0x03, 0xd6, 0x2b, 0xa5, 0x8c, 0x16, 0xa0, 0xcc, 0xdb, 0xcc, 0x9f, 0x52,
|
||
|
0x41, 0x0a, 0x54, 0xb8, 0xa0, 0xae, 0xb5, 0x7a, 0x1a, 0x56, 0xe6, 0xd0, 0x0a, 0x2c, 0x32, 0xfa,
|
||
|
0x9d, 0x76, 0xaf, 0xd7, 0x3e, 0x14, 0x86, 0xf3, 0x34, 0x5e, 0xb2, 0x98, 0xf1, 0x2d, 0xd0, 0x13,
|
||
|
0x56, 0x96, 0x0a, 0x12, 0x25, 0x19, 0xb5, 0x76, 0xac, 0xe9, 0xbd, 0x76, 0x47, 0xdf, 0x69, 0x1f,
|
||
|
0xb5, 0x76, 0x6b, 0xf8, 0x58, 0x59, 0x4c, 0xa9, 0xf8, 0xa8, 0xeb, 0x6d, 0xdc, 0xd2, 0xb0, 0x82,
|
||
|
0xd0, 0x6d, 0xa8, 0x26, 0x2a, 0xc1, 0x98, 0x00, 0x97, 0x92, 0xf0, 0x53, 0x2d, 0xfb, 0x21, 0x70,
|
||
|
0xcb, 0xe3, 0x40, 0x9e, 0x73, 0xb7, 0x92, 0xd6, 0xa5, 0xfc, 0xad, 0xa2, 0x3b, 0x70, 0x73, 0xac,
|
||
|
0x9b, 0x74, 0x78, 0x63, 0x3c, 0xab, 0x93, 0x1e, 0xab, 0xe8, 0x1e, 0xdc, 0x92, 0xe7, 0x59, 0xe7,
|
||
|
0x53, 0x10, 0xcf, 0x98, 0x72, 0x13, 0xad, 0xc3, 0xed, 0xd4, 0x94, 0x4e, 0x5a, 0xac, 0xd1, 0x80,
|
||
|
0x72, 0x8a, 0x1a, 0xd6, 0x7b, 0xb8, 0xb6, 0x4f, 0x0f, 0xfb, 0x5b, 0x34, 0xfa, 0x02, 0x27, 0x89,
|
||
|
0x6f, 0xb3, 0x8a, 0x25, 0x1e, 0x7b, 0xe7, 0xa8, 0xd3, 0x68, 0x2a, 0x77, 0x68, 0xc5, 0x32, 0xee,
|
||
|
0x1e, 0x17, 0xde, 0xa5, 0xf8, 0xbd, 0x36, 0xd6, 0x0e, 0xb4, 0xda, 0xae, 0xbe, 0xcf, 0x0a, 0x9a,
|
||
|
0x66, 0x4d, 0xb9, 0x47, 0xcb, 0x8a, 0xfa, 0x41, 0xa3, 0xa5, 0xef, 0xb7, 0x6a, 0xbd, 0x03, 0x4a,
|
||
|
0xb9, 0x4e, 0xfd, 0x33, 0x11, 0xe3, 0xdd, 0x6f, 0xb7, 0xa8, 0xf4, 0x3e, 0xc5, 0x33, 0x29, 0x67,
|
||
|
0x16, 0x62, 0x55, 0x7d, 0x06, 0x95, 0xa6, 0x67, 0xb2, 0xa4, 0x6c, 0xb8, 0x03, 0x0f, 0x3d, 0x84,
|
||
|
0x59, 0xc7, 0x88, 0x74, 0xc7, 0xb5, 0xc4, 0x51, 0xbe, 0x14, 0xe7, 0x20, 0xcd, 0xd1, 0xcd, 0xa6,
|
||
|
0x11, 0x35, 0x5d, 0x0b, 0xcf, 0x38, 0xec, 0xaf, 0xfa, 0x12, 0x8a, 0x9d, 0x80, 0x96, 0xae, 0xd1,
|
||
|
0x19, 0x42, 0x50, 0x70, 0x8d, 0x21, 0x11, 0x55, 0x0b, 0xfb, 0x4d, 0x0b, 0xbe, 0xd7, 0x86, 0x33,
|
||
|
0x22, 0xa2, 0x54, 0xe1, 0x0d, 0x74, 0x1f, 0x2a, 0x23, 0xdb, 0x8d, 0x1e, 0x7f, 0xa8, 0x73, 0x25,
|
||
|
0xdd, 0x3a, 0x0a, 0xb8, 0xcc, 0x65, 0x2f, 0xa8, 0x48, 0xfd, 0xe5, 0x14, 0x28, 0x9a, 0x1b, 0xd9,
|
||
|
0xd1, 0x99, 0x54, 0x6c, 0x28, 0x30, 0x35, 0xb4, 0xfb, 0xc2, 0x01, 0xfd, 0x89, 0x56, 0x61, 0xc6,
|
||
|
0xf1, 0x4c, 0xc3, 0x89, 0x1d, 0x88, 0x16, 0x5a, 0x87, 0x72, 0x9f, 0x84, 0x66, 0x60, 0xfb, 0x6c,
|
||
|
0x37, 0xe1, 0xe5, 0xa6, 0x2c, 0xa2, 0x3d, 0x0b, 0x4d, 0x2f, 0x88, 0x4f, 0x72, 0xde, 0x40, 0x77,
|
||
|
0x01, 0xa4, 0xa3, 0x94, 0x1f, 0xe3, 0x92, 0x84, 0xea, 0x23, 0xcf, 0xb7, 0x4d, 0xc3, 0xb1, 0xa3,
|
||
|
0x33, 0x71, 0x90, 0x4b, 0x92, 0xf3, 0xe5, 0xd0, 0xec, 0x57, 0x2e, 0x87, 0x76, 0xa0, 0xe4, 0x88,
|
||
|
0x89, 0x09, 0xab, 0x45, 0x56, 0xbe, 0x64, 0xd2, 0xc8, 0x33, 0x88, 0xc7, 0x30, 0xf4, 0x43, 0x00,
|
||
|
0x9f, 0x4f, 0x8f, 0x4d, 0xc2, 0x6a, 0x89, 0x91, 0x64, 0xef, 0xa9, 0x62, 0x22, 0xb1, 0x84, 0x51,
|
||
|
0xff, 0x9a, 0x87, 0xe5, 0xae, 0x31, 0x20, 0x5d, 0x62, 0x04, 0xe6, 0x2b, 0x69, 0x2e, 0x3e, 0x82,
|
||
|
0x69, 0xa3, 0x3f, 0x72, 0x22, 0x71, 0x4d, 0xb8, 0xca, 0x51, 0xc2, 0x01, 0x14, 0x19, 0xfa, 0x9e,
|
||
|
0x37, 0x60, 0x53, 0x76, 0x45, 0x24, 0x03, 0xa0, 0x67, 0x30, 0x3b, 0x24, 0x7d, 0x1a, 0x6b, 0x71,
|
||
|
0xda, 0x5c, 0x05, 0x1b, 0x43, 0xd0, 0xf7, 0xa1, 0xf8, 0xda, 0xf6, 0x1c, 0x36, 0xb3, 0x85, 0x2b,
|
||
|
0xc3, 0x13, 0x0c, 0x7a, 0x0c, 0x85, 0xc0, 0x30, 0xcf, 0xae, 0x51, 0x31, 0x31, 0x7b, 0xf5, 0x0d,
|
||
|
0x94, 0x69, 0xd6, 0x78, 0xae, 0x85, 0x89, 0x19, 0xa1, 0x0f, 0xa0, 0x3c, 0xb4, 0x5d, 0xfd, 0x0a,
|
||
|
0x49, 0x56, 0x1a, 0xda, 0x2e, 0xff, 0xc9, 0x40, 0xc6, 0x69, 0x02, 0xca, 0x5f, 0x06, 0x32, 0x4e,
|
||
|
0xf9, 0x4f, 0x35, 0x80, 0x52, 0x9d, 0xde, 0xfe, 0x58, 0x5e, 0x6f, 0xc0, 0x34, 0xbb, 0x0a, 0x0a,
|
||
|
0x87, 0x28, 0x85, 0x65, 0x66, 0x98, 0x1b, 0x8c, 0x33, 0x23, 0x2f, 0x67, 0xc6, 0x7b, 0x30, 0xef,
|
||
|
0xdb, 0xa7, 0xc4, 0xd1, 0x07, 0x81, 0x61, 0x26, 0x49, 0x95, 0xc7, 0x73, 0x4c, 0xba, 0x27, 0x84,
|
||
|
0xea, 0x11, 0x54, 0x77, 0xbd, 0xa1, 0xed, 0x1a, 0x6e, 0xc4, 0x48, 0x43, 0x69, 0xc9, 0x7c, 0x0f,
|
||
|
0x66, 0x98, 0x87, 0xb0, 0x9a, 0x63, 0x2b, 0xf1, 0x7e, 0x56, 0x08, 0x93, 0x5e, 0x63, 0x01, 0x50,
|
||
|
0x1d, 0x58, 0x60, 0x17, 0x92, 0x4e, 0xb2, 0x32, 0xd1, 0x31, 0x2c, 0xf4, 0x85, 0x27, 0x3d, 0xa1,
|
||
|
0xa5, 0x43, 0xfb, 0x4e, 0x16, 0x6d, 0x56, 0xc7, 0xf0, 0x7c, 0x3f, 0xa5, 0x51, 0x7f, 0x9f, 0x83,
|
||
|
0x62, 0x3d, 0xf0, 0xfc, 0x03, 0xdb, 0x8d, 0xbe, 0xce, 0x1b, 0x4e, 0x7a, 0x77, 0xc9, 0x9f, 0xdb,
|
||
|
0x5d, 0xb6, 0x60, 0xc9, 0x1e, 0xfa, 0x5e, 0x10, 0x19, 0xae, 0x49, 0x26, 0x03, 0x8d, 0xc6, 0xaa,
|
||
|
0x24, 0xda, 0x2f, 0x60, 0x29, 0xee, 0xa7, 0x1c, 0xe8, 0x1f, 0x00, 0x98, 0x81, 0xe7, 0xeb, 0xaf,
|
||
|
0xa8, 0x5c, 0x04, 0x3b, 0x33, 0xed, 0x63, 0x02, 0x5c, 0x32, 0x63, 0x2a, 0xf5, 0x31, 0x2c, 0x24,
|
||
|
0xbc, 0x1d, 0x23, 0x30, 0x86, 0x21, 0x7a, 0x17, 0xe6, 0x8c, 0xd0, 0x27, 0x66, 0xa4, 0xb3, 0x67,
|
||
|
0x0a, 0x4e, 0x9b, 0xc7, 0x15, 0x2e, 0xc4, 0x4c, 0xa6, 0xee, 0x02, 0x7a, 0x49, 0x4e, 0x76, 0xe3,
|
||
|
0xfb, 0x8a, 0x80, 0x6e, 0xc2, 0x92, 0xed, 0x9a, 0xce, 0xa8, 0x4f, 0x74, 0x8b, 0x78, 0xa9, 0xe7,
|
||
|
0x81, 0x22, 0x5e, 0x14, 0xaa, 0x7d, 0xe2, 0x89, 0x57, 0x02, 0xf5, 0x4f, 0x79, 0xa8, 0xb0, 0xd9,
|
||
|
0xae, 0xd3, 0x4b, 0xeb, 0x69, 0x84, 0xf6, 0x61, 0x8e, 0xad, 0x7c, 0xcf, 0xb5, 0xf4, 0x80, 0x98,
|
||
|
0x91, 0x98, 0x82, 0xcc, 0xbb, 0xab, 0x94, 0x6e, 0xb8, 0xec, 0x48, 0xb9, 0xf7, 0x1e, 0xcc, 0x3b,
|
||
|
0x86, 0x6b, 0x8d, 0xe8, 0x05, 0x9a, 0x07, 0x27, 0xbf, 0x3e, 0xb5, 0x51, 0xc2, 0x73, 0xb1, 0x94,
|
||
|
0x8d, 0x18, 0x75, 0x61, 0x71, 0x1c, 0x3f, 0xdd, 0x67, 0xa3, 0x10, 0x15, 0xe9, 0xfb, 0x6f, 0x0b,
|
||
|
0xa3, 0x88, 0x17, 0x5e, 0x30, 0x27, 0x02, 0xf8, 0x29, 0x2c, 0xa7, 0xde, 0x82, 0x62, 0xde, 0x19,
|
||
|
0xc6, 0xfb, 0x20, 0x8b, 0xf7, 0x7c, 0x3c, 0x31, 0x7a, 0x73, 0x4e, 0xa6, 0x7e, 0x99, 0x83, 0x65,
|
||
|
0xb1, 0x02, 0x08, 0x8b, 0x1d, 0x26, 0x3f, 0x1d, 0x91, 0x90, 0x6e, 0x37, 0xd3, 0xec, 0x7d, 0x40,
|
||
|
0xc4, 0xec, 0xce, 0xa5, 0xf7, 0x7d, 0xcc, 0x6d, 0xd1, 0x53, 0x28, 0x0e, 0xf8, 0xf3, 0x0e, 0x8f,
|
||
|
0x50, 0x79, 0xfb, 0xde, 0x5b, 0x9e, 0x81, 0x70, 0x02, 0xa0, 0x09, 0xc3, 0x9f, 0x28, 0x4c, 0x3e,
|
||
|
0x7d, 0x6c, 0xfd, 0x5e, 0x92, 0x30, 0xf2, 0x54, 0xe3, 0x8a, 0x2d, 0xb5, 0xd4, 0xe7, 0xb0, 0xca,
|
||
|
0xb4, 0xe3, 0xb5, 0x1d, 0x2f, 0x09, 0x05, 0xa6, 0xc6, 0x2f, 0x24, 0xf4, 0x27, 0xba, 0x07, 0x65,
|
||
|
0x9f, 0x7a, 0x75, 0x47, 0xc3, 0x13, 0x12, 0xc4, 0x8f, 0x4f, 0x54, 0xd4, 0x62, 0x12, 0xf5, 0x57,
|
||
|
0x45, 0x58, 0x99, 0x08, 0x51, 0xe8, 0x7b, 0x6e, 0x48, 0xd0, 0xc7, 0xa0, 0x0c, 0x0c, 0x93, 0x48,
|
||
|
0x8f, 0x7a, 0x71, 0xd6, 0x7c, 0xf3, 0x6a, 0xd7, 0x19, 0xbc, 0x30, 0x48, 0xb5, 0x43, 0xf4, 0x63,
|
||
|
0x58, 0x8e, 0x6f, 0xe0, 0x29, 0x5a, 0x1e, 0xcd, 0x8d, 0x2c, 0xda, 0xc9, 0x92, 0x07, 0x2f, 0xc5,
|
||
|
0x2c, 0x32, 0x79, 0x17, 0x14, 0xc7, 0xb3, 0xbc, 0x14, 0xf1, 0xd4, 0x35, 0x89, 0x17, 0x28, 0x83,
|
||
|
0x4c, 0x7a, 0x04, 0x8b, 0x8e, 0x71, 0x42, 0x9c, 0x14, 0x6b, 0xe1, 0x9a, 0xac, 0x0a, 0xa3, 0x98,
|
||
|
0xe8, 0xeb, 0xc4, 0x83, 0x69, 0x58, 0x9d, 0xbe, 0x6e, 0x5f, 0x29, 0x83, 0x4c, 0xfa, 0x09, 0x2c,
|
||
|
0x0f, 0x46, 0x8e, 0xa3, 0x4f, 0x30, 0xb3, 0xcb, 0xfd, 0x25, 0x93, 0xd6, 0x4b, 0xd1, 0x60, 0x44,
|
||
|
0x39, 0xd2, 0x32, 0x74, 0x02, 0xab, 0xa1, 0x31, 0x20, 0x7a, 0xc8, 0xea, 0x1d, 0x99, 0x9b, 0xe7,
|
||
|
0xe9, 0xc3, 0x2c, 0xee, 0x8b, 0x8a, 0x24, 0xbc, 0x1c, 0x5e, 0x54, 0x3a, 0x59, 0x70, 0x8b, 0x27,
|
||
|
0xc8, 0xb8, 0xce, 0x92, 0x1d, 0x15, 0x2f, 0xdf, 0x68, 0x26, 0xce, 0x41, 0x7c, 0xd3, 0x4e, 0x0b,
|
||
|
0x24, 0x47, 0x3a, 0xac, 0x48, 0xfb, 0x98, 0xe4, 0xa2, 0xcc, 0x5c, 0x7c, 0xeb, 0xad, 0x7b, 0x99,
|
||
|
0xbc, 0x10, 0xcd, 0x0b, 0x0e, 0x9a, 0x06, 0xcc, 0xa5, 0xf6, 0x34, 0xf6, 0x06, 0x72, 0x49, 0xaa,
|
||
|
0xcb, 0x9b, 0x19, 0xae, 0xc8, 0xdb, 0x18, 0xad, 0x4f, 0x48, 0x10, 0x78, 0x01, 0x2b, 0xaf, 0xa4,
|
||
|
0xfa, 0x24, 0xf0, 0xcd, 0xcd, 0x2e, 0x7b, 0xdd, 0xc6, 0xdc, 0x00, 0x1d, 0x88, 0xc7, 0xcd, 0xd3,
|
||
|
0xa8, 0xba, 0xc2, 0x6c, 0x37, 0x2f, 0x0d, 0xd5, 0xb9, 0xbd, 0x03, 0xc7, 0x70, 0xf5, 0x8f, 0xd2,
|
||
|
0xa6, 0xb9, 0x67, 0x3b, 0xe3, 0x0d, 0x61, 0x0f, 0x2a, 0xb6, 0xeb, 0x8f, 0x22, 0xfe, 0xae, 0x66,
|
||
|
0xbd, 0xed, 0xbc, 0x69, 0x50, 0x5b, 0xf6, 0xca, 0x66, 0xe1, 0xb2, 0x3d, 0x6e, 0xa0, 0xe7, 0x50,
|
||
|
0x0a, 0x04, 0x67, 0x9c, 0xfa, 0xdf, 0xce, 0x22, 0xb9, 0x70, 0x6b, 0xc2, 0x63, 0xbc, 0x3a, 0x80,
|
||
|
0xb5, 0x1d, 0x23, 0x4a, 0x56, 0x12, 0x37, 0x0c, 0xe3, 0x7d, 0xfe, 0x00, 0x8a, 0x01, 0xff, 0x19,
|
||
|
0xef, 0x5d, 0x0f, 0xaf, 0xe8, 0x89, 0x81, 0x70, 0x82, 0x56, 0x3f, 0x83, 0x5b, 0x17, 0xfa, 0x11,
|
||
|
0xb1, 0x49, 0x8d, 0x29, 0xf7, 0x3f, 0x8e, 0xe9, 0x2f, 0x79, 0xa8, 0xd6, 0xc2, 0x33, 0xd7, 0x4c,
|
||
|
0x4f, 0x03, 0x1f, 0xd2, 0xd7, 0x35, 0x0b, 0xff, 0x27, 0xa7, 0x19, 0xa5, 0xf2, 0x46, 0x91, 0x34,
|
||
|
0xa0, 0xc2, 0xe5, 0x54, 0x6d, 0x66, 0x2c, 0x46, 0x54, 0xf1, 0xa4, 0x96, 0x3a, 0x80, 0x9b, 0x17,
|
||
|
0x84, 0x4d, 0xcc, 0xd0, 0x39, 0x3f, 0xb9, 0xaf, 0xec, 0xc7, 0x85, 0xbb, 0xcc, 0x4f, 0x6a, 0x41,
|
||
|
0x50, 0x67, 0xc9, 0xba, 0x6b, 0x9e, 0x5b, 0x77, 0x99, 0xf5, 0x77, 0xd6, 0x44, 0x4b, 0x6b, 0x2f,
|
||
|
0x80, 0x7b, 0x99, 0xfe, 0xc4, 0xe8, 0xda, 0xe7, 0xd7, 0xdf, 0xa3, 0x6b, 0x78, 0x3c, 0xbf, 0x06,
|
||
|
0x1d, 0x28, 0x4b, 0x4b, 0x87, 0xde, 0x99, 0x2d, 0x33, 0xd4, 0xc5, 0x57, 0x12, 0x1e, 0xba, 0xcc,
|
||
|
0x9b, 0xca, 0xbe, 0x19, 0x8a, 0x6f, 0x24, 0x25, 0x2b, 0xfe, 0x89, 0x6e, 0x41, 0x69, 0x68, 0x0f,
|
||
|
0x89, 0xce, 0x9e, 0x45, 0xc5, 0x37, 0x1a, 0x2a, 0xe8, 0x9d, 0xf9, 0x44, 0xfd, 0x39, 0x54, 0xe4,
|
||
|
0x78, 0xa3, 0x36, 0x2c, 0x50, 0x77, 0x7d, 0x12, 0x46, 0xb6, 0xcb, 0x77, 0xe7, 0xdc, 0xe5, 0xa7,
|
||
|
0xd8, 0xbe, 0x19, 0xee, 0x8e, 0xad, 0xf1, 0xbc, 0x95, 0x6a, 0xa3, 0x3b, 0x00, 0x27, 0x34, 0x7a,
|
||
|
0x7a, 0x68, 0x7f, 0x41, 0x44, 0x19, 0x54, 0x62, 0x92, 0xae, 0xfd, 0x05, 0x51, 0xef, 0x40, 0x29,
|
||
|
0xe9, 0xf4, 0xf9, 0x2a, 0x4a, 0x55, 0x61, 0x3e, 0xcd, 0x7f, 0x81, 0xcd, 0x1f, 0xf2, 0xb0, 0xd8,
|
||
|
0x8e, 0x3f, 0x57, 0x1e, 0x92, 0xc8, 0xe8, 0x1b, 0x91, 0x81, 0x34, 0x98, 0x0e, 0x69, 0x98, 0xc5,
|
||
|
0x83, 0x40, 0xe6, 0xa7, 0x96, 0x73, 0x48, 0xb6, 0xbd, 0x13, 0xcc, 0xd1, 0xe8, 0x29, 0x94, 0xcd,
|
||
|
0x80, 0x18, 0x11, 0xd1, 0x23, 0x7b, 0xc8, 0x9f, 0x60, 0xca, 0xdb, 0x6b, 0x31, 0x59, 0xfc, 0x31,
|
||
|
0x74, 0xb3, 0x17, 0x7f, 0x0c, 0xc5, 0xc0, 0xcd, 0xa9, 0x80, 0x82, 0x47, 0x7e, 0x3f, 0x01, 0xcf,
|
||
|
0xbc, 0x1d, 0xcc, 0xcd, 0xa9, 0x40, 0xfd, 0x18, 0xa6, 0x59, 0x4f, 0xd0, 0x0a, 0x2c, 0x76, 0x7b,
|
||
|
0xb5, 0xde, 0xe4, 0x77, 0xc8, 0x32, 0xcc, 0xd6, 0xb1, 0x56, 0xeb, 0x69, 0xbb, 0x4a, 0x8e, 0x36,
|
||
|
0xf0, 0x51, 0xab, 0xd5, 0x68, 0xed, 0x2b, 0x79, 0x54, 0x84, 0xc2, 0x6e, 0xbb, 0xa5, 0x29, 0x53,
|
||
|
0x68, 0x0e, 0x4a, 0xf5, 0x5a, 0xab, 0xae, 0x35, 0x9b, 0xda, 0xae, 0x52, 0x78, 0x40, 0x00, 0xa4,
|
||
|
0xb7, 0xf8, 0x32, 0xcc, 0x8a, 0x87, 0x69, 0xe5, 0x1d, 0xb4, 0x08, 0x73, 0x2f, 0x34, 0x7c, 0xac,
|
||
|
0x1f, 0xb5, 0x9a, 0x8d, 0xe7, 0x5a, 0xf3, 0x58, 0xc9, 0xa1, 0x0a, 0x14, 0x93, 0x56, 0x9e, 0xb6,
|
||
|
0x3a, 0xed, 0x6e, 0xb7, 0xb1, 0xd3, 0xa4, 0xc4, 0x00, 0x33, 0x42, 0x53, 0x40, 0x0b, 0x50, 0x66,
|
||
|
0x50, 0x21, 0x98, 0xde, 0xfe, 0x7b, 0x1e, 0xe6, 0xe5, 0xb3, 0xce, 0x0b, 0xd0, 0x6f, 0x73, 0xb0,
|
||
|
0x74, 0xc1, 0x2e, 0x8e, 0xb6, 0x33, 0xaf, 0xad, 0x99, 0x47, 0xcb, 0xda, 0x07, 0xd7, 0xc2, 0xf0,
|
||
|
0xb4, 0x52, 0xef, 0xfe, 0xe2, 0xcb, 0x7f, 0xfe, 0x3a, 0x5f, 0x55, 0x97, 0x92, 0xaf, 0xf7, 0xe1,
|
||
|
0x13, 0x51, 0x81, 0x90, 0x27, 0xb9, 0x07, 0xe8, 0x37, 0x39, 0xb8, 0x91, 0x91, 0xea, 0xe8, 0xf1,
|
||
|
0xa5, 0xf9, 0x9c, 0xb9, 0x17, 0xad, 0x25, 0x97, 0x1b, 0xe9, 0xc3, 0xfa, 0x78, 0xbd, 0xa9, 0xef,
|
||
|
0xb3, 0x2e, 0xdd, 0x57, 0x6f, 0xd3, 0x2e, 0x0d, 0x28, 0xf0, 0x89, 0x71, 0x8e, 0xf0, 0x49, 0xee,
|
||
|
0xc1, 0xce, 0xcf, 0x60, 0xcd, 0xf4, 0x86, 0x19, 0x9d, 0xd8, 0x59, 0x4a, 0x87, 0xba, 0x43, 0x57,
|
||
|
0x55, 0x27, 0xf7, 0xa3, 0x67, 0xc2, 0xdc, 0xf2, 0xe8, 0x65, 0x72, 0xd3, 0x0b, 0xac, 0x2d, 0x8b,
|
||
|
0xb8, 0x6c, 0xcd, 0x6d, 0x71, 0x95, 0xe1, 0xdb, 0xe1, 0xe4, 0xff, 0x07, 0x3c, 0xe5, 0xbf, 0xfe,
|
||
|
0x93, 0xcb, 0xfd, 0x2e, 0x5f, 0xd8, 0xaf, 0xbf, 0x68, 0x9d, 0xcc, 0x30, 0xc8, 0x07, 0xff, 0x0d,
|
||
|
0x00, 0x00, 0xff, 0xff, 0x7a, 0xea, 0x20, 0x54, 0x0a, 0x21, 0x00, 0x00,
|
||
|
}
|