이미지에서 텍스트 감지

입력 이미지를 이미지 바이트 배열(base64 인코딩 이미지 바이트) 또는 Amazon S3 객체로 제공할 수 있습니다. 이 절차에서는 S3 버킷에 JPEG 또는 PNG 이미지를 업로드하고 파일 이름을 지정합니다.

이미지(API)에서 텍스트를 감지하려면

아직 수행하지 않은 경우 다음 사전 조건을 완료하세요.
1. AmazonRekognitionFullAccess 권한과 AmazonS3ReadOnlyAccess 권한을 가진 사용자를 생성하거나 업데이트합니다. 자세한 내용은 1단계: AWS 계정 설정 및 사용자 생성 섹션을 참조하세요.
2. AWS Command Line Interface와 AWS SDK를 설치하고 구성합니다. 자세한 내용은 2단계: AWS CLI 및 AWS SDK 설정 섹션을 참조하세요.
텍스트를 포함하는 이미지를 S3 버킷에 업로드합니다.

Amazon Simple Storage Service 사용자 가이드에서 Amazon S3로 객체 업로드를 참조하세요.

다음 예제를 사용하여 DetectText 작업을 호출합니다.

Java

다음 예제 코드는 이미지에서 감지된 줄과 단어를 표시합니다.

bucket 및 photo의 값을 2단계에서 사용한 S3 버킷과 이미지의 이름으로 바꿉니다.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

package aws.example.rekognition.image;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.DetectTextRequest;
import com.amazonaws.services.rekognition.model.DetectTextResult;
import com.amazonaws.services.rekognition.model.TextDetection;
import java.util.List;



public class DetectText {

   public static void main(String[] args) throws Exception {
      
  
      String photo = "inputtext.jpg";
      String bucket = "bucket";

      AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();

     
      
      DetectTextRequest request = new DetectTextRequest()
              .withImage(new Image()
              .withS3Object(new S3Object()
              .withName(photo)
              .withBucket(bucket)));
    

      try {
         DetectTextResult result = rekognitionClient.detectText(request);
         List<TextDetection> textDetections = result.getTextDetections();

         System.out.println("Detected lines and words for " + photo);
         for (TextDetection text: textDetections) {
      
                 System.out.println("Detected: " + text.getDetectedText());
                 System.out.println("Confidence: " + text.getConfidence().toString());
                 System.out.println("Id : " + text.getId());
                 System.out.println("Parent Id: " + text.getParentId());
                 System.out.println("Type: " + text.getType());
                 System.out.println();
         }
      } catch(AmazonRekognitionException e) {
         e.printStackTrace();
      }
   }
}

Java V2

이 코드는 AWS 설명서 SDK 예제 GitHub 리포지토리에서 가져왔습니다. 전체 예제는 여기에서 확인하세요.


