> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Reconocimiento de palabras con espacios

> Reconozca palabras que contienen espacios (como 'New York') en ABBYY FineReader Engine agregando el carácter de espacio al alfabeto del idioma, al diccionario y a OneWordPerLine.

ABBYY FineReader Engine le permite agregar palabras con espacios a un diccionario. Esta función puede ser muy útil para comprobar palabras como "New York". Recomendamos usar un diccionario de palabras con espacios durante el reconocimiento a nivel de campo cuando pueda reconocer los campos (pequeños fragmentos de imagen que contienen fragmentos cortos de texto) utilizando información específica sobre el tipo de datos que pueden contener. La palabra "New York", por ejemplo, puede ser útil si está reconociendo direcciones.

Para reconocer palabras con espacios, haga lo siguiente:

1. Agregue el carácter "espacio" al alfabeto del idioma actual.
2. Agregue al diccionario las palabras con espacios necesarias.
3. Establezca la propiedad [OneWordPerLine](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#onewordperline) del objeto [RecognizerParams](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) en TRUE.

A continuación se ofrece una descripción detallada de esta operación:

1. Cree un nuevo idioma de texto a partir de un [idioma predefinido](/es/fine-reader/engine/specifications/predefined-languages). Para ello, cree un objeto [TextLanguage](/es/fine-reader/engine/api-reference/language-related-objects/textlanguage) mediante el método [CreateTextLanguage](/es/fine-reader/engine/api-reference/language-related-objects/languagedatabase/createtextlanguage-method) del objeto [LanguageDatabase](/es/fine-reader/engine/api-reference/language-related-objects/languagedatabase) y copie los atributos del idioma predefinido.
2. Agregue el carácter "espacio" al objeto [BaseLanguage](/es/fine-reader/engine/api-reference/language-related-objects/baselanguage) dentro del objeto TextLanguage, mediante la propiedad [LetterSet](/es/fine-reader/engine/api-reference/language-related-objects/baselanguage/letterset-property) del objeto BaseLanguage.
3. Cree un diccionario nuevo y agregue a él todas las palabras con espacios necesarias. Puede usar el objeto [Dictionary](/es/fine-reader/engine/api-reference/language-related-objects/dictionary) para ello.
4. Cree un objeto [UserDictionaryDescription](/es/fine-reader/engine/api-reference/language-related-objects/userdictionarydescription). Asigne la ruta del nuevo diccionario a la propiedad [FileName](/es/fine-reader/engine/api-reference/language-related-objects/userdictionarydescription#filename) de este objeto.
5. Agregue el objeto UserDictionaryDescription a la colección [DictionaryDescriptions](/es/fine-reader/engine/api-reference/language-related-objects/baselanguage#dictionarydescriptions) del objeto BaseLanguage.
6. En el objeto [RecognizerParams](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) de todos los bloques de texto, asigne el objeto TextLanguage creado anteriormente a la propiedad [TextLanguage](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#textlanguage) y el valor TRUE a la propiedad [OneWordPerLine](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#onewordperline).

A continuación puede ver un ejemplo en el que se ha agregado el carácter "espacio" al alfabeto del idioma inglés y se ha agregado la palabra "New York" al diccionario.

<Accordion title="Código C++ (COM)">
  ```cpp theme={null}
  // Crear un objeto LanguageDatabase
  FREngine::ILanguageDatabasePtr pLanguageDatabase = Engine->CreateLanguageDatabase();
  // Crear un nuevo objeto TextLanguage
  FREngine::ITextLanguagePtr pTextLanguage = pLanguageDatabase->CreateTextLanguage();
  // Copiar todos los atributos del idioma inglés predefinido
  FREngine::ITextLanguagePtr pEnglishLanguage =
            Engine->PredefinedLanguages->Find( "English" )->TextLanguage;
  pTextLanguage->CopyFrom( pEnglishLanguage );
  pTextLanguage->InternalName = L"SampleTL";
  // Asociar el nuevo diccionario al primer (y único) objeto BaseLanguage dentro de TextLanguage
  FREngine::IBaseLanguagePtr pBaseLanguage = pTextLanguage->BaseLanguages->Item(0);
  // Cambiar el nombre interno del diccionario por un nombre definido por el usuario
  pBaseLanguage->InternalName = L"SampleBL"; 
  // Agregar el carácter de espacio
  _bstr_t alphabet = pBaseLanguage->GetLetterSet( FREngine::BLLS_Alphabet );
  pBaseLanguage->put_LetterSet( FREngine::BLLS_Alphabet, alphabet + L" " );
   
  // Crear un diccionario nuevo
  _bstr_t dictionaryFile = L"D:\\sample.amd";
  FREngine::IDictionaryPtr pDictionary =
  pLanguageDatabase->CreateNewDictionary( dictionaryFile, FREngine::LI_EnglishUnitedStates );
  pDictionary->Name = L"Sample";
  // Agregar palabras con espacios al diccionario
  pDictionary->AddWord( "New York", 100 );
  // Obtener la colección de descripciones de diccionarios y eliminar todos los elementos
  FREngine::IDictionaryDescriptionsPtr pDictionaryDescriptions =
   pBaseLanguage->DictionaryDescriptions;
  pDictionaryDescriptions->DeleteAll();
  // Crear una descripción de diccionario de usuario y agregarla a la colección
  FREngine::IDictionaryDescriptionPtr dic =
   pDictionaryDescriptions->AddNew(FREngine::DT_UserDictionary);
  // Especificar la ruta del diccionario que contiene palabras con espacios
  FREngine::IUserDictionaryDescriptionPtr userDic =
   dic->GetAsUserDictionaryDescription();
  userDic->FileName = dictionaryFile;
  FREngine::ILayoutPtr pLayout;
  ...
  // Especificar las Propiedades del objeto RecognizerParams para todos los bloques de texto
  // Recorrer los bloques
  for( int i = pLayout->Blocks->Count - 1; i >= 0; i-- ) {
    FREngine::BlockTypeEnum blockType = pLayout->Blocks->Item( i )->Type;
    // Buscar el bloque de texto
    if( blockType != FREngine::BT_Text ) {
      pLayout->Blocks->DeleteAt(i);
    } else {
      pLayout->Blocks->Item(i)->GetAsTextBlock()->RecognizerParams->
   TextLanguage = pTextLanguage;
      pLayout->Blocks->Item(i)->GetAsTextBlock()->RecognizerParams->
   OneWordPerLine = VARIANT_TRUE;
    }
  }
  ...
  ```
</Accordion>

<Accordion title="Código C#">
  ```csharp theme={null}
  // Crear un objeto LanguageDatabase
  FREngine.ILanguageDatabase languageDatabase = engineLoader.Engine.CreateLanguageDatabase();
  // Crear un objeto TextLanguage
  FREngine.ITextLanguage textLanguage = languageDatabase.CreateTextLanguage();
  // Copiar todos los atributos del idioma inglés predefinido
  FREngine.ITextLanguage englishLanguage = engineLoader.Engine.PredefinedLanguages.Find( "English" ).TextLanguage;
  textLanguage.CopyFrom( englishLanguage );
  textLanguage.InternalName = "SampleTL";
  // Asociar el nuevo diccionario al primer (y único) objeto BaseLanguage de TextLanguage
  FREngine.IBaseLanguage baseLanguage = textLanguage.BaseLanguages[0];
  // Cambiar el nombre interno del diccionario por uno definido por el usuario
  baseLanguage.InternalName = "SampleBL";
  // Agregar el carácter de espacio
  string alphabet = baseLanguage.get_LetterSet( FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet );
  baseLanguage.set_LetterSet( FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet, alphabet + " " );
  // Crear un diccionario nuevo
  string dictionaryFilePath = "D:\\sample.amd";
  FREngine.IDictionary dictionary = languageDatabase.CreateNewDictionary( dictionaryFilePath, FREngine.LanguageIdEnum.LI_EnglishUnitedStates );
  dictionary.Name = "Sample";
  // Agregar al diccionario palabras con espacios
  dictionary.AddWord( "New York", 100 );
  // Obtener la colección de descripciones de diccionarios y eliminar todos los elementos
  FREngine.IDictionaryDescriptions dictionaryDescriptions = baseLanguage.DictionaryDescriptions;
  dictionaryDescriptions.DeleteAll();
  // Crear una descripción de diccionario de usuario y agregarla a la colección
  FREngine.IDictionaryDescription dic = dictionaryDescriptions.AddNew(FREngine.DictionaryTypeEnum.DT_UserDictionary);
  // Especificar la ruta al diccionario que contiene palabras con espacios
  FREngine.IUserDictionaryDescription userDic = dic.GetAsUserDictionaryDescription();
  userDic.FileName = dictionaryFilePath;
  FREngine.ILayout layout;
  ...
  // Especificar las propiedades del objeto RecognizerParams para todos los bloques de texto
  // Recorrer los bloques
  for( int i = layout.Blocks.Count - 1; i >= 0; i-- ) {
      FREngine.IBlockTypeEnum blockType = layout.Blocks[i].Type;
      // Buscar el bloque de texto
      if( blockType != FREngine.BlockTypeEnum.BT_Text ) {
          layout.Blocks.DeleteAt(i);
      } else {
          layout.Blocks[i].GetAsTextBlock().RecognizerParams.TextLanguage = textLanguage;
          layout.Blocks[i].GetAsTextBlock().RecognizerParams.OneWordPerLine = true;
      }
  }
  ...
  ```
</Accordion>

<div id="see-also">
  ## Consulte también
</div>

[Trabajar con idiomas](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-languages)

[Trabajar con diccionarios](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-dictionaries)

[Reconocimiento a nivel de campo](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition)