Java Synset.getPointers方法代码示例

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
/**
   * Get the chain of parents from the given synset to the top of the
   * wordnet hierarchy.  Checks for loops (they exist!).
   * @param synset Child synset of which we want the parent chain.
   * @param history The list of synsets we've already traversed.
   * @return The hypernym chain.
   */
  public List<Synset> hypernymChain(Synset synset, List<Synset> history) {
    List<Synset> chain = new ArrayList<Synset>();

    Pointer[] links = synset.getPointers();
    if( links != null ) {
      for( Pointer link : links ) {
        // HYPERNYM is the type of link in WordNet.  However, they also have an "instance hypernym"
        // which does not have a PointerType type in their API, yet appears in their database.
        // This is a hack that checks the key "@i" is an instance, "@" is standard hypernym.
//        if( link.getType() == PointerType.HYPERNYM ) {
        if( link.getType() != null && link.getType().getKey().charAt(0) == hypernymChar ) {
          try {
            Synset target = link.getTargetSynset();
            if( !history.contains(target) ) {
              history.add(target);
              chain.add(target);
              List<Synset> upperChain = hypernymChain(target, history);
              if( upperChain != null ) chain.addAll(upperChain);
              // ** There's only one parent per synset, right?
              return chain;
            }
            else System.out.println("Wordnet found loop at " + synset + "\nhistory=" + history);
          } catch( Exception ex ) { ex.printStackTrace(); }
        }
      }
    }
    return null;
  }
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
/**
 * @param s
 * @param lookFor 
 * @return
 * @throws JWNLException 
 */
private static boolean canBe(Synset s, List<String> lookFor,LinkedList<Synset> checked) throws JWNLException {
	if(!checked.contains(s)) {
		checked.add(s); //to avoid circles
		for(String lf:lookFor) {
			if(s.containsWord(lf)) {
				return true;
			}
		}
		for(Pointer p:s.getPointers(PointerType.HYPERNYM)) {
			if(canBe(p.getTargetSynset(),lookFor,checked)){
				return true;
			}
		}		
	}
	return false;
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
/**
 * @return True if the synset has a "hypernym instance" link.
 */
public boolean hasHypernymInstance(Synset synset) {
  Pointer[] links = synset.getPointers();
  if( links != null ) {
    for( Pointer link : links )
      if( link.getType().getKey().equals(hypernymInstance) )
        return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if there is some synset with this token that has a 
 *              nominalization relation attached to it.
 */
public boolean isNominalization(String token) {
  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets == null ) {
    //      System.out.println("isNominalization null synsets: " + token);
  }
  else {
    for( Synset synset : synsets ) {
      Pointer[] links = synset.getPointers();
      if( links != null ) {
        for( Pointer link : links ) {
          // Found a link from this noun as a Nominalization to another.
          if( link.getType() == PointerType.NOMINALIZATION ) {
            // Check that the nominalized word is a verb (e.g. not an adjective).
            try {
              Synset target = link.getTargetSynset();
              if( target.getPOS() == POS.VERB ) {
                //		  System.out.println("WordNet isNom() link found: " + link);
                //		  System.out.println(" --> " + link.getTargetSynset());
                return true;
              }
            } catch( Exception ex ) { ex.printStackTrace(); }
          }
        }
      }
    }
  }
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
/**
 * Gets all of the verbs that are in the synset of which the given noun token
 * has a nominalization pointer to.
 * @param token A noun e.g. explosion
 * @return A list of strings that are verbs e.g. explode, detonate
 */
public List<String> getVerbsOfNominalization(String token) {
  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets != null ) {
    for( Synset synset : synsets ) {
      Pointer[] links = synset.getPointers();
      if( links != null ) {
        for( Pointer link : links ) {
          // Found a link from this noun as a Nominalization to another.
          if( link.getType() == PointerType.NOMINALIZATION ) {
            // Check that the nominalized word is a verb (e.g. not an adjective).
            try {
              Synset target = link.getTargetSynset();
              if( target.getPOS() == POS.VERB ) {
                Synset verbSynset = link.getTargetSynset();
                Word[] verbs = verbSynset.getWords();
                List<String> theverbs = new ArrayList<String>();
                for( Word verb : verbs )
                  theverbs.add(verb.getLemma());
                return theverbs;
              }
            } catch( Exception ex ) { ex.printStackTrace(); }
          }
        }
      }
    }
  }
  return null;
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
private static void addAllLemmas(IndexWord _iw,List<String> list) throws JWNLException {
	for(Synset syn:_iw.getSenses()) {
		addLemmas(syn,list);
		Pointer[] _pts = syn.getPointers(PointerType.ANTONYM);					
		for(Pointer p:_pts) {
			addLemmas(p.getTargetSynset(),list);
		}
	}
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
private static boolean checkHypernymTree(IndexWord idw,List<String> wordsToCHeck) throws JWNLException {		
	if(idw != null) {
		//System.out.println("checking senses of: "+_idw.getLemma());
		for(Synset s :idw.getSenses()) {
			//ignore instances!!!
			if(s.getPointers(PointerType.INSTANCE_HYPERNYM).length != 0) {
				continue;
			}				
			if(canBe(s,wordsToCHeck, new LinkedList<Synset>())) {
				return true;
			}					
		}
	}
	return false;		
}
 

import net.didion.jwnl.data.Synset; //导入方法依赖的package包/类
public static String deriveVerb(String noun) {
	try {
		IndexWord _idw = f_dictionary.lookupIndexWord(POS.NOUN, noun);
		if(_idw == null) {
			System.err.println("Could not find IndexWord for: "+noun);
			return null;
		}
		String _selected = null;
		int _distance = 0;
		for(Synset s: _idw.getSenses()) {
			Pointer[] _targets = s.getPointers();
			for(Pointer p:_targets) {
				if(p.getType() == PointerType.NOMINALIZATION && p.getTargetPOS() == POS.VERB) {
					for(Word w:p.getTargetSynset().getWords()) {
						int _d = StringUtils.calculateEditDistance(w.getLemma(), noun);
						if(_selected == null || _d<_distance) {
							_selected = w.getLemma();
							_distance = _d;
						}
					}						
				}
			}
		}
		return _selected;
	} catch (JWNLException e) {
		e.printStackTrace();
		return null;
	}	
}