@Override public void visit(OWLClass desc) { if (!processedClasses.contains(desc)) { processedClasses.add(desc); Set<OWLClassExpression> set = desc.getSuperClasses(onts); for (OWLClassExpression s : set) { if (s.equals(desc)) { break; } else { s.accept(this); } } } }
@Override public void visit(OWLClass desc) { if (!processedClasses.contains(desc)) { processedClasses.add(desc); Set<OWLClassExpression> set = desc.getSuperClasses(onts); for (OWLClassExpression s : set) { if (s.equals(desc)) { break; } else { s.accept(this); } } } }
public Set<OWLClass> getSuperClassesOf(OWLClass owlClass) { Set<OWLClass> superClasses = new HashSet<OWLClass>(); Iterator<OWLClassExpression> iterator = owlClass.getSuperClasses(mergedOntology).iterator(); while (iterator.hasNext()) { OWLClassExpression next = iterator.next(); if (!next.isAnonymous()) { superClasses.add(next.asOWLClass()); } } return superClasses; }
private void addMatchingParents(OWLClass source, OWLClass target, StringBuffer sb) { Set<OWLClassExpression> targetParents = target.getSuperClasses(diffs.getTargetOntology()); for (OWLClassExpression sourceParent : source.getSuperClasses(diffs.getSourceOntology())) { OWLClass targetParent = (OWLClass) diffs.getEntityMap().get(sourceParent); if (targetParent != null && targetParents.contains(targetParent)) { sb.append("Source entity has parent\n\t"); sb.append(renderer.renderSourceObject((OWLClass) sourceParent)); sb.append("\nwhich maps to the following parent of the target entity\n\t"); sb.append(renderer.renderTargetObject(targetParent)); sb.append('\n'); } } }
public Set<OWLClass> getSourceSuperClasses(OWLClass c) { Set<OWLClass> superClasses = new HashSet<OWLClass>(); for (OWLClassExpression ce : c.getSuperClasses(diffs.getSourceOntology())) { if (!ce.isAnonymous()) { superClasses.add(ce.asOWLClass()); } } return superClasses; }
public void visit(OWLClass cls) { if (visitedClasses.contains(cls)) { return; } else if (onts != null){ visitedClasses.add(cls); for (OWLClassExpression superCls : cls.getSuperClasses(onts)){ superCls.accept(this); } for (OWLClassExpression equiv : cls.getEquivalentClasses(onts)){ equiv.accept(this); } } }
public Collection<Class> getSuperClassOf() { return convertC(cl().getSuperClasses(onto)); }
private Set<OWLClassExpression> getInferredParents(OWLOntology sourceOntology, OWLClass child, Set<OWLClass> viewed) { Set<OWLClassExpression> result = new TreeSet<OWLClassExpression>(); if (!viewed.contains(child)) { viewed.add(child); Set<OWLClassExpression> parents = new TreeSet<OWLClassExpression>(); parents.addAll(child.getSuperClasses(sourceOntology)); parents.addAll(child.getEquivalentClasses(sourceOntology)); for (OWLClassExpression parent : parents) { if (parent instanceof OWLClass) { result.add(parent); result.addAll(getInferredParents(sourceOntology, (OWLClass) parent, viewed)); } else if (parent instanceof OWLObjectIntersectionOf) { Set<OWLClassExpression> inferredParents = ((OWLObjectIntersectionOf) parent).getOperands(); result.addAll(inferredParents); for (OWLClassExpression inferredParent : inferredParents) { if (inferredParent instanceof OWLClass) { result.addAll(getInferredParents(sourceOntology, (OWLClass) inferredParent, viewed)); } } } else { result.add(parent); } } } return result; }
public Double recomputeMetric() { int total = 0; int count = 0; Set<OWLClass> processedClasses = new HashSet<OWLClass>(); for (OWLOntology ont : getOntologies()) { for (OWLClass cls : ont.getClassesInSignature()) { if (!processedClasses.contains(cls)) { count++; int prevTotal = total; processedClasses.add(cls); for (OWLClassExpression desc : cls.getSuperClasses(ont)) { if (!desc.isAnonymous()) { total++; } } if (prevTotal == total) { total++; } } } } return ((double) total) / count; }
public Integer recomputeMetric() { int count = 0; Set<OWLClass> processedClasses = new HashSet<OWLClass>(); for (OWLOntology ont : getOntologies()) { for (OWLClass cls : ont.getClassesInSignature()) { if (!processedClasses.contains(cls)) { processedClasses.add(cls); int curCount = 0; for (OWLClassExpression desc : cls.getSuperClasses(ont)) { if (!desc.isAnonymous()) { curCount++; } } if (curCount > count) { count = curCount; } } } } return count; }
@Override public void visit(OWLClass desc) { if (!done && !processedClasses.contains(desc)) { processedClasses.add(desc); Set<OWLClassExpression> set = desc.getSuperClasses(onts); for (OWLClassExpression s : set) { if (s.equals(desc)) { break; } else if (!done && !(s.isAnonymous() || s.asOWLClass().isBuiltIn())) s.asOWLClass().accept(this); } } }
public void visit(OWLClass cls) { if (onts != null){ for (OWLClassExpression superCls : cls.getSuperClasses(onts)){ superCls.accept(this); } for (OWLClassExpression equiv : cls.getEquivalentClasses(onts)){ equiv.accept(this); } } }
private Set<GraphArc> findOutgoingConditionsRelationships(OWLEntity entityOfInterest, boolean mustBeVisible) { Set<GraphArc> arcs = new HashSet<GraphArc>(); if (!(entityOfInterest instanceof OWLClass)) { return arcs; } OWLClass owlClass = (OWLClass) entityOfInterest; convertOWLClassExpressionsToArcs(owlClass, owlClass.getSuperClasses(owlOntology), arcs, null, mustBeVisible); OWLIconProviderImpl iconProvider = new OWLIconProviderImpl(owlModelManager); Icon icon = iconProvider.getIcon(owlClass); convertOWLClassExpressionsToArcs(owlClass, owlClass.getEquivalentClasses(owlOntology), arcs, icon, mustBeVisible); return arcs; }
public Collection<OWLClass> getSuperClasses(OWLClass owlClass) { Set<OWLClass> superClasses = new HashSet<OWLClass>(); for (OWLClassExpression ce : owlClass.getSuperClasses(ontology.getImportsClosure())) { if (!ce.isAnonymous()) { superClasses.add(ce.asOWLClass()); } else if (ce instanceof OWLObjectIntersectionOf) { superClasses.addAll(getNamedConjuncts((OWLObjectIntersectionOf) ce)); } } for (OWLClassExpression ce : owlClass.getEquivalentClasses(ontology.getImportsClosure())) { if (ce instanceof OWLObjectIntersectionOf) { superClasses.addAll(getNamedConjuncts((OWLObjectIntersectionOf) ce)); } } superClasses.remove(factory.getOWLThing()); return superClasses; }
private void initializeInferredSubclasses() { topLevelClasses = new TreeSet<OWLClass>(); for (OWLClass owlClass : ontology.getClassesInSignature()) { boolean foundParent = false; for (OWLClassExpression parent : owlClass.getSuperClasses(ontology)) { if (hasGoodDirectSuperClass(owlClass, parent) || searchForSuperclassesFromIntersection(owlClass, parent)) { foundParent = true; } } for (OWLClassExpression parent : owlClass.getEquivalentClasses(ontology)) { if (searchForSuperclassesFromIntersection(owlClass, parent)) { foundParent = true; } } if (!foundParent) { topLevelClasses.add(owlClass); } } }
@Override public synchronized Collection<IConcept> getParents() { Set<IConcept> concepts = new HashSet<>(); synchronized (_owl) { Set<OWLClassExpression> set = _owl.getSuperClasses(_manager.manager .getOntologies()); for (OWLClassExpression s : set) { if (s.equals(_owl)) { KLAB.error("self-referential inheritance for " + this); break; } else if (!(s.isAnonymous() || s.asOWLClass().isBuiltIn())) concepts.add(new Concept(s.asOWLClass(), _manager, _manager .getConceptSpace(s.asOWLClass().getIRI()))); } } return concepts; }
List<OWLOntologyChange> getDirectInferredEdges(OWLClass ce) { List<OWLOntologyChange> changes = new ArrayList<>(); //find direct inferred superclasses, D Set<OWLClass> directSuperclasses = reasoner.getSuperClasses(ce, true).getFlattened(); //find indirect superclasses, I Set<OWLClass> indirectSuperclasses = reasoner.getSuperClasses(ce, false).getFlattened(); //find asserted superclasses, A Set<OWLClassExpression> assertedSuperclasses = ce.asOWLClass().getSuperClasses(ont); //for each d in D, add an edge subClassOf(x d) for (OWLClass directSuperclass: directSuperclasses) { OWLAxiom axiom = factory.getOWLSubClassOfAxiom(ce, directSuperclass); AddAxiom addAxiom = new AddAxiom(ont, axiom); changes.add(addAxiom); } //for each a in A for (OWLClassExpression assertedSuperclass: assertedSuperclasses) { if (assertedSuperclass.isAnonymous()) { continue; } //if a is in I and not in D, then remove edge subClassOf(x a) if (indirectSuperclasses.contains(assertedSuperclass.asOWLClass()) && !directSuperclasses.contains(assertedSuperclass.asOWLClass())) { OWLAxiom axiom = factory.getOWLSubClassOfAxiom(ce, assertedSuperclass); RemoveAxiom removeAxiom = new RemoveAxiom(ont, axiom); changes.add(removeAxiom); } } return changes; }
System.out.println("Subclass: "+rendering.render(c1e)); c1eqclasses = c1.getSuperClasses(localOntology); for(OWLClassExpression c1e : c1eqclasses) System.out.println("Superclass: "+rendering.render(c1e));
write(eachClass); writeSpace(); flatten(eachClass.getSuperClasses(ontology), KRSSVocabulary.AND); writeCloseBracket(); writeln();
write(eachClass); writeSpace(); flatten(eachClass.getSuperClasses(ontology), KRSSVocabulary.AND); writeCloseBracket(); writeln();