Java OWLClassNodeSet类代码示例

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * @deprecated
 */
private Set<Integer> extractMeaningfulRoots(NodeSet<OWLClass> nodes, int level){
	
	Set<Integer> mroots=new HashSet<Integer>();
	OWLClassNodeSet mrootsClass =  new OWLClassNodeSet();
	
	for (Node<OWLClass> node : nodes.getNodes()){
	
		for (Node<OWLClass> topNode : reasoner.getSubClasses(node.getRepresentativeElement(), true)){
			mrootsClass.addNode(topNode);
			if (class2identifier.containsKey(topNode.getRepresentativeElement())){
				mroots.add(class2identifier.get(topNode.getRepresentativeElement()));
			}
		}
	}
	if (mroots.size()>=minNumberOfRoots || level==3){ //we want to avoid infinite recursion
		return mroots;

	}
	else {
		return extractMeaningfulRoots(mrootsClass, level+1);
	}
	
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * It was an error in original method. the result set contained both the given class and its equivalents.
 */
public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) {
       //super.ensurePrepared();
       OWLClassNodeSet nodeSet = new OWLClassNodeSet();
       if (!ce.isAnonymous()) {
           for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
               for (OWLDisjointClassesAxiom ax : ontology.getDisjointClassesAxioms(ce.asOWLClass())) {
                   for (OWLClassExpression op : ax.getClassExpressions()) {
                       if (!op.isAnonymous() && !op.equals(ce)) { //Op must be differnt to ce
                           nodeSet.addNode(getEquivalentClasses(op));
                       }
                   }
               }
           }
       }
       
       
       
       return nodeSet;
   }
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * OWLDisjointAxiom(A,B,C)
 * @param reasoner
 * @param ontology
 * @param cls
 * @return
 */
public static OWLClassNodeSet getExplicitOWLDisjointnessAxioms(OWLReasoner reasoner, OWLOntology ontology, OWLClass cls){
	
	OWLClassNodeSet nodeSet = new OWLClassNodeSet();
	
	for (OWLDisjointClassesAxiom ax : ontology.getDisjointClassesAxioms(cls)) {                	
           for (OWLClassExpression op : ax.getClassExpressions()) {
               if (!op.isAnonymous() && !op.equals(cls)) { //Op must be differnt to ce
                   nodeSet.addNode(reasoner.getEquivalentClasses(op));
               }
           }
       }
	
	return nodeSet;
	
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * A ^ B -> bottom
 * @param reasoner
 * @param ontology
 * @param cls
 * @author Shuo Zhang
 * @return
 */
public static OWLClassNodeSet getExplicitDLDisjointnessAxioms(OWLReasoner reasoner, OWLOntology ontology, OWLClass cls){
	
	OWLClassNodeSet nodeSet = new OWLClassNodeSet();
	
	OWLClassExpression subExp;
   	Set<OWLClassExpression> set;
       for (OWLSubClassOfAxiom sax : ontology.getSubClassAxiomsForSuperClass(OWLManager.getOWLDataFactory().getOWLNothing())) {
       	subExp = sax.getSubClass();
       	if (subExp instanceof OWLObjectIntersectionOf) {
       		set = subExp.asConjunctSet();
       		if (set.contains(cls) && set.size() == 2) {
       			for (OWLClassExpression op : set) {
       				if (!op.equals(cls) && !op.isAnonymous()) {
       					nodeSet.addNode(reasoner.getEquivalentClasses(op));
       					break;
       				}
       			}
       		}
       	}
       } 
	
       return nodeSet;
       
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) {
    ensurePrepared();
    OWLClassNodeSet nodeSet = new OWLClassNodeSet();
    if (!ce.isAnonymous()) {
        for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
            for (OWLDisjointClassesAxiom ax : ontology.getDisjointClassesAxioms(ce.asOWLClass())) {
                for (OWLClassExpression op : ax.getClassExpressions()) {
                    if (!op.isAnonymous()) {
                        nodeSet.addNode(getEquivalentClasses(op));
                    }
                }
            }
        }
    }
    return nodeSet;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getTypes(OWLNamedIndividual ind, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
    for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
        for (OWLClassAssertionAxiom axiom : ontology.getClassAssertionAxioms(ind)) {
            OWLClassExpression ce = axiom.getClassExpression();
            if (!ce.isAnonymous()) {
                result.addNode(classHierarchyInfo.getEquivalents(ce.asOWLClass()));
                if (!direct) {
                    result.addAllNodes(getSuperClasses(ce, false).getNodes());
                }
            }
        }
    }
    return result;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct)
throws ReasonerInterruptedException, TimeOutException,
FreshEntitiesException, InconsistentOntologyException,
ClassExpressionNotInProfileException {

	DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
	Set<OWLObject> subs = gw.queryDescendants(ce, false, true);
	for (OWLObject s : subs) {
		if (s instanceof OWLClassExpression) {
			if (s instanceof OWLClass) {
				result.addEntity((OWLClass) s);
			}
			else {

			}
		}
		else {

		}
	}
	return result;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce,
		boolean direct) throws InconsistentOntologyException,
		ClassExpressionNotInProfileException, FreshEntitiesException,
		ReasonerInterruptedException, TimeOutException {

	DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
	Set<OWLObject> supers = gw.getSubsumersFromClosure(ce);
	for (OWLObject sup : supers) {
		if (sup instanceof OWLClassExpression) {
			if (sup instanceof OWLClass) {
				result.addEntity((OWLClass) sup);
			}
			else {

			}
		}
		else {

		}
	}
	return result;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * Getting all disjoint classes is costly. We get only explicit disjointness.
 * We will complete with questions (A intersection B) later  if necessary
 */
public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) {
       
	 OWLClassNodeSet nodeSet = new OWLClassNodeSet();
        
     if (!ce.isAnonymous()) {
	     for (OWLOntology ontology : getRootOntology().getImportsClosure()) {	        	
		        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
		        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
		        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
	     }
     }
        
     return nodeSet;
	
	/*if (!ce.isAnonymous()) {                   	
       	for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
       		
               for (OWLDisjointClassesAxiom ax : ontology.getDisjointClassesAxioms(ce.asOWLClass())) {                	
                   for (OWLClassExpression op : ax.getClassExpressions()) {
                       if (!op.isAnonymous() && !op.equals(ce)) { //Op must be differnt to ce
                           nodeSet.addNode(getEquivalentClasses(op));
                       }
                   }
               }
           }
       } */       
       
   }
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
	 
	OWLClassNodeSet ns = new OWLClassNodeSet();
    
    try{        	
    	//System.out.println("Class ok: " + ce.toString());        	
    	return super.getSubClasses(ce, direct);
    }
    catch (StackOverflowError e){
		//to catch StackOverflowError error
		System.err.println("StackOverflowError in Structural reasoner: getSubClasses for Class " + ce.toString());
		return ns;
	}
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    
	OWLClassNodeSet ns = new OWLClassNodeSet();
    
    try{
    	return super.getSuperClasses(ce, direct);
    }
    catch (StackOverflowError e){
		//to catch StackOverflowError error
		System.err.println("StackOverflowError in Structural reasoner: getSuperClasses for Class " + ce.toString());
		return ns;
	}
    
    
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
/**
 * Getting all disjoint classes is costly. We get only explicit disjointness.
 * We will complete with questions (A intersection B) later  if necessary
 */
public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) {
       OWLClassNodeSet nodeSet = new OWLClassNodeSet();
       
       if (!ce.isAnonymous()) {
        for (OWLOntology ontology : getRootOntology().getImportsClosure()) {	        	
	        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
	        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
	        nodeSet.addAllNodes(DisjointnessAxiomExtractor.getExplicitOWLDisjointnessAxioms(this, ontology, ce.asOWLClass()).getNodes());
        }
       }
       
       return nodeSet;
       
       
       /*if (!ce.isAnonymous()) {
       for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
           for (OWLDisjointClassesAxiom ax : ontology.getDisjointClassesAxioms(ce.asOWLClass())) {
               for (OWLClassExpression op : ax.getClassExpressions()) {
                   if (!op.isAnonymous() && !op.equals(ce)) { //Op must be differnt to ce
                       nodeSet.addNode(getEquivalentClasses(op));
                   }
               }
           }
       }
   	}*/
   }
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    OWLClassNodeSet ns = new OWLClassNodeSet();
    if (!ce.isAnonymous()) {
        ensurePrepared();
        return classHierarchyInfo.getNodeHierarchyChildren(ce.asOWLClass(), direct, ns);
    }
    return ns;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    OWLClassNodeSet ns = new OWLClassNodeSet();
    if (!ce.isAnonymous()) {
        ensurePrepared();
        return classHierarchyInfo.getNodeHierarchyParents(ce.asOWLClass(), direct, ns);
    }
    return ns;
}
 

import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet; //导入依赖的package包/类
public NodeSet<OWLClass> getDataPropertyDomains(OWLDataProperty pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
    for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
        for (OWLDataPropertyDomainAxiom axiom : ontology.getDataPropertyDomainAxioms(pe)) {
            result.addNode(getEquivalentClasses(axiom.getDomain()));
            if (!direct) {
                result.addAllNodes(getSuperClasses(axiom.getDomain(), false).getNodes());
            }
        }
    }
    return result;
}