AnnotateImageResponse

Resposta a uma solicitação de anotação de imagem.

Representação JSON 
{
  "faceAnnotations": [
    {
      object(FaceAnnotation)
    }
  ],
  "landmarkAnnotations": [
    {
      object(EntityAnnotation)
    }
  ],
  "logoAnnotations": [
    {
      object(EntityAnnotation)
    }
  ],
  "labelAnnotations": [
    {
      object(EntityAnnotation)
    }
  ],
  "localizedObjectAnnotations": [
    {
      object(LocalizedObjectAnnotation)
    }
  ],
  "customLabelAnnotations": [
    {
      object(CustomEntityAnnotation)
    }
  ],
  "textAnnotations": [
    {
      object(EntityAnnotation)
    }
  ],
  "fullTextAnnotation": {
    object(TextAnnotation)
  },
  "safeSearchAnnotation": {
    object(SafeSearchAnnotation)
  },
  "imagePropertiesAnnotation": {
    object(ImageProperties)
  },
  "cropHintsAnnotation": {
    object(CropHintsAnnotation)
  },
  "webDetection": {
    object(WebDetection)
  },
  "productSearchResults": {
    object(ProductSearchResults)
  },
  "error": {
    object(Status)
  },
  "context": {
    object(ImageAnnotationContext)
  },
  "imageQualityAnnotation": {
    object(ImageQuality)
  },
  "objectAttributeAnnotations": [
    {
      object(EntityAnnotation)
    }
  ],
  "qualityOptimizationResult": {
    object(QualityOptimizationResult)
  },
  "localizedBarcodeAnnotations": [
    {
      object(LocalizedBarcodeAnnotation)
    }
  ]
}
Campos
faceAnnotations[]

object(FaceAnnotation)

Se presente, a detecção facial foi concluída com sucesso.

landmarkAnnotations[]

object(EntityAnnotation)

Se presente, a detecção de ponto de referência foi concluída com sucesso.

logoAnnotations[]

object(EntityAnnotation)

Se presente, a detecção de logotipo foi concluída com sucesso.

labelAnnotations[]

object(EntityAnnotation)

Se presente, a detecção de rótulos foi concluída com sucesso.

localizedObjectAnnotations[]

object(LocalizedObjectAnnotation)

Se presente, a detecção de objeto localizada foi concluída com sucesso. A classificação será decrescente por pontuação de confiança.

customLabelAnnotations[]

object(CustomEntityAnnotation)

Se presente, a anotação personalizada foi concluída.

textAnnotations[]

object(EntityAnnotation)

Se presente, a detecção de texto (OCR) foi concluída com sucesso.

fullTextAnnotation

object(TextAnnotation)

Se presente, a detecção de texto (OCR) ou de texto de documentos foi concluída com sucesso. Esta anotação fornece a hierarquia estrutural para o texto detectado pelo OCR.

safeSearchAnnotation

object(SafeSearchAnnotation)

Se presente, a anotação de pesquisa segura foi concluída com sucesso.

imagePropertiesAnnotation

object(ImageProperties)

Se presente, as propriedades da imagem foram extraídas com sucesso.

cropHintsAnnotation

object(CropHintsAnnotation)

Se presente, as dicas de corte foram concluídas com sucesso.

webDetection

object(WebDetection)

Quando presente, significa que a detecção da Web foi concluída.

productSearchResults

object(ProductSearchResults)

Quando presente, significa que a pesquisa de produtos foi concluída.

error

object(Status)

Quando definido, representa a mensagem de erro da operação. Observe que há uma garantia de que as anotações de imagens preenchidas são corretas, mesmo quando error está definido.

context

object(ImageAnnotationContext)

Se presente, as informações contextuais são necessárias para entender de onde vem essa imagem.

imageQualityAnnotation

object(ImageQuality)

Se presente, o cálculo da qualidade da imagem foi concluído.

objectAttributeAnnotations[]

object(EntityAnnotation)

Se presente, o cálculo dos atributos dos objetos foi concluído. O valor dos atributos será preenchido em EntityAnnotation.properties. Exemplo: objectAttributeAnnotations { properties { name: "color" value: "blue" confidence: 0.1 } properties { name: "color" value: "white" confidence: 0.2 } properties { name: "material" value: "silk" confidence: 0.3 } }

qualityOptimizationResult

object(QualityOptimizationResult)

Se presente, a otimização da qualidade da imagem foi concluída.

localizedBarcodeAnnotations[]

object(LocalizedBarcodeAnnotation)

Se presente, a detecção de código de barras localizado foi concluída com sucesso.

FaceAnnotation

Um objeto de anotação de rosto contém os resultados da detecção facial.

Representação JSON 
{
  "boundingPoly": {
    object(BoundingPoly)
  },
  "fdBoundingPoly": {
    object(BoundingPoly)
  },
  "landmarks": [
    {
      object(Landmark)
    }
  ],
  "rollAngle": number,
  "panAngle": number,
  "tiltAngle": number,
  "detectionConfidence": number,
  "landmarkingConfidence": number,
  "joyLikelihood": enum(Likelihood),
  "sorrowLikelihood": enum(Likelihood),
  "angerLikelihood": enum(Likelihood),
  "surpriseLikelihood": enum(Likelihood),
  "underExposedLikelihood": enum(Likelihood),
  "blurredLikelihood": enum(Likelihood),
  "headwearLikelihood": enum(Likelihood)
}
Campos
boundingPoly

object(BoundingPoly)

O polígono delimitador ao redor do rosto. As coordenadas da caixa delimitadora estão na escala da imagem original. A caixa delimitadora é processada para "enquadrar" o rosto de acordo com as expectativas humanas. Ela usa como base os resultados do detector de ponto de referência. Uma ou mais coordenadas X ou Y talvez não sejam geradas no BoundingPoly (o polígono será ilimitado) se apenas parte do rosto aparecer na imagem que será anotada.

fdBoundingPoly

object(BoundingPoly)

O polígono delimitador fdBoundingPoly é mais restrito que o boundingPoly e inclui apenas a parte da pele do rosto. Normalmente, ele é usado para eliminar o rosto de qualquer análise da imagem que detecta a "quantidade de pele" visível. Ele não se baseia nos resultados do detector de ponto de referência, apenas na detecção inicial de rosto. Por isso, há o prefixo

fd

(detecção de rosto).
landmarks[]

object(Landmark)

Pontos de referência detectados do rosto.

rollAngle

number

Ângulo de giro, que indica a quantidade de rotação no sentido horário/anti-horário do rosto em relação à imagem vertical do eixo perpendicular ao rosto. Intervalo [-180,180].

panAngle

number

Ângulo de desvio, que indica o ângulo de desvio para a esquerda/direita que o rosto aponta em relação ao plano vertical perpendicular à imagem. Intervalo [-180,180].

tiltAngle

number

Ângulo de inclinação, que indica o ângulo de inclinação para cima/baixo que o rosto aponta em relação ao plano horizontal da imagem. Intervalo [-180,180].

detectionConfidence

number

Confiança da detecção. Intervalo [0, 1].

landmarkingConfidence

number

Confiança da detecção de ponto de referência do rosto. Intervalo [0, 1].

joyLikelihood

enum(Likelihood)

Probabilidade de alegria.

sorrowLikelihood

enum(Likelihood)

Probabilidade de tristeza.

angerLikelihood

enum(Likelihood)

Probabilidade de raiva.

surpriseLikelihood

enum(Likelihood)

Probabilidade de surpresa.

underExposedLikelihood

enum(Likelihood)

Probabilidade de subexposição.

blurredLikelihood

enum(Likelihood)

Probabilidade de desfoque.

headwearLikelihood

enum(Likelihood)

Probabilidade de acessório na cabeça.

Ponto de referência

Um ponto de referência específico do rosto. Por exemplo, uma característica.

Representação JSON 
{
  "type": enum(Type),
  "position": {
    object(Position)
  }
}
Campos
type

enum(Type)

Tipo de ponto de referência do rosto.

position

object(Position)

Posição do ponto de referência do rosto.

Tipo

Tipo de ponto de referência do rosto (característica). Os lados esquerdo e direito são definidos do ponto de vista de quem vê a imagem, sem considerar as projeções de espelhamento típicas das fotos. Normalmente, LEFT_EYE é o olho direito da pessoa.

Tipos enumerados
UNKNOWN_LANDMARK Ponto de referência desconhecido do rosto detectado. Não preencha.
LEFT_EYE Olho esquerdo.
RIGHT_EYE Olho direito.
LEFT_OF_LEFT_EYEBROW Esquerda da sobrancelha esquerda.
RIGHT_OF_LEFT_EYEBROW Direita da sobrancelha esquerda.
LEFT_OF_RIGHT_EYEBROW Esquerda da sobrancelha direita.
RIGHT_OF_RIGHT_EYEBROW Direita da sobrancelha direita.
MIDPOINT_BETWEEN_EYES Ponto intermediário entre os olhos.
NOSE_TIP Ponta do nariz.
UPPER_LIP Lábio superior.
LOWER_LIP Lábio inferior.
MOUTH_LEFT Lado esquerdo da boca.
MOUTH_RIGHT Lado direito da boca.
MOUTH_CENTER Centro da boca.
NOSE_BOTTOM_RIGHT Nariz, parte inferior direita.
NOSE_BOTTOM_LEFT Nariz, parte inferior esquerda.
NOSE_BOTTOM_CENTER Nariz, centro inferior.
LEFT_EYE_TOP_BOUNDARY Olho esquerdo, limite superior.
LEFT_EYE_RIGHT_CORNER Olho esquerdo, canto direito.
LEFT_EYE_BOTTOM_BOUNDARY Olho esquerdo, limite inferior.
LEFT_EYE_LEFT_CORNER Olho esquerdo, canto esquerdo.
RIGHT_EYE_TOP_BOUNDARY Olho direito, limite superior.
RIGHT_EYE_RIGHT_CORNER Olho direito, canto direito.
RIGHT_EYE_BOTTOM_BOUNDARY Olho direito, limite inferior.
RIGHT_EYE_LEFT_CORNER Olho direito, canto esquerdo.
LEFT_EYEBROW_UPPER_MIDPOINT Sobrancelha esquerda, ponto intermediário superior.
RIGHT_EYEBROW_UPPER_MIDPOINT Sobrancelha direita, ponto intermediário superior.
LEFT_EAR_TRAGION Trágus da orelha esquerda.
RIGHT_EAR_TRAGION Trágus da orelha direita.
LEFT_EYE_PUPIL Pupila do olho esquerdo.
RIGHT_EYE_PUPIL Pupila do olho direito.
FOREHEAD_GLABELLA Glabela da testa.
CHIN_GNATHION Gnátio do queixo.
CHIN_LEFT_GONION Gônio esquerdo do queixo.
CHIN_RIGHT_GONION Gônio direito do queixo.

Posição

Uma posição 3D na imagem, usada principalmente para pontos de referência de detecção facial. Uma posição válida precisa ter as coordenadas X e Y. As coordenadas da posição estão na mesma escala que a imagem original.

Representação JSON 
{
  "x": number,
  "y": number,
  "z": number
}
Campos
x

number

Coordenada X.

y

number

Coordenada Y.

z

number

Coordenada Z (ou profundidade).

Probabilidade

Uma representação de probabilidade em intervalos com o objetivo de gerar resultados altamente estáveis aos clientes em todos os upgrades de modelo.

Tipos enumerados
UNKNOWN Probabilidade desconhecida.
VERY_UNLIKELY É muito improvável que a imagem pertença à vertical especificada.
UNLIKELY É improvável que a imagem pertença à vertical especificada.
POSSIBLE É possível que a imagem pertença à vertical especificada.
LIKELY É provável que a imagem pertença à vertical especificada.
VERY_LIKELY É muito provável que a imagem pertença à vertical especificada.

EntityAnnotation

Conjunto de recursos detectados da entidade.

Representação JSON 
{
  "mid": string,
  "locale": string,
  "description": string,
  "score": number,
  "confidence": number,
  "topicality": number,
  "boundingPoly": {
    object(BoundingPoly)
  },
  "locations": [
    {
      object(LocationInfo)
    }
  ],
  "properties": [
    {
      object(Property)
    }
  ]
}
Campos
mid

string

Código da entidade opaca. Alguns códigos podem estar disponíveis na Google Knowledge Graph Search API.

locale

string

O código do idioma da localidade em que a description textual da entidade é expressa.

description

string

Descrição textual da entidade, expressa no respectivo idioma de locale.

score

number

Pontuação geral do resultado. Intervalo [0, 1].

confidence
(deprecated)

number

Descontinuado. Use score. A precisão da detecção de entidade em uma imagem. Por exemplo, para uma imagem em que a entidade "Torre Eiffel" é detectada, esse campo representa a confiança de que há uma torre na imagem da consulta. Intervalo [0, 1].
topicality

number

A relevância do marcador de anotação de conteúdo da imagem (ICA, na sigla em inglês) em relação à imagem. Por exemplo, a relevância de "torre" provavelmente é maior em uma imagem que contém a "Torre Eiffel" detectada do que em uma imagem com um prédio alto distante detectado, mesmo que a confiança de que há uma torre em cada imagem possa ser a mesma. Intervalo [0, 1].

boundingPoly

object(BoundingPoly)

Região da imagem a que esta entidade pertence. Não produzido para os recursos LABEL_DETECTION.

locations[]

object(LocationInfo)

As informações de local da entidade detectada. Vários elementos de LocationInfo podem estar presentes porque um local pode indicar a localização da cena na imagem, e outro pode indicar a localização do lugar em que a imagem foi gerada. Em geral, há informações de local disponíveis para pontos de referência.

properties[]

object(Property)

Algumas entidades podem ter campos opcionais de Property (nome/valor) fornecidos pelo usuário, como pontuação ou string que qualifica a entidade.

LocationInfo

Informações de local da entidade detectada.

Representação JSON 
{
  "latLng": {
    object(LatLng)
  }
}
Campos
latLng

object(LatLng)

Coordenadas de local "lat/long".

Propriedade

Uma Property consiste em um par de nome/valor fornecido pelo usuário.

Representação JSON 
{
  "name": string,
  "value": string,
  "uint64Value": string,
  "confidence": number,
  "mid": string
}
Campos
name

string

Nome da propriedade.

value

string

Valor da propriedade.

uint64Value

string

Valor das propriedades numéricas.

confidence

number

Valor no intervalo [0..1]. Confiança desse valor de propriedade.

mid

string

