source: other-projects/the-macronizer/trunk/src/java/monogram/restorer/MonogramRestorer.java@ 30062

/*
 * This class dose all the hard work. I will look up the input token in the MonogramModel and return.
 */
package monogram.restorer;

import monogram.model.MonogramFactory;
import monogram.model.MonogramModel;
import monogram.model.ListModel;
import util.StringUtil;
import web.servlets.DirectInput;

/**
* @author University of Waikato - Te Whare Wānanga o Waikato
 * @version 1.0
 * @since   2014-11-20 
 */
public class MonogramRestorer {

    private boolean preserveMacrons;
    private MonogramModel macronModel;
    private MonogramModel doubleVowelModel;
    private ListModel blackListModel;
   
    private String previousToken;
    private String currentToken;
    private Selector selector;

    public MonogramRestorer(boolean preserveMacrons) {
        this.preserveMacrons = preserveMacrons;
        macronModel = MonogramFactory.getMacronModel();
        doubleVowelModel = MonogramFactory.getDoubleVowelModel();
    blackListModel = MonogramFactory.getBlackList();
        previousToken = "";
        selector = new Selector(3);
    }

    public String restore(String token) {
        
        // Test to see if it should preserve the macrons already in the input texts. If not remove all macrons.
        if (!preserveMacrons && StringUtil.containsAccents(token)) {
            token = StringUtil.removeAccents(token);
        }
        
        
        // Make lower case copy of token.
        final String tokenLowerCase = token.toLowerCase();
        
        String restoredToken = token;
        //If the word is in the black list return the token with no macron.
if(blackListModel.contains(token)){return restoredToken;}
        // Is selector > 0 it is on a sequence
        if (selector.isMacronTokenSequence()) {
            if (restoreByMacronModel(tokenLowerCase)) {
                
                //Restore capitalization
                restoredToken = StringUtil.copyCapitalization(token, currentToken);
                // If restoredToken is not the same as token then macron/s have been add so add <mark> html. This is the yellow background around the words on the front end.  
                if(!restoredToken.equals(token)){
                     // only add <mark> html tag if it directinput and not being output to a file.
                    if(DirectInput.DI){restoredToken = "<mark>"+restoredToken+"</mark> ";}
                }
                
                //if the tonken can not be restored by the MacronModel try and restor it with the DoubleVowelModel.
            } else if (restoreByDoubleVowelModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyDVowelCapitalization(token, currentToken);
            } else {
                currentToken = tokenLowerCase;
            }
        } 
        // else if it is not in a sequence
        else {
            // Try and restor it with the DoubleVowelModel
            if (restoreByDoubleVowelModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyDVowelCapitalization(token, currentToken);
            } 
            // try and restor it with the MacronModel
            else if (restoreByMacronModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyCapitalization(token, currentToken);
            } 
            // Dose not need to be restored
            else {
                currentToken = tokenLowerCase;
            }
        }
        previousToken = currentToken;
        return restoredToken;
    }

    // trys to restore by using the MacronModel and return boolean if it has. 
    private boolean restoreByMacronModel(String token) {
        
        // Test to see if token is in the Distinct Transformation hashset. 
        if (macronModel.isDistinctTransformation(token)) {
            //if token is in Distinct Transformation hashset make the distinct ransformation then move along the sequence.
            currentToken = macronModel.getDistinctTransformation(token);
            selector.incrementMacronTokenSequence();
            return true;
        } 
        // If token is in Indistinct Transformation hashset 
        else if (macronModel.isIndistinctTransformation(token)) {
            final String[] transformations = macronModel.getIndistinctTransformation(token);
            double maxProbability = Double.MIN_VALUE;
            String maxToken = token;
            // loops all transformation and finds the one with the highest probability given the previous token.
            for (String transformation : transformations) {
                //double probability = macronModel.getIndistinctProbability(transformation);
                double probability = 1.0;
                //if macron model has a probability for this transformation then get its probability.
                if (macronModel.containsMonogramProbability(transformation, previousToken)) {
                    probability *= macronModel.getMonogramProbability(transformation, previousToken);
                }
                
                // if transformation not in macron model then try and find probability in Indistinct probability
                if (probability == 1.0) {
                    probability = macronModel.getIndistinctProbability(transformation);
                }
                
                //If probability is better then any before it update maxProbability and maxToken.
                if (probability >= maxProbability) {
                    maxProbability = probability;
                    maxToken = transformation;
                }
            }
            currentToken = maxToken;
            selector.incrementMacronTokenSequence();
            return true;
        }
        return false;
    }

    private boolean restoreByDoubleVowelModel(String token) {
        if (doubleVowelModel.isDistinctTransformation(token)) {
            try {
                currentToken = doubleVowelModel.getDistinctTransformation(token);
                selector.incrementDoubleVowelTokenSequence();
                return true;
            } catch (Exception e) {
                System.err.println("double vowel error 1");
                System.exit(0);
            }
        } else if (doubleVowelModel.isIndistinctTransformation(token)) {
            String[] transformations = doubleVowelModel.getIndistinctTransformation(token);
            Double maxProbability = Double.MIN_VALUE;
            String maxToken = token;
            for (String transformation : transformations) {
                //double probability = doubleVowelModel.getIndistinctProbability(transformation);

                double probability = 1.0;
                if (doubleVowelModel.containsMonogramProbability(transformation, previousToken)) {
                    probability *= doubleVowelModel.getMonogramProbability(transformation, previousToken);
                }
                if (probability == 1.0) {
                    probability = doubleVowelModel.getIndistinctProbability(transformation);
                }
                if (probability >= maxProbability) {
                    maxProbability = probability;
                    maxToken = transformation;
                }
            }
            currentToken = maxToken;
            selector.incrementDoubleVowelTokenSequence();
            return true;
        }
        return false;
    }

    private class Selector {

        private int max;
        private int current;

        public Selector(int max) {
            this.max = max;
            current = max;
        }

        public void incrementMacronTokenSequence() {
            if (current < max) {
                current++;
            }
        }

        public void incrementDoubleVowelTokenSequence() {
            if (current > 0) {
                current--;
            }
        }

        public boolean isMacronTokenSequence() {
            return current > 0;
        }

        public boolean isDoubleVowelTokenSequence() {
            return current == 0;
        }
    }
}