Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* This file is part of the OWL API.
*
* The contents of this file are subject to the LGPL License, Version 3.0.
*
* Copyright (C) 2011, Ulm University
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://www.gnu.org/licenses/.
*
*
* Alternatively, the contents of this file may be used under the terms of the Apache License, Version 2.0
* in which case, the provisions of the Apache License Version 2.0 are applicable instead of those above.
*
* Copyright 2011, Ulm University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package de.uulm.ecs.ai.owlapi.krssrenderer;
import static de.uulm.ecs.ai.owlapi.krssrenderer.KRSS2Vocabulary.*;
import java.io.IOException;
import java.io.Writer;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.semanticweb.owlapi.model.AxiomType;
import org.semanticweb.owlapi.model.OWLAsymmetricObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLDataPropertyDomainAxiom;
import org.semanticweb.owlapi.model.OWLDataPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLDeclarationAxiom;
import org.semanticweb.owlapi.model.OWLDifferentIndividualsAxiom;
import org.semanticweb.owlapi.model.OWLDisjointClassesAxiom;
import org.semanticweb.owlapi.model.OWLDisjointDataPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLDisjointObjectPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLDisjointUnionAxiom;
import org.semanticweb.owlapi.model.OWLEquivalentClassesAxiom;
import org.semanticweb.owlapi.model.OWLEquivalentDataPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLEquivalentObjectPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLFunctionalDataPropertyAxiom;
import org.semanticweb.owlapi.model.OWLFunctionalObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLImportsDeclaration;
import org.semanticweb.owlapi.model.OWLIndividual;
import org.semanticweb.owlapi.model.OWLInverseFunctionalObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLInverseObjectPropertiesAxiom;
import org.semanticweb.owlapi.model.OWLIrreflexiveObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLNamedIndividual;
import org.semanticweb.owlapi.model.OWLNegativeDataPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLNegativeObjectPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLObjectInverseOf;
import org.semanticweb.owlapi.model.OWLObjectOneOf;
import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
import org.semanticweb.owlapi.model.OWLObjectPropertyDomainAxiom;
import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
import org.semanticweb.owlapi.model.OWLObjectPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.OWLOntologyManager;
import org.semanticweb.owlapi.model.OWLPropertyExpression;
import org.semanticweb.owlapi.model.OWLReflexiveObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLSubClassOfAxiom;
import org.semanticweb.owlapi.model.OWLSubDataPropertyOfAxiom;
import org.semanticweb.owlapi.model.OWLSubObjectPropertyOfAxiom;
import org.semanticweb.owlapi.model.OWLSubPropertyChainOfAxiom;
import org.semanticweb.owlapi.model.OWLSymmetricObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLTransitiveObjectPropertyAxiom;
/**
* KRSS2ObjectRenderer is an extension of {@link KRSSObjectRenderer
* KRSSObjectRenderer} which uses the extended vocabulary.
*
* Abbreviations
*
*
*
CN
*
concept name
*
*
*
C,D,E
*
concept expression
*
*
*
RN
*
role name
*
*
*
R, R1, R2,...
*
role expressions, i.e. role name or inverse role
*
*
*
* KRSS concept language
*
*
*
KRSS
*
OWLClassExpression
*
*
*
*
(at-least n R C)
*
(OWLObjectMinCardinality R n C)
*
*
*
*
(at-most n R C)
*
(OWLObjectMaxCardinality R n C)
*
*
*
*
(exactly n R C)
*
(OWLObjectExactCardinality R n C)
*
*
*
*
(some R C)
*
(OWLObjectSomeValuesFrom R C)
*
*
*
*
(all R C)
*
(OWLObjectAllValuesFrom R C)
*
*
*
*
(not C)
*
(OWLObjectComplementOf C)
*
*
*
*
(and C D E)
*
(OWLObjectIntersectionOf C D E)
*
*
*
*
(or C D E)
*
(OWLObjectUnionOf C D E)
*
*
*
*
*
* KRSS role language
*
*
*
KRSS
*
OWLObjectPropertyExpression
*
*
*
*
(inv R)
*
(OWLInverseObjectPropertiesAxiom R)
*
*
*
* Each referenced class, object property as well as individual is
* defined using define-concept resp. define-primitive-concept,
* define-role and define-individual. In addition, axioms are
* translated as follows.
*
*
*
OWLAxiom
*
KRSS syntax
*
Remarks
*
*
*
OWLDisjointClassesAxiom
*
(disjoint C D)
*
OWLDisjointClasses C D1 D2 ... Dn will be translated to:
* { (disjoint i(j) i(j+k)) | 1 <= j <=n, j<k<=n, j=|=k}
*
*
*
*
OWLEquivalentClasses
*
(define-concept C D)
*
OWLEquivalentClasses C D1 D2...Dn will be translated to:
* (define-concept C (and D1 D2...Dn))
*
* Only applicable if there is no OWLSubClassOf axiom.
*
*
*
*
OWLSubClassOfAxiom
*
(define-primitive-concept C D)
*
*
OWLSubClassOfAxiom C D1...Dn (n>1) will be translated to:
* (define-primitive-concept C (and D1...Dn))
*
* Only applicable if there is no OWLEquivalentClasses axiom. In that
* case the class will be introduced via (define-concept...) and
* all subclass axioms are handled via implies
*
*
*
*
*
OWLSubClassOfAxiom
*
(implies D C)
*
Only in case of GCIs with concept expression (not named class) D,
* or in case that D is a non-primitive concept. Otherwise superclasses
* are introduced via (define-primitive-concept D ...)
*
*
*
*
*
OWLEquivalentObjectPropertiesAxiom
*
(roles-equivalent r s)
*
All roles are explicitly introduced via
* define-primitive-role.
*
*
*
*
OWLSubPropertyChainOfAxiom
*
(role-inclusion (compose r s) t)
*
Role inclusions of the kind (role-inclusion (compose r s) r)
* resp. (role-inclusion (compose s r) r) are handled within the
* (define-primitive-role) statement as right- resp. left-identities iff
* it is the only role-inclusion wrt. the super property.
*
*
*
OWLSubObjectPropertyAxiom
*
(define-primitive-role R :parent S)
* (define-primitive-role R :parents S T U)
* Additional attributes:
*
*
:transitive t
*
:symmetric t
*
:reflexive t
*
:inverse I
*
:domain C resp. :domain (and C C1...Cn)
*
:range D resp. :range (and D D1..Dn)
*
*
*
This will be only used if there is no OWLEquivalentClasses
* axiom containing R (see define-role).
* The additional attributes are added if there is an OWLTransitiveObjectProperyAxiom,
* OWLSymmetricObjectPropertyAxiom, OWLReflexiveObjectPropertyAxiom,
* OWLObjectPropertyDomainAxiom, OWLObjectPropertyRangeAxiom resp.
* OWLInverseObjectPropertiesAxiom. If there are multiple OWLInverseObjectPropertiesAxioms
* only one inverse is handled here, all others are handled via
* (inverse) statements. Domains/ranges of multiple
* domain/range axioms are handled as (and C C1...Cn).
*
*
*
*
*
OWLSubObjectPropertyAxiom
*
(implies-role r s)
*
Only applicable if r is an inverse property, otherwise superproperties
* are handled within the define-primitive-role
* statement.
*
*
*
*
*
*
OWLInverseObjectPropertiesAxiom
*
(inverse r s)
*
Only inverse properties which are not introduced via
* define-primitive-role.
*
*
*
*
OWLObjectPropertyRangeAxiom
*
*
see define-primitive-role
*
*
*
*
OWLObjectPropertyDomainAxiom
*
*
see define-primitive-role
*
*
*
OWLSymmetricObjectPropertyAxiom
*
*
see define-primitive-role
*
*
*
*
OWLTransitiveObjectPropertyAxiom
*
*
see define-primitive-role
*
*
*
*
OWLReflexiveObjectPropertyAxiom
*
*
see define-primitive-role
*
*
*
*
OWLClassAssertionAxiom
*
(instance i D)
*
*
*
*
OWLDifferentIndividualsAxiom
*
(distinct i1 i2)
*
OWLDifferentIndividualsAxiom i1 i2 ... in will be splitted into:
* { (distinct i(j) i(j+k)) | 1 <= j <=n, j<k<=n, j=|=k}
*
*
*
*
OWLObjectPropertyAssertionAxiom
*
(related i1 P i2)
*
i1: subject, i2: object
*
*
*
OWLSameIndividualsAxiom
*
(equal i1 i2)
*
OWLSameIndividual i1 i2 ...i(n-1) in in will be splitted into:
* { (equal i(j) i(j+k)) | 1 <= j <=n, j<k<=n, j=|=k}
* (equal i1 i2)
* (equal i1 i3)
* ...
* (equal i(n-1) in)
*
*
*
*
*
* Author: Olaf Noppens
* Ulm University
* Institute of Artificial Intelligence
*/
@SuppressWarnings("javadoc")
public class KRSS2ObjectRenderer extends KRSSObjectRenderer {
private final Set leftRightIdentityUsed;
/**
* If declarations are ignored, entities which are only referenced in a declaration
* are not rendered.
*/
protected boolean ignoreDeclarations = false;
@Deprecated
public KRSS2ObjectRenderer(OWLOntologyManager manager, OWLOntology ontology, Writer writer) {
this(ontology, writer);
}
public KRSS2ObjectRenderer(OWLOntology ontology, Writer writer) {
super(ontology, writer);
leftRightIdentityUsed = new HashSet();
}
public void setIgnoreDeclarations(boolean ignoreDeclarations) {
this.ignoreDeclarations = ignoreDeclarations;
}
protected void write(KRSS2Vocabulary v) {
write(v.toString());
}
@Override
public final void visit(OWLOntology ontology1) {
reset();
for (final OWLClass eachClass : ontology1.getClassesInSignature()) {
if (ignoreDeclarations) {
if (ontology1.getAxioms(eachClass).size() == 1
&& ontology1.getDeclarationAxioms(eachClass).size() == 1) {
continue;
}
}
final boolean primitive = !eachClass.isDefined(ontology1);// !eachClass.getSuperClasses(ontology).isEmpty();
writeOpenBracket();
if (primitive) { //there is no equivalentclasses axiom!
write(DEFINE_PRIMITIVE_CONCEPT);
write(eachClass);
writeSpace();
flatten(eachClass.getSuperClasses(ontology1), KRSSVocabulary.AND);
writeCloseBracket();
writeln();
for (OWLClassExpression description : eachClass
.getEquivalentClasses(ontology1)) {
writeOpenBracket();
write(eachClass);
write(EQUIVALENT);
write(description);
writeCloseBracket();
writeln();
}
} else {
writeOpenBracket();
write(DEFINE_CONCEPT);
write(eachClass);
flatten(eachClass.getEquivalentClasses(ontology1), KRSSVocabulary.AND);
writeCloseBracket();
writeln();
for (OWLClassExpression description : eachClass
.getSuperClasses(ontology1)) {
writeOpenBracket();
write(eachClass);
write(IMPLIES);
write(description);
writeCloseBracket();
writeln();
}
}
}
/* for (final OWLClassAxiom axiom : ontology.getGeneralClassAxioms()) {
axiom.accept(this);
}
*/
for (final OWLObjectProperty property : sort(ontology1
.getObjectPropertiesInSignature())) {
if (ignoreDeclarations) {
if (ontology1.getAxioms(property).size() == 1
&& ontology1.getDeclarationAxioms(property).size() == 1) {
continue;
}
}
writeOpenBracket();
final Set properties = property
.getEquivalentProperties(ontology1);
final boolean isPrimitive = properties.isEmpty();
if (isPrimitive) {
write(DEFINE_PRIMITIVE_ROLE);
write(property);
Set superProperties = property
.getSuperProperties(ontology1);
if (superProperties.size() == 1) {
writeSpace();
write(PARENT_ATTR);
writeSpace();
write(superProperties.iterator().next());
} else if (superProperties.size() > 1) {
writeSpace();
write(PARENTS_ATTR);
writeSpace();
flattenProperties(superProperties, null);
} else {
//right/left identity?
//we only allow for either right or left identity axiom, otherwise it is
//expressed via role-inclusion axioms
Set chainAxioms = getPropertyChainSubPropertyAxiomsFor(property);
if (chainAxioms.size() == 1) {
OWLSubPropertyChainOfAxiom axiom = chainAxioms.iterator().next();
if (isLeftIdentityAxiom(axiom, property)) {
leftRightIdentityUsed.add(axiom);
writeSpace();
write(LEFTIDENTITY_ATTR);
write(axiom.getPropertyChain().get(0));
} else if (isRightIdentityAxiom(axiom, property)) {
leftRightIdentityUsed.add(axiom);
writeSpace();
write(RIGHTIDENTITY_ATTR);
write(axiom.getPropertyChain().get(1));
}
}
}
} else {
if (properties.isEmpty()) {
write(DEFINE_PRIMITIVE_ROLE);
write(property);
writeSpace();
} else {
write(DEFINE_ROLE);
write(property);
OWLObjectPropertyExpression expr = properties.iterator().next();
write(expr);
properties.remove(expr);
writeSpace();
}
}
if (property.isTransitive(ontology1)) {
writeSpace();
write(TRANSITIVE_ATTR);
writeSpace();
write(TRUE);
}
if (property.isSymmetric(ontology1)) {
writeSpace();
write(SYMMETRIC_ATTR);
writeSpace();
write(TRUE);
}
if (property.isReflexive(ontology1)) {
writeSpace();
write(REFLEXIVE_ATTR);
writeSpace();
write(TRUE);
}
final Iterator inverses = property.getInverses(
ontology1).iterator();
if (inverses.hasNext()) {
writeSpace();
write(INVERSE_ATTR);
write(inverses.next());
}
Set desc = property.getDomains(ontology1);
if (!desc.isEmpty()) {
writeSpace();
write(DOMAIN_ATTR);
flatten(desc, KRSSVocabulary.AND);
}
desc = property.getRanges(ontology1);
if (!desc.isEmpty()) {
writeSpace();
write(RANGE_ATTR);
flatten(desc, KRSSVocabulary.AND);
}
writeCloseBracket();
writeln();
while (inverses.hasNext()) {
writeOpenBracket();
write(INVERSE);
write(property);
write(inverses.next());
writeOpenBracket();
writeln();
}
for (OWLObjectPropertyExpression expr : properties) {
writeOpenBracket();
write(ROLES_EQUIVALENT);
write(property);
write(expr);
writeCloseBracket();
writeln();
}
}
for (final OWLNamedIndividual individual : sort(ontology1
.getIndividualsInSignature())) {
if (ignoreDeclarations) {
if (ontology1.getAxioms(individual).size() == 1
&& ontology1.getDeclarationAxioms(individual).size() == 1)
{
continue;
}
}
writeOpenBracket();
write(DEFINE_INDIVIDUAL);
write(individual);
writeCloseBracket();
writeln();
}
for (final OWLAxiom axiom : ontology1.getAxioms()) {
axiom.accept(this);
}
try {
writer.flush();
} catch (IOException io) {
io.printStackTrace();
}
}
@Override
public final void visit(OWLSubClassOfAxiom axiom) {
//we only handle GCIs
if (!(axiom.getSubClass() instanceof OWLClass)) {
writeOpenBracket();
write(IMPLIES);
write(axiom.getSubClass());
write(axiom.getSuperClass());
writeCloseBracket();
writeln();
}
}
@Override
public void visit(OWLDisjointClassesAxiom axiom) {
List descs = sort(axiom.getClassExpressions());
int size = descs.size();
if (size <= 1) {
return;
}
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
writeOpenBracket();
write(DISJOINT);
write(descs.get(i));
write(descs.get(j));
writeCloseBracket();
writeln();
}
}
}
@Override
public void visit(OWLNegativeObjectPropertyAssertionAxiom axiom) {
}
@Override
public void visit(OWLAsymmetricObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLReflexiveObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLDataPropertyDomainAxiom axiom) {
}
@Override
public void visit(OWLImportsDeclaration axiom) {
}
@Override
public void visit(OWLObjectPropertyDomainAxiom axiom) {
}
@Override
public void visit(OWLEquivalentObjectPropertiesAxiom axiom) {
List properties = sort(axiom.getProperties());
int size = properties.size();
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
writeOpenBracket();
write(ROLES_EQUIVALENT);
write(properties.get(i));
write(properties.get(j));
writeCloseBracket();
writeln();
}
}
}
@Override
public void visit(OWLNegativeDataPropertyAssertionAxiom axiom) {
}
@Override
public void visit(OWLDifferentIndividualsAxiom axiom) {
}
@Override
public void visit(OWLDisjointDataPropertiesAxiom axiom) {
}
@Override
public void visit(OWLDisjointObjectPropertiesAxiom axiom) {
List properties = sort(axiom.getProperties());
int size = properties.size();
if (size <= 1) {
return;
}
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
writeOpenBracket();
write(DISJOINT_ROLES);
write(properties.get(i));
write(properties.get(j));
writeCloseBracket();
writeln();
}
}
}
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
}
@Override
public final void visit(OWLObjectPropertyAssertionAxiom axiom) {
write(RELATED);
write(axiom.getSubject());
write(axiom.getProperty());
write(axiom.getObject());
writeln();
}
@Override
public void visit(OWLFunctionalObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLSubObjectPropertyOfAxiom axiom) {
if (!(axiom.getSubProperty() instanceof OWLObjectProperty)) {
writeOpenBracket();
write(IMPLIES_ROLE);
write(axiom.getSubProperty());
write(axiom.getSuperProperty());
writeCloseBracket();
writeln();
}
}
@Override
public void visit(OWLDisjointUnionAxiom axiom) {
}
@Override
public void visit(OWLDeclarationAxiom axiom) {
}
@Override
public void visit(OWLSymmetricObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLDataPropertyRangeAxiom axiom) {
}
@Override
public void visit(OWLFunctionalDataPropertyAxiom axiom) {
}
@Override
public void visit(OWLEquivalentDataPropertiesAxiom axiom) {
}
@Override
public void visit(OWLEquivalentClassesAxiom axiom) {
List descriptions = sort(axiom.getClassExpressions());
int size = descriptions.size();
if (size <= 1) {
return;
}
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
writeOpenBracket();
write(EQUIVALENT);
write(descriptions.get(i));
write(descriptions.get(j));
writeCloseBracket();
writeln();
}
}
}
@Override
public void visit(OWLDataPropertyAssertionAxiom axiom) {
}
@Override
public void visit(OWLTransitiveObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLIrreflexiveObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLSubDataPropertyOfAxiom axiom) {
}
@Override
public void visit(OWLInverseFunctionalObjectPropertyAxiom axiom) {
}
@Override
public void visit(OWLSubPropertyChainOfAxiom axiom) {
if (leftRightIdentityUsed.contains(axiom)) {
return;
}
writeOpenBracket();
write(ROLE_INCLUSTION);
writeSpace();
writeChain(axiom.getPropertyChain(), 0);
writeSpace();
write(axiom.getSuperProperty());
writeCloseBracket();
writeln();
}
protected void writeChain(final List expressions, int i) {
if (i == expressions.size() - 1) {
write(expressions.get(i));
} else {
writeOpenBracket();
write(COMPOSE);
write(expressions.get(i));
writeChain(expressions, i + 1);
writeCloseBracket();
}
}
@Override
public void visit(OWLInverseObjectPropertiesAxiom axiom) {
writeOpenBracket();
write(INVERSE);
axiom.getFirstProperty().accept(this);
axiom.getSecondProperty().accept(this);
writeCloseBracket();
writeln();
}
@Override
public final void visit(OWLClass desc) {
write(desc.getIRI());
}
@Override
public void visit(OWLObjectOneOf desc) {
writeOpenBracket();
write(ONE_OF);
for (OWLIndividual individual : desc.getIndividuals()) {
write(individual);
}
writeCloseBracket();
}
@Override
public final void visit(OWLObjectProperty property) {
write(property.getIRI());
}
@Override
public final void visit(OWLObjectInverseOf property) {
writeOpenBracket();
write(INV);
writeSpace();
property.getInverseProperty();
property.getInverse().accept(this);
writeCloseBracket();
}
protected boolean isLeftIdentityAxiom(OWLSubPropertyChainOfAxiom axiom, OWLObjectProperty property) {
if (axiom.getSuperProperty().equals(property)) {
Iterator chain = axiom.getPropertyChain().iterator();
if (chain.hasNext()) {
if (chain.next() instanceof OWLObjectProperty) {
if (chain.hasNext() && chain.next().equals(property)) {
return !chain.hasNext();
}
}
}
}
return false;
}
protected boolean isRightIdentityAxiom(OWLSubPropertyChainOfAxiom axiom, OWLObjectProperty property) {
if (axiom.getSuperProperty().equals(property)) {
Iterator chain = axiom.getPropertyChain().iterator();
if (chain.hasNext()) {
if (chain.next().equals(property)) {
if (chain.hasNext()) {
chain.next();
return !chain.hasNext();
}
}
}
}
return false;
}
protected Set getPropertyChainSubPropertyAxiomsFor(OWLPropertyExpression property) {
Set axioms = new HashSet();
for (OWLSubPropertyChainOfAxiom axiom : ontology.getAxioms(AxiomType.SUB_PROPERTY_CHAIN_OF)) {
if (axiom.getSuperProperty().equals(property)) {
axioms.add(axiom);
}
}
return axioms;
}
public void reset() {
leftRightIdentityUsed.clear();
}
}
