Parser.java

Go to the documentation of this file.

package org.ros.nlp;

import java.io.CharArrayReader;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.util.Collection;
import java.util.List;

import org.apache.commons.logging.Log;
import org.ros.node.DefaultNodeFactory;
import org.ros.message.MessageListener;
import org.ros.node.Node;
import org.ros.node.NodeConfiguration;
import org.ros.node.NodeMain;
import org.ros.node.topic.Publisher;
import org.ros.message.stanford_parser_msgs.Dependency;
import org.ros.message.stanford_parser_msgs.Parse;
import org.ros.message.stanford_parser_msgs.SquashedParseTreeNode;

import edu.stanford.nlp.ling.HasWord;
import edu.stanford.nlp.parser.lexparser.LexicalizedParser;
import edu.stanford.nlp.process.Tokenizer;
import edu.stanford.nlp.trees.EnglishGrammaticalStructure;
import edu.stanford.nlp.trees.GrammaticalRelation;
import edu.stanford.nlp.trees.PennTreebankLanguagePack;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.trees.TreebankLanguagePack;
import edu.stanford.nlp.trees.TreeGraphNode;
import edu.stanford.nlp.trees.TypedDependency;



public class Parser implements NodeMain {



    private LexicalizedParser lp;
    private Publisher<Parse> publisher;



    private MessageListener<org.ros.message.std_msgs.String> text_callback =
        new MessageListener<org.ros.message.std_msgs.String>() {
        @Override
        public void onNewMessage(org.ros.message.std_msgs.String message) {
            // Get data needed to form message
            // - Parse tree
            String text = message.data;
            CharArrayReader reader = new CharArrayReader(text.toCharArray());
            TreebankLanguagePack tlp = new PennTreebankLanguagePack();
            Tokenizer<? extends HasWord> toke = tlp.getTokenizerFactory().getTokenizer(reader);
            List<? extends HasWord> wordList = toke.tokenize(); // Part of this is taken stanford_parser's example code
            Tree parse = null;
            if (lp.parse(wordList)) {
                parse = lp.getBestParse();
            }

            // - Dependencies
            EnglishGrammaticalStructure egs = new EnglishGrammaticalStructure(parse);
            // vv todo use typedDependenciesCCprocessed(true)?  (see GrammaticalStructure.java:513)
            //      it doesn't seem to matter much from:
            //      https://mailman.stanford.edu/pipermail/java-nlp-user/2010-May/000408.html
            Collection<TypedDependency> collapsed = egs.typedDependenciesCollapsedTree();

            // Form message
            // - Parse tree (squashed)
            System.out.println(parse.toString());
            Parse p = squashParseTree(parse);
            // - Dependencies
            for(TypedDependency td : collapsed) {
                System.out.println(td.toString());
                GrammaticalRelation relation = td.reln();
                TreeGraphNode governor = td.gov();
                TreeGraphNode dependent = td.dep();
                Dependency dependency = new Dependency();
                // Follow the toString() method of GrammaticalRelation to
                //   get the seen/"correct" name for each dependency.
                String shortName = relation.getShortName();
                String specific = relation.getSpecific();
                if(specific == null) {
                    dependency.relation = shortName;
                }
                else {
                    dependency.relation = shortName + '_' + specific;
                }
                // Word indices start at 0 in message arrays,
                //    1 in the Stanford parser arrays.
                dependency.governor_index = governor.index() - 1;
                dependency.dependent_index = dependent.index() - 1;
                p.dependencies.add(dependency);
            }

            publisher.publish(p);
        }
    };



    private Parse squashParseTree(Tree tree) {
        Parse p = new Parse();
        squashParseTreeRecursive(tree, -1, p);
        return p;
    }



    private void squashParseTreeRecursive(Tree tree, int parentNodeIndex, Parse p) {
        // First, we add the root of the tree.
        int in = p.nodes.size(); // Index of added node
        SquashedParseTreeNode sptn = new SquashedParseTreeNode();
        // - tag
        String tag = tree.value();
        try {
            sptn.tag = lookupTagInt(tag);
        }
        catch(Exception e) {
            // Tag not found.  Add to tags[] and reference that.
            int it = p.tags.size();
            p.tags.add(tag);
            sptn.tag = it;
        }
        // - parent_id
        sptn.parent_id = parentNodeIndex;
        // - score
        sptn.score = tree.score();
        // - word
        boolean atWord = tree.isPreTerminal(); // The child is a word; this is the label for that word.
        if(atWord) {
            int iw = p.words.size(); // Index of added word
            p.words.add(tree.firstChild().value());
            sptn.word_index = iw;
        }
        else {
            sptn.word_index = -1; // None, since we're not at a word.
        }
        p.nodes.add(sptn);

        // Then, we add children, if any
        if(!atWord) {
            for(int i=0; i<tree.numChildren(); i++) {
                squashParseTreeRecursive(tree.getChild(i), in, p);
            }
        }
    }



    private int lookupTagInt(String s) throws Exception {
        // Sanitize: '-' -> '_', '$' -> '_S'
        String s2 = new String(s);
        s2.replace('-', '_').replace("$", "_S");
        // Lookup corresponding field in the SquashedParseTreeNode class.
        //   (msg constants are stored as static public final ints.)
        return SquashedParseTreeNode.class.getField(s2).getInt(null);
    }



    @Override
        public void main(NodeConfiguration configuration) {
        Node node = null;
        Log log = null;
        try {
            // Init Stanford Parser
            InputStream is = Parser.class.getResourceAsStream("englishPCFG.ser");
            ObjectInputStream ois = new ObjectInputStream(is);
            lp = new LexicalizedParser(ois);

            // Init ROS
            node = new DefaultNodeFactory().newNode("stanford_parser_ros", configuration);
            log = node.getLog();
            publisher = node.newPublisher("parse", "stanford_parser_msgs/Parse");
            node.newSubscriber("text", "std_msgs/String", text_callback);
        }
        catch (Exception e) {
            if (node != null) {
                log.fatal(e);
            }
            e.printStackTrace();
            return;
        }
    }



    @Override
        public void shutdown() {
        return; // Nothing to do here...
    }
}