import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
private TaggedFileRecord(String file, Format format, 
                         String encoding, String tagSeparator,
                         TreeTransformer treeTransformer,
                         TreeNormalizer treeNormalizer,
                         NumberRangesFileFilter treeRange,
                         Filter<Tree> treeFilter,
                         Integer wordColumn, Integer tagColumn) {
  this.file = file;
  this.format = format;
  this.encoding = encoding;
  this.tagSeparator = tagSeparator;
  this.treeTransformer = treeTransformer;
  this.treeNormalizer = treeNormalizer;
  this.treeRange = treeRange;
  this.treeFilter = treeFilter;
  this.wordColumn = wordColumn;
  this.tagColumn = tagColumn;
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
private TaggedFileRecord(String file, Format format,
                         String encoding, String tagSeparator,
                         TreeTransformer treeTransformer,
                         TreeNormalizer treeNormalizer,
                         NumberRangesFileFilter treeRange,
                         Filter<Tree> treeFilter,
                         Integer wordColumn, Integer tagColumn) {
  this.file = file;
  this.format = format;
  this.encoding = encoding;
  this.tagSeparator = tagSeparator;
  this.treeTransformer = treeTransformer;
  this.treeNormalizer = treeNormalizer;
  this.treeRange = treeRange;
  this.treeFilter = treeFilter;
  this.wordColumn = wordColumn;
  this.tagColumn = tagColumn;
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
/**
 * Build a CTBErrorCorrectingTreeNormalizer.
 *
 * @param splitNPTMP Temporal annotation on NPs
 * @param splitPPTMP Temporal annotation on PPs
 * @param splitXPTMP Temporal annotation on any phrase marked in CTB
 * @param charTags Whether you wish to push POS tags down on to the
 *           characters of a word (for unsegmented text)
 */
public CTBErrorCorrectingTreeNormalizer(boolean splitNPTMP, boolean splitPPTMP, boolean splitXPTMP, boolean charTags) {
  this.splitNPTMP = splitNPTMP;
  this.splitPPTMP = splitPPTMP;
  this.splitXPTMP = splitXPTMP;
  if (charTags) {
    try {
      tagExtender = (TreeTransformer) Class.forName("edu.stanford.nlp.trees.international.pennchinese.CharacterLevelTagExtender").newInstance();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
/**
 * returns a NegraPennCollinizer
 */
@Override
public TreeTransformer collinizer() {
  return new NegraPennCollinizer(this);
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
/**
 * returns a NegraPennCollinizer
 */
@Override
public TreeTransformer collinizerEvalb() {
  return new NegraPennCollinizer(this, false);
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
public NodePruner(ExhaustivePCFGParser parser, TreeTransformer debinarizer) {
  this.parser = parser;
  this.debinarizer = debinarizer;
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
/**
 * Execute with no arguments for usage.
 */
public static void main(String[] args) {

  if(!validateCommandLine(args)) {
    System.err.println(usage);
    System.exit(-1);
  }

  final TreebankLangParserParams tlpp = Languages.getLanguageParams(LANGUAGE);
  final PrintWriter pwOut = tlpp.pw();

  final Treebank guessTreebank = tlpp.diskTreebank();
  guessTreebank.loadPath(guessFile);
  pwOut.println("GUESS TREEBANK:");
  pwOut.println(guessTreebank.textualSummary());

  final Treebank goldTreebank = tlpp.diskTreebank();
  goldTreebank.loadPath(goldFile);
  pwOut.println("GOLD TREEBANK:");
  pwOut.println(goldTreebank.textualSummary());

  final LeafAncestorEval metric = new LeafAncestorEval("LeafAncestor");

  final TreeTransformer tc = tlpp.collinizer();

  //The evalb ref implementation assigns status for each tree pair as follows:
  //
  //   0 - Ok (yields match)
  //   1 - length mismatch
  //   2 - null parse e.g. (()).
  //
  //In the cases of 1,2, evalb does not include the tree pair in the LP/LR computation.
  final Iterator<Tree> goldItr = goldTreebank.iterator();
  final Iterator<Tree> guessItr = guessTreebank.iterator();
  int goldLineId = 0;
  int guessLineId = 0;
  int skippedGuessTrees = 0;
  while( guessItr.hasNext() && goldItr.hasNext() ) {
    Tree guessTree = guessItr.next();
    List<Label> guessYield = guessTree.yield();
    guessLineId++;

    Tree goldTree = goldItr.next();
    List<Label> goldYield = goldTree.yield();
    goldLineId++;

    // Check that we should evaluate this tree
    if(goldYield.size() > MAX_GOLD_YIELD) {
      skippedGuessTrees++;
      continue;
    }

    // Only trees with equal yields can be evaluated
    if(goldYield.size() != guessYield.size()) {
      pwOut.printf("Yield mismatch gold: %d tokens vs. guess: %d tokens (lines: gold %d guess %d)%n", goldYield.size(), guessYield.size(), goldLineId, guessLineId);
      skippedGuessTrees++;
      continue;
    }
    
    final Tree evalGuess = tc.transformTree(guessTree);
    final Tree evalGold = tc.transformTree(goldTree);

    metric.evaluate(evalGuess, evalGold, ((VERBOSE) ? pwOut : null));
  }
  
  if(guessItr.hasNext() || goldItr.hasNext()) {
    System.err.printf("Guess/gold files do not have equal lengths (guess: %d gold: %d)%n.", guessLineId, goldLineId);
  }
  
  pwOut.println("================================================================================");
  if(skippedGuessTrees != 0) pwOut.printf("%s %d guess trees\n", "Unable to evaluate", skippedGuessTrees);
  metric.display(true, pwOut);
  pwOut.close();
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
@Override
public TreeTransformer collinizer() {
  return new TreeCollinizer(treebankLanguagePack());
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
@Override
public TreeTransformer collinizerEvalb() {
  return new TreeCollinizer(treebankLanguagePack(),collinizerRetainsPunctuation,false);
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
@Override
public TreeTransformer collinizer() {
  return new TreeCollinizer(tlp, true, false);
}
 

import edu.stanford.nlp.trees.TreeTransformer; //导入依赖的package包/类
/**
 * Stand-in collinizer does nothing to the tree.
 */
@Override
public TreeTransformer collinizerEvalb() {
  return collinizer();
}