> ## 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.

# Erkennung von Wörtern mit Leerzeichen

> Erkennen Sie Wörter mit Leerzeichen (wie etwa 'New York') in ABBYY FineReader Engine, indem Sie das Leerzeichen zum Sprachalphabet, zum Wörterbuch und zu OneWordPerLine hinzufügen.

ABBYY FineReader Engine ermöglicht es, Wörter mit Leerzeichen zu einem Wörterbuch hinzuzufügen. Diese Funktion kann sehr nützlich sein, um Wörter wie "New York" zu überprüfen. Wir empfehlen, bei der Felderkennung ein Wörterbuch für Wörter mit Leerzeichen zu verwenden, wenn sich die Felder (kleine Bildausschnitte mit kurzen Textfragmenten) anhand bestimmter Informationen über die Art der enthaltenen Daten erkennen lassen. Das Wort "New York" kann zum Beispiel nützlich sein, wenn Sie Adressen erkennen.

Gehen Sie wie folgt vor, um Wörter mit Leerzeichen zu erkennen:

1. Fügen Sie das Zeichen "Leerzeichen" zum Alphabet der aktuellen Sprache hinzu.
2. Fügen Sie dem Wörterbuch die erforderlichen Wörter mit Leerzeichen hinzu.
3. Setzen Sie die Eigenschaft [OneWordPerLine](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#onewordperline) des Objekts [RecognizerParams](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) auf TRUE.

Nachfolgend finden Sie eine detaillierte Beschreibung dieses Vorgangs:

1. Erstellen Sie auf Grundlage einer [vordefinierten Sprache](/de/fine-reader/engine/specifications/predefined-languages) eine neue Textsprache. Erstellen Sie dazu mithilfe der Methode [CreateTextLanguage](/de/fine-reader/engine/api-reference/language-related-objects/languagedatabase/createtextlanguage-method) des Objekts [LanguageDatabase](/de/fine-reader/engine/api-reference/language-related-objects/languagedatabase) ein Objekt vom Typ [TextLanguage](/de/fine-reader/engine/api-reference/language-related-objects/textlanguage) und kopieren Sie die Attribute der vordefinierten Sprache.
2. Fügen Sie das Zeichen "Leerzeichen" mithilfe der Eigenschaft [LetterSet](/de/fine-reader/engine/api-reference/language-related-objects/baselanguage/letterset-property) des Objekts BaseLanguage zum Objekt [BaseLanguage](/de/fine-reader/engine/api-reference/language-related-objects/baselanguage) innerhalb des TextLanguage-Objekts hinzu.
3. Erstellen Sie ein neues Wörterbuch und fügen Sie diesem Wörterbuch alle erforderlichen Wörter mit Leerzeichen hinzu. Dazu können Sie das Objekt [Dictionary](/de/fine-reader/engine/api-reference/language-related-objects/dictionary) verwenden.
4. Erstellen Sie ein Objekt vom Typ [UserDictionaryDescription](/de/fine-reader/engine/api-reference/language-related-objects/userdictionarydescription). Weisen Sie der Eigenschaft [FileName](/de/fine-reader/engine/api-reference/language-related-objects/userdictionarydescription#filename) dieses Objekts den Pfad zum neuen Wörterbuch zu.
5. Fügen Sie das Objekt UserDictionaryDescription der Sammlung [DictionaryDescriptions](/de/fine-reader/engine/api-reference/language-related-objects/baselanguage#dictionarydescriptions) des Objekts BaseLanguage hinzu.
6. Weisen Sie im Objekt [RecognizerParams](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) aller Textblöcke der Eigenschaft [TextLanguage](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#textlanguage) das zuvor erstellte TextLanguage-Objekt und der Eigenschaft [OneWordPerLine](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#onewordperline) den Wert TRUE zu.

Nachfolgend sehen Sie ein Beispiel, in dem das Zeichen "Leerzeichen" zum Alphabet der englischen Sprache hinzugefügt und das Wort "New York" zum Wörterbuch hinzugefügt wurde.

<Accordion title="C++ (COM)-Code">
  ```cpp theme={null}
  // Ein LanguageDatabase-Objekt erstellen
  FREngine::ILanguageDatabasePtr pLanguageDatabase = Engine->CreateLanguageDatabase();
  // Ein neues TextLanguage-Objekt erstellen
  FREngine::ITextLanguagePtr pTextLanguage = pLanguageDatabase->CreateTextLanguage();
  // Alle Attribute aus der vordefinierten englischen Sprache übernehmen
  FREngine::ITextLanguagePtr pEnglishLanguage =
            Engine->PredefinedLanguages->Find( "English" )->TextLanguage;
  pTextLanguage->CopyFrom( pEnglishLanguage );
  pTextLanguage->InternalName = L"SampleTL";
  // Das neue Wörterbuch an das erste (und einzige) BaseLanguage-Objekt in TextLanguage binden
  FREngine::IBaseLanguagePtr pBaseLanguage = pTextLanguage->BaseLanguages->Item(0);
  // Den internen Namen des Wörterbuchs in einen benutzerdefinierten Namen ändern
  pBaseLanguage->InternalName = L"SampleBL"; 
  // Das Leerzeichen hinzufügen
  _bstr_t alphabet = pBaseLanguage->GetLetterSet( FREngine::BLLS_Alphabet );
  pBaseLanguage->put_LetterSet( FREngine::BLLS_Alphabet, alphabet + L" " );
   
  // Ein neues Wörterbuch erstellen
  _bstr_t dictionaryFile = L"D:\\sample.amd";
  FREngine::IDictionaryPtr pDictionary =
  pLanguageDatabase->CreateNewDictionary( dictionaryFile, FREngine::LI_EnglishUnitedStates );
  pDictionary->Name = L"Sample";
  // Wörter mit Leerzeichen zum Wörterbuch hinzufügen
  pDictionary->AddWord( "New York", 100 );
  // Die Sammlung der Wörterbuchbeschreibungen abrufen und alle Einträge entfernen
  FREngine::IDictionaryDescriptionsPtr pDictionaryDescriptions =
   pBaseLanguage->DictionaryDescriptions;
  pDictionaryDescriptions->DeleteAll();
  // Eine Benutzerwörterbuchbeschreibung erstellen und der Sammlung hinzufügen
  FREngine::IDictionaryDescriptionPtr dic =
   pDictionaryDescriptions->AddNew(FREngine::DT_UserDictionary);
  // Den Pfad zum Wörterbuch angeben, das Wörter mit Leerzeichen enthält
  FREngine::IUserDictionaryDescriptionPtr userDic =
   dic->GetAsUserDictionaryDescription();
  userDic->FileName = dictionaryFile;
  FREngine::ILayoutPtr pLayout;
  ...
  // Die Eigenschaften des RecognizerParams-Objekts für alle Textblöcke festlegen
  // Blöcke durchlaufen
  for( int i = pLayout->Blocks->Count - 1; i >= 0; i-- ) {
    FREngine::BlockTypeEnum blockType = pLayout->Blocks->Item( i )->Type;
    // Den Textblock ermitteln
    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#-Code">
  ```csharp theme={null}
  // Erstellen Sie ein LanguageDatabase-Objekt
  FREngine.ILanguageDatabase languageDatabase = engineLoader.Engine.CreateLanguageDatabase();
  // Erstellen Sie ein neues TextLanguage-Objekt
  FREngine.ITextLanguage textLanguage = languageDatabase.CreateTextLanguage();
  // Kopieren Sie alle Attribute aus der vordefinierten Sprache Englisch
  FREngine.ITextLanguage englishLanguage = engineLoader.Engine.PredefinedLanguages.Find( "English" ).TextLanguage;
  textLanguage.CopyFrom( englishLanguage );
  textLanguage.InternalName = "SampleTL";
  // Weisen Sie das neue Wörterbuch dem ersten (und einzigen) BaseLanguage-Objekt innerhalb von TextLanguage zu
  FREngine.IBaseLanguage baseLanguage = textLanguage.BaseLanguages[0];
  // Setzen Sie den internen Wörterbuchnamen auf einen benutzerdefinierten Namen
  baseLanguage.InternalName = "SampleBL";
  // Fügen Sie das Leerzeichen hinzu
  string alphabet = baseLanguage.get_LetterSet( FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet );
  baseLanguage.set_LetterSet( FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet, alphabet + " " );
  // Erstellen Sie ein neues Wörterbuch
  string dictionaryFilePath = "D:\\sample.amd";
  FREngine.IDictionary dictionary = languageDatabase.CreateNewDictionary( dictionaryFilePath, FREngine.LanguageIdEnum.LI_EnglishUnitedStates );
  dictionary.Name = "Sample";
  // Fügen Sie dem Wörterbuch Wörter mit Leerzeichen hinzu
  dictionary.AddWord( "New York", 100 );
  // Rufen Sie die Sammlung der Wörterbuchbeschreibungen ab und entfernen Sie alle Einträge
  FREngine.IDictionaryDescriptions dictionaryDescriptions = baseLanguage.DictionaryDescriptions;
  dictionaryDescriptions.DeleteAll();
  // Erstellen Sie eine Benutzerwörterbuchbeschreibung und fügen Sie sie der Sammlung hinzu
  FREngine.IDictionaryDescription dic = dictionaryDescriptions.AddNew(FREngine.DictionaryTypeEnum.DT_UserDictionary);
  // Geben Sie den Pfad zum Wörterbuch an, das Wörter mit Leerzeichen enthält
  FREngine.IUserDictionaryDescription userDic = dic.GetAsUserDictionaryDescription();
  userDic.FileName = dictionaryFilePath;
  FREngine.ILayout layout;
  ...
  // Geben Sie die Properties des RecognizerParams-Objekts für alle Textblöcke an
  // Durchlaufen Sie die Blöcke
  for( int i = layout.Blocks.Count - 1; i >= 0; i-- ) {
      FREngine.IBlockTypeEnum blockType = layout.Blocks[i].Type;
      // Suchen Sie den Textblock
      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">
  ## Siehe auch
</div>

[Arbeiten mit Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-languages)

[Arbeiten mit Wörterbüchern](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-dictionaries)

[Felderkennung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition)