PrefixManager pm= new DefaultPrefixManager("http://www.co-ode.org/ontologies/pizza/pizza.owl#"); OWLClass american=factory.getOWLClass("American", pm); Set<OWLClassAxiom> tempAx=localOntology.getAxioms(american); for(OWLClassAxiom ax: tempAx){ for(OWLClassExpression nce:ax.getNestedClassExpressions()) if(nce.getClassExpressionType()!=ClassExpressionType.OWL_CLASS) System.out.println(ax); }
public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) { return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType); } }
public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) { return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType); } }
public boolean shouldBracket(OWLObject parentObject, OWLObject childObject) { return childObject instanceof OWLClassExpression && ((OWLClassExpression) childObject).getClassExpressionType().equals(classExpressionType); } }
protected void retainOnlyExistentialRestrictions(Set<OWLClassExpression> cs) { //Set<OWLClassExpression> add = new HashSet<OWLClassExpression>(); for (Iterator<OWLClassExpression> it = cs.iterator(); it.hasNext();) { OWLClassExpression c = it.next(); if (!c.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM) && !c.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM)) { it.remove(); /*c = aterm2complexAtermEq.get(c); if (c!=null && ATermUtils.isSomeValues(c)) { add.add(c); }*/ } } //cs.addAll(add); } protected Set<OWLClassExpression> getCommunSubsumees(
public String toString() { StringBuilder sb = new StringBuilder(); sb.append(classExpression.getClassExpressionType().getName()); sb.append(" class expressions are not allowed in profile: "); sb.append(classExpression); sb.append(" ["); sb.append(getAxiom()); sb.append(" in "); sb.append(getOntologyID()); sb.append("]"); return sb.toString(); } }
private void convertOWLClassExpressionsToArcs(OWLClass owlClass, Set<OWLClassExpression> expressions, Set<GraphArc> arcs, Icon icon, boolean mustBeVisible) { for(OWLClassExpression expression : expressions) { if(expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM) || expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_ALL_VALUES_FROM)) { convertOWLClassExpressionToArcs(owlClass, expression, arcs, icon, mustBeVisible); } else if(expression.getClassExpressionType().equals(ClassExpressionType.OBJECT_INTERSECTION_OF)) { for(OWLClassExpression e : expression.asConjunctSet()) { convertOWLClassExpressionToArcs(owlClass, e, arcs, icon, mustBeVisible); } } } }
@Override public String toString() { return toString("Class expressions not allowed in profile: %s", getExpression().getClassExpressionType() .getName()); } }
@Override public String toString() { return toString("Class expressions not allowed in profile: %s", getExpression().getClassExpressionType() .getName()); } }
@Override public String toString() { return toString("Class expressions not allowed in profile: %s", getExpression().getClassExpressionType() .getName()); } }
private boolean containsObjectAllRestriction(OWLClassExpression d){ for(OWLClassExpression child : d.getNestedClassExpressions()){ if(child.getClassExpressionType() == ClassExpressionType.OBJECT_ALL_VALUES_FROM){ return true; } } return false; } }
@Override protected void writeDisjointUnionAxiom(Set<OWLClassExpression> set) { if (set.size() > 1) { String s = "(disjoint-union "; for (OWLClassExpression c : set) { ClassExpressionType type = c.getClassExpressionType(); if (type != ClassExpressionType.OWL_CLASS) exit("Concept type " + type + " not supported in disjoint union axiom"); else s += getShortName(c.asOWLClass()) + " "; } s += ")"; print(s); } }
public static boolean isNegatedOWLQLRHSConcept(OWLClassExpression cl) { ClassExpressionType type = cl.getNNF().getClassExpressionType(); return type.equals(ClassExpressionType.OBJECT_COMPLEMENT_OF) || type.equals(ClassExpressionType.OBJECT_ALL_VALUES_FROM) || type.equals(ClassExpressionType.DATA_ALL_VALUES_FROM); }
public Set<OWLClass> getUnsatisfiableNamedClasses() { if (unsatisfiableClasses == null) { unsatisfiableClasses = new HashSet<OWLClass>(); // unsatisfiabe named classes C are in the negative closure in the form // subclass( C, not(C)) for (OWLSubClassOfAxiom ax: getNegativeInclInNegClosure()) { OWLClassExpression sub = ax.getSubClass(); OWLClassExpression sup = ax.getSuperClass(); if (!sub.isAnonymous() && sup.getClassExpressionType().equals(ClassExpressionType.OBJECT_COMPLEMENT_OF) && ((OWLObjectComplementOf) sup).getOperand().equals(sub)) { unsatisfiableClasses.add(sub.asOWLClass()); } } } return Collections.unmodifiableSet(unsatisfiableClasses); //return new HashSet<OWLClass>(); } public Set<OWLProperty> getUnsatisfiableProperties() {
protected boolean isValidOWLQLLeftConcept(OWLClassExpression owlclass) { // check that subclass is either atomic or someValuesFrom(R, Top) if (!owlclass.isAnonymous()) { return true; } if (!owlclass.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM) && !owlclass.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)) { return false; } OWLQuantifiedRestriction quant = (OWLQuantifiedRestriction) owlclass; OWLPropertyRange cl= quant.getFiller(); if (cl instanceof OWLClassExpression) { OWLClassExpression clexp = (OWLClassExpression) cl; return clexp.isOWLThing(); } else if (cl instanceof OWLDataRange) { OWLDataRange dr = (OWLDataRange) cl; //TODO handle qualified data existential restriction return dr.isTopDatatype(); } else { assert false: "Unknown OWLPropertyRange: " +cl; return false; } }
/** * returns the key associated with a class expression * @param lhsConcept * @return */ public static String getKey(OWLClassExpression lhsConcept) { if (!lhsConcept.isAnonymous()) { return lhsConcept.asOWLClass().getIRI().toString(); } else if (lhsConcept.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM) || lhsConcept.getClassExpressionType().equals(ClassExpressionType.DATA_SOME_VALUES_FROM)) { OWLQuantifiedRestriction rest = (OWLQuantifiedRestriction) lhsConcept; OWLPropertyExpression pe = rest.getProperty(); return getKey(pe); } else { assert false : "Invalid left hand side concept: "+lhsConcept; return null; } }
/** * return named properties p such that c \subseteq \some inv(p) T * @param c * @return */ protected Set<URI> getNamedInverseSuperPropertiesOrSelf(OWLClassExpression c) { Set<OWLClassExpression> subs = taxo.getAllSubsumers(c); Set<URI> ret = new HashSet<URI>(); for (OWLClassExpression ex: subs) { if (ex.getClassExpressionType().equals(ClassExpressionType.OBJECT_SOME_VALUES_FROM)) { OWLObjectSomeValuesFrom rest = (OWLObjectSomeValuesFrom) ex; OWLObjectPropertyExpression prop = rest.getProperty().getSimplified(); if (prop.isAnonymous()) { OWLObjectProperty namedProp = prop.getNamedProperty(); ret.add(namedProp.getIRI().toURI()); } } } return ret; } /**
@Override protected void writeEquivalentClassesAxiom(Set<OWLClassExpression> set) { String name = null; OWLClassExpression leftClass = null; for (OWLClassExpression c : set) if (c.getClassExpressionType() == ClassExpressionType.OWL_CLASS) { name = getShortName(c.asOWLClass()); leftClass = c; break; } if (name == null) exit("Equivalent classes axiom " + set + " require at least one atomic class"); for (OWLClassExpression c : set) if (c != leftClass) print("(define-concept " + name + " " + getClassName(c) + " )"); }
@Override protected void writeSubclassOfAxiom(OWLClassExpression subclass, OWLClassExpression superclass, double d) { // if (superclass.isOWLThing() != false) { ClassExpressionType type = subclass.getClassExpressionType(); if ((type == ClassExpressionType.OWL_CLASS) && (d == 1)) print("(define-primitive-concept " + getShortName(subclass.asOWLClass()) + " " + getClassName(superclass) + ")"); else print("(implies " + getClassName(subclass) + " " + getClassName(superclass) + " " + d + ")"); } }
public static RDFResourceTree materializePropertyDomains(RDFResourceTree tree, AbstractReasonerComponent reasoner) { RDFResourceTree newTree = new RDFResourceTree(tree.getData()); Consumer<OWLClass> addTypeChild = (cls) -> newTree.addChild(new RDFResourceTree(OwlApiJenaUtils.asNode(cls)), RDF.type.asNode()); tree.getEdges().forEach(edge -> { List<RDFResourceTree> children = tree.getChildren(edge); // add existing children children.forEach(child -> { RDFResourceTree newChild = materializePropertyDomains(child, reasoner); newTree.addChild(newChild, edge); }); // add the rdf:type statements for the property domain(s) OWLClassExpression dom = reasoner.getDomain(OwlApiJenaUtils.asOWLEntity(edge, EntityType.OBJECT_PROPERTY)); if(!dom.isAnonymous() && !dom.isOWLThing()) { addTypeChild.accept(dom.asOWLClass()); } else { if(dom.getClassExpressionType() == ClassExpressionType.OBJECT_INTERSECTION_OF) { dom.getNestedClassExpressions().stream() .filter(ce -> !ce.isAnonymous()) .map(OWLClassExpression::asOWLClass) .forEach(addTypeChild); } } }); return newTree; }