ID do valor da propriedade opaca. Alguns IDs podem estar disponíveis na API Google Knowledge Graph Search. Um exemplo de propriedade para um casaco azul seria: Property { name: 'color' value: 'blue' mid: '/m/01g5v' // For color blue }

LocalizedObjectAnnotation

Conjunto de objetos detectados com caixas delimitadoras.

Representação JSON 
{
  "mid": string,
  "languageCode": string,
  "name": string,
  "score": number,
  "boundingPoly": {
    object(BoundingPoly)
  }
}
Campos
mid

string

ID do objeto que deve se alinhar a EntityAnnotation no meio.

languageCode

string

O código de idioma BCP-47, como pt-BR ou en-US. Para mais informações, consulte http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.

name

string

Nome do objeto, expresso no idioma languageCode.

score

number

Pontuação do resultado. Intervalo [0, 1].

boundingPoly

object(BoundingPoly)

Região da imagem a que o objeto pertence. Esse campo precisa ser preenchido.

CustomEntityAnnotation

Um CustomEntityAnnotation contém anotações previstas usando modelos personalizados do Vision.

Representação JSON 
{
  "model": string,
  "label": string,
  "score": number
}
Campos
model

string

Identifica o modelo personalizado usado para criar essa anotação. O formato do nome do modelo é o URL do recurso do modo personalizado que foi consultado: /projects/PROJECT_ID/models/MODEL_ID, ou /models/MODEL_ID se o modelo pertencer ao projeto atual.

label

string

O rótulo previsto pelo modelo personalizado.

score

number

A pontuação de confiança do rótulo pelo modelo personalizado.

TextAnnotation

TextAnnotation contém uma representação estruturada do texto extraído pelo OCR. A hierarquia de uma estrutura de texto extraído pelo OCR tem esta aparência: TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol. Cada componente estrutural, começando por Page, ainda pode ter propriedades próprias. As propriedades descrevem os idiomas detectados, as quebras etc. Consulte a definição da mensagem TextAnnotation.TextProperty abaixo para mais detalhes.

Representação JSON 
{
  "pages": [
    {
      object(Page)
    }
  ],
  "text": string
}
Campos
pages[]

object(Page)

Lista de páginas detectadas pelo OCR.

text

string

Texto UTF-8 detectado nas páginas.

Página

Página detectada do OCR.

Representação JSON 
{
  "property": {
    object(TextProperty)
  },
  "width": number,
  "height": number,
  "blocks": [
    {
      object(Block)
    }
  ],
  "confidence": number,
  "mergedText": string
}
Campos
property

object(TextProperty)

Informações adicionais detectadas na página.

width

number

Largura da página. Nos PDFs, a unidade é a pontuação. Para imagens (incluindo TIFFs), a unidade é pixels.

height

number

Altura da página. Nos PDFs, a unidade é a pontuação. Para imagens (incluindo TIFFs), a unidade é pixels.

blocks[]

object(Block)

Lista de blocos de texto, imagens, entre outros, nesta página.

confidence

number

Confiança dos resultados do OCR na página. Intervalo [0, 1].

mergedText

string

Todo o texto UTF-8 detectado nesta página. Por padrão, esse campo não é retornado, a menos que especificado em TextDetectionParams.page_filter.

TextProperty

Informações adicionais detectadas sobre o componente estrutural.

Representação JSON 
{
  "detectedLanguages": [
    {
      object(DetectedLanguage)
    }
  ],
  "detectedBreak": {
    object(DetectedBreak)
  }
}
Campos
detectedLanguages[]

object(DetectedLanguage)

Uma lista de idiomas detectados juntamente com a confiança.

detectedBreak

object(DetectedBreak)

Início ou fim detectado de um segmento de texto.

DetectedLanguage

Idioma detectado para um componente estrutural.

Representação JSON 
{
  "languageCode": string,
  "confidence": number
}
Campos
languageCode

string

O código de idioma BCP-47, como pt-BR ou en-US. Para mais informações, consulte http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.

confidence

number

Confiança do idioma detectado. Intervalo [0, 1].

DetectedBreak

Início ou fim da detecção de um componente estrutural.

Representação JSON 
{
  "type": enum(BreakType),
  "isPrefix": boolean
}
Campos
type

enum(BreakType)

Tipo de quebra detectado.

isPrefix

boolean

Verdadeiro se a quebra preceder o elemento.

BreakType

Enum para denotar o tipo de quebra encontrado. Nova linha, espaço etc.

Tipos enumerados
UNKNOWN Tipo de marcador de quebra desconhecido.
SPACE Espaço regular.
SURE_SPACE Espaço garantido (muito largo).
EOL_SURE_SPACE Quebra de linha.
HYPHEN Hífen de fim de linha que não está presente no texto. Não ocorre juntamente com SPACE, LEADER_SPACE ou LINE_BREAK.
LINE_BREAK Quebra de linha que termina um parágrafo.

Bloco

Elemento lógico na página.

Representação JSON 
{
  "property": {
    object(TextProperty)
  },
  "boundingBox": {
    object(BoundingPoly)
  },
  "paragraphs": [
    {
      object(Paragraph)
    }
  ],
  "blockType": enum(BlockType),
  "confidence": number,
  "table": {
    object(Table)
  },
  "keyValuePair": {
    object(KeyValuePair)
  },
  "mergedText": string
}
Campos
property

object(TextProperty)

Informações adicionais detectadas para o bloco.

boundingBox

object(BoundingPoly)

A caixa delimitadora do bloco. Os vértices estão na seguinte ordem: superior esquerda, superior direita, inferior direita e inferior esquerda. Quando for detectada uma rotação da caixa delimitadora, ela será representada no canto superior esquerdo, como definido pela leitura do texto na orientação natural. Exemplo:

  • Quando o texto é horizontal, pode ser semelhante ao seguinte:
    0----1
    |    |
    3----2
  • Quando girado 180 graus em torno do canto superior esquerdo, ele se torna:
    2----3
    |    |
    1----0

e a ordem dos vértices ainda será (0, 1, 2, 3).
paragraphs[]

object(Paragraph)

Lista de parágrafos neste bloco, se ele for do tipo "texto".

blockType

enum(BlockType)

Tipo de bloco detectado (texto, imagem etc.) para este bloco.

confidence

number

Confiança dos resultados do OCR no bloco. Intervalo [0, 1].

table

object(Table)

Tabela detectada para TABLE blocktype. Por padrão, esse campo não é retornado, a menos que seja ativado por TextDetectionParams.table_detection_options. O boundingBox desse bloco será os limites detectados para essa tabela.

keyValuePair

object(KeyValuePair)

Par detectado para KEY_VALUE_PAIR blocktype. Este campo é retornado por padrão, a menos que DocumentType seja especificado.

mergedText

string

Todo o texto UTF-8 foi detectado neste bloco. Por padrão, esse campo não é retornado, a menos que especificado em TextDetectionParams.block_filter.

Parágrafo

Unidade estrutural de texto que representa uma série de palavras em determinada ordem.

Representação JSON 
{
  "property": {
    object(TextProperty)
  },
  "boundingBox": {
    object(BoundingPoly)
  },
  "words": [
    {
      object(Word)
    }
  ],
  "confidence": number,
  "mergedText": string
}
Campos
property

object(TextProperty)

Informações adicionais detectadas para o parágrafo.

boundingBox

object(BoundingPoly)

A caixa delimitadora do parágrafo. Os vértices estão na seguinte ordem: superior esquerda, superior direita, inferior direita e inferior esquerda. Quando for detectada uma rotação da caixa delimitadora, ela será representada no canto superior esquerdo, como definido pela leitura do texto na orientação natural. Por exemplo: * quando o texto é horizontal, é semelhante ao seguinte: 0----1 | | 3----2 * quando é girado em 180 graus em torno do canto superior esquerdo, torna-se: 2----3 | | 1----0, e a ordem dos vértices ainda é (0, 1, 2, 3).

words[]

object(Word)

Lista de palavras neste parágrafo.

confidence

number

Confiança dos resultados do OCR para o parágrafo. Intervalo [0, 1].

mergedText

string

Todo o texto UTF-8 detectado neste parágrafo. Por padrão, esse campo não é retornado, a menos que especificado em TextDetectionParams.paragraph_filter.

Word

Uma representação de palavra.

Representação JSON 
{
  "property": {
    object(TextProperty)
  },
  "boundingBox": {
    object(BoundingPoly)
  },
  "symbols": [
    {
      object(Symbol)
    }
  ],
  "confidence": number,
  "mergedText": string
}
Campos
property

object(TextProperty)

Informações adicionais detectadas para a palavra.

boundingBox

object(BoundingPoly)

A caixa delimitadora da palavra. Os vértices estão na seguinte ordem: superior esquerda, superior direita, inferior direita e inferior esquerda. Quando for detectada uma rotação da caixa delimitadora, ela será representada no canto superior esquerdo, como definido pela leitura do texto na orientação natural. Por exemplo: * quando o texto é horizontal, é semelhante ao seguinte: 0----1 | | 3----2 * quando é girado em 180 graus em torno do canto superior esquerdo, torna-se: 2----3 | | 1----0, e a ordem dos vértices ainda é (0, 1, 2, 3).

symbols[]

object(Symbol)

Lista de símbolos na palavra. A ordem dos símbolos segue a ordem de leitura natural.

confidence

number

Confiança dos resultados do OCR para a palavra. Intervalo [0, 1].

mergedText

string

Todo o texto UTF-8 detectado nesta palavra. Por padrão, esse campo não é retornado, a menos que especificado em TextDetectionParams.word_filter.

Symbol

Uma única representação de símbolo.

Representação JSON 
{
  "property": {
    object(TextProperty)
  },
  "boundingBox": {
    object(BoundingPoly)
  },
  "text": string,
  "confidence": number
}
Campos
property

object(TextProperty)

Informações adicionais detectadas para o símbolo.

boundingBox

object(BoundingPoly)

A caixa delimitadora do símbolo. Os vértices estão na seguinte ordem: superior esquerda, superior direita, inferior direita e inferior esquerda. Quando for detectada uma rotação da caixa delimitadora, ela será representada no canto superior esquerdo, como definido pela leitura do texto na orientação natural. Por exemplo: * quando o texto é horizontal, é semelhante ao seguinte: 0----1 | | 3----2 * quando é girado 180 graus em torno do canto superior esquerdo, torna-se: 2----3 | | 1----0, e a ordem dos vértices ainda é (0, 1, 2, 3).

text

string

A representação UTF-8 real do símbolo.

confidence

number

Confiança dos resultados do OCR para o símbolo. Intervalo [0, 1].

BlockType

Tipo de um bloco (texto, imagem etc.), conforme identificado pelo OCR.

Tipos enumerados
UNKNOWN Tipo de bloco desconhecido
TEXT Bloco de texto regular
TABLE Bloco de tabelas
PICTURE Bloco de imagens
RULER Caixa de linha horizontal/vertical
BARCODE Bloco de códigos de barras
KEY_VALUE_PAIR Um bloco de pares de chave-valor.

Tabela

Uma representação de tabela semelhante à estrutura da tabela HTML.

Representação JSON 
{
  "headerRows": [
    {
      object(TableRow)
    }
  ],
  "bodyRows": [
    {
      object(TableRow)
    }
  ]
}
Campos
headerRows[]

object(TableRow)

Linhas de cabeçalho da tabela

bodyRows[]

object(TableRow)

Linhas do corpo da tabela

TableRow

Uma linha de células da tabela.

Representação JSON 
{
  "cells": [
    {
      object(TableCell)
    }
  ]
}
Campos
cells[]

object(TableCell)

Células que compõem esta linha.

TableCell

Uma representação das células dentro de tabelas.

Representação JSON 
{
  "rowSpan": number,
  "colSpan": number,
  "textBlock": {
    object(Block)
  },
  "text": string
}
Campos
rowSpan

number

Quantas linhas a célula abrange.

colSpan

number

Quantas colunas esta célula abrange.

textBlock

object(Block)

Bloco de texto para a célula que também contém a caixa delimitadora normalizada para a célula e estruturas mais profundas dentro de uma célula, se presente.

text

string

O valor de texto mesclado dessa célula, omitindo informações estruturais mais profundas, diferentemente de textBlock. Isso é útil para células simples.

KeyValuePair

Proto para um par de chave-valor.

Representação JSON 
{
  "key": string,
  "keyBlock": {
    object(Block)
  },
  "valueBlock": {
    object(Block)
  },
  "valueType": string,
  "normalizedKey": string
}
Campos
key

string

O valor da string da chave.

keyBlock

object(Block)

Bloco de chaves do par que contém a caixa delimitadora normalizada e o texto da chave.

valueBlock

object(Block)

Bloco de valores do par que contém a caixa delimitadora normalizada e o texto do valor, incluindo estruturas potencialmente mais profundas no texto do valor.

valueType

string

Tipo do valor. As strings válidas são as seguintes:

"generic": para texto genérico mapeado para um valor. "number": para tipos numéricos "id": para identificadores genéricos. "currency": para valores de moeda. "date": para datas. "time": para valores de tempo e duração. "date_range": para períodos. "address": para valores de endereço (pode ser longo). "person": para nomes de pessoas ou outros identificadores pessoais. "phone": para números de telefone.
normalizedKey

string

(Opcional) O texto da chave normalizada se o texto for comum e classificado.

Por exemplo, "TOTAL DUE" será normalizado para "Valor total".

SafeSearchAnnotation

Conjunto de recursos pertencentes à imagem, calculados por métodos de visão computacional em verticais da pesquisa segura. Por exemplo, conteúdo adulto, paródia, assunto médico, violência.

Representação JSON 
{
  "adult": enum(Likelihood),
  "spoof": enum(Likelihood),
  "medical": enum(Likelihood),
  "violence": enum(Likelihood),
  "racy": enum(Likelihood)
}
Campos
adult

enum(Likelihood)

Representa a probabilidade de conteúdo adulto na imagem. O conteúdo adulto pode conter elementos como nudez, imagens ou desenhos animados pornográficos ou atividades sexuais.

spoof

enum(Likelihood)

Probabilidade de paródia. A probabilidade de uma modificação ter sido feita na versão canônica da imagem para que pareça engraçada ou ofensiva.

medical

enum(Likelihood)

Probabilidade de ser uma imagem médica.

violence

enum(Likelihood)

Probabilidade de ser uma imagem com conteúdo violento.

racy

enum(Likelihood)

Probabilidade de conteúdo indecente na imagem da solicitação. Conteúdos indecentes podem incluir, por exemplo: roupas curtas ou transparentes, nudez estrategicamente coberta, poses obscenas ou provocativas ou closes de partes inapropriadas do corpo.

ImageProperties

Armazena as propriedades da imagem, como as cores dominantes.

Representação JSON 
{
  "dominantColors": {
    object(DominantColorsAnnotation)
  }
}
Campos
dominantColors

object(DominantColorsAnnotation)

Quando presente, as cores dominantes foram concluídas.

DominantColorsAnnotation

Conjunto de cores dominantes e as pontuações correspondentes.

Representação JSON 
{
  "colors": [
    {
      object(ColorInfo)
    }
  ]
}
Campos
colors[]

object(ColorInfo)

Valores de cor RGB com a respectiva pontuação e fração de pixel.

ColorInfo

As informações de cores consistem em canais RGB, pontuação e a fração da imagem ocupada pela cor.

Representação JSON 
{
  "color": {
    object(Color)
  },
  "score": number,
  "pixelFraction": number
}
Campos
color

object(Color)

Componentes RGB da cor.

score

number

Pontuação específica da imagem referente a esta cor. Valor no intervalo [0, 1].

pixelFraction

number

A fração de pixels que a cor ocupa na imagem. Valor no intervalo [0, 1].

Cor

Representa uma cor no espaço de cores RGBA. Essa representação foi projetada para dar preferência à simplicidade, e não à concisão, no momento da conversão entre representações de cores de várias linguagens. Por exemplo, os campos dessa representação podem ser fornecidos com facilidade ao construtor de java.awt.Color em Java. Eles também podem ser fornecidos com facilidade ao método +colorWithRed:green:blue:alpha de UIColor no iOS. Além disso, seguindo algumas etapas, eles também podem ser formatados de maneira simples em uma string rgba() de CSS no JavaScript.

Observação: o proto não inclui informações sobre o espaço de cores absoluto que precisa ser usado para interpretar o valor RGB. Por exemplo, sRGB, Adobe RGB, DCI-P3, BT.2020 etc. Por padrão, os aplicativos usam o espaço de cores sRGB.

Exemplo (Java):

 import com.google.type.Color;

 // ...
 public static java.awt.Color fromProto(Color protocolor) {
   float alpha = protocolor.hasAlpha()
       ? protocolor.getAlpha().getValue()
       : 1.0;

   return new java.awt.Color(
       protocolor.getRed(),
       protocolor.getGreen(),
       protocolor.getBlue(),
       alpha);
 }

 public static Color toProto(java.awt.Color color) {
   float red = (float) color.getRed();
   float green = (float) color.getGreen();
   float blue = (float) color.getBlue();
   float denominator = 255.0;
   Color.Builder resultBuilder =
       Color
           .newBuilder()
           .setRed(red / denominator)
           .setGreen(green / denominator)
           .setBlue(blue / denominator);
   int alpha = color.getAlpha();
   if (alpha != 255) {
     result.setAlpha(
         FloatValue
             .newBuilder()
             .setValue(((float) alpha) / denominator)
             .build());
   }
   return resultBuilder.build();
 }
 // ...

Exemplo (iOS/Obj-C):

 // ...
 static UIColor* fromProto(Color* protocolor) {
    float red = [protocolor red];
    float green = [protocolor green];
    float blue = [protocolor blue];
    FloatValue* alpha_wrapper = [protocolor alpha];
    float alpha = 1.0;
    if (alpha_wrapper != nil) {
      alpha = [alpha_wrapper value];
    }
    return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
 }

 static Color* toProto(UIColor* color) {
     CGFloat red, green, blue, alpha;
     if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
       return nil;
     }
     Color* result = [[Color alloc] init];
     [result setRed:red];
     [result setGreen:green];
     [result setBlue:blue];
     if (alpha <= 0.9999) {
       [result setAlpha:floatWrapperWithValue(alpha)];
     }
     [result autorelease];
     return result;
}
// ...

