import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
@Override
public void process(JCas aJCas)
	throws AnalysisEngineProcessException
{
	for (Token t : select(aJCas, Token.class)) {
		//This corresponds roughly to what is happening in MorphaAnnotator.
		String token = t.getCoveredText();
		String lemma;
		if (t.getPos() != null) {
			lemma = morphology.lemmatize(new WordTag(token, t.getPos().getPosValue()))
					.lemma();
		}
		else {
			lemma = morphology.stem(token);
		}
		if (lemma == null) {
               lemma = token;
           }
		Lemma l = new Lemma(aJCas, t.getBegin(), t.getEnd());
		l.setValue(lemma);
		l.addToIndexes();
		t.setLemma(l);
	}
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
@Override
protected
Set<?> makeObjects(Tree tree) {
  List<TaggedWord> twList;
  if (useTag) {
    twList = myExtractor(tree);
  } else {
    twList = tree.taggedYield();
  }
  Set<Pair<Integer,WordTag>> set = new HashSet<Pair<Integer,WordTag>>();
  for (int i = 0, sz = twList.size(); i < sz; i++) {
    TaggedWord tw = twList.get(i);
    //IntTaggedWord iTW = new IntTaggedWord(Numberer.number("words",tw.word()), Numberer.number("tags",tw.tag()));
    Pair<Integer,WordTag> positionWT = new Pair<Integer,WordTag>(Integer.valueOf(i), new WordTag(tw.value(), tw.tag()));
    //WordTag positionWT = new WordTag(tw.value(),tw.tag());
    //System.out.println(iTW);
    //if (! tw.tag.equals("*"))
    set.add(positionWT);
  }
  if (DEBUG_MORE) System.err.println("Tags: " + set);
  return set;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
public List<WordTag> lemmatizeText(String tokenizedText)
{
	final List<WordTag> lemmatized = new ArrayList<WordTag>();
	final String[] tokens = tokenizedText.split("\\s+");
	
	for (String token : tokens)
	{
		final String lemma = analyzer.stem(token);
		lemmatized.add(new WordTag(token, lemma));
	}
	
	return lemmatized;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
public Object apply(Object in) {
  if (in instanceof WordTag) {
    return stem((WordTag) in);
  }
  if (in instanceof Word) {
    return stem((Word) in);
  }
  return in;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
/**
 * Lemmatize returning a <code>WordLemmaTag </code>.
 */
public WordLemmaTag lemmatize(WordTag wT) {
  String tag = wT.tag();
  String word = wT.word();
  String lemma = stem(wT).word();
  return new WordLemmaTag(word, lemma, tag);
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
/** Run the morphological analyzer.  Options are:
 *  <ul>
 *  <li>-rebuildVerbTable verbTableFile Convert a verb table from a text file
 *  (e.g., /u/nlp/data/morph/verbstem.list) to Java code contained in Morpha.flex .
 *  <li>-stem args ...  Stem each of the following arguments, which should either be
 *  in the form of just word or word/tag.
 *  <li> args ...  Each argument is a file and the contents of it are stemmed as
 *  space-separated tokens.    <i>Note:</i> If the tokens are tagged
 *  words, they must be in the format of whitespace separated word_tag pairs.
 */
public static void main(String[] args) throws IOException {
  if (args.length == 0) {
    System.err.println("java Morphology [-rebuildVerbTable file|-stem word+|file+]");
  } else if (args.length == 2 && args[0].equals("-rebuildVerbTable")) {
    String verbs = IOUtils.slurpFile(args[1]);
    String[] words = verbs.split("\\s+");
    System.out.print(" private static String[] verbStems = new String[] { ");
    for (int i = 0; i < words.length; i++) {
      System.out.print("\"" + words[i] + "\"");
      if (i != words.length - 1) {
        System.out.print(", ");
        if (i % 5 == 0) {
          System.out.println();
          System.out.print("    ");
        }
      }
    }
    System.out.println(" };");
  } else if (args[0].equals("-stem")) {
    for (int i = 1; i < args.length; i++) {
      System.out.println(args[i] + " --> " + stemStatic(WordTag.valueOf(args[i])));
    }
  } else {
    for (String arg :  args) {
      Morphology morph = new Morphology(arg);
      for (Word next; (next = morph.next()) != null; ) {
        System.out.print(next);
        System.out.print(" ");
      }
    }
  }
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
private static String treeAsStemmedCollocation(Tree t, boolean threadSafe) {
  List<WordTag> list= getStemmedWordTagsFromTree(t, threadSafe);
  // err.println(list.size());
  StringBuffer s = new StringBuffer(160);
  WordTag firstWord = list.remove(0);
  s.append(firstWord.word());
  for(WordTag wt : list) {
    s.append("_");
    s.append(wt.word());
  }
  //err.println("Expressing this as:"+s.toString());
  return s.toString();
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
private static String treeAsNonStemmedCollocation(Tree t) {
  List<WordTag> list= getNonStemmedWordTagsFromTree(t);

  StringBuffer s = new StringBuffer(160);
  WordTag firstWord = list.remove(0);
  s.append(firstWord.word());
  for(WordTag wt : list) {
    s.append("_");
    s.append(wt.word());
  }
  return s.toString();
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
/**
 *
 * @param t a tree
 * @return the WordTags corresponding to the leaves of the tree,
 * stemmed according to their POS tags in the tree.
 */
private static List<WordTag> getStemmedWordTagsFromTree(Tree t, boolean threadSafe) {
  List<WordTag> stemmedWordTags = Generics.newArrayList();
  Sentence<TaggedWord> s = t.taggedYield();
  for (TaggedWord w : s) {
    WordTag wt = threadSafe ? Morphology.stemStaticSynchronized(w.word(), w.tag())
            : Morphology.stemStatic(w.word(), w.tag());
    stemmedWordTags.add(wt);
  }
  return stemmedWordTags;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
private static List<WordTag> getNonStemmedWordTagsFromTree(Tree t) {
  List<WordTag> wordTags = Generics.newArrayList();
  Sentence<TaggedWord> s = t.taggedYield();
  for (TaggedWord w : s) {
    WordTag wt = new WordTag(w.word(), w.tag());
    wordTags.add(wt);
  }
  return wordTags;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
private void processTree(Tree t, String tag) {
  if (t.isPreTerminal()) {
    tag = t.label().value();
  }
  if (t.isLeaf()) {
    WordTag wt = morpha.stem(t.label().value(), tag);
    t.label().setValue(wt.word());
  } else {
    for (Tree kid : t.children()) {
      processTree(kid, tag);
    }
  }
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
/**
 *
 * @param t a tree
 * @return the WordTags corresponding to the leaves of the tree,
 * stemmed according to their POS tags in the tree.
 */
private static List<WordTag> getStemmedWordTagsFromTree(Tree t, boolean threadSafe) {
  List<WordTag> stemmedWordTags = Generics.newArrayList();
  ArrayList<TaggedWord> s = t.taggedYield();
  for (TaggedWord w : s) {
    WordTag wt = threadSafe ? Morphology.stemStaticSynchronized(w.word(), w.tag())
            : Morphology.stemStatic(w.word(), w.tag());
    stemmedWordTags.add(wt);
  }
  return stemmedWordTags;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
private static List<WordTag> getNonStemmedWordTagsFromTree(Tree t) {
  List<WordTag> wordTags = Generics.newArrayList();
  ArrayList<TaggedWord> s = t.taggedYield();
  for (TaggedWord w : s) {
    WordTag wt = new WordTag(w.word(), w.tag());
    wordTags.add(wt);
  }
  return wordTags;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
public Object apply(Object in) {
  if (in instanceof WordTag) {
    WordTag wt = (WordTag) in;
    String tag = wt.tag();
    return new WordTag(lemmatize(wt.word(), tag, lexer, lexer.option(1)), tag);
  }
  if (in instanceof Word) {
    return stem((Word) in);
  }
  return in;
}
 

import edu.stanford.nlp.ling.WordTag; //导入依赖的package包/类
/**
 * Lemmatize returning a <code>WordLemmaTag </code>.
 */
public WordLemmaTag lemmatize(WordTag wT) {
  String tag = wT.tag();
  String word = wT.word();
  String lemma = lemma(word, tag);
  return new WordLemmaTag(word, lemma, tag);
}