ParseUtils (illinois-cogcomp-nlp 3.1.29 API)

java.lang.Object
- edu.illinois.cs.cogcomp.nlp.utilities.ParseUtils

```
public class ParseUtils
extends Object
```
This class contains utility functions for manipulating parse trees.

Author:

Vivek Srikumar

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`PATH_DOWN_STRING` This string indicates a path going down a parse tree in the path string.
`static String`	`PATH_UP_STRING` This string indicates a path going up a parse tree in the path string.

Constructor Summary

Constructors
Constructor and Description

ParseUtils()

Constructors
Constructor and Description
`ParseUtils()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static String`	`convertBracketsFromPTBFormat(String sentence)` Convert brackets from the Penn treebank format (which uses strings like -LRB-, -RRB-, etc to denote '(', ')', etc.) to readable tokens.
`static String`	`convertBracketsToPTBFormat(String sentence)` Convert brackets from readable forms to the Penn treebank format (which uses strings like -LRB-, -RRB-, etc to denote '(', ')', etc.)
`static String[]`	`getAllPhraseSiblingLabels(String parseViewName, Constituent constituent)` Get the labels of all the siblings of the parse tree node that covers the input constituent.
`static String[]`	`getAllSiblingLabels(Tree<String> node)` Get the labels of all siblings of a given tree node.
`static <T> Tree<T>`	`getCommonAncestor(Tree<T> t1, Tree<T> t2, Tree<T> tree)` Deprecated.
`static int`	`getHeadWordPosition(Constituent c, HeadFinderBase headFinder, String parseViewName)` Get the head word of a constituent using the `HeadFinderBase` that is passed as an argument.
`static Tree<String>`	`getParseTree(String parseViewName, Sentence s)` Get the parse tree of a sentence.
`static Tree<String>`	`getParseTree(String parseViewName, TextAnnotation ta, int sentenceId)` Get the parse tree of the `sentenceId`th sentence from the text annotation.
`static Tree<String>`	`getParseTree(TextAnnotation ta, int sentenceId)` Deprecated.
`static Tree<String>`	`getParseTreeCovering(String parseViewName, Constituent c)` Get a parse tree from a text annotation that covers the specified constituent.
`static <T> Pair<List<Tree<T>>,List<Tree<T>>>`	`getPath(Tree<T> start, Tree<T> end, Tree<T> tree, int maxDepth)` Deprecated.
`static <T> String`	`getPathString(Tree<T> start, Tree<T> end, Tree<T> tree, int maxDepth)` Deprecated.
`static <T> String`	`getPathStringIgnoreLexicalItems(Tree<T> start, Tree<T> end, Tree<T> tree, int maxDepth)` Deprecated.
`static <T> String`	`getPathStringToCommonAncestor(Tree<T> start, Tree<T> end, Tree<T> tree, int maxDepth)` Deprecated.
`static <T> List<T>`	`getPathToRoot(Tree<T> tree, Tree<T> leaf, int maxDepth)` Deprecated.
`static <T> List<Tree<T>>`	`getPathTreesToRoot(Tree<T> tree, Tree<T> node, int maxDepth)` Deprecated.
`static Constituent`	`getPhraseFromHead(Constituent predicate, Constituent argHead, String parseViewName)` Primarily a fix for prepSRL objects; converts them from single head words to constituents.
`static String`	`getSentenceFromTree(Tree<String> tree)` Gets the terminal string from the parse tree.
`static Tree<Pair<String,IntPair>>`	`getSpanLabeledTree(Tree<String> parseTree)` Transforms a parse tree into a new tree where each node is labeled by the span it covers in addition to the label of that node from the original parse tree.
`static String`	`getSubcatFrame(Tree<String> yieldNode)` Assuming that the tree comes with lexical items and POS tags, the subcat frame for the verb can be found by going to the parent of the POS tag (which is probably a VP) and listing its children.
`static String`	`getTerminalString(Tree<String> tree)`
`static String[]`	`getTerminalStringSentence(Tree<String> tree)`
`static List<String>`	`getTerminalTokens(Tree<String> tree)`
`static Tree<Pair<String,IntPair>>`	`getTokenIndexedCleanedParseTreeNodeCovering(Constituent c, String parseViewName)`
`static Tree<Pair<String,IntPair>>`	`getTokenIndexedParseTreeNodeCovering(String parseViewName, Constituent c)`
`static Tree<Pair<String,IntPair>>`	`getTokenIndexedTreeCovering(Tree<String> parse, int start, int end)` From a parse tree and a span that is specified with the start and end (exclusive), this function returns a tree that corresponds to the subtree that covers the span.
`static Tree<String>`	`getTreeCovering(Tree<String> parse, int start, int end)`
`static Tree<String>`	`snipNullNodes(Tree<String> tree)` Removes subtrees labeled with the null label (-NONE-) and returns a new tree
`static String`	`stripFunctionTags(String label)` Strips function tags from a given node label.
`static Tree<String>`	`stripFunctionTags(Tree<String> tree)` Strips function tags from a tree and returns a new tree.
`static String`	`stripIndexReferences(String label)`
`static Tree<String>`	`stripIndexReferences(Tree<String> tree)` Removes index information in the parse tree to other nodes.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PATH_UP_STRING
```
public static final String PATH_UP_STRING
```
    This string indicates a path going up a parse tree in the path string.
    
    See Also:
    
    Constant Field Values
  - PATH_DOWN_STRING
```
public static final String PATH_DOWN_STRING
```
    This string indicates a path going down a parse tree in the path string.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ParseUtils
```
public ParseUtils()
```
- Method Detail
  - convertBracketsFromPTBFormat
```
public static String convertBracketsFromPTBFormat(String sentence)
```
    Convert brackets from the Penn treebank format (which uses strings like -LRB-, -RRB-, etc to denote '(', ')', etc.) to readable tokens.
    
    Parameters:
    
    sentence - A sentence which is to be converted
    
    Returns:
    
    A new sentence.
  - convertBracketsToPTBFormat
```
public static String convertBracketsToPTBFormat(String sentence)
```
    Convert brackets from readable forms to the Penn treebank format (which uses strings like -LRB-, -RRB-, etc to denote '(', ')', etc.)
    
    Parameters:
    
    sentence - A sentence which is to be converted
    
    Returns:
    
    A new sentence.
  - getSpanLabeledTree
```
public static Tree<Pair<String,IntPair>> getSpanLabeledTree(Tree<String> parseTree)
```
    Transforms a parse tree into a new tree where each node is labeled by the span it covers in addition to the label of that node from the original parse tree.
    For example, consider the following input tree:
```
 (S1 (S (NP (DT The)
            (NN bird))
        (VP (VBD flew)))
        (. .))
 
```
    This is transformed as follows:
```
 ([S1,[0,4]] ([S,[0,4]] ([NP,[0,2]] ([DT,[0,1]] [The,<0,1]])
                                    ([NN,[1,2]] [bird,[1,2]]))
                        ([VP,[2,3]] ([VBD,[2,3]] [flew,[2,3]]))
                        ([.,[3,4]] [.,[3,4]])))
 
```
    Here, the notation [.,.] is used to denote a Pair object. That is, the node labeled [NP,[0,2]] indicates that the corresponding node in the parse tree is labeled NP and that NP spans the tokens ranging from 0 to 2 (exclusive.)
    Parameters:
    
    parseTree - The parse tree to be annotated with the spans
    
    Returns:
    
    A new tree where each node is the Pair of the original node's label and the span that the node covers.
  - snipNullNodes
```
public static Tree<String> snipNullNodes(Tree<String> tree)
```
    Removes subtrees labeled with the null label (-NONE-) and returns a new tree
    
    Parameters:
    
    tree - A parse tree, possibly containing null labels
    
    Returns:
    
    A new parse tree where subtrees with the null label are removed
  - stripFunctionTags
```
public static String stripFunctionTags(String label)
```
    Strips function tags from a given node label. This function assumes that everything that comes before the first hyphen is useful and returns that.
    
    Parameters:
    
    label - A node label
    
    Returns:
    
    The node label without function tags
  - stripFunctionTags
```
public static Tree<String> stripFunctionTags(Tree<String> tree)
```
    Strips function tags from a tree and returns a new tree.
    
    Parameters:
    
    tree - A parse tree
    
    Returns:
    
    A parse tree without any function tags
  - stripIndexReferences
```
public static Tree<String> stripIndexReferences(Tree<String> tree)
```
    Removes index information in the parse tree to other nodes. That is, for nodes of the form "X=1", it converts it to just "X".
    
    Parameters:
    
    tree - A parse tree
    
    Returns:
    
    A new tree where the index information is removed.
  - getSentenceFromTree
```
public static String getSentenceFromTree(Tree<String> tree)
```
    Gets the terminal string from the parse tree. The tokens in the output are separated by spaces.
    
    Parameters:
    
    tree - The parse tree, where the leaf nodes are the terminals we care about
    
    Returns:
    
    The terminal string
  - stripIndexReferences
```
public static String stripIndexReferences(String label)
```
  - getAllPhraseSiblingLabels
```
public static String[] getAllPhraseSiblingLabels(String parseViewName,
                                                 Constituent constituent)
```
    Get the labels of all the siblings of the parse tree node that covers the input constituent. Note that the input constituent could be from any view. The output includes the phrase label of this constituent too.
    
    Parameters:
    
    parseViewName - The name of the parse view. This might typically be one of ViewNames.PARSE_CHARNIAK or ViewNames.PARSE_STANFORD
    
    constituent - The constituent whose sibling phrases are required.
    
    Returns:
    
    An array of strings. If the input constituent is the entire sentence, then an array of size zero is returned to indicate that the corresponding parse tree node does not have any siblings.
  - getAllSiblingLabels
```
public static String[] getAllSiblingLabels(Tree<String> node)
```
    Get the labels of all siblings of a given tree node.
    
    Parameters:
    
    node - The node whose siblings are required.
    
    Returns:
    
    The labels of the siblings of the input node, as an array of strings. If the input is the root of the tree, then a string array of size zero is returned to indicate that the corresponding parse tree node does not have any siblings.
  - getCommonAncestor
```
@Deprecated
public static <T> Tree<T> getCommonAncestor(Tree<T> t1,
                                                        Tree<T> t2,
                                                        Tree<T> tree)
                                                 throws Exception
```
    Deprecated.
    
    Finds a common ancestor of two trees which are both contained in a larger tree. This searches the path from the head of the trees to the root of the trees till it finds a common node. If none is found, then the function returns null.
    
    Parameters:
    
    t1 - The first tree
    
    t2 - The second tree
    
    tree - The tree that contains t1 and t2.
    
    Returns:
    
    The tree that is the common ancestor of t1 and t2 . If none is found, then the function returns null.
    
    Throws:
    
    Exception
  - getParseTree
```
public static Tree<String> getParseTree(String parseViewName,
                                        Sentence s)
```
    Get the parse tree of a sentence. This code assumes that the view called parseViewName exists in the text annotation.
    
    Parameters:
    
    parseViewName - The name of the parse view
    
    s - The sentence
    
    Returns:
    
    The parse tree of the sentence
  - getParseTree
```
public static Tree<String> getParseTree(String parseViewName,
                                        TextAnnotation ta,
                                        int sentenceId)
```
    Get the parse tree of the sentenceIdth sentence from the text annotation. This code assumes that the view called parseViewName exists in the text annotation.
    
    Parameters:
    
    parseViewName - The name of the parse view
    
    ta - The text annotation object
    
    sentenceId - The sentence whose parse tree is required
    
    Returns:
    
    The parse tree of the sentenceIdth sentence
  - getParseTree
```
@Deprecated
public static Tree<String> getParseTree(TextAnnotation ta,
                                                    int sentenceId)
```
    Deprecated.
    
    Get the Charniak parse tree of the sentenceIdth sentence from the text annotation. This code assumes that the view called ViewNames.PARSE_CHARNIAK exists in the text annotation.
    
    Parameters:
    
    ta - The text annotation object
    
    sentenceId - The sentence whose parse tree is required
    
    Returns:
    
    The parse tree of the sentenceIdth sentence
  - getParseTreeCovering
```
public static Tree<String> getParseTreeCovering(String parseViewName,
                                                Constituent c)
```
    Get a parse tree from a text annotation that covers the specified constituent.
    
    Parameters:
    
    parseViewName - The name of the parse view
    
    c - The constituent that we care about
    
    Returns:
    
    The portion of the parse tree of the TextAnnotation to which the constituent belongs which covers the constituent.
  - getPath
```
@Deprecated
public static <T> Pair<List<Tree<T>>,List<Tree<T>>> getPath(Tree<T> start,
                                                                        Tree<T> end,
                                                                        Tree<T> tree,
                                                                        int maxDepth)
                                                                 throws Exception
```
    Deprecated.
    
    Returns a pair of paths. The first element of the pair is the path up from the start node to the common ancestor of start and end. The second element is the path down from the common ancestor to the end node.
    
    Throws:
    
    Exception
  - getPathString
```
@Deprecated
public static <T> String getPathString(Tree<T> start,
                                                   Tree<T> end,
                                                   Tree<T> tree,
                                                   int maxDepth)
                                            throws Exception
```
    Deprecated.
    
    Get a string representing the path between trees start and end that belong to the tree tree
    
    Throws:
    
    Exception
  - getPathStringIgnoreLexicalItems
```
@Deprecated
public static <T> String getPathStringIgnoreLexicalItems(Tree<T> start,
                                                                     Tree<T> end,
                                                                     Tree<T> tree,
                                                                     int maxDepth)
                                                              throws Exception
```
    Deprecated.
    
    Throws:
    
    Exception
  - getPathStringToCommonAncestor
```
@Deprecated
public static <T> String getPathStringToCommonAncestor(Tree<T> start,
                                                                   Tree<T> end,
                                                                   Tree<T> tree,
                                                                   int maxDepth)
                                                            throws Exception
```
    Deprecated.
    
    Throws:
    
    Exception
  - getPathToRoot