Exemplo (JavaScript):

// ...

var protoToCssColor = function(rgb_color) {
   var redFrac = rgb_color.red || 0.0;
   var greenFrac = rgb_color.green || 0.0;
   var blueFrac = rgb_color.blue || 0.0;
   var red = Math.floor(redFrac * 255);
   var green = Math.floor(greenFrac * 255);
   var blue = Math.floor(blueFrac * 255);

   if (!('alpha' in rgb_color)) {
      return rgbToCssColor_(red, green, blue);
   }

   var alphaFrac = rgb_color.alpha.value || 0.0;
   var rgbParams = [red, green, blue].join(',');
   return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
};

var rgbToCssColor_ = function(red, green, blue) {
  var rgbNumber = new Number((red << 16) | (green << 8) | blue);
  var hexString = rgbNumber.toString(16);
  var missingZeros = 6 - hexString.length;
  var resultBuilder = ['#'];
  for (var i = 0; i < missingZeros; i++) {
     resultBuilder.push('0');
  }
  resultBuilder.push(hexString);
  return resultBuilder.join('');
};

// ...
Representação JSON 
{
  "red": number,
  "green": number,
  "blue": number,
  "alpha": number
}
Campos
red

number

A quantidade de vermelho na cor como um valor no intervalo [0, 1].

green

number

A quantidade de verde na cor como um valor no intervalo [0, 1].

blue

number

A quantidade de azul na cor como um valor no intervalo [0, 1].

alpha

number

A fração desta cor que deve ser aplicada ao pixel. Ou seja, a cor final do pixel é definida pela equação:

cor do pixel = alfa * (esta cor) + (1,0 - alfa) * (cor de fundo)

Isto significa que um valor de 1,0 corresponde a uma cor sólida, enquanto um valor de 0,0 corresponde a uma cor completamente transparente. Esse recurso usa uma mensagem de wrapper, em vez de um escalar flutuante simples, para que seja possível distinguir entre um valor padrão e o valor que está sendo desativado. Se o valor for omitido, este objeto de cor precisará ser renderizado como uma cor sólida, como se fosse informado explicitamente o valor de alfa de 1,0.

CropHintsAnnotation

Conjunto de dicas de corte usadas para gerar novos cortes ao fornecer as imagens.

Representação JSON 
{
  "cropHints": [
    {
      object(CropHint)
    }
  ]
}
Campos
cropHints[]

object(CropHint)

Resultados da dica de corte.

CropHint

Dica de corte único usada para gerar um corte ao fornecer uma imagem.

Representação JSON 
{
  "boundingPoly": {
    object(BoundingPoly)
  },
  "confidence": number,
  "importanceFraction": number
}
Campos
boundingPoly