/**
*  To run this code example, ensure that you perform the Prerequisites as stated in the Amazon Rekognition Guide:
*  https://docs.aws.amazon.com/rekognition/latest/dg/video-analyzing-with-sqs.html
*
* Also, ensure that set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/

//snippet-start:[rekognition.java2.detect_text.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DetectTextRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.DetectTextResponse;
import software.amazon.awssdk.services.rekognition.model.TextDetection;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
//snippet-end:[rekognition.java2.detect_text.import]

/**
* Before running this Java V2 code example, set up your development environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DetectTextImage {

 public static void main(String[] args) {

     final String usage = "\n" +
         "Usage: " +
         "   <sourceImage>\n\n" +
         "Where:\n" +
         "   sourceImage - The path to the image that contains text (for example, C:\\AWS\\pic1.png). \n\n";

   if (args.length != 1) {
         System.out.println(usage);
         System.exit(1);
     }

     String sourceImage = args[0] ;
     Region region = Region.US_WEST_2;
     RekognitionClient rekClient = RekognitionClient.builder()
         .region(region)
         .credentialsProvider(ProfileCredentialsProvider.create("default"))
         .build();

     detectTextLabels(rekClient, sourceImage );
     rekClient.close();
 }

 // snippet-start:[rekognition.java2.detect_text.main]
 public static void detectTextLabels(RekognitionClient rekClient, String sourceImage) {

     try {
         InputStream sourceStream = new FileInputStream(sourceImage);
         SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
         Image souImage = Image.builder()
             .bytes(sourceBytes)
             .build();

         DetectTextRequest textRequest = DetectTextRequest.builder()
             .image(souImage)
             .build();

         DetectTextResponse textResponse = rekClient.detectText(textRequest);
         List<TextDetection> textCollection = textResponse.textDetections();
         System.out.println("Detected lines and words");
         for (TextDetection text: textCollection) {
             System.out.println("Detected: " + text.detectedText());
             System.out.println("Confidence: " + text.confidence().toString());
             System.out.println("Id : " + text.id());
             System.out.println("Parent Id: " + text.parentId());
             System.out.println("Type: " + text.type());
             System.out.println();
         }

     } catch (RekognitionException | FileNotFoundException e) {
         System.out.println(e.getMessage());
         System.exit(1);
     }
 }
 // snippet-end:[rekognition.java2.detect_text.main]

AWS CLI

이 AWS CLI 명령은 detect-text CLI 작업에 대한 JSON 출력을 표시합니다.

Bucket 및 Name의 값을 2단계에서 사용한 S3 버킷과 이미지의 이름으로 바꿉니다.

profile_name의 값을 개발자 프로필 이름으로 대체하세요.


aws rekognition detect-text  --image "{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}" --profile default

Windows 디바이스에서 CLI에 액세스하는 경우 작은따옴표 대신 큰따옴표를 사용하고 내부 큰따옴표는 백슬래시(즉 \)로 이스케이프 처리하여 발생할 수 있는 구문 분석 오류를 해결합니다. 예를 들어 다음을 참조하세요.


aws rekognition detect-text  --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" --profile default

Python

다음 예제 코드는 이미지에서 감지된 줄과 단어를 표시합니다.

bucket 및 photo의 값을 2단계에서 사용한 S3 버킷과 이미지의 이름으로 바꿉니다. Rekognition 세션을 생성하는 라인에서 profile_name의 값을 개발자 프로필의 이름으로 대체합니다.


# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

import boto3

def detect_text(photo, bucket):

    session = boto3.Session(profile_name='default')
    client = session.client('rekognition')

    response = client.detect_text(Image={'S3Object': {'Bucket': bucket, 'Name': photo}})

    textDetections = response['TextDetections']
    print('Detected text\n----------')
    for text in textDetections:
        print('Detected text:' + text['DetectedText'])
        print('Confidence: ' + "{:.2f}".format(text['Confidence']) + "%")
        print('Id: {}'.format(text['Id']))
        if 'ParentId' in text:
            print('Parent Id: {}'.format(text['ParentId']))
        print('Type:' + text['Type'])
        print()
    return len(textDetections)

def main():
    bucket = 'bucket-name'
    photo = 'photo-name'
    text_count = detect_text(photo, bucket)
    print("Text detected: " + str(text_count))

if __name__ == "__main__":
    main()

.NET

다음 예제 코드는 이미지에서 감지된 줄과 단어를 표시합니다.

bucket 및 photo의 값을 2단계에서 사용한 S3 버킷과 이미지의 이름으로 바꿉니다.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;

public class DetectText
{
    public static void Example()
    {
        String photo = "input.jpg";
        String bucket = "bucket";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        DetectTextRequest detectTextRequest = new DetectTextRequest()
        {
            Image = new Image()
            {
                S3Object = new S3Object()
                {
                    Name = photo,
                    Bucket = bucket
                }
            }
        };

        try
        {
            DetectTextResponse detectTextResponse = rekognitionClient.DetectText(detectTextRequest);
            Console.WriteLine("Detected lines and words for " + photo);
            foreach (TextDetection text in detectTextResponse.TextDetections)
            {
                Console.WriteLine("Detected: " + text.DetectedText);
                Console.WriteLine("Confidence: " + text.Confidence);
                Console.WriteLine("Id : " + text.Id);
                Console.WriteLine("Parent Id: " + text.ParentId);
                Console.WriteLine("Type: " + text.Type);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Node.JS

다음 예제 코드는 이미지에서 감지된 줄과 단어를 표시합니다.

bucket 및 photo의 값을 2단계에서 사용한 S3 버킷과 이미지의 이름으로 바꿉니다. region의 값을 .aws 보안 인증 정보에서 확인할 수 있는 리전으로 바꾸세요. Rekognition 세션을 생성하는 라인에서 profile_name의 값을 개발자 프로필의 이름으로 대체합니다.


var AWS = require('aws-sdk');

const bucket = 'bucket' // the bucketname without s3://
const photo  = 'photo' // the name of file

const config = new AWS.Config({
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
}) 
AWS.config.update({region:'region'});
const client = new AWS.Rekognition();
const params = {
  Image: {
    S3Object: {
      Bucket: bucket,
      Name: photo
    },
  },
}
client.detectText(params, function(err, response) {
  if (err) {
    console.log(err, err.stack); // handle error if an error occurred
  } else {
    console.log(`Detected Text for: ${photo}`)
    console.log(response)
    response.TextDetections.forEach(label => {
      console.log(`Detected Text: ${label.DetectedText}`),
      console.log(`Type: ${label.Type}`),
      console.log(`ID: ${label.Id}`),
      console.log(`Parent ID: ${label.ParentId}`),
      console.log(`Confidence: ${label.Confidence}`),
      console.log(`Polygon: `)
      console.log(label.Geometry.Polygon)
    } 
    )
  } 
});

DetectText 작업 요청

DetectText 작업에서 사용자는 입력 이미지를 base64로 인코딩된 바이트 배열 또는 Amazon S3 버킷에 저장된 이미지로 제공합니다. 다음 예제 JSON 요청은 Amazon S3 버킷에서 불러온 이미지를 표시합니다.


{
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "inputtext.jpg"
        }
    }
}

Filters

텍스트 영역, 크기 및 신뢰도 점수로 필터링하면 텍스트 감지 출력을 제어할 수 있는 추가적인 유연성이 제공됩니다. 관심 영역을 사용하면 텍스트 감지를 사용자와 관련된 영역으로 쉽게 제한할 수 있습니다. 프로필 사진의 오른쪽 상단이나 기계 이미지에서 부품 번호를 읽을 때 참조점을 기준으로 고정된 위치를 예로 들 수 있습니다. 단어 경계 상자 크기 필터는 정보 전달을 방해하거나 관련이 없는 작은 배경 텍스트를 피하는 데 사용할 수 있습니다. 단어 신뢰도 필터를 사용하면 흐릿하거나 번져서 신뢰할 수 없는 결과를 제거할 수 있습니다.

필터 값에 대한 자세한 내용은 DetectTextFilters 섹션을 참조하세요.

다음 필터를 사용할 수 있습니다.

MinConfidence - 단어 감지의 신뢰도를 설정합니다. 이 수준보다 감지 신뢰도가 낮은 단어는 결과에서 제외됩니다. 값은 0과 100 사이여야 합니다.
MinBoundingBoxWidth - 단어 경계 상자의 최소 너비를 설정합니다. 경계 상자 너비가 이 값보다 작은 단어는 결과에서 제외됩니다. 이 값은 이미지 프레임 너비를 기준으로 합니다.
MinBoundingBoxHeight - 단어 경계 상자의 최소 높이를 설정합니다. 경계 상자 높이가 이 값보다 작은 단어는 결과에서 제외됩니다. 이 값은 이미지 프레임 높이를 기준으로 합니다.
RegionsOfInterest - 이미지 프레임의 특정 영역으로 감지를 제한합니다. 값은 프레임의 치수를 기준으로 합니다. 영역 내에 일부만 있는 텍스트의 경우 응답이 정의되지 않습니다.

DetectText 작업 응답

DetectText 작업은 이미지를 분석하고 TextDetections 배열을 반환합니다. 이때 각 요소(TextDetection)는 이미지에서 감지된 줄이나 단어를 나타냅니다. 각 요소마다 DetectText는 다음 정보를 반환합니다.

감지된 텍스트(DetectedText)
단어와 줄의 관계(Id 및 ParentId)
이미지에서 텍스트의 위치(Geometry)
Amazon Rekognition가 감지한 텍스트와 경계 상자의 신뢰도(Confidence)
감지된 텍스트(Type)의 유형

감지된 텍스트

각 TextDetection 요소는 DetectedText 필드에서 인식된 텍스트(단어 또는 줄)를 포함합니다. 단어는 공백으로 구분되지 않은 하나 이상의 문자입니다. DetectText는 이미지에서 최대 100개의 단어를 감지할 수 있습니다. 반환된 텍스트에는 단어를 인식할 수 없도록 만드는 문자가 포함될 수 있습니다. 예를 들어 Cat 대신 C@t이 반환될 수 있습니다. TextDetection 요소가 텍스트 또는 단어로 구성된 줄을 나타내는지 확인하려면 Type 필드를 사용합니다.

각 TextDetection 요소에는 감지된 텍스트와 텍스트를 둘러싼 경계 상자의 정확도에 대한 Amazon Rekognition의 신뢰도를 나타내는 백분율 값이 포함됩니다.

단어와 줄의 관계

각 TextDetection 요소에는 식별자 필드 Id가 있습니다. Id는 줄에서 단어의 위치를 나타냅니다. 요소가 단어인 경우, 상위 식별자 ParentId는 단어가 감지되는 줄을 확인해 줍니다. 줄의 ParentId는 null입니다. 예를 들어 예제 이미지의 "but keep"이라는 줄에는 Id 및 ParentId 값이 있습니다.

Text	ID	상위 ID
but keep	3
but	8	3
Keep	9	3

이미지에서 텍스트의 위치

이미지에서 인식된 텍스트의 위치를 확인하려면 DetectText가 반환하는 경계 상자(Geometry) 정보를 사용합니다. Geometry 객체에는 감지된 선과 단어에 대한 두 가지 유형의 경계 상자 정보가 있습니다.

BoundingBox 객체의 축으로 정렬된 거친 직사각형 윤곽
Point 배열에서 여러 개의 X와 Y 좌표로 구성된, 세분화된 다각형

테두리 상자와 다각형 좌표는 원본 이미지의 텍스트 위치를 나타냅니다. 좌표 값은 전체 이미지 크기의 비율입니다. 자세한 내용을 알아보려면 BoundingBox를 참조하세요.

DetectText 작업의 다음 JSON 응답은 다음 이미지에서 감지된 단어와 줄을 표시합니다.


{
 'TextDetections': [{'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 0,
                     'Type': 'LINE'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442459374666214,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.3525116443634033,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.353712260723114},
                                              {'X': 0.9522717595100403,
                                               'Y': 0.3525116443634033},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355844974518},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693623065948486}]},
                     'Id': 1,
                     'Type': 'LINE'},
                    {'Confidence': 99.6160888671875,
                     'DetectedText': 'but keep',
                     'Geometry': {'BoundingBox': {'Height': 0.08314694464206696,
                                                  'Left': 0.6398131847381592,
                                                  'Top': 0.5267938375473022,
                                                  'Width': 0.2021435648202896},
                                  'Polygon': [{'X': 0.640289306640625,
                                               'Y': 0.5267938375473022},
                                              {'X': 0.8419567942619324,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806723594666,
                                               'Y': 0.609940767288208},
                                              {'X': 0.6398131847381592,
                                               'Y': 0.6072247624397278}]},
                     'Id': 2,
                     'Type': 'LINE'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 3,
                     'Type': 'LINE'},
                    {'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 4,
                     'ParentId': 0,
                     'Type': 'WORD'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442466825246811,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.35251158475875854,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.3537122905254364},
                                              {'X': 0.9522718787193298,
                                               'Y': 0.35251158475875854},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355546951294},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693626046180725}]},
                     'Id': 5,
                     'ParentId': 1,
                     'Type': 'WORD'},
                    {'Confidence': 99.96778869628906,
                     'DetectedText': 'but',
                     'Geometry': {'BoundingBox': {'Height': 0.0625,
                                                  'Left': 0.6402802467346191,
                                                  'Top': 0.5283203125,
                                                  'Width': 0.08027780801057816},
                                  'Polygon': [{'X': 0.6402802467346191,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5908203125},
                                              {'X': 0.6402802467346191,
                                               'Y': 0.5908203125}]},
                     'Id': 6,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 99.26438903808594,
                     'DetectedText': 'keep',
                     'Geometry': {'BoundingBox': {'Height': 0.0818721204996109,
                                                  'Left': 0.7344760298728943,
                                                  'Top': 0.5280686020851135,
                                                  'Width': 0.10748066753149033},
                                  'Polygon': [{'X': 0.7349520921707153,
                                               'Y': 0.5280686020851135},
                                              {'X': 0.8419566750526428,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806127548218,
                                               'Y': 0.6099407076835632},
                                              {'X': 0.7344760298728943,
                                               'Y': 0.6084995269775391}]},
                     'Id': 7,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 8,
                     'ParentId': 3,
                     'Type': 'WORD'}],
 'TextModelVersion': '3.0'}

javascript가 브라우저에서 비활성화되거나 사용이 불가합니다.

AWS 설명서를 사용하려면 Javascript가 활성화되어야 합니다. 지침을 보려면 브라우저의 도움말 페이지를 참조하십시오.

문서 규칙

텍스트 감지

저장된 비디오에서 텍스트 감지