```
@Deprecated
public static <T> List<T> getPathToRoot(Tree<T> tree,
                                                    Tree<T> leaf,
                                                    int maxDepth)
                                             throws Exception
```
    Deprecated.
    
    Throws:
    
    Exception
  - getPathTreesToRoot
```
@Deprecated
public static <T> List<Tree<T>> getPathTreesToRoot(Tree<T> tree,
                                                               Tree<T> node,
                                                               int maxDepth)
                                                        throws Exception
```
    Deprecated.
    
    This function returns a list of trees from a node in the tree to the root. If the node is deeper than maxdepth, then the bottom maxDepth nodes are returned.
    
    Throws:
    
    Exception
  - getSubcatFrame
```
public static String getSubcatFrame(Tree<String> yieldNode)
```
    Assuming that the tree comes with lexical items and POS tags, the subcat frame for the verb can be found by going to the parent of the POS tag (which is probably a VP) and listing its children.
  - getTerminalString
```
public static String getTerminalString(Tree<String> tree)
```
  - getTerminalStringSentence
```
public static String[] getTerminalStringSentence(Tree<String> tree)
```
  - getTerminalTokens
```
public static List<String> getTerminalTokens(Tree<String> tree)
```
  - getTokenIndexedCleanedParseTreeNodeCovering
```
public static Tree<Pair<String,IntPair>> getTokenIndexedCleanedParseTreeNodeCovering(Constituent c,
                                                                                     String parseViewName)
```
  - getTokenIndexedParseTreeNodeCovering
```
public static Tree<Pair<String,IntPair>> getTokenIndexedParseTreeNodeCovering(String parseViewName,
                                                                              Constituent c)
```
  - getTokenIndexedTreeCovering
```
public static Tree<Pair<String,IntPair>> getTokenIndexedTreeCovering(Tree<String> parse,
                                                                     int start,
                                                                     int end)
```
    From a parse tree and a span that is specified with the start and end (exclusive), this function returns a tree that corresponds to the subtree that covers the span. Each node in the new tree corresponds to a node in the input tree and is labeled with the label of the original node along with the span that this node covered in the original tree.
    
    Returns:
    
    A new tree that covers the specified span and each node specifies the label and the span of the original tree that it covers.
  - getTreeCovering
```
public static Tree<String> getTreeCovering(Tree<String> parse,
                                           int start,
                                           int end)
```
  - getHeadWordPosition
```
public static int getHeadWordPosition(Constituent c,
                                      HeadFinderBase headFinder,
                                      String parseViewName)
                               throws Exception
```
    Get the head word of a constituent using the HeadFinderBase that is passed as an argument. To use this function, first, a head finder should be created. For example:
```
   TextAnnotation ta = ... // some text annotation
   Constituent c = ... // some constituent
 
   CollinsHeadFinder headFinder = new CollinsHeadFinder();
 
   int headId = ParseHelper.getHeadWordPosition(c, headFinder);
 
   // now we can do other things with the headId.
   String headWord = WordHelpers.getWord(ta, headId);
 
```
    Parameters:
    
    parseViewName - The name of the view which contains the parse trees
    
    c - The constituent whose head we wish to find
    
    headFinder - The head finder
    
    Returns:
    
    The index of the head word..
    
    Throws:
    
    Exception
  - getPhraseFromHead
```
public static Constituent getPhraseFromHead(Constituent predicate,
                                            Constituent argHead,
                                            String parseViewName)
```
    Primarily a fix for prepSRL objects; converts them from single head words to constituents. E.g. for the sentence "the man with the telescope", the object of the preposition will be "the telescope" instead of just "telescope".
    
    Parameters:
    
    predicate - The predicate of the construction (e.g. "with")
    
    argHead - The head-word of the argument of the construction (e.g. "telescope")
    
    parseViewName - The name of the parse view used to extract the phrase-structure tree
    
    Returns:
    
    The full constituent phrase containing the argument head

Class ParseUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PATH_UP_STRING

PATH_DOWN_STRING

Constructor Detail

ParseUtils

Method Detail

convertBracketsFromPTBFormat

convertBracketsToPTBFormat

getSpanLabeledTree

snipNullNodes

stripFunctionTags

stripFunctionTags

stripIndexReferences

getSentenceFromTree

stripIndexReferences

getAllPhraseSiblingLabels

getAllSiblingLabels

getCommonAncestor

getParseTree

getParseTree

getParseTree

getParseTreeCovering

getPath

getPathString

getPathStringIgnoreLexicalItems

getPathStringToCommonAncestor

getPathToRoot

getPathTreesToRoot

getSubcatFrame

getTerminalString

getTerminalStringSentence

getTerminalTokens

getTokenIndexedCleanedParseTreeNodeCovering

getTokenIndexedParseTreeNodeCovering

getTokenIndexedTreeCovering

getTreeCovering

getHeadWordPosition

getPhraseFromHead