object(BoundingPoly)

O polígono delimitador da região do corte. As coordenadas da caixa delimitadora estão na escala da imagem original.

confidence

number

A confiança de que se trata de uma região saliente. Intervalo [0, 1].

importanceFraction

number

Fração de importância da região saliente em relação à imagem original.

WebDetection

Informações relevantes sobre a imagem retiradas da Internet.

Representação JSON 
{
  "webEntities": [
    {
      object(WebEntity)
    }
  ],
  "fullMatchingImages": [
    {
      object(WebImage)
    }
  ],
  "partialMatchingImages": [
    {
      object(WebImage)
    }
  ],
  "pagesWithMatchingImages": [
    {
      object(WebPage)
    }
  ],
  "visuallySimilarImages": [
    {
      object(WebImage)
    }
  ],
  "bestGuessLabels": [
    {
      object(WebLabel)
    }
  ]
}
Campos
webEntities[]

object(WebEntity)

Entidades deduzidas de imagens semelhantes na Internet.

fullMatchingImages[]

object(WebImage)

Imagens da Internet totalmente correspondentes. Pode incluir cópias redimensionadas da imagem de consulta.

partialMatchingImages[]

object(WebImage)

Imagens da Internet parcialmente correspondentes. Elas são semelhantes o suficiente para compartilhar algumas características importantes. Por exemplo, uma imagem original provavelmente apresenta correspondência parcial em relação aos cortes.

pagesWithMatchingImages[]

object(WebPage)

Páginas da Web que contêm as imagens correspondentes da Internet.

visuallySimilarImages[]

object(WebImage)

Os resultados visualmente semelhantes da imagem.

bestGuessLabels[]

object(WebLabel)

O melhor palpite do serviço quanto ao tópico da imagem da solicitação. Inferido com base em imagens semelhantes na Web aberta.

WebEntity

Entidade deduzida de imagens semelhantes na Internet.

Representação JSON 
{
  "entityId": string,
  "score": number,
  "description": string
}
Campos
entityId

string

ID da entidade opaca.

score

number

Pontuação geral de relevância da entidade. Não normalizada e não comparável em diferentes consultas de imagem.

description

string

Descrição canônica da entidade, em inglês.

WebImage

Metadados das imagens on-line.

Representação JSON 
{
  "url": string,
  "score": number
}
Campos
url

string

O URL da imagem do resultado.

score

number

Pontuação geral de relevância da imagem (descontinuada).

WebPage

Metadados para páginas da Web.

Representação JSON 
{
  "url": string,
  "score": number,
  "pageTitle": string,
  "fullMatchingImages": [
    {
      object(WebImage)
    }
  ],
  "partialMatchingImages": [
    {
      object(WebImage)
    }
  ]
}
Campos
url

string

O URL da página da Web de resultados.

score

number

Pontuação geral de relevância para a página da Web (obsoleta).

pageTitle

string

Título da página da Web, pode conter marcações HTML.

fullMatchingImages[]

object(WebImage)

Imagens totalmente correspondentes na página. Pode incluir cópias redimensionadas da imagem de consulta.

partialMatchingImages[]

object(WebImage)

Imagens parcialmente correspondentes na página. Elas são semelhantes o suficiente para compartilhar algumas características importantes. Por exemplo, uma imagem original provavelmente apresenta correspondência parcial em relação aos cortes.

WebLabel

Rótulo para fornecer metadados adicionais para detecção da Web.

Representação JSON 
{
  "label": string,
  "languageCode": string
}
Campos
label

string

Rótulo para metadados adicionais.

languageCode

string

O código de idioma BCP-47 para label, como en-US ou pt-BR. Para mais informações, consulte http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.

ProductSearchResults

Resultados para uma solicitação de pesquisa de produtos.

Representação JSON 
{
  "indexTime": string,
  "results": [
    {
      object(Result)
    }
  ],
  "productGroupedResults": [
    {
      object(GroupedResult)
    }
  ]
}
Campos
indexTime

string (Timestamp format)

O carimbo de data/hora do índice que forneceu esses resultados. As alterações feitas após esse período não serão refletidas nos resultados atuais.

Um carimbo de data/hora no formato UTC “Zulu” RFC3339, medido com precisão de nanossegundos. Exemplo: "2014-10-02T15:01:23.045123456Z".
results[]

object(Result)

Lista de resultados, um para cada correspondência de produto.

productGroupedResults[]

object(GroupedResult)

Lista de resultados agrupados por produtos detectados na imagem da consulta. Cada entrada corresponde a um polígono delimitador na imagem da consulta e contém os produtos correspondentes específicos dessa região. Pode haver correspondências duplicadas de produtos na união de todos os resultados por produto.

Resultado

Informações sobre um produto.

Representação JSON 
{
  "product": {
    object(Product)
  },
  "score": number,
  "image": string
}
Campos
product

object(Product)

O produto.

score

number

Nível de confiança na correspondência, variando de 0 (nenhuma confiança) a 1 (confiança total).

image

string

O nome do recurso da imagem do produto que é a correspondência mais próxima da consulta.

GroupedResult

Informações sobre os produtos semelhantes a um único produto em uma imagem de consulta.

Representação JSON 
{
  "boundingPoly": {
    object(BoundingPoly)
  },
  "results": [
    {
      object(Result)
    }
  ],
  "objectAnnotations": [
    {
      object(ObjectAnnotation)
    }
  ]
}
Campos
boundingPoly

object(BoundingPoly)

O polígono delimitador ao redor do produto detectado na imagem da consulta.

results[]

object(Result)

Lista de resultados, um para cada correspondência de produto.

objectAnnotations[]

object(ObjectAnnotation)

Lista de previsões genéricas sobre o objeto na caixa delimitadora.

ObjectAnnotation

Previsão sobre o que é o objeto na caixa delimitadora.

Representação JSON 
{
  "mid": string,
  "languageCode": string,
  "name": string,
  "score": number
}
Campos
mid

string

ID do objeto que deve se alinhar a EntityAnnotation no meio.

languageCode

string

O código de idioma BCP-47, como pt-BR ou en-US. Para mais informações, consulte http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.

name

string

Nome do objeto, expresso no idioma languageCode.

score

number

Pontuação do resultado. Intervalo [0, 1].

ImageAnnotationContext

Se uma imagem foi produzida com base em um arquivo, como um PDF, essa mensagem fornece informações sobre a origem da imagem.

Representação JSON 
{
  "uri": string,
  "pageNumber": number
}
Campos
uri

string

O URI do arquivo usado para produzir a imagem.

pageNumber

number

Se o arquivo for um PDF ou TIFF, esse campo fornecerá o número da página no arquivo usado para produzir a imagem.

ImageQuality

Armazena índices de qualidade da imagem, que podem ser de qualidade estética ou técnica.

Representação JSON 
{
  "qualityScore": number
}
Campos
qualityScore

number

É uma pontuação que representa a qualidade estética/técnica da imagem. A pontuação está no intervalo [0, 1]. O valor mais alto corresponde a fotos com aparência mais profissional. Zero significa que a imagem está muito ruim, 1 significa que a imagem tem uma qualidade muito alta.

QualityOptimizationResult

Armazena bytes de imagem aprimorados.

Representação JSON 
{
  "qualityOptimizationType": enum(Type),
  "image": string,
  "mimeType": string
}
Campos
qualityOptimizationType

enum(Type)

Tipo de otimização obrigatório.

image

string (bytes format)

Bytes de imagem otimizados.

Uma string codificada em base64.
mimeType

string

Tipo MIME do imagem de saída.

LocalizedBarcodeAnnotation

Conjunto de códigos de barras detectados com caixas delimitadoras.

Representação JSON 
{
  "format": string,
  "valueFormat": string,
  "value": string,
  "confidence": number,
  "boundingPoly": {
    object(BoundingPoly)
  }
}
Campos
format

string

O formato Barcode descreve o formato de um código de barras. Os formatos compatíveis são: CODE_128: tipo de código 128. CODE_39: tipo de código 39. CODE_93: tipo de código 93. CODABAR: tipo Codabar. DATA_MATRIX: tipo de matriz de dados 2D. ITF: tipo ITF. EAN_13: tipo EAN-13. EAN_8: tipo EAN-8. QR_CODE: é um tipo de código QR 2D. UPC_A: tipo UPC-A. UPC_E: tipo UPC-E. PDF417: tipo PDF417. AZTEC: tipo de código Aztec 2D. DATABAR: tipo de código GS1 DataBar.

valueFormat

string

O formato de valor do código de barras descreve o formato do valor que o código de barras codifica. Os formatos de valor compatíveis são: CONTACT_INFO: dados de contato. EMAIL: endereço de e-mail. ISBN: identificador ISBN. PHONE: número de telefone. PRODUCT: produto. SMS: mensagem SMS. TEXT: string de texto. URL: endereço do URL. Wi-Fi: informações de Wi-Fi. Geolocalização: localização geográfica (long. e lat.). CALENDAR_EVENT: evento da agenda. DRIVER_LICENSE: carteira de habilitação.

value

string

Barcode é o valor de código de barras que é o valor ASCII capturado no código de barras. Barcode pode codificar valores estruturados, por exemplo, 'MEBKM:TITLE:Google;URL:https://www.google.com;;.

confidence

number

O nível de confiança do resultado. Intervalo [0, 1].

boundingPoly

object(BoundingPoly)

Região da imagem à qual este código de barras pertence. Esse campo precisa ser preenchido.