@Override public Set<OWLAxiom> visit(OWLSubClassOfAxiom axiom) { OWLClassExpression sub = axiom.getSubClass(); OWLClassExpression sup = axiom.getSuperClass(); Set<OWLClassExpression> supGens = ceGeneralizer.generalize(sup); return supGens.stream() .map(supGen -> df.getOWLSubClassOfAxiom(sub, supGen)) .collect(Collectors.toCollection(TreeSet::new)); }
public MacroExpansions() { visitor = new GCIVisitor(inputOntology, newAxioms); inputOntology.axioms(AxiomType.SUBCLASS_OF).forEach(axiom -> axiom.accept(visitor)); inputOntology.axioms(AxiomType.EQUIVALENT_CLASSES) .forEach(axiom -> axiom.accept(visitor)); inputOntology.axioms(AxiomType.CLASS_ASSERTION).forEach(axiom -> axiom.accept(visitor)); inputOntology.axioms(AxiomType.ANNOTATION_ASSERTION).forEach(this::expand); }
@Override public void visit(OWLSubClassOfAxiom axiom) { hashCode = 139; hashCode = hashCode * MULT + axiom.getSubClass().hashCode(); hashCode = hashCode * MULT + axiom.getSuperClass().hashCode(); hashCode = hashCode * MULT + axiom.getAnnotations().hashCode(); }
@Override default Stream<?> componentsAnnotationsFirst() { return Stream.of(annotationsAsList(), getSubClass(), getSuperClass()); }
@Override default Stream<?> componentsWithoutAnnotations() { return Stream.of(getSubClass(), getSuperClass()); }
@Override public Collection<OWLClass> getChildren(OWLClass parent) { Collection<OWLClass> result = new HashSet<>(); for (OWLAxiom ax : asUnorderedSet( getRootOntology().referencingAxioms(parent, INCLUDED))) { if (ax instanceof OWLSubClassOfAxiom) { OWLSubClassOfAxiom sca = (OWLSubClassOfAxiom) ax; if (!sca.getSubClass().isAnonymous()) { Set<OWLClassExpression> conjuncts = sca.getSuperClass().asConjunctSet(); if (conjuncts.contains(parent)) { result.add(sca.getSubClass().asOWLClass()); } } } else if (ax instanceof OWLEquivalentClassesAxiom) { OWLEquivalentClassesAxiom eca = (OWLEquivalentClassesAxiom) ax; eca.classExpressions().filter(ce -> ce.containsConjunct(parent)) .forEach(ce -> eca .classExpressions().forEach(sub -> { if (!sub.isAnonymous() && !sub.equals(ce)) { result.add(sub.asOWLClass()); } })); } } return result; } }
private static Stream<PropertyFiller> toPropertyFillerExtractors(Stream<OWLAxiom> axiomStream) { return axiomStream .filter(ax -> ax instanceof OWLSubClassOfAxiom) .map(ax -> ((OWLSubClassOfAxiom) ax)) .filter(ax -> !ax.getSubClass().isAnonymous()) .map(ax -> new PropertyFiller(ax.getSubClass(), ax.getSuperClass())) .filter(ext -> ext.isPropertyAndFillerPresent()); } }
private void createEdgesForClass(Set<Edge> edges, Set<OWLEntity> processed, OWLClass cls) { var subClassAxioms = getOntologies().flatMap(o -> o.getSubClassAxiomsForSubClass(cls).stream().sorted()); var equivalentClassesAxioms = getEquivalentClassAxiomsAsSubClassOfAxioms(cls); var combinedAxioms = Streams.concat(subClassAxioms, equivalentClassesAxioms); combinedAxioms .filter(ax -> isNamedClass(ax.getSubClass())) .forEach(ax -> createEdgeForSubClassOfAxiom(cls, ax, edges, processed)); }
private static OptimizedDirectedMultigraph<OWLClass> extractGraphFromSubsumptionAxiomsWith(final OWLOntology ontology, final ClassCollector visitor) { final OptimizedDirectedMultigraph<OWLClass> graph = new OptimizedDirectedMultigraph<>(); ontology.axioms(AxiomType.SUBCLASS_OF).forEach(axiom -> // processSubsumption(graph, axiom.getSubClass(), axiom.getSuperClass(), visitor)); ontology.axioms(AxiomType.EQUIVALENT_CLASSES).forEach(axiom -> { final Set<OWLClassExpression> equivalences = axiom.classExpressions().collect(Collectors.toSet()); for (final OWLClassExpression equivalence1 : equivalences) for (final OWLClassExpression equivalence2 : equivalences) if (equivalence1 != equivalence2) processSubsumption(graph, equivalence1, equivalence2, visitor); }); return graph; }
private void createEdgeForSubClassOfAxiom(OWLClass subCls, OWLSubClassOfAxiom subClassOfAxiom, Set<Edge> edges, Set<OWLEntity> processed) { OWLEntityData subClsData = renderer.getClassData(subCls); subClassOfAxiom .getSuperClass() .asConjunctSet() .stream() .filter(ClassExpression::isNotOwlThing) .forEach(superClass -> addEdgeForSuperClass(edges, processed, subClsData, superClass)); }
private void generateChanges(OWLClass cls, OWLObjectPropertyExpression property, Collection<OWLOntology> ontologies, OWLOntology targetOntology) { // We collect all of the fillers for existential restrictions along // the target property and all of the fillers for hasValue restrictions // as nominals FillerCollector collector = new FillerCollector(property); ontologies.forEach(o -> o.subClassAxiomsForSubClass(cls) .forEach(ax -> ax.getSuperClass().accept(collector))); if (collector.fillers.isEmpty()) { return; } OWLObjectUnionOf union = df.getOWLObjectUnionOf(collector.fillers); OWLClassExpression closureAxiomDesc = df.getOWLObjectAllValuesFrom(property, union); addChange(new AddAxiom(targetOntology, df.getOWLSubClassOfAxiom(cls, closureAxiomDesc))); }
private void generateChanges(OWLOntology targetOntology, OWLClass cls, Collection<OWLOntology> ontologies) { // We remove the existing superclasses and then combine these // into an intersection which is made equivalent. List<OWLClassExpression> descs = new ArrayList<>(); for (OWLOntology ont : ontologies) { ont.subClassAxiomsForSubClass(cls).forEach(ax -> { addChange(new RemoveAxiom(ont, ax)); descs.add(ax.getSuperClass()); }); } OWLClassExpression equivalentClass = df.getOWLObjectIntersectionOf(descs); addChange(new AddAxiom(targetOntology, df.getOWLEquivalentClassesAxiom(Arrays.asList(cls, equivalentClass)))); } }
@Override public OWLAxiom visit(OWLSubClassOfAxiom axiom) { return df.getOWLSubClassOfAxiom(axiom.getSubClass().accept(classVisitor), axiom.getSuperClass().accept(classVisitor)); }
public Collection<OWLClass> getChildren(OWLClass parent) { Collection<OWLClass> result = new HashSet<OWLClass>(); for (OWLOntology ont : getRootOntology().getImportsClosure()) { for (OWLAxiom ax : ont.getReferencingAxioms(parent)) { if (ax instanceof OWLSubClassOfAxiom) { OWLSubClassOfAxiom sca = (OWLSubClassOfAxiom) ax; if (!sca.getSubClass().isAnonymous()) { Set<OWLClassExpression> conjuncts = sca.getSuperClass().asConjunctSet(); if (conjuncts.contains(parent)) { result.add(sca.getSubClass().asOWLClass()); } } } else if (ax instanceof OWLEquivalentClassesAxiom) { OWLEquivalentClassesAxiom eca = (OWLEquivalentClassesAxiom) ax; for (OWLClassExpression ce : eca.getClassExpressions()) { if (ce.containsConjunct(parent)) { for (OWLClassExpression sub : eca.getClassExpressions()) { if (!sub.isAnonymous() && !sub.equals(ce)) { result.add(sub.asOWLClass()); } } } } } } } return result; } }
public void visit(OWLSubClassOfAxiom axiom) { if (!axiom.getSubClass().isAnonymous()) { if (!isFilterSet(UsageFilter.filterNamedSubsSupers) || (!axiom.getSubClass().equals(entity) && !axiom.getSuperClass().equals(entity))) { axiom.getSubClass().asOWLClass().accept(this); } } else { additionalAxioms.add(axiom); usageCount++; } }
protected Set<OWLSubClassOfAxiom> getClassAxioms(OWLClassExpression descr, OWLOntology ont) { if (!descr.isAnonymous()){ return ont.getSubClassAxiomsForSubClass(descr.asOWLClass()); } else{ Set<OWLSubClassOfAxiom> axioms = new HashSet<>(); for (OWLAxiom ax : ont.getGeneralClassAxioms()){ if (ax instanceof OWLSubClassOfAxiom && ((OWLSubClassOfAxiom)ax).getSubClass().equals(descr)){ axioms.add((OWLSubClassOfAxiom)ax); } } return axioms; } }
protected Set<OWLClassAssertionAxiom> getExamples(ParameterizedSparqlString queryTemplate, EvaluatedAxiom<OWLSubClassOfAxiom> evAxiom) { OWLSubClassOfAxiom axiom = evAxiom.getAxiom(); queryTemplate.setIri("cls1", axiom.getSubClass().asOWLClass().toStringID()); queryTemplate.setIri("cls2", axiom.getSuperClass().asOWLClass().toStringID()); Set<OWLClassAssertionAxiom> examples = new TreeSet<>(); ResultSet rs = executeSelectQuery(queryTemplate.toString()); while (rs.hasNext()) { QuerySolution qs = rs.next(); OWLIndividual subject = df.getOWLNamedIndividual(IRI.create(qs.getResource("s").getURI())); examples.add(df.getOWLClassAssertionAxiom(axiom.getSuperClass(), subject)); } return examples; }
private static OptimizedDirectedMultigraph<OWLClass> extractGraphFromSubsumptionAxiomsWith(OWLOntology ontology, ClassCollector visitor) { OptimizedDirectedMultigraph<OWLClass> graph = new OptimizedDirectedMultigraph<OWLClass>(); for (OWLSubClassOfAxiom axiom : ontology.getAxioms(AxiomType.SUBCLASS_OF)) { processSubsumption(graph, axiom.getSubClass(), axiom.getSuperClass(), visitor); } for (OWLEquivalentClassesAxiom axiom : ontology.getAxioms(AxiomType.EQUIVALENT_CLASSES)) { Set<OWLClassExpression> equivalences = axiom.getClassExpressions(); for (OWLClassExpression equivalence1 : equivalences) { for (OWLClassExpression equivalence2 : equivalences) { if (equivalence1 != equivalence2) { processSubsumption(graph, equivalence1, equivalence2, visitor); } } } } return graph; }
@Override public void visit(OWLClass desc) { if (!processedClasses.contains(desc)) { processedClasses.add(desc); for (OWLSubClassOfAxiom ax : this.ontology.getSubClassAxiomsForSubClass(desc)) { ax.getSuperClass().accept(this); } } }
public void visit(OWLSubClassOfAxiom node) { node.getSubClass().accept(this); write(" \u2291 "); node.getSuperClass().accept(this); }