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

# Recognizing Chinese, Japanese, and Korean Languages

Chinese, Japanese, and Korean languages are often grouped together under the abbreviation "CJK". They have several features in common, such as the use of Chinese characters and of vertical as well as horizontal writing direction.

This section deals with certain peculiarities of recognizing and exporting texts in CJK languages with ABBYY FineReader Engine 12.

First, in order to recognize CJK languages, you must have an ABBYY FineReader Engine license that supports the [Chinese](/fine-reader/engine/licensing/modules#chinese), [Japanese](/fine-reader/engine/licensing/modules#japanese), and [Korean](/fine-reader/engine/licensing/modules#korean) language modules. For more information about licenses and modules, see the [Licensing](/fine-reader/engine/licensing) section.

## Recognition languages

ABBYY FineReader Engine supports the following predefined recognition languages for CJK texts:

<Note> ChinesePRC and ChineseTaiwan are still accepted to allow backwards compatibility but new implementations should use ChineseSimplified and ChineseTraditional.</Note>

* "ChineseSimplified"
* "ChineseTraditional"
* "Japanese"
* "JapaneseModern"
* "Korean"
* "KoreanHangul"

To select one of these predefined languages, you can use the [SetPredefinedTextLanguage](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) method of the [RecognizerParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) object.

<Warning>
  Japanese (Modern) recognition language is a compound language consisting of the Japanese and English languages and four letters of the Greek language. This language is intended for recognizing contemporary Japanese texts, which may include some Kanji characters, Kana (Katakana or Hiragana) symbols, some Latin and/or Greek letters (such as reports, research papers, etc.). To get the best recognition results for all documents written primarily in Japanese, we strongly recommend using the Japanese (Modern) recognition language as an independent language, without using its combinations with the English language.
</Warning>

ABBYY FineReader Engine supports recognition language combinations consisting of several of these languages or combinations of CJK and other languages.

## Fonts

To prevent garbling of Asian characters, you must specify for document synthesis a font that includes the necessary set of characters, e.g., Arial Unicode MS, SimSun. You can set the font with the help of the [ISynthesisParamsForDocument::FontSet](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument#fontset) property. The SystemFontSet property of the [FontSet](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/fontset) object is set by default to selecting those of the system fonts which correspond to the recognition languages of the document.

## Export

You can export CJK languages to PDF/A in "text under the image" mode (IPDFExportParams::TextExportMode = PEM\_ImageOnText) to ensure that the document looks the same.

## The procedure of recognition and export

To process documents written in CJK languages, do the following:

1. Create a [DocumentProcessingParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/documentprocessingparams) object using the [CreateDocumentProcessingParams](/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) method of the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object.
2. Specify the recognition language. Use the [SetPredefinedTextLanguage](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) method of the [RecognizerParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) subobject of the [PageProcessingParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams) subobject.
3. Select the font set suitable for CJK languages. Use the [ISynthesisParamsForDocument::FontSet](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument#fontset) property of the [SynthesisParamsForDocument](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument) subobject.
4. Pass the configured DocumentProcessingParams object to the [Process](/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) method of the [FRDocument](/fine-reader/engine/api-reference/document-related-objects/frdocument) object. If you use methods of the Engine object, you should call one of the synthesis methods of the Engine object with the configured SynthesisParamsForDocument object as a parameter before export.
5. Perform export of the recognized text with the help of the [Export](/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) method of the FRDocument object. If you export to PDF of PDF/A format, specify the required export mode.

<Note>
  Do not use the [Word](/fine-reader/engine/api-reference/text-related-objects/word) object and its properties or the [IsWordFirst](/fine-reader/engine/api-reference/text-related-objects/charparams#iswordfirst) , [IsWordLeftmost](/fine-reader/engine/api-reference/text-related-objects/charparams#iswordleftmost) properties of the [CharParams](/fine-reader/engine/api-reference/text-related-objects/charparams) object for the texts written in CJK languages. The processing technology divides the text lines into "words" only for internal purposes, and those groups of symbols do not coincide with the actual words.
</Note>

<Accordion title="C++ code">
  ```cpp theme={null}
  // We assume that Engine was already created
  // and the document loaded
  IEngine* Engine;
  IFRDocument* frDocument;
  HRESULT res; // use this variable to check if the call to the method was successful
  ...
  // Create a DocumentProcessingParams object
  IDocumentProcessingParams* params = 0;
  IPageProcessingParams* pageParams = 0;
  IRecognizerParams* recParams = 0;
  res = Engine->CreateDocumentProcessingParams( ¶ms );
  res = params->get_PageProcessingParams( &pageParams );
  res = pageParams->get_RecognizerParams( &recParams );
   
  // Specify the recognition language
  res = recParams->SetPredefinedTextLanguage( L"Japanese" );
   
  ISynthesisParamsForDocument* synthesisParams = 0;
  IFontSet* set = 0;
  ISystemFontSet* systemSet = 0;
  res = params->get_SynthesisParamsForDocument( &synthesisParams );
  res = synthesisParams->get_FontSet( &set );
  res = set->get_SystemFontSet( &systemSet );
   
  // Select font set
  res = systemSet->put_FontNamesFilter( FNF_Japanese );
  // Recognize and export the document
  frDocument->Process( params );
  frDocument->Export( L"/opt/Demo.rtf", FEF_RTF, 0 );
  ...
  ```
</Accordion>

<Accordion title="C++ (COM) code">
  ```cpp theme={null}
  FREngine::IEnginePtr Engine;
  FREngine::IFRDocumentPtr frDocument;
  ...
  // Create a DocumentProcessingParams object
  FREngine::IDocumentProcessingParamsPtr pDocumentProcessingParams = Engine->CreateDocumentProcessingParams();
  // Specify the recognition language
  pDocumentProcessingParams->PageProcessingParams->RecognizerParams->SetPredefinedTextLanguage( "Japanese" );
  // Select font set
  pDocumentProcessingParams->SynthesisParamsForDocument->FontSet->SystemFontSet->FontNamesFilter = FREngine::FNF_Japanese;
  // Recognize and export the document
  frDocument->Process( pDocumentProcessingParams );
  frDocument->Export( L"D:\\Demo.rtf", FREngine::FEF_RTF, 0 );
  ...
  ```
</Accordion>

<Accordion title="C# code">
  ```csharp theme={null}
  FREngine.IEngine engine;
  FREngine.IFRDocument frdoc;
  ...
  // Create a DocumentProcessingParams object
  FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
  // Specify the recognition language
  dpp.PageProcessingParams.RecognizerParams.SetPredefinedTextLanguage( "Japanese" );
  // Select font set
  dpp.SynthesisParamsForDocument.FontSet.SystemFontSet.FontNamesFilter = (int)FREngine.FontNamesFiltersEnum.FNF_Japanese;
  // Recognize and export the document
  frdoc.Process( dpp );
  frdoc.Export( "D:\\Demo.rtf", FREngine.FileExportFormatEnum.FEF_RTF, null );
  ...
  ```
</Accordion>

## See also

[Working with Languages](/fine-reader/engine/guided-tour/advanced-techniques/working-with-languages)