As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Localização do item em uma página de documento
As operações do Amazon Textract retornam a localização e a geometria dos itens encontrados em uma página de documento.[DetectDocumentText](API_DetectDocumentText.md)e[GetDocumentTextDetection](API_GetDocumentTextDetection.md)retorna a localização e a geometria para linhas e palavras, enquanto[AnalyzeDocument](API_AnalyzeDocument.md)e[GetDocumentAnalysis](API_GetDocumentAnalysis.md)Retorna a localização e a geometria de pares de chave-valor, tabelas, células e elementos de seleção.
Para determinar onde um item está em uma página de documento, use a caixa delimitadora ([Geometry](API_Geometry.md)) informações retornadas pela operação do Amazon Textract em um[Block](API_Block.md)objeto. O`Geometry`O objeto contém dois tipos de localização e informações geométricas para os itens detectados:
+ Um eixo alinhado[BoundingBox](API_BoundingBox.md)O objeto que contém a coordenada superior esquerda e a largura e a altura do item.
+ Um objeto polígono que descreve o contorno do item, especificado como uma matriz de[Point](API_Point.md)objetos que contêm`X`(eixo horizontal) e`Y`(eixo vertical) coordenadas da página do documento de cada ponto.
O JSON para um`Block`O objeto será semelhante à seguinte. Observe o`BoundingBox`e`Polygon`campos.
```
{
"Geometry": {
"BoundingBox": {
"Width": 0.053907789289951324,
"Top": 0.08913730084896088,
"Left": 0.11085548996925354,
"Height": 0.013171200640499592
},
"Polygon": [
{
"Y": 0.08985357731580734,
"X": 0.11085548996925354
},
{
"Y": 0.08913730084896088,
"X": 0.16447919607162476
},
{
"Y": 0.10159222036600113,
"X": 0.16476328670978546
},
{
"Y": 0.10230850428342819,
"X": 0.11113958805799484
}
]
},
"Text": "Name:",
"TextType": "PRINTED",
"BlockType": "WORD",
"Confidence": 99.56285858154297,
"Id": "c734fca6-c4c4-415c-b6c1-30f7510b72ee"
},
```
Você pode usar informações de geometria para desenhar caixas delimitadoras em torno de itens detectados. Para um exemplo que usa`BoundingBox`e`Polygon`informações para desenhar caixas em torno de linhas e linhas verticais no início e no final de cada palavra, consulte[Detectando texto do documento com o Amazon Textract](detecting-document-text.md). A saída de exemplo é semelhante à seguinte.
## Bounding Box
Uma caixa delimitadora (`BoundingBox`) tem as seguintes propriedades:
+ Altura — Altura a altura da caixa delimitadora como uma proporção da altura total da página do documento.
+ Esquerda — A coordenada X do ponto superior esquerdo da caixa delimitadora como uma proporção da largura total da página do documento.
+ Superior — A coordenada Y do ponto superior esquerdo da caixa delimitadora como uma proporção da altura total da página do documento.
+ Largura — a largura da caixa delimitadora como uma proporção da largura total da página do documento.
Cada propriedade BoundingBox tem um valor entre 0 e 1. O valor é uma proporção da largura total da imagem (aplica-se a`Left`e`Width`) ou altura (aplica-se a`Height`e`Top`). Por exemplo, se a imagem de entrada tiver 700 x 200 pixels e a coordenada superior esquerda da caixa delimitadora tiver (350,50) pixels, a API retornará um`Left`valor de 0,5 (350/700) e um`Top`valor de 0,25 (50/200).
O diagrama a seguir mostra o intervalo de uma página de documento que cada propriedade BoundingBox abrange.
Para exibir a caixa delimitadora com o local e o tamanho corretos, você precisa multiplicar os valores da BoundingBox pela largura ou altura da página do documento (dependendo do valor que deseja) para obter os valores de pixels. Você pode usar os valores de pixel para exibir a caixa delimitadora. Um exemplo é usar uma página de documento de 608 pixels de largura x 588 pixels de altura e os seguintes valores de caixa delimitadora para texto analisado:
```
BoundingBox.Left: 0.3922065
BoundingBox.Top: 0.15567766
BoundingBox.Width: 0.284666
BoundingBox.Height: 0.2930403
```
A localização da caixa delimitadora de texto em pixels é calculada da seguinte forma:
`Left coordinate = BoundingBox.Left (0.3922065) * document page width (608) = 238`
`Top coordinate = BoundingBox.Top (0.15567766) * document page height (588) = 91`
`Bounding box width = BoundingBox.Width (0.284666) * document page width (608) = 173`
`Bounding box height = BoundingBox.Height (0.2930403) * document page height (588) = 172`
Você pode usar esses valores para exibir uma caixa delimitadora em torno do texto analisado. Os exemplos de Java e Python a seguir demonstram como exibir uma caixa delimitadora.
------
#### [ Java ]
```
public void ShowBoundingBox(int imageHeight, int imageWidth, BoundingBox box, Graphics2D g2d) {
float left = imageWidth * box.getLeft();
float top = imageHeight * box.getTop();
// Display bounding box.
g2d.setColor(new Color(0, 212, 0));
g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
Math.round((imageWidth * box.getWidth()) / scale), Math.round((imageHeight * box.getHeight())) / scale);
}
```
------
#### [ Python ]
Este exemplo em Python leva na`response`retornado pelo[DetectDocumentText](API_DetectDocumentText.md)Operação da API.
```
def process_text_detection(response):
# Get the text blocks
blocks = response['Blocks']
width, height = image.size
draw = ImageDraw.Draw(image)
print('Detected Document Text')
# Create image showing bounding box/polygon the detected lines/text
for block in blocks:
draw = ImageDraw.Draw(image)
if block['BlockType'] == "LINE":
box=block['Geometry']['BoundingBox']
left = width * box['Left']
top = height * box['Top']
draw.rectangle([left,top, left + (width * box['Width']), top +(height * box['Height'])],outline='black')
# Display the image
image.show()
return len(blocks)
```
------
## Polígono
O polígono retornado por`AnalyzeDocument`é uma matriz de[Point](API_Point.md)objects. EACH`Point`tem uma coordenada X e Y para um local específico na página do documento. Como as coordenadas BoundingBox, as coordenadas do polígono são normalizadas para a largura e a altura do documento, e estão entre 0 e 1.
Você pode usar pontos na matriz de polígonos para exibir uma caixa delimitadora de grãos mais finos em torno de um`Block`objeto. Você calcula a posição de cada ponto de polígono na página do documento usando a mesma técnica usada para`BoundingBoxes`. Multiplique a coordenada X pela largura da página do documento e multiplique a coordenada Y pela altura da página do documento.
O exemplo a seguir mostra como exibir as linhas verticais de um polígono.
```
public void ShowPolygonVerticals(int imageHeight, int imageWidth, List points, Graphics2D g2d) {
g2d.setColor(new Color(0, 212, 0));
Object[] parry = points.toArray();
g2d.setStroke(new BasicStroke(2));
g2d.drawLine(Math.round(((Point) parry[0]).getX() * imageWidth),
Math.round(((Point) parry[0]).getY() * imageHeight), Math.round(((Point) parry[3]).getX() * imageWidth),
Math.round(((Point) parry[3]).getY() * imageHeight));
g2d.setColor(new Color(255, 0, 0));
g2d.drawLine(Math.round(((Point) parry[1]).getX() * imageWidth),
Math.round(((Point) parry[1]).getY() * imageHeight), Math.round(((Point) parry[2]).getX() * imageWidth),
Math.round(((Point) parry[2]).getY() * imageHeight));
}
```