Tutoriel sur la reconnaissance optique des caractères (OCR)

Découvrez comment effectuer la reconnaissance optique des caractères (OCR) sur Google Cloud Platform. Ce tutoriel explique comment importer des fichiers images sur Google Cloud Storage, extraire le texte des images à l'aide de l'API Google Cloud Vision, traduire le texte avec l'API Google Cloud Translation et enregistrer vos traductions dans Cloud Storage. Google Cloud Pub/Sub est utilisé pour mettre différentes tâches en attente et déclencher les fonctions cloud nécessaires à leur exécution.

Objectifs

  • Rédiger et déployer plusieurs fonctions cloud d'arrière-plan
  • Importer des images dans Cloud Storage
  • Extraire, traduire et enregistrer le texte contenu dans les images importées

Coûts

Ce tutoriel fait appel à des composants facturables de Cloud Platform, en particulier :

  • Google Cloud Functions
  • Google Cloud Pub/Sub
  • Google Cloud Storage
  • API Google Cloud Translation
  • API Google Cloud Vision

Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Les nouveaux utilisateurs de Cloud Platform peuvent bénéficier d'un essai gratuit.

Avant de commencer

    https://cloud.google.com/functions/docs/tutorials/ocr beta cloudfunctions,pubsub,storage_api,translate,vision.googleapis.com Cloud Functions, Cloud Pub/Sub, Cloud Storage, Cloud Translation, and Cloud Vision no_credentials
  1. Connectez-vous à votre compte Google.

    Si vous n'en avez pas encore, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Mettez à jour les composants gcloud :
    gcloud components update
  5. Préparez votre environnement de développement.

Visualiser le flux de données

Le flux de données dans l'application du tutoriel OCR comprend plusieurs étapes :

  1. Une image contenant du texte dans n'importe quelle langue est importée dans Cloud Storage.
  2. Une fonction cloud utilisant l'API Vision pour extraire le texte et détecter la langue source est déclenchée.
  3. Le texte est mis en file d'attente pour traduction en publiant un message dans un sujet Pub/Sub. Une traduction est mise en file d'attente pour chaque langue cible différente de la langue source.
  4. Si une langue cible correspond à la langue source, la file d'attente de traduction est ignorée et le texte est envoyé à la file d'attente des résultats, autre sujet Pub/Sub.
  5. Une fonction cloud utilise l'API Translation pour traduire le texte dans la file d'attente de traduction. Le résultat traduit est envoyé à la file d'attente des résultats.
  6. Une autre fonction cloud enregistre le texte traduit depuis la file d'attente des résultats dans Cloud Storage.
  7. Les résultats apparaissent dans Cloud Storage sous la forme de fichiers txt pour chaque traduction.

Observez le schéma ci-dessous pour visualiser les étapes :

Préparer l'application

  1. Créez un bucket Cloud Storage pour importer vos images, avec un attribut de nom YOUR_IMAGE_BUCKET_NAME encore jamais utilisé :

        gsutil mb gs://YOUR_IMAGE_BUCKET_NAME
        
  2. Créez un bucket Cloud Storage pour enregistrer les traductions, avec un attribut de nom YOUR_TEXT_BUCKET_NAME encore jamais utilisé :

        gsutil mb gs://YOUR_TEXT_BUCKET_NAME
        
  3. Clonez le dépôt de l'exemple d'application sur votre machine locale :

    Node.js

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Python

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Go

    git clone https://github.com/GoogleCloudPlatform/golang-samples.git

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

  4. Accédez au répertoire contenant l'exemple de code de Cloud Functions :

    Node.js

    cd nodejs-docs-samples/functions/ocr/app/

    Python

    cd python-docs-samples/functions/ocr/app/

    Go

    cd golang-samples/functions/ocr/app/

  5. Configurez l'application :

    Node.js

    À l'aide du fichier config.default.json comme modèle, créez un fichier config.json dans le répertoire app avec le contenu suivant :
    {
        "RESULT_TOPIC": "YOUR_RESULT_TOPIC_NAME",
        "RESULT_BUCKET": "YOUR_TEXT_BUCKET_NAME",
        "TRANSLATE_TOPIC": "YOUR_TRANSLATE_TOPIC_NAME",
        "TRANSLATE": true,
        "TO_LANG": ["en", "fr", "es", "ja", "ru"]
        }
    • Remplacez YOUR_RESULT_TOPIC_NAME par un nom de sujet Pub/Sub à utiliser pour enregistrer les résultats une fois la traduction terminée.
    • Remplacez YOUR_TEXT_BUCKET_NAME par un nom de bucket à utiliser pour enregistrer les résultats de traduction.
    • Remplacez YOUR_TRANSLATE_TOPIC_NAME par un nom de sujet Pub/Sub à utiliser pour traduire le texte extrait lors de l'étape de l'OCR.

    Python

    Modifiez le fichier config.json dans le répertoire app pour obtenir le contenu suivant :
    {
        "RESULT_TOPIC": "YOUR_RESULT_TOPIC_NAME",
        "RESULT_BUCKET": "YOUR_TEXT_BUCKET_NAME",
        "TRANSLATE_TOPIC": "YOUR_TRANSLATE_TOPIC_NAME",
        "TRANSLATE": true,
        "TO_LANG": ["en", "fr", "es", "ja", "ru"]
        }
    • Remplacez YOUR_RESULT_TOPIC_NAME par un nom de sujet Pub/Sub à utiliser pour enregistrer les résultats une fois l'étape de traduction terminée.
    • Remplacez YOUR_TEXT_BUCKET_NAME par un nom de bucket à utiliser pour enregistrer les résultats de traduction.
    • Remplacez YOUR_TRANSLATE_TOPIC_NAME par un nom de sujet Pub/Sub pour déclencher la traduction du texte extrait.

    Go

    Modifiez le fichier config.json dans le répertoire app pour obtenir le contenu suivant :
    {
        "RESULT_TOPIC": "YOUR_RESULT_TOPIC_NAME",
        "RESULT_BUCKET": "YOUR_TEXT_BUCKET_NAME",
        "TRANSLATE_TOPIC": "YOUR_TRANSLATE_TOPIC_NAME",
        "TO_LANG": ["en", "fr", "es", "ja", "ru"]
        }
    • Remplacez YOUR_RESULT_TOPIC_NAME par un nom de sujet Pub/Sub à utiliser pour enregistrer les résultats une fois la traduction terminée.
    • Remplacez YOUR_TEXT_BUCKET_NAME par un nom de bucket à utiliser pour enregistrer les résultats.
    • Remplacez YOUR_TRANSLATE_TOPIC_NAME par un nom de sujet Pub/Sub à utiliser pour la traduire les résultats.

Comprendre le code

Importer des dépendances

L'application doit importer plusieurs dépendances afin de pouvoir communiquer avec les services Google Cloud Platform :

Node.js

const config = require('./config.json');

    // Get a reference to the Pub/Sub component
    const {PubSub} = require('@google-cloud/pubsub');
    const pubsub = new PubSub();
    // Get a reference to the Cloud Storage component
    const {Storage} = require('@google-cloud/storage');
    const storage = new Storage();

    // Get a reference to the Cloud Vision API component
    const Vision = require('@google-cloud/vision');
    const vision = new Vision.ImageAnnotatorClient();

    // Get a reference to the Translate API component
    const {Translate} = require('@google-cloud/translate');
    const translate = new Translate();

    const Buffer = require('safe-buffer').Buffer;

Python

import base64
    import json
    import os

    from google.cloud import pubsub_v1
    from google.cloud import storage
    from google.cloud import translate
    from google.cloud import vision

    vision_client = vision.ImageAnnotatorClient()
    translate_client = translate.Client()
    publisher = pubsub_v1.PublisherClient()
    storage_client = storage.Client()

    project_id = os.environ['GCP_PROJECT']

    with open('config.json') as f:
        data = f.read()
    config = json.loads(data)

Go


    // Package ocr contains Go samples for creating OCR
    // (Optical Character Recognition) Cloud functions.
    package ocr

    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"os"
    	"time"

    	"cloud.google.com/go/pubsub"
    	"cloud.google.com/go/storage"
    	"cloud.google.com/go/translate"
    	vision "cloud.google.com/go/vision/apiv1"
    	"golang.org/x/text/language"
    )

    type configuration struct {
    	ProjectID      string   `json:"PROJECT_ID"`
    	ResultTopic    string   `json:"RESULT_TOPIC"`
    	ResultBucket   string   `json:"RESULT_BUCKET"`
    	TranslateTopic string   `json:"TRANSLATE_TOPIC"`
    	ToLang         []string `json:"TO_LANG"`
    }

    type ocrMessage struct {
    	Text     string       `json:"text"`
    	FileName string       `json:"fileName"`
    	Lang     language.Tag `json:"lang"`
    	SrcLang  language.Tag `json:"srcLang"`
    }

    // GCSEvent is the payload of a GCS event.
    type GCSEvent struct {
    	Bucket         string    `json:"bucket"`
    	Name           string    `json:"name"`
    	Metageneration string    `json:"metageneration"`
    	ResourceState  string    `json:"resourceState"`
    	TimeCreated    time.Time `json:"timeCreated"`
    	Updated        time.Time `json:"updated"`
    }

    // PubSubMessage is the payload of a Pub/Sub event.
    type PubSubMessage struct {
    	Data []byte `json:"data"`
    }

    var (
    	visionClient    *vision.ImageAnnotatorClient
    	translateClient *translate.Client
    	pubsubClient    *pubsub.Client
    	storageClient   *storage.Client
    	config          *configuration
    )

    func setup(ctx context.Context) error {
    	if config == nil {
    		cfgFile, err := os.Open("config.json")
    		if err != nil {
    			return fmt.Errorf("os.Open: %v", err)
    		}

    		d := json.NewDecoder(cfgFile)
    		config = &configuration{}
    		if err = d.Decode(config); err != nil {
    			return fmt.Errorf("Decode: %v", err)
    		}
    	}

    	var err error // Prevent shadowing clients with :=.

    	if visionClient == nil {
    		visionClient, err = vision.NewImageAnnotatorClient(ctx)
    		if err != nil {
    			return fmt.Errorf("vision.NewImageAnnotatorClient: %v", err)
    		}
    	}

    	if translateClient == nil {
    		translateClient, err = translate.NewClient(ctx)
    		if err != nil {
    			return fmt.Errorf("translate.NewClient: %v", err)
    		}
    	}

    	if pubsubClient == nil {
    		pubsubClient, err = pubsub.NewClient(ctx, config.ProjectID)
    		if err != nil {
    			return fmt.Errorf("translate.NewClient: %v", err)
    		}
    	}

    	if storageClient == nil {
    		storageClient, err = storage.NewClient(ctx)
    		if err != nil {
    			return fmt.Errorf("storage.NewClient: %v", err)
    		}
    	}
    	return nil
    }
    

Traiter les images

La fonction suivante lit un fichier image importé depuis Cloud Storage et appelle une fonction pour détecter la présence de contenu texte dans l'image :

Node.js

/**
     * This function is exported by index.js, and is executed when
     * a file is uploaded to the Cloud Storage bucket you created
     * for uploading images.
     *
     * @param {object} event.data (Node 6) A Google Cloud Storage File object.
     * @param {object} event (Node 8+) A Google Cloud Storage File object.
     */
    exports.processImage = event => {
      const file = event.data || event;

      return Promise.resolve()
        .then(() => {
          if (file.resourceState === 'not_exists') {
            // This was a deletion event, we don't want to process this
            return;
          }

          if (!file.bucket) {
            throw new Error(
              'Bucket not provided. Make sure you have a "bucket" property in your request'
            );
          }
          if (!file.name) {
            throw new Error(
              'Filename not provided. Make sure you have a "name" property in your request'
            );
          }

          return detectText(file.bucket, file.name);
        })
        .then(() => {
          console.log(`File ${file.name} processed.`);
        });
    };

Python

def process_image(file, context):
        """Cloud Function triggered by Cloud Storage when a file is changed.
        Args:
            file (dict): Metadata of the changed file, provided by the triggering
                                     Cloud Storage event.
            context (google.cloud.functions.Context): Metadata of triggering event.
        Returns:
            None; the output is written to stdout and Stackdriver Logging
        """
        bucket = validate_message(file, 'bucket')
        name = validate_message(file, 'name')

        detect_text(bucket, name)

        print('File {} processed.'.format(file['name']))

Go


    package ocr

    import (
    	"context"
    	"fmt"
    	"log"
    )

    // ProcessImage is executed when a file is uploaded to the Cloud Storage bucket you
    // created for uploading images. It runs detectText, which processes the image for text.
    func ProcessImage(ctx context.Context, event GCSEvent) error {
    	if err := setup(ctx); err != nil {
    		return fmt.Errorf("ProcessImage: %v", err)
    	}
    	if event.Bucket == "" {
    		return fmt.Errorf("empty file.Bucket")
    	}
    	if event.Name == "" {
    		return fmt.Errorf("empty file.Name")
    	}
    	if err := detectText(ctx, event.Bucket, event.Name); err != nil {
    		return fmt.Errorf("detectText: %v", err)
    	}
    	log.Printf("File %s processed.", event.Name)
    	return nil
    }
    

La fonction suivante extrait le texte de l'image à l'aide de l'API Cloud Vision, et met le texte en file d'attente pour traduction :

Node.js

/**
     * Detects the text in an image using the Google Vision API.
     *
     * @param {string} bucketName Cloud Storage bucket name.
     * @param {string} filename Cloud Storage file name.
     * @returns {Promise}
     */
    function detectText(bucketName, filename) {
      let text;

      console.log(`Looking for text in image ${filename}`);
      return vision
        .textDetection(`gs://${bucketName}/${filename}`)
        .then(([detections]) => {
          const annotation = detections.textAnnotations[0];
          text = annotation ? annotation.description : '';
          console.log(`Extracted text from image (${text.length} chars)`);
          return translate.detect(text);
        })
        .then(([detection]) => {
          if (Array.isArray(detection)) {
            detection = detection[0];
          }
          console.log(`Detected language "${detection.language}" for ${filename}`);

          // Submit a message to the bus for each language we're going to translate to
          const tasks = config.TO_LANG.map(lang => {
            let topicName = config.TRANSLATE_TOPIC;
            if (detection.language === lang) {
              topicName = config.RESULT_TOPIC;
            }
            const messageData = {
              text: text,
              filename: filename,
              lang: lang,
            };

            return publishResult(topicName, messageData);
          });

          return Promise.all(tasks);
        });
    }

Python

def detect_text(bucket, filename):
        print('Looking for text in image {}'.format(filename))

        futures = []

        text_detection_response = vision_client.text_detection({
            'source': {'image_uri': 'gs://{}/{}'.format(bucket, filename)}
        })
        annotations = text_detection_response.text_annotations
        if len(annotations) > 0:
            text = annotations[0].description
        else:
            text = ''
        print('Extracted text {} from image ({} chars).'.format(text, len(text)))

        detect_language_response = translate_client.detect_language(text)
        src_lang = detect_language_response['language']
        print('Detected language {} for text {}.'.format(src_lang, text))

        # Submit a message to the bus for each target language
        for target_lang in config.get('TO_LANG', []):
            topic_name = config['TRANSLATE_TOPIC']
            if src_lang == target_lang or src_lang == 'und':
                topic_name = config['RESULT_TOPIC']
            message = {
                'text': text,
                'filename': filename,
                'lang': target_lang,
                'src_lang': src_lang
            }
            message_data = json.dumps(message).encode('utf-8')
            topic_path = publisher.topic_path(project_id, topic_name)
            future = publisher.publish(topic_path, data=message_data)
            futures.append(future)
        for future in futures:
            future.result()

Go


    package ocr

    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"log"

    	"cloud.google.com/go/pubsub"
    	"golang.org/x/text/language"
    	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
    )

    // detectText detects the text in an image using the Google Vision API.
    func detectText(ctx context.Context, bucketName, fileName string) error {
    	log.Printf("Looking for text in image %v", fileName)
    	maxResults := 1
    	image := &visionpb.Image{
    		Source: &visionpb.ImageSource{
    			GcsImageUri: fmt.Sprintf("gs://%s/%s", bucketName, fileName),
    		},
    	}
    	annotations, err := visionClient.DetectTexts(ctx, image, &visionpb.ImageContext{}, maxResults)
    	if err != nil {
    		return fmt.Errorf("DetectTexts: %v", err)
    	}
    	text := ""
    	if len(annotations) > 0 {
    		text = annotations[0].Description
    	}
    	if len(annotations) == 0 || len(text) == 0 {
    		log.Printf("No text detected in image %q. Returning early.", fileName)
    		return nil
    	}
    	log.Printf("Extracted text %q from image (%d chars).", text, len(text))

    	detectResponse, err := translateClient.DetectLanguage(ctx, []string{text})
    	if err != nil {
    		return fmt.Errorf("DetectLanguage: %v", err)
    	}
    	if len(detectResponse) == 0 || len(detectResponse[0]) == 0 {
    		return fmt.Errorf("DetectLanguage gave empty response")
    	}
    	srcLang := detectResponse[0][0].Language.String()
    	log.Printf("Detected language %q for text %q.", srcLang, text)

    	// Submit a message to the bus for each target language
    	for _, targetLang := range config.ToLang {
    		topicName := config.TranslateTopic
    		if srcLang == targetLang || srcLang == "und" { // detection returns "und" for undefined language
    			topicName = config.ResultTopic
    		}
    		targetTag, err := language.Parse(targetLang)
    		if err != nil {
    			return fmt.Errorf("language.Parse: %v", err)
    		}
    		srcTag, err := language.Parse(srcLang)
    		if err != nil {
    			return fmt.Errorf("language.Parse: %v", err)
    		}
    		message, err := json.Marshal(ocrMessage{
    			Text:     text,
    			FileName: fileName,
    			Lang:     targetTag,
    			SrcLang:  srcTag,
    		})
    		if err != nil {
    			return fmt.Errorf("json.Marshal: %v", err)
    		}
    		topic := pubsubClient.Topic(topicName)
    		ok, err := topic.Exists(ctx)
    		if err != nil {
    			return fmt.Errorf("Exists: %v", err)
    		}
    		if !ok {
    			topic, err = pubsubClient.CreateTopic(ctx, topicName)
    			if err != nil {
    				return fmt.Errorf("CreateTopic: %v", err)
    			}
    		}
    		msg := &pubsub.Message{
    			Data: []byte(message),
    		}
    		if _, err = topic.Publish(ctx, msg).Get(ctx); err != nil {
    			return fmt.Errorf("Get: %v", err)
    		}
    	}
    	return nil
    }
    

Traduire du texte

La fonction suivante traduit le texte extrait et met en file d'attente le texte traduit à renvoyer dans Cloud Storage pour enregistrement :

Node.js

/**
     * This function is exported by index.js, and is executed when
     * a message is published to the Cloud Pub/Sub topic specified
     * by the TRANSLATE_TOPIC value in the config.json file. The
     * function translates text using the Google Translate API.
     *
     * @param {object} event.data (Node 6) The Cloud Pub/Sub Message object.
     * @param {object} event (Node 8+) The Cloud Pub/Sub Message object.
     * @param {string} {messageObject}.data The "data" property of the Cloud Pub/Sub
     * Message. This property will be a base64-encoded string that you must decode.
     */
    exports.translateText = event => {
      const pubsubData = event.data.data || event.data;
      const jsonStr = Buffer.from(pubsubData, 'base64').toString();
      const payload = JSON.parse(jsonStr);

      return Promise.resolve()
        .then(() => {
          if (!payload.text) {
            throw new Error(
              'Text not provided. Make sure you have a "text" property in your request'
            );
          }
          if (!payload.filename) {
            throw new Error(
              'Filename not provided. Make sure you have a "filename" property in your request'
            );
          }
          if (!payload.lang) {
            throw new Error(
              'Language not provided. Make sure you have a "lang" property in your request'
            );
          }

          console.log(`Translating text into ${payload.lang}`);
          return translate.translate(payload.text, payload.lang);
        })
        .then(([translation]) => {
          const messageData = {
            text: translation,
            filename: payload.filename,
            lang: payload.lang,
          };

          return publishResult(config.RESULT_TOPIC, messageData);
        })
        .then(() => {
          console.log(`Text translated to ${payload.lang}`);
        });
    };

Python

def translate_text(event, context):
        if event.get('data'):
            message_data = base64.b64decode(event['data']).decode('utf-8')
            message = json.loads(message_data)
        else:
            raise ValueError('Data sector is missing in the Pub/Sub message.')

        text = validate_message(message, 'text')
        filename = validate_message(message, 'filename')
        target_lang = validate_message(message, 'lang')
        src_lang = validate_message(message, 'src_lang')

        print('Translating text into {}.'.format(target_lang))
        translated_text = translate_client.translate(text,
                                                     target_language=target_lang,
                                                     source_language=src_lang)
        topic_name = config['RESULT_TOPIC']
        message = {
            'text': translated_text['translatedText'],
            'filename': filename,
            'lang': target_lang,
        }
        message_data = json.dumps(message).encode('utf-8')
        topic_path = publisher.topic_path(project_id, topic_name)
        future = publisher.publish(topic_path, data=message_data)
        future.result()

Go


    package ocr

    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"log"

    	"cloud.google.com/go/pubsub"
    	"cloud.google.com/go/translate"
    )

    // TranslateText is executed when a message is published to the Cloud Pub/Sub topic specified
    // by TRANSLATE_TOPIC in config.json, and translates the text using the Google Translate API.
    func TranslateText(ctx context.Context, event PubSubMessage) error {
    	if err := setup(ctx); err != nil {
    		return fmt.Errorf("setup: %v", err)
    	}
    	if event.Data == nil {
    		return fmt.Errorf("empty data")
    	}
    	var message ocrMessage
    	if err := json.Unmarshal(event.Data, &message); err != nil {
    		return fmt.Errorf("json.Unmarshal: %v", err)
    	}

    	log.Printf("Translating text into %s.", message.Lang.String())
    	opts := translate.Options{
    		Source: message.SrcLang,
    	}
    	translateResponse, err := translateClient.Translate(ctx, []string{message.Text}, message.Lang, &opts)
    	if err != nil {
    		return fmt.Errorf("Translate: %v", err)
    	}
    	if len(translateResponse) == 0 {
    		return fmt.Errorf("Empty Translate response")
    	}
    	translatedText := translateResponse[0]

    	messageData, err := json.Marshal(ocrMessage{
    		Text:     translatedText.Text,
    		FileName: message.FileName,
    		Lang:     message.Lang,
    		SrcLang:  message.SrcLang,
    	})
    	if err != nil {
    		return fmt.Errorf("json.Marshal: %v", err)
    	}

    	topic := pubsubClient.Topic(config.ResultTopic)
    	ok, err := topic.Exists(ctx)
    	if err != nil {
    		return fmt.Errorf("Exists: %v", err)
    	}
    	if !ok {
    		topic, err = pubsubClient.CreateTopic(ctx, config.ResultTopic)
    		if err != nil {
    			return fmt.Errorf("CreateTopic: %v", err)
    		}
    	}
    	msg := &pubsub.Message{
    		Data: messageData,
    	}
    	if _, err = topic.Publish(ctx, msg).Get(ctx); err != nil {
    		return fmt.Errorf("Get: %v", err)
    	}
    	log.Printf("Sent translation: %q", translatedText.Text)
    	return nil
    }
    

Enregistrer les traductions

Enfin, la fonction suivante reçoit le texte traduit et l'enregistre dans Cloud Storage :

Node.js

/**
     * This function is exported by index.js, and is executed when
     * a message is published to the Cloud Pub/Sub topic specified
     * by the RESULT_TOPIC value in the config.json file. The
     * function saves the data packet to a file in GCS.
     *
     * @param {object} event.data (Node 6) The Cloud Pub/Sub Message object.
     * @param {object} event (Node 8+) The Cloud Pub/Sub Message object.
     * @param {string} {messageObject}.data The "data" property of the Cloud Pub/Sub
     * Message. This property will be a base64-encoded string that you must decode.
     */
    exports.saveResult = event => {
      const pubsubData = event.data.data || event.data;
      const jsonStr = Buffer.from(pubsubData, 'base64').toString();
      const payload = JSON.parse(jsonStr);

      return Promise.resolve()
        .then(() => {
          if (!payload.text) {
            throw new Error(
              'Text not provided. Make sure you have a "text" property in your request'
            );
          }
          if (!payload.filename) {
            throw new Error(
              'Filename not provided. Make sure you have a "filename" property in your request'
            );
          }
          if (!payload.lang) {
            throw new Error(
              'Language not provided. Make sure you have a "lang" property in your request'
            );
          }

          console.log(`Received request to save file ${payload.filename}`);

          const bucketName = config.RESULT_BUCKET;
          const filename = renameImageForSave(payload.filename, payload.lang);
          const file = storage.bucket(bucketName).file(filename);

          console.log(`Saving result to ${filename} in bucket ${bucketName}`);

          return file.save(payload.text);
        })
        .then(() => {
          console.log(`File saved.`);
        });
    };

Python

def save_result(event, context):
        if event.get('data'):
            message_data = base64.b64decode(event['data']).decode('utf-8')
            message = json.loads(message_data)
        else:
            raise ValueError('Data sector is missing in the Pub/Sub message.')

        text = validate_message(message, 'text')
        filename = validate_message(message, 'filename')
        lang = validate_message(message, 'lang')

        print('Received request to save file {}.'.format(filename))

        bucket_name = config['RESULT_BUCKET']
        result_filename = '{}_{}.txt'.format(filename, lang)
        bucket = storage_client.get_bucket(bucket_name)
        blob = bucket.blob(result_filename)

        print('Saving result to {} in bucket {}.'.format(result_filename,
                                                         bucket_name))

        blob.upload_from_string(text)

        print('File saved.')

Go


    package ocr

    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"log"
    )

    // SaveResult is executed when a message is published to the Cloud Pub/Sub topic specified by
    // RESULT_TOPIC in config.json file, and saves the data packet to a file in GCS.
    func SaveResult(ctx context.Context, event PubSubMessage) error {
    	if err := setup(ctx); err != nil {
    		return fmt.Errorf("ProcessImage: %v", err)
    	}
    	var message ocrMessage
    	if event.Data == nil {
    		return fmt.Errorf("Empty data")
    	}
    	if err := json.Unmarshal(event.Data, &message); err != nil {
    		return fmt.Errorf("json.Unmarshal: %v", err)
    	}
    	log.Printf("Received request to save file %q.", message.FileName)

    	bucketName := config.ResultBucket
    	resultFilename := fmt.Sprintf("%s_%s.txt", message.FileName, message.Lang)
    	bucket := storageClient.Bucket(bucketName)

    	log.Printf("Saving result to %q in bucket %q.", resultFilename, bucketName)

    	w := bucket.Object(resultFilename).NewWriter(ctx)
    	defer w.Close()
    	fmt.Fprint(w, message.Text)

    	log.Printf("File saved.")
    	return nil
    }
    

Déployer les fonctions

Cette section décrit comment déployer vos fonctions.

  1. Pour déployer la fonction de traitement d'image avec un déclencheur Cloud Storage, exécutez la commande suivante dans le répertoire app :

    Node.js

    gcloud functions deploy ocr-extract --runtime nodejs8 --trigger-bucket YOUR_IMAGE_BUCKET_NAME --entry-point processImage
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Node.js :
    • nodejs6 (obsolète)
    • nodejs8
    • nodejs10 (version bêta)

    Python

    gcloud functions deploy ocr-extract --runtime python37 --trigger-bucket YOUR_IMAGE_BUCKET_NAME --entry-point process_image

    Go

    gcloud functions deploy ocr-extract --runtime go111 --trigger-bucket YOUR_IMAGE_BUCKET_NAME --entry-point ProcessImage
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Go :
    • go111
    • go113 (version bêta)

    YOUR_IMAGE_BUCKET_NAME est le nom de votre bucket Cloud Storage dans lequel vous allez importer des images.

  2. Pour déployer la fonction de traduction de texte avec un déclencheur Cloud Pub/Sub, exécutez la commande suivante dans le répertoire app :

    Node.js

    gcloud functions deploy ocr-translate --runtime nodejs8 --trigger-topic YOUR_TRANSLATE_TOPIC_NAME --entry-point translateText
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Node.js :
    • nodejs6 (obsolète)
    • nodejs8
    • nodejs10 (version bêta)

    Python

    gcloud functions deploy ocr-translate --runtime python37 --trigger-topic YOUR_TRANSLATE_TOPIC_NAME --entry-point translate_text

    Go

    gcloud functions deploy ocr-translate --runtime go111 --trigger-topic YOUR_TRANSLATE_TOPIC_NAME --entry-point TranslateText
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Go :
    • go111
    • go113 (version bêta)

    YOUR_TRANSLATE_TOPIC_NAME est le nom de votre sujet Cloud Pub/Sub avec lequel les traductions seront déclenchées.

  3. Pour déployer la fonction qui enregistre les résultats dans Cloud Storage avec un déclencheur Cloud Pub/Sub, exécutez la commande suivante dans le répertoire app :

    Node.js

    gcloud functions deploy ocr-save --runtime nodejs8 --trigger-topic YOUR_RESULT_TOPIC_NAME --entry-point saveResult
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Node.js :
    • nodejs6 (obsolète)
    • nodejs8
    • nodejs10 (version bêta)

    Python

    gcloud functions deploy ocr-save --runtime python37 --trigger-topic YOUR_RESULT_TOPIC_NAME --entry-point save_result

    Go

    gcloud functions deploy ocr-save --runtime go111 --trigger-topic YOUR_RESULT_TOPIC_NAME --entry-point SaveResult
    Vous pouvez attribuer les valeurs suivantes à l'option --runtime, afin de spécifier votre version préférée de Go :
    • go111
    • go113 (version bêta)

    YOUR_RESULT_TOPIC_NAME est le nom de votre sujet Cloud Pub/Sub avec lequel l'enregistrement des résultats sera déclenché.

Importer une image

  1. Importez une image dans le bucket Cloud Storage approprié :

        gsutil cp PATH_TO_IMAGE gs://YOUR_IMAGE_BUCKET_NAME
        

    Où :

    • PATH_TO_IMAGE est un chemin d'accès à un fichier image (contenant du texte) sur votre système local.
    • YOUR_IMAGE_BUCKET_NAME est le nom du bucket dans lequel vous importez des images.

    Vous pouvez télécharger l'une des images de l'exemple de projet.

  2. Consultez les journaux pour vous assurer que les exécutions sont terminées :

        gcloud functions logs read --limit 100
        
  3. Vous pouvez afficher les traductions enregistrées dans le bucket Cloud Storage spécifié par la valeur RESULT_BUCKET dans votre fichier de configuration.

Nettoyer

Afin d'éviter que des frais ne soient facturés sur votre compte Google Cloud Platform pour les ressources utilisées dans ce tutoriel, procédez comme suit :

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

    console
  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page "Gérer les ressources"

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les fonctions cloud

La suppression de fonctions Cloud Functions ne supprime pas les ressources stockées dans Cloud Storage.

Pour supprimer les fonctions Cloud Functions que vous savez créées dans ce tutoriel, exécutez les commandes suivantes :

    gcloud functions delete ocr-extract
    gcloud functions delete ocr-translate
    gcloud functions delete ocr-save
    

Vous pouvez également supprimer des fonctions Cloud Functions à partir de la console Google Cloud.