Translating text from a photo

import html import os # Imports the Google Cloud client libraries from google.api_core.exceptions import AlreadyExists from google.cloud import texttospeech from google.cloud import translate_v3beta1 as translate from google.cloud import vision 

// Imports the Google Cloud client library const textToSpeech = require('@google-cloud/text-to-speech'); const translate = require('@google-cloud/translate').v3beta1; const vision = require('@google-cloud/vision'); // Import other required libraries const fs = require('fs'); //const escape = require('escape-html'); const util = require('util');

def pic_to_text(infile: str) -> str:  """Detects text in an image file  Args:  infile: path to image file  Returns:  String of text detected in image  """ # Instantiates a client client = vision.ImageAnnotatorClient() # Opens the input image file with open(infile, "rb") as image_file: content = image_file.read() image = vision.Image(content=content) # For dense text, use document_text_detection # For less dense text, use text_detection response = client.document_text_detection(image=image) text = response.full_text_annotation.text print(f"Detected text: {text}") return text

/**  * Detects text in an image file  *  * ARGS  * inputFile: path to image file  * RETURNS  * string of text detected in the input image  **/ async function picToText(inputFile) {  // Creates a client  const client = new vision.ImageAnnotatorClient();  // Performs text detection on the local file  const [result] = await client.textDetection(inputFile);  return result.fullTextAnnotation.text; }

def create_glossary( languages: list, project_id: str, glossary_name: str, glossary_uri: str, ) -> str:  """Creates a GCP glossary resource  Assumes you've already manually uploaded a glossary to Cloud Storage  Args:  languages: list of languages in the glossary  project_id: GCP project id  glossary_name: name you want to give this glossary resource  glossary_uri: the uri of the glossary you uploaded to Cloud Storage  Returns:  name of the created or existing glossary  """ # Instantiates a client client = translate.TranslationServiceClient() # Designates the data center location that you want to use location = "us-central1" # Set glossary resource name name = client.glossary_path(project_id, location, glossary_name) # Set language codes language_codes_set = translate.Glossary.LanguageCodesSet(language_codes=languages) gcs_source = translate.GcsSource(input_uri=glossary_uri) input_config = translate.GlossaryInputConfig(gcs_source=gcs_source) # Set glossary resource information glossary = translate.Glossary( name=name, language_codes_set=language_codes_set, input_config=input_config ) parent = f"projects/{project_id}/locations/{location}" # Create glossary resource # Handle exception for case in which a glossary # with glossary_name already exists try: operation = client.create_glossary(parent=parent, glossary=glossary) operation.result(timeout=90) print("Created glossary " + glossary_name + ".") except AlreadyExists: print( "The glossary " + glossary_name + " already exists. No new glossary was created." ) return glossary_name

/** Creates a GCP glossary resource  * Assumes you've already manually uploaded a glossary to Cloud Storage  *  * ARGS  * languages: list of languages in the glossary  * projectId: GCP project id  * glossaryName: name you want to give this glossary resource  * glossaryUri: the uri of the glossary you uploaded to Cloud Storage  * RETURNS  * nothing  **/ async function createGlossary(  languages,  projectId,  glossaryName,  glossaryUri ) {  // Instantiates a client  const translationClient = await new translate.TranslationServiceClient();  // Construct glossary  const glossary = {  languageCodesSet: {  languageCodes: languages,  },  inputConfig: {  gcsSource: {  inputUri: glossaryUri,  },  },  name: translationClient.glossaryPath(  projectId,  'us-central1',  glossaryName  ),  };  // Construct request  const request = {  parent: translationClient.locationPath(projectId, 'us-central1'),  glossary: glossary,  };  // Create glossary using a long-running operation.  try {  const [operation] = await translationClient.createGlossary(request);  // Wait for operation to complete.  await operation.promise();  console.log('Created glossary ' + glossaryName + '.');  } catch (AlreadyExists) {  console.log(  'The glossary ' +  glossaryName +  ' already exists. No new glossary was created.'  );  } }

def translate_text( text: str, source_language_code: str, target_language_code: str, project_id: str, glossary_name: str, ) -> str:  """Translates text to a given language using a glossary  Args:  text: String of text to translate  source_language_code: language of input text  target_language_code: language of output text  project_id: GCP project id  glossary_name: name you gave your project's glossary  resource when you created it  Return:  String of translated text  """ # Instantiates a client client = translate.TranslationServiceClient() # Designates the data center location that you want to use location = "us-central1" glossary = client.glossary_path(project_id, location, glossary_name) glossary_config = translate.TranslateTextGlossaryConfig(glossary=glossary) parent = f"projects/{project_id}/locations/{location}" result = client.translate_text( request={ "parent": parent, "contents": [text], "mime_type": "text/plain", # mime types: text/plain, text/html "source_language_code": source_language_code, "target_language_code": target_language_code, "glossary_config": glossary_config, } ) # Extract translated text from API response return result.glossary_translations[0].translated_text

/**  * Translates text to a given language using a glossary  *  * ARGS  * text: String of text to translate  * sourceLanguageCode: language of input text  * targetLanguageCode: language of output text  * projectId: GCP project id  * glossaryName: name you gave your project's glossary  * resource when you created it  * RETURNS  * String of translated text  **/ async function translateText(  text,  sourceLanguageCode,  targetLanguageCode,  projectId,  glossaryName ) {  // Instantiates a client  const translationClient = new translate.TranslationServiceClient();  const glossary = translationClient.glossaryPath(  projectId,  'us-central1',  glossaryName  );  const glossaryConfig = {  glossary: glossary,  };  // Construct request  const request = {  parent: translationClient.locationPath(projectId, 'us-central1'),  contents: [text],  mimeType: 'text/plain', // mime types: text/plain, text/html  sourceLanguageCode: sourceLanguageCode,  targetLanguageCode: targetLanguageCode,  glossaryConfig: glossaryConfig,  };  // Run request  const [response] = await translationClient.translateText(request);  // Extract the string of translated text  return response.glossaryTranslations[0].translatedText; }

def text_to_speech(text: str, outfile: str) -> str:  """Converts plaintext to SSML and  generates synthetic audio from SSML  Args:  text: text to synthesize  outfile: filename to use to store synthetic audio  Returns:  String of synthesized audio  """ # Replace special characters with HTML Ampersand Character Codes # These Codes prevent the API from confusing text with # SSML commands # For example, '<' --> '&lt;' and '&' --> '&amp;' escaped_lines = html.escape(text) # Convert plaintext to SSML in order to wait two seconds # between each line in synthetic speech ssml = "<speak>{}</speak>".format( escaped_lines.replace("\n", '\n<break time="2s"/>') ) # Instantiates a client client = texttospeech.TextToSpeechClient() # Sets the text input to be synthesized synthesis_input = texttospeech.SynthesisInput(ssml=ssml) # Builds the voice request, selects the language code ("en-US") and # the SSML voice gender ("MALE") voice = texttospeech.VoiceSelectionParams( language_code="en-US", ssml_gender=texttospeech.SsmlVoiceGender.MALE ) # Selects the type of audio file to return audio_config = texttospeech.AudioConfig( audio_encoding=texttospeech.AudioEncoding.MP3 ) # Performs the text-to-speech request on the text input with the selected # voice parameters and audio file type request = texttospeech.SynthesizeSpeechRequest( input=synthesis_input, voice=voice, audio_config=audio_config ) response = client.synthesize_speech(request=request) # Writes the synthetic audio to the output file. with open(outfile, "wb") as out: out.write(response.audio_content) print("Audio content written to file " + outfile)

/**  * Generates synthetic audio from plaintext tagged with SSML.  *  * Given the name of a text file and an output file name, this function  * tags the text in the text file with SSML. This function then  * calls the Text-to-Speech API. The API returns a synthetic audio  * version of the text, formatted according to the SSML commands. This  * function saves the synthetic audio to the designated output file.  *  * ARGS  * text: String of plaintext  * outFile: String name of file under which to save audio output  * RETURNS  * nothing  *  */ async function syntheticAudio(text, outFile) {  // Replace special characters with HTML Ampersand Character Codes  // These codes prevent the API from confusing text with SSML tags  // For example, '<' --> '&lt;' and '&' --> '&amp;'  let escapedLines = text.replace(/&/g, '&amp;');  escapedLines = escapedLines.replace(/"/g, '&quot;');  escapedLines = escapedLines.replace(/</g, '&lt;');  escapedLines = escapedLines.replace(/>/g, '&gt;');  // Convert plaintext to SSML  // Tag SSML so that there is a 2 second pause between each address  const expandedNewline = escapedLines.replace(/\n/g, '\n<break time="2s"/>');  const ssmlText = '<speak>' + expandedNewline + '</speak>';  // Creates a client  const client = new textToSpeech.TextToSpeechClient();  // Constructs the request  const request = {  // Select the text to synthesize  input: {ssml: ssmlText},  // Select the language and SSML Voice Gender (optional)  voice: {languageCode: 'en-US', ssmlGender: 'MALE'},  // Select the type of audio encoding  audioConfig: {audioEncoding: 'MP3'},  };  // Performs the Text-to-Speech request  const [response] = await client.synthesizeSpeech(request);  // Write the binary audio content to a local file  const writeFile = util.promisify(fs.writeFile);  await writeFile(outFile, response.audioContent, 'binary');  console.log('Audio content written to file ' + outFile); }

def main() -> None:  """This method is called when the tutorial is run in the Google Cloud  Translation API. It creates a glossary, translates text to  French, and speaks the translated text.  Args:  None  Returns:  None  """ # Photo from which to extract text infile = "resources/example.png" # Name of file that will hold synthetic speech outfile = "resources/example.mp3" # Defines the languages in the glossary # This list must match the languages in the glossary # Here, the glossary includes French and English glossary_langs = ["fr", "en"] # Name that will be assigned to your project's glossary resource glossary_name = "bistro-glossary" # uri of .csv file uploaded to Cloud Storage glossary_uri = "gs://cloud-samples-data/translation/bistro_glossary.csv" created_glossary_name = create_glossary( glossary_langs, PROJECT_ID, glossary_name, glossary_uri ) # photo -> detected text text_to_translate = pic_to_text(infile) # detected text -> translated text text_to_speak = translate_text( text_to_translate, "fr", "en", PROJECT_ID, created_glossary_name ) # translated text -> synthetic audio text_to_speech(text_to_speak, outfile)

await createGlossary(glossaryLangs, projectId, glossaryName, glossaryUri); const text = await picToText(inFile); const translatedText = await translateText(  text,  'fr',  'en',  projectId,  glossaryName ); syntheticAudio(translatedText, outFile);