Chinese Script Converter (CSC)

Codepoint Conversion: Codepoint conversion uses a mapping table to convert characters on a codepoint-by-codepoint basis. For example, the simplified form 头发 might be converted to a traditional form by first mapping 头 to 頭, and then 发 to either 髮 or 發. Using this approach, however, there is no recognition that 头发 is a word, so the choice could be 發, in which case the end result 頭發 is nonsense. On the other hand, the choice of 髮 leads to errors for other words. So while conversion mapping is straightforward, it is unreliable.

Orthographic Conversion: The second level of conversion is orthographic. This level relies upon identification of the words in the input text. Within each word, orthographic variants of each character may be reflected in the conversion. In the above example, 头发 is identified as a word and is converted to a traditional variant of the word, 頭髮. There is no basis for converting it to 頭發, because the conversion considers the word as a whole rather than as a collection of individual characters.

Lexemic Conversion: The third level of conversion is lexemic. This level also relies upon identification of words. But rather than converting a word to an orthographic variant, the aim here is to convert it to an entirely different word. For example, "computer" is usually 计算机 in SC but 電腦 in TC. Whereas codepoint conversion is strictly character-by-character and orthographic conversion is character-by-character within a word, lexemic conversion is word-by-word.

Create a BaseLinguisticsFactory and set the required options.

final BaseLinguisticsFactory factory = new BaseLinguisticsFactory();
factory.setOption(BaseLinguisticsOption.rootDirectory, rootDirectory);
factory.setOption(BaseLinguisticsOption.licensePath, licensePath);
factory.setOption(BaseLinguisticsOption.conversionLevel, CSConversionLevel.orthographic.levelName());
factory.setOption(BaseLinguisticsOption.language, LanguageCode.SIMPLIFIED_CHINESE.ISO639_3());
factory.setOption(BaseLinguisticsOption.targetLanguage, LanguageCode.TRADITIONAL_CHINESE.ISO639_3());

Create an annotator to get translations.

final EnumMap<BaseLinguisticsOption, String> options = new EnumMap<>(BaseLinguisticsOption.class);
options.put(BaseLinguisticsOption.language, LanguageCode.SIMPLIFIED_CHINESE.ISO639_3());
options.put(BaseLinguisticsOption.targetLanguage, LanguageCode.TRADITIONAL_CHINESE.ISO639_3());
final Annotator cscAnnotator = factory.createCSCAnnotator(options);

Annotate the input text for tokens and translations.

final AnnotatedText annotatedText = cscAnnotator.annotate(inputText);
final Iterator<Token> tokenIterator = annotatedText.getTokens().iterator();
for (final String translation : annotatedText.getTranslatedTokens().get(0).getTranslations()) {  
    final String originalToken = tokenIterator.hasNext() ? tokenIterator.next().getText() : "";
    outputData.format(OUTPUT_FORMAT, originalToken, translation);       
}

Set up a BaseLinguisticsFactory.

BaseLinguisticsFactory factory = new BaseLinguisticsFactory();
factory.setOption(BaseLinguisticsOption.rootDirectory, rootDirectory);
factory.setOption(BaseLinguisticsOption.licensePath, licensePath);

Use the BaseLinguisticsFactory to create a Tokenizer to tokenize Chinese text.

Tokenizer tokenizer = factory.create(new StringReader(tcInput), LanguageCode.CHINESE);

Use the BaseLinguisticsFactory to create a CSCAnalyzer to convert from TC to SC.

CSCAnalyzer cscAnalyzer =
   factory.createCSCAnalyzer(LanguageCode.TRADITIONAL_CHINESE, LanguageCode.SIMPLIFIED_CHINESE);

Use the CSCAnalyzer to analyze each Token found by the Tokenizer.

Token token;
while ((token = tokenizer.next()) != null) {
    String tokenIn = new String(token.getSurfaceChars(),
        token.getSurfaceStart(),
        token.getLength());
    System.out.println("Input: " + tokenIn);
    cscAnalyzer.analyze(token);

Get the conversion (SC or TC) from each Token.

System.out.println("SC translation: " + token.getTranslation());