Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[3924] trunk/components-core
|
From: <lor...@us...> - 2013-04-19 14:04:25
|
Revision: 3924
http://sourceforge.net/p/dl-learner/code/3924
Author: lorenz_b
Date: 2013-04-19 14:04:20 +0000 (Fri, 19 Apr 2013)
Log Message:
-----------
Added class expression to SPARQL rewriter.
Modified Paths:
--------------
trunk/components-core/pom.xml
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomPatternFinder.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomRenamer.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionOrderingComparator.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionRenamer.java
Added Paths:
-----------
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLLiteralRenamer.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLObjectComparator.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternAxiomToSPARQLConverter.java
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternExpressionToSPARQLConverter.java
trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java
trunk/components-core/src/main/resources/db_settings.ini.dist
Modified: trunk/components-core/pom.xml
===================================================================
--- trunk/components-core/pom.xml 2013-04-15 20:53:29 UTC (rev 3923)
+++ trunk/components-core/pom.xml 2013-04-19 14:04:20 UTC (rev 3924)
@@ -112,13 +112,32 @@
</exclusion>
</exclusions>
</dependency>
+ <dependency>
+ <groupId>org.ini4j</groupId>
+ <artifactId>ini4j</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>mysql</groupId>
+ <artifactId>mysql-connector-java</artifactId>
+ </dependency>
<dependency>
<groupId>net.sourceforge.owlapi</groupId>
<artifactId>owlapi-distribution</artifactId>
- <version>3.4.4</version>
+ <version>3.4</version>
</dependency>
<dependency>
+ <groupId>net.sourceforge.owlapi</groupId>
+ <artifactId>owlapi-dlsyntax</artifactId>
+ <version>3.3</version>
+ </dependency>
+ <dependency>
+ <groupId>net.sourceforge.owlapi</groupId>
+ <artifactId>owlapi-functional</artifactId>
+ <version>3.3</version>
+ </dependency>
+
+ <dependency>
<groupId>net.sourceforge.owlapi</groupId>
<artifactId>owlapi-reasoner</artifactId>
</dependency>
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomPatternFinder.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomPatternFinder.java 2013-04-15 20:53:29 UTC (rev 3923)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomPatternFinder.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -1,22 +1,46 @@
package org.dllearner.algorithms.pattern;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
import java.net.URI;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Queue;
+import java.util.prefs.Preferences;
+import org.coode.owlapi.functionalrenderer.OWLFunctionalSyntaxRenderer;
import org.dllearner.kb.dataset.OWLOntologyDataset;
import org.dllearner.kb.repository.OntologyRepository;
import org.dllearner.kb.repository.OntologyRepositoryEntry;
+import org.ini4j.IniPreferences;
+import org.ini4j.InvalidFileFormatException;
import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.AbstractOWLRenderer;
+import org.semanticweb.owlapi.io.OWLObjectRenderer;
import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLFunctionalDataPropertyAxiom;
import org.semanticweb.owlapi.model.OWLLogicalAxiom;
import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyChange;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLOntologyID;
import org.semanticweb.owlapi.model.OWLOntologyManager;
+import org.semanticweb.owlapi.reasoner.OWLReasoner;
+import org.semanticweb.owlapi.reasoner.OWLReasonerFactory;
+import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
+
+import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multisets;
@@ -45,6 +69,15 @@
private OntologyRepository repository;
private OWLOntologyManager manager;
private OWLDataFactory dataFactory;
+
+ private Connection conn;
+ private PreparedStatement selectOntologyIdPs;
+ private PreparedStatement insertOntologyPs;
+ private PreparedStatement selectPatternIdPs;
+ private PreparedStatement insertPatternIdPs;
+ private PreparedStatement insertOntologyPatternPs;
+
+ private OWLObjectRenderer axiomRenderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
public OWLAxiomPatternFinder(OWLOntologyDataset dataset) {
@@ -54,33 +87,228 @@
this.repository = repository;
manager = OWLManager.createOWLOntologyManager();
dataFactory = manager.getOWLDataFactory();
+
+ initDBConnection();
+ createTables();
+ try {
+ selectOntologyIdPs = conn.prepareStatement("SELECT id FROM Ontology WHERE url=?");
+ insertOntologyPs = conn.prepareStatement("INSERT INTO Ontology (url, iri, repository) VALUES(?,?,?)");
+ selectPatternIdPs = conn.prepareStatement("SELECT id FROM Pattern WHERE pattern=?");
+ insertPatternIdPs = conn.prepareStatement("INSERT INTO Pattern (pattern,pattern_pretty) VALUES(?,?)");
+ insertOntologyPatternPs = conn.prepareStatement("INSERT INTO Ontology_Pattern (ontology_id, pattern_id, occurrences) VALUES(?,?,?)");
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
}
- public void start(){
+ private String render(OWLAxiom axiom){
+ try {
+ OWLOntologyManager man = OWLManager.createOWLOntologyManager();
+ OWLOntology ontology = man.createOntology();
+ man.addAxiom(ontology, axiom);
+ StringWriter sw = new StringWriter();
+ org.coode.owlapi.functionalrenderer.OWLObjectRenderer r = new org.coode.owlapi.functionalrenderer.OWLObjectRenderer(man, ontology, sw);
+ axiom.accept(r);
+ return sw.toString();
+ } catch (OWLOntologyCreationException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ private void initDBConnection() {
+ try {
+ InputStream is = this.getClass().getClassLoader().getResourceAsStream("db_settings.ini");
+ Preferences prefs = new IniPreferences(is);
+ String dbServer = prefs.node("database").get("server", null);
+ String dbName = prefs.node("database").get("name", null);
+ String dbUser = prefs.node("database").get("user", null);
+ String dbPass = prefs.node("database").get("pass", null);
+
+ Class.forName("com.mysql.jdbc.Driver");
+ String url = "jdbc:mysql://" + dbServer + "/" + dbName;
+ conn = DriverManager.getConnection(url, dbUser, dbPass);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } catch (InvalidFileFormatException e) {
+ e.printStackTrace();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private void createTables(){
+ try {
+ Statement statement = conn.createStatement();
+
+ statement.execute("CREATE TABLE IF NOT EXISTS Pattern ("
+ + "id MEDIUMINT NOT NULL AUTO_INCREMENT,"
+ + "pattern VARCHAR(2000) NOT NULL,"
+ + "pattern_pretty VARCHAR(2000) NOT NULL,"
+ + "PRIMARY KEY(id),"
+ + "INDEX(pattern)) DEFAULT CHARSET=utf8");
+
+ statement.execute("CREATE TABLE IF NOT EXISTS Ontology ("
+ + "id MEDIUMINT NOT NULL AUTO_INCREMENT,"
+ + "url VARCHAR(2000) NOT NULL,"
+ + "iri VARCHAR(2000) NOT NULL,"
+ + "repository VARCHAR(200) NOT NULL,"
+ + "PRIMARY KEY(id),"
+ + "INDEX(url)) DEFAULT CHARSET=utf8");
+
+ statement.execute("CREATE TABLE IF NOT EXISTS Ontology_Pattern ("
+ + "ontology_id MEDIUMINT NOT NULL,"
+ + "pattern_id MEDIUMINT NOT NULL,"
+ + "occurrences INTEGER(8) NOT NULL,"
+ + "FOREIGN KEY (ontology_id) REFERENCES Ontology(id),"
+ + "FOREIGN KEY (pattern_id) REFERENCES Pattern(id),"
+ + "PRIMARY KEY(ontology_id, pattern_id)) DEFAULT CHARSET=utf8");
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ private int addPattern(OWLAxiom axiom){
+ String axiomString = render(axiom);
+ //check for existing entry
+ try {
+ selectPatternIdPs.setString(1, axiomString);
+ ResultSet rs = selectPatternIdPs.executeQuery();
+ if(rs.next()){
+ return rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ //add pattern entry
+ try {
+ insertPatternIdPs.setString(1, axiomString);
+ insertPatternIdPs.setString(2, axiomRenderer.render(axiom));
+ insertPatternIdPs.execute();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ //get the auto generated ID
+ try {
+ selectPatternIdPs.setString(1, axiomString);
+ ResultSet rs = selectPatternIdPs.executeQuery();
+ if(rs.next()){
+ return rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return -1;
+ }
+
+ private boolean ontologyProcessed(URI uri){
+ //check if ontology was already processed
+ try {
+ selectOntologyIdPs.setString(1, uri.toString());
+ ResultSet rs = selectOntologyIdPs.executeQuery();
+ return rs.next();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return false;
+ }
+
+ private int addOntology(URI physicalURI, OWLOntology ontology){
+ String url = physicalURI.toString();
+ String ontologyIRI = ontology.getOntologyID().getOntologyIRI().toString();
+ //check for existing entry
+ try {
+ selectOntologyIdPs.setString(1, url);
+ ResultSet rs = selectOntologyIdPs.executeQuery();
+ if(rs.next()){
+ return rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ //add ontology entry
+ try {
+ insertOntologyPs.setString(1, url);
+ insertOntologyPs.setString(2, ontologyIRI);
+ insertOntologyPs.setString(3, repository.getName());
+ insertOntologyPs.execute();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ //get the auto generated ID
+ try {
+ selectOntologyIdPs.setString(1, url);
+ ResultSet rs = selectOntologyIdPs.executeQuery();
+ if(rs.next()){
+ return rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return -1;
+ }
+
+ private void addOntologyPatterns(URI physicalURI, OWLOntology ontology, Multiset<OWLAxiom> patterns){
+ int ontologyId = addOntology(physicalURI, ontology);
+ for (OWLAxiom pattern : patterns.elementSet()) {
+ try {
+ int patternId = addPattern(pattern);
+ int occurrences = patterns.count(pattern);
+ insertOntologyPatternPs.setInt(1, ontologyId);
+ insertOntologyPatternPs.setInt(2, patternId);
+ insertOntologyPatternPs.setInt(3, occurrences);
+ insertOntologyPatternPs.execute();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public void start() {
OWLAxiomRenamer renamer = new OWLAxiomRenamer(dataFactory);
Collection<OntologyRepositoryEntry> entries = repository.getEntries();
- Multiset<OWLAxiom> multiset = HashMultiset.create();
+ Multiset<OWLAxiom> allAxiomPatterns = HashMultiset.create();
for (OntologyRepositoryEntry entry : entries) {
- try {
- URI uri = entry.getPhysicalURI();
- OWLOntology ontology = manager.loadOntology(IRI.create(uri));
- for(OWLLogicalAxiom axiom : ontology.getLogicalAxioms()){
- OWLAxiom renamedAxiom = renamer.rename(axiom);
- multiset.add(renamedAxiom);
+ URI uri = entry.getPhysicalURI();
+ if (!ontologyProcessed(uri)) {
+ System.out.println("Loading " + uri);
+ try {
+ OWLOntology ontology = manager.loadOntology(IRI.create(uri));
+ Multiset<OWLAxiom> axiomPatterns = HashMultiset.create();
+ for (OWLLogicalAxiom axiom : ontology.getLogicalAxioms()) {
+ OWLAxiom renamedAxiom = renamer.rename(axiom);
+ axiomPatterns.add(renamedAxiom);
+ }
+ allAxiomPatterns.addAll(axiomPatterns);
+ addOntologyPatterns(uri, ontology, axiomPatterns);
+ for (OWLAxiom owlAxiom : Multisets.copyHighestCountFirst(allAxiomPatterns).elementSet()) {
+// System.out.println(owlAxiom + ": " + allAxiomPatterns.count(owlAxiom));
+ }
+ manager.removeOntology(ontology);
+ } catch (OWLOntologyCreationException e) {
+ e.printStackTrace();
}
- } catch (OWLOntologyCreationException e) {
- e.printStackTrace();
}
- for (OWLAxiom owlAxiom : Multisets.copyHighestCountFirst(multiset).elementSet()) {
- System.out.println(owlAxiom + ": " + multiset.count(owlAxiom));
- }
+
}
- for (OWLAxiom owlAxiom : Multisets.copyHighestCountFirst(multiset).elementSet()) {
- System.out.println(owlAxiom + ": " + multiset.count(owlAxiom));
- }
}
public static void main(String[] args) throws Exception {
+ String ontologyURL = "ontologyURL";
+ OWLOntologyManager man = OWLManager.createOWLOntologyManager();
+ OWLDataFactory dataFactory = man.getOWLDataFactory();
+ OWLFunctionalDataPropertyAxiom axiom = dataFactory.getOWLFunctionalDataPropertyAxiom(dataFactory.getOWLDataProperty(IRI.create("http://ex.org/p")));
+ OWLOntology ontology = man.createOntology();
+ man.addAxiom(ontology, axiom);
+ StringWriter sw = new StringWriter();
+ org.coode.owlapi.functionalrenderer.OWLObjectRenderer r = new org.coode.owlapi.functionalrenderer.OWLObjectRenderer(man, ontology, sw);
+ axiom.accept(r);
+ System.out.println(sw.toString());
}
}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomRenamer.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomRenamer.java 2013-04-15 20:53:29 UTC (rev 3923)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLAxiomRenamer.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -2,8 +2,10 @@
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.TreeSet;
import org.semanticweb.owlapi.model.OWLAnnotationAssertionAxiom;
@@ -12,6 +14,7 @@
import org.semanticweb.owlapi.model.OWLAsymmetricObjectPropertyAxiom;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLAxiomVisitor;
+import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.model.OWLDataFactory;
@@ -108,14 +111,26 @@
@Override
public void visit(OWLAsymmetricObjectPropertyAxiom axiom) {
+ OWLObjectPropertyExpression property = axiom.getProperty();
+ property = expressionRenamer.rename(property);
+ renamedAxiom = df.getOWLAsymmetricObjectPropertyAxiom(property);
}
@Override
public void visit(OWLReflexiveObjectPropertyAxiom axiom) {
+ OWLObjectPropertyExpression property = axiom.getProperty();
+ property = expressionRenamer.rename(property);
+ renamedAxiom = df.getOWLReflexiveObjectPropertyAxiom(property);
}
@Override
public void visit(OWLDisjointClassesAxiom axiom) {
+ Set<OWLClassExpression> classExpressions = axiom.getClassExpressions();
+ Set<OWLClassExpression> renamedClassExpressions = new HashSet<OWLClassExpression>();
+ for (OWLClassExpression classExpression : classExpressions) {
+ renamedClassExpressions.add(expressionRenamer.rename(classExpression));
+ }
+ renamedAxiom = df.getOWLDisjointClassesAxiom(renamedClassExpressions);
}
@Override
@@ -138,22 +153,46 @@
@Override
public void visit(OWLEquivalentObjectPropertiesAxiom axiom) {
+ Set<OWLObjectPropertyExpression> properties = axiom.getProperties();
+ Set<OWLObjectPropertyExpression> renamedProperties = new HashSet<OWLObjectPropertyExpression>();
+ for (OWLObjectPropertyExpression property : properties) {
+ renamedProperties.add(expressionRenamer.rename(property));
+ }
+ renamedAxiom = df.getOWLEquivalentObjectPropertiesAxiom(renamedProperties);
}
@Override
public void visit(OWLNegativeDataPropertyAssertionAxiom axiom) {
+// axiom.
}
@Override
public void visit(OWLDifferentIndividualsAxiom axiom) {
+ Set<OWLIndividual> renamedIndividuals = new HashSet<OWLIndividual>();
+ for(OWLIndividual ind : axiom.getIndividuals()){
+ renamedIndividuals.add(expressionRenamer.rename(ind));
+ }
+ renamedAxiom = df.getOWLDifferentIndividualsAxiom(renamedIndividuals);
}
@Override
public void visit(OWLDisjointDataPropertiesAxiom axiom) {
+ Set<OWLDataPropertyExpression> properties = axiom.getProperties();
+ Set<OWLDataPropertyExpression> renamedProperties = new HashSet<OWLDataPropertyExpression>();
+ for (OWLDataPropertyExpression property : properties) {
+ renamedProperties.add(expressionRenamer.rename(property));
+ }
+ renamedAxiom = df.getOWLDisjointDataPropertiesAxiom(renamedProperties);
}
@Override
public void visit(OWLDisjointObjectPropertiesAxiom axiom) {
+ Set<OWLObjectPropertyExpression> properties = axiom.getProperties();
+ Set<OWLObjectPropertyExpression> renamedProperties = new HashSet<OWLObjectPropertyExpression>();
+ for (OWLObjectPropertyExpression property : properties) {
+ renamedProperties.add(expressionRenamer.rename(property));
+ }
+ renamedAxiom = df.getOWLDisjointObjectPropertiesAxiom(renamedProperties);
}
@Override
@@ -194,6 +233,14 @@
@Override
public void visit(OWLDisjointUnionAxiom axiom) {
+ OWLClass cls = axiom.getOWLClass();
+ cls = expressionRenamer.rename(cls).asOWLClass();
+ Set<OWLClassExpression> classExpressions = axiom.getClassExpressions();
+ Set<OWLClassExpression> renamedClassExpressions = new HashSet<OWLClassExpression>();
+ for (OWLClassExpression classExpression : classExpressions) {
+ renamedClassExpressions.add(expressionRenamer.rename(classExpression));
+ }
+ renamedAxiom = df.getOWLDisjointUnionAxiom(cls, renamedClassExpressions);
}
@Override
@@ -221,6 +268,12 @@
@Override
public void visit(OWLEquivalentDataPropertiesAxiom axiom) {
+ Set<OWLDataPropertyExpression> properties = axiom.getProperties();
+ Set<OWLDataPropertyExpression> renamedProperties = new HashSet<OWLDataPropertyExpression>();
+ for (OWLDataPropertyExpression property : properties) {
+ renamedProperties.add(expressionRenamer.rename(property));
+ }
+ renamedAxiom = df.getOWLEquivalentDataPropertiesAxiom(renamedProperties);
}
@Override
@@ -278,10 +331,18 @@
@Override
public void visit(OWLInverseFunctionalObjectPropertyAxiom axiom) {
+ OWLObjectPropertyExpression property = axiom.getProperty();
+ property = expressionRenamer.rename(property);
+ renamedAxiom = df.getOWLInverseFunctionalObjectPropertyAxiom(property);
}
@Override
public void visit(OWLSameIndividualAxiom axiom) {
+ Set<OWLIndividual> renamedIndividuals = new HashSet<OWLIndividual>();
+ for(OWLIndividual ind : axiom.getIndividuals()){
+ renamedIndividuals.add(expressionRenamer.rename(ind));
+ }
+ renamedAxiom = df.getOWLSameIndividualAxiom(renamedIndividuals);
}
@Override
@@ -290,6 +351,11 @@
@Override
public void visit(OWLInverseObjectPropertiesAxiom axiom) {
+ OWLObjectPropertyExpression firstProperty = axiom.getFirstProperty();
+ firstProperty = expressionRenamer.rename(firstProperty);
+ OWLObjectPropertyExpression secondProperty = axiom.getSecondProperty();
+ secondProperty = expressionRenamer.rename(secondProperty);
+ renamedAxiom = df.getOWLInverseObjectPropertiesAxiom(firstProperty, secondProperty);
}
@Override
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionOrderingComparator.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionOrderingComparator.java 2013-04-15 20:53:29 UTC (rev 3923)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionOrderingComparator.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -5,6 +5,7 @@
import java.util.List;
import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.util.OWLObjectTypeIndexProvider;
import uk.ac.manchester.cs.owl.owlapi.OWLClassExpressionImpl;
import uk.ac.manchester.cs.owl.owlapi.OWLClassImpl;
@@ -32,6 +33,8 @@
OWLObjectMaxCardinalityImpl.class,
OWLObjectExactCardinalityImpl.class
);
+
+ private final OWLObjectTypeIndexProvider indexProvider = new OWLObjectTypeIndexProvider();
@Override
public int compare(OWLClassExpression o1, OWLClassExpression o2) {
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionRenamer.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionRenamer.java 2013-04-15 20:53:29 UTC (rev 3923)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLClassExpressionRenamer.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -1,10 +1,6 @@
package org.dllearner.algorithms.pattern;
-import java.io.BufferedReader;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.Arrays;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
@@ -58,23 +54,46 @@
import org.semanticweb.owlapi.model.OWLObjectUnionOf;
import org.semanticweb.owlapi.model.OWLPropertyExpression;
import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitor;
-import org.semanticweb.owlapi.util.OWLClassExpressionVisitorAdapter;
public class OWLClassExpressionRenamer implements OWLClassExpressionVisitor, OWLPropertyExpressionVisitor, OWLIndividualVisitor, OWLDataRangeVisitor {
private static final String NS = "http://dl-learner.org/pattern/";
- private Queue<String> classVarQueue = new LinkedList<String>(Arrays.asList("A", "B", "C" , "D", "E", "F", "G"));
- private Queue<String> propertyVarQueue = new LinkedList<String>(Arrays.asList("p", "q", "r" , "s", "t"));
- private Queue<String> individualVarQueue = new LinkedList<String>(Arrays.asList("a", "b", "c" , "d", "e", "f", "g"));
private OWLDataFactory df;
private Map<OWLEntity, OWLEntity> renaming;
private OWLObject renamedOWLObject;
- private OWLClassExpressionOrderingComparator comparator = new OWLClassExpressionOrderingComparator();
+// private OWLClassExpressionOrderingComparator comparator = new OWLClassExpressionOrderingComparator();
+ private OWLObjectComparator comparator = new OWLObjectComparator();
+ private Queue<String> classVarQueue = new LinkedList<String>();
+ private Queue<String> propertyVarQueue = new LinkedList<String>();
+ private Queue<String> individualVarQueue = new LinkedList<String>();
+ private OWLLiteralRenamer literalRenamer;
+
+ private boolean normalizeCardinalities = true;
+ private boolean normalizeHasValue = true;
+ private boolean normalizeOneOf = true;
+
public OWLClassExpressionRenamer(OWLDataFactory df, Map<OWLEntity, OWLEntity> renaming) {
this.df = df;
this.renaming = renaming;
+
+ literalRenamer = new OWLLiteralRenamer(df);
+
+ for(int i = 65; i <= 90; i++){
+ classVarQueue.add(String.valueOf((char)i));
+ }
+ for(int j = 2; j <=5; j++){
+ for(int i = 65; i <= 90; i++){
+ classVarQueue.add(String.valueOf((char)i) + "_" + j);
+ }
+ }
+ for(int i = 97; i <= 111; i++){
+ individualVarQueue.add(String.valueOf((char)i));
+ }
+ for(int i = 112; i <= 122; i++){
+ propertyVarQueue.add(String.valueOf((char)i));
+ }
}
public OWLClassExpression rename(OWLClassExpression expr){
@@ -103,7 +122,7 @@
public OWLLiteral rename(OWLLiteral lit){
renamedOWLObject = null;
- renamedOWLObject = lit;
+ renamedOWLObject = literalRenamer.rename(lit);
return (OWLLiteral) renamedOWLObject;
}
@@ -134,6 +153,7 @@
OWLDataPropertyExpression property = desc.getProperty();
property = rename(property);
OWLLiteral value = desc.getValue();
+ value = rename(value);
renamedOWLObject = df.getOWLDataHasValue(property, value);
}
@@ -178,6 +198,9 @@
OWLClassExpression filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLObjectMinCardinality(cardinality, property, filler);
}
@@ -188,6 +211,9 @@
OWLClassExpression filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLObjectExactCardinality(cardinality, property, filler);
}
@@ -198,6 +224,9 @@
OWLClassExpression filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLObjectMaxCardinality(cardinality, property, filler);
}
@@ -243,6 +272,9 @@
OWLDataRange filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLDataMinCardinality(cardinality, property, filler);
}
@@ -253,6 +285,9 @@
OWLDataRange filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLDataExactCardinality(cardinality, property, filler);
}
@@ -263,6 +298,9 @@
OWLDataRange filler = desc.getFiller();
filler = rename(filler);
int cardinality = desc.getCardinality();
+ if(normalizeCardinalities){
+ cardinality = 1;
+ }
renamedOWLObject = df.getOWLDataMaxCardinality(cardinality, property, filler);
}
@@ -355,19 +393,37 @@
}
@Override
- public void visit(OWLDataComplementOf arg0) {
+ public void visit(OWLDataComplementOf desc) {
+ OWLDataRange dataRange = desc.getDataRange();
+ dataRange = rename(dataRange);
+ renamedOWLObject = df.getOWLDataComplementOf(dataRange);
}
@Override
- public void visit(OWLDataIntersectionOf arg0) {
+ public void visit(OWLDataIntersectionOf desc) {
+ List<OWLDataRange> operands = new ArrayList<OWLDataRange>(desc.getOperands());
+ Collections.sort(operands, comparator);
+ SortedSet<OWLDataRange> renamedOperands = new TreeSet<OWLDataRange>(comparator);
+ for(OWLDataRange expr : operands){
+ renamedOperands.add(rename(expr));
+ }
+ renamedOWLObject = df.getOWLDataIntersectionOf(renamedOperands);
}
@Override
- public void visit(OWLDataUnionOf arg0) {
+ public void visit(OWLDataUnionOf desc) {
+ List<OWLDataRange> operands = new ArrayList<OWLDataRange>(desc.getOperands());
+ Collections.sort(operands, comparator);
+ SortedSet<OWLDataRange> renamedOperands = new TreeSet<OWLDataRange>(comparator);
+ for(OWLDataRange expr : operands){
+ renamedOperands.add(rename(expr));
+ }
+ renamedOWLObject = df.getOWLDataUnionOf(renamedOperands);
}
@Override
- public void visit(OWLDatatypeRestriction arg0) {
+ public void visit(OWLDatatypeRestriction desc) {
+ renamedOWLObject = desc;
}
}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLLiteralRenamer.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLLiteralRenamer.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLLiteralRenamer.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -0,0 +1,44 @@
+package org.dllearner.algorithms.pattern;
+
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLDatatype;
+import org.semanticweb.owlapi.model.OWLLiteral;
+import org.semanticweb.owlapi.vocab.OWL2Datatype;
+
+public class OWLLiteralRenamer {
+
+ private OWLDataFactory dataFactory;
+
+ public OWLLiteralRenamer(OWLDataFactory dataFactory) {
+ this.dataFactory = dataFactory;
+ }
+
+ public OWLLiteral rename(OWLLiteral literal){
+ OWLLiteral renamedLiteral = literal;
+ OWLDatatype datatype = literal.getDatatype();
+ if(datatype.isRDFPlainLiteral()){
+ if(literal.hasLang()){
+ renamedLiteral = dataFactory.getOWLLiteral("plain", literal.getLang());
+ } else {
+ renamedLiteral = dataFactory.getOWLLiteral("plain");
+ }
+ } else {
+ if(datatype.getIRI().equals(OWL2Datatype.XSD_STRING.getIRI())){
+ renamedLiteral = dataFactory.getOWLLiteral("string", datatype);
+ } else if(datatype.getIRI().equals(OWL2Datatype.XSD_DOUBLE.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_DECIMAL.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_FLOAT.getIRI())){
+ renamedLiteral = dataFactory.getOWLLiteral("1.0", datatype);
+ } else if(datatype.getIRI().equals(OWL2Datatype.XSD_INT.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_INTEGER.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_LONG.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_BYTE.getIRI()) ||
+ datatype.getIRI().equals(OWL2Datatype.XSD_SHORT.getIRI())){
+ renamedLiteral = dataFactory.getOWLLiteral("1", datatype);
+ }
+ }
+ renamedLiteral = dataFactory.getOWLLiteral("", OWL2Datatype.RDF_PLAIN_LITERAL);
+ return renamedLiteral;
+ }
+
+}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLObjectComparator.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLObjectComparator.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/OWLObjectComparator.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -0,0 +1,21 @@
+package org.dllearner.algorithms.pattern;
+
+import java.util.Comparator;
+
+import org.semanticweb.owlapi.model.OWLObject;
+import org.semanticweb.owlapi.util.OWLObjectTypeIndexProvider;
+
+public class OWLObjectComparator implements Comparator<OWLObject> {
+
+ private final OWLObjectTypeIndexProvider indexProvider = new OWLObjectTypeIndexProvider();
+
+ @Override
+ public int compare(OWLObject o1, OWLObject o2) {
+ int diff = indexProvider.getTypeIndex(o1) - indexProvider.getTypeIndex(o2);
+ if(diff == 0){
+ return o1.compareTo(o2);
+ } else {
+ return diff;
+ }
+ }
+}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternAxiomToSPARQLConverter.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternAxiomToSPARQLConverter.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternAxiomToSPARQLConverter.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -0,0 +1,286 @@
+package org.dllearner.algorithms.pattern;
+
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.ToStringRenderer;
+import org.semanticweb.owlapi.model.OWLAnnotationAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLAnnotationPropertyDomainAxiom;
+import org.semanticweb.owlapi.model.OWLAnnotationPropertyRangeAxiom;
+import org.semanticweb.owlapi.model.OWLAsymmetricObjectPropertyAxiom;
+import org.semanticweb.owlapi.model.OWLAxiom;
+import org.semanticweb.owlapi.model.OWLAxiomVisitor;
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLDataPropertyAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLDataPropertyDomainAxiom;
+import org.semanticweb.owlapi.model.OWLDataPropertyRangeAxiom;
+import org.semanticweb.owlapi.model.OWLDatatypeDefinitionAxiom;
+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.OWLHasKeyAxiom;
+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.OWLNegativeDataPropertyAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLNegativeObjectPropertyAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLObjectPropertyDomainAxiom;
+import org.semanticweb.owlapi.model.OWLObjectPropertyRangeAxiom;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+import org.semanticweb.owlapi.model.OWLReflexiveObjectPropertyAxiom;
+import org.semanticweb.owlapi.model.OWLSameIndividualAxiom;
+import org.semanticweb.owlapi.model.OWLSubAnnotationPropertyOfAxiom;
+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;
+import org.semanticweb.owlapi.model.PrefixManager;
+import org.semanticweb.owlapi.model.SWRLRule;
+import org.semanticweb.owlapi.util.DefaultPrefixManager;
+
+import uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;
+
+import com.hp.hpl.jena.query.Query;
+import com.hp.hpl.jena.query.QueryFactory;
+import com.hp.hpl.jena.query.Syntax;
+
+public class PatternAxiomToSPARQLConverter implements OWLAxiomVisitor {
+
+ private String root = "?x";
+ private PatternExpressionToSPARQLConverter expressionConverter;
+ private String sparql;
+
+ public PatternAxiomToSPARQLConverter() {
+ }
+
+ public Query convert(OWLAxiom axiom) {
+ expressionConverter = new PatternExpressionToSPARQLConverter();
+
+ sparql = "SELECT " + root + " WHERE {\n";
+ axiom.accept(this);
+ sparql += "}";
+
+ return QueryFactory.create(sparql, Syntax.syntaxARQ);
+ }
+
+ @Override
+ public void visit(OWLAnnotationAssertionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLSubAnnotationPropertyOfAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLAnnotationPropertyDomainAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLAnnotationPropertyRangeAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDeclarationAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLSubClassOfAxiom axiom) {
+ OWLClassExpression subClass = axiom.getSubClass();
+ sparql += expressionConverter.convert(root, subClass);
+ OWLClassExpression superClass = axiom.getSuperClass();
+ sparql += expressionConverter.convert(root, superClass);
+ }
+
+ @Override
+ public void visit(OWLNegativeObjectPropertyAssertionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLAsymmetricObjectPropertyAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLReflexiveObjectPropertyAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDisjointClassesAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDataPropertyDomainAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLObjectPropertyDomainAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLEquivalentObjectPropertiesAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLNegativeDataPropertyAssertionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDifferentIndividualsAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDisjointDataPropertiesAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDisjointObjectPropertiesAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLObjectPropertyRangeAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLObjectPropertyAssertionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLFunctionalObjectPropertyAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLSubObjectPropertyOfAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDisjointUnionAxiom 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(OWLClassAssertionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLEquivalentClassesAxiom axiom) {
+ }
+
+ @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(OWLSameIndividualAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLSubPropertyChainOfAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLInverseObjectPropertiesAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLHasKeyAxiom axiom) {
+ }
+
+ @Override
+ public void visit(OWLDatatypeDefinitionAxiom axiom) {
+ }
+
+ @Override
+ public void visit(SWRLRule axiom) {
+ }
+
+ public static void main(String[] args) throws Exception {
+ ToStringRenderer.getInstance().setRenderer(new DLSyntaxObjectRenderer());
+ PatternAxiomToSPARQLConverter converter = new PatternAxiomToSPARQLConverter();
+
+ OWLOntologyManager man = OWLManager.createOWLOntologyManager();
+ OWLDataFactory df = man.getOWLDataFactory();
+ PrefixManager pm = new DefaultPrefixManager("http://examples.org/ontology#");
+
+ OWLClass clsA = df.getOWLClass("A", pm);
+ OWLClass clsB = df.getOWLClass("B", pm);
+ OWLClass clsC = df.getOWLClass("C", pm);
+
+ OWLObjectProperty propR = df.getOWLObjectProperty("r", pm);
+ OWLObjectProperty propS = df.getOWLObjectProperty("s", pm);
+
+ OWLIndividual indA = df.getOWLNamedIndividual("a", pm);
+ OWLIndividual indB = df.getOWLNamedIndividual("b", pm);
+
+ OWLAxiom axiom = df.getOWLSubClassOfAxiom(
+ clsA,
+ clsB);
+ Query query = converter.convert(axiom);
+ System.out.println(axiom + "\n" + query);
+
+ axiom = df.getOWLSubClassOfAxiom(
+ clsA,
+ df.getOWLObjectSomeValuesFrom(propR, clsB));
+ query = converter.convert(axiom);
+ System.out.println(axiom + "\n" + query);
+
+ axiom = df.getOWLSubClassOfAxiom(
+ clsA,
+ df.getOWLObjectIntersectionOf(
+ df.getOWLObjectSomeValuesFrom(propR, clsB),
+ clsB));
+ query = converter.convert(axiom);
+ System.out.println(axiom + "\n" + query);
+
+ axiom = df.getOWLSubClassOfAxiom(
+ clsA,
+ df.getOWLObjectAllValuesFrom(propR, clsB));
+ query = converter.convert(axiom);
+ System.out.println(axiom + "\n" + query);
+
+ }
+
+}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternExpressionToSPARQLConverter.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternExpressionToSPARQLConverter.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternExpressionToSPARQLConverter.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -0,0 +1,207 @@
+package org.dllearner.algorithms.pattern;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLClassExpressionVisitor;
+import org.semanticweb.owlapi.model.OWLDataAllValuesFrom;
+import org.semanticweb.owlapi.model.OWLDataExactCardinality;
+import org.semanticweb.owlapi.model.OWLDataHasValue;
+import org.semanticweb.owlapi.model.OWLDataMaxCardinality;
+import org.semanticweb.owlapi.model.OWLDataMinCardinality;
+import org.semanticweb.owlapi.model.OWLDataProperty;
+import org.semanticweb.owlapi.model.OWLDataSomeValuesFrom;
+import org.semanticweb.owlapi.model.OWLEntity;
+import org.semanticweb.owlapi.model.OWLObjectAllValuesFrom;
+import org.semanticweb.owlapi.model.OWLObjectComplementOf;
+import org.semanticweb.owlapi.model.OWLObjectExactCardinality;
+import org.semanticweb.owlapi.model.OWLObjectHasSelf;
+import org.semanticweb.owlapi.model.OWLObjectHasValue;
+import org.semanticweb.owlapi.model.OWLObjectIntersectionOf;
+import org.semanticweb.owlapi.model.OWLObjectInverseOf;
+import org.semanticweb.owlapi.model.OWLObjectMaxCardinality;
+import org.semanticweb.owlapi.model.OWLObjectMinCardinality;
+import org.semanticweb.owlapi.model.OWLObjectOneOf;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
+import org.semanticweb.owlapi.model.OWLObjectSomeValuesFrom;
+import org.semanticweb.owlapi.model.OWLObjectUnionOf;
+import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitor;
+
+public class PatternExpressionToSPARQLConverter implements OWLClassExpressionVisitor, OWLPropertyExpressionVisitor{
+
+ private String sparql = "";
+ private Stack<String> variables = new Stack<String>();
+ private Map<OWLEntity, String> variablesMapping;
+
+ private int classCnt = 0;
+ private int propCnt = 0;
+ private int indCnt = 0;
+
+ public PatternExpressionToSPARQLConverter() {
+ variablesMapping = new HashMap<OWLEntity, String>();
+ }
+
+ public String convert(String root, OWLClassExpression expr){
+ sparql = "";
+ variables.push(root);
+ expr.accept(this);
+ return sparql;
+ }
+
+ private String getVariable(OWLEntity entity){
+ String var = variablesMapping.get(entity);
+ if(var == null){
+ if(entity.isOWLClass()){
+ var = "?cls" + classCnt++;
+ } else if(entity.isOWLObjectProperty() || entity.isOWLDataProperty()){
+ var = "?p" + propCnt++;
+ } else if(entity.isOWLNamedIndividual()){
+ var = buildIndividualVariable();
+ }
+ variablesMapping.put(entity, var);
+ }
+ return var;
+ }
+
+ private String buildIndividualVariable(){
+ return "?s" + indCnt++;
+ }
+
+ private String triple(String subject, String predicate, String object){
+ return subject + " " + predicate + " " + object + ".\n";
+ }
+
+ @Override
+ public void visit(OWLClass expr) {
+ sparql += variables.peek() + " a " + getVariable(expr) +".\n";
+ }
+
+ @Override
+ public void visit(OWLObjectProperty property) {
+
+ }
+
+ @Override
+ public void visit(OWLDataProperty property) {
+ }
+
+ @Override
+ public void visit(OWLObjectIntersectionOf expr) {
+ Set<OWLClassExpression> operands = expr.getOperands();
+ String variable = variables.peek();
+ for (OWLClassExpression operand : operands) {
+ sparql += convert(variable, operand);
+ }
+ }
+
+ @Override
+ public void visit(OWLObjectUnionOf expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectComplementOf expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectSomeValuesFrom expr) {
+ String variable = variables.peek();
+ OWLObjectPropertyExpression property = expr.getProperty();
+ if(!property.isAnonymous()){
+ String objectVariable = buildIndividualVariable();
+ variables.push(objectVariable);
+ //build the triple for the property
+ sparql += triple(variable, getVariable(property.asOWLObjectProperty()), objectVariable);
+ //build the rest according to the role filler
+ OWLClassExpression filler = expr.getFiller();
+ filler.accept(this);
+ variables.pop();
+
+ } else {
+ System.err.println("TODO: complex property expressions");
+ }
+
+ }
+
+ @Override
+ public void visit(OWLObjectAllValuesFrom expr) {
+ String variable = variables.peek();
+ OWLObjectPropertyExpression property = expr.getProperty();
+ if(!property.isAnonymous()){
+ String objectVariable = buildIndividualVariable();
+ variables.push(objectVariable);
+ //build the triple for the property
+ sparql += triple(variable, getVariable(property.asOWLObjectProperty()), objectVariable);
+ OWLClassExpression filler = expr.getFiller();
+ filler.accept(this);
+ //build the rest according to the role filler
+ sparql += "FILTER NOT EXISTS{";
+ objectVariable = buildIndividualVariable();
+ variables.push(objectVariable);
+ sparql += triple(variable, getVariable(property.asOWLObjectProperty()), objectVariable);
+ variables.pop();
+ sparql += "}";
+
+
+ } else {
+ System.err.println("TODO: complex property expressions");
+ }
+ }
+
+ @Override
+ public void visit(OWLObjectHasValue expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectMinCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectExactCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectMaxCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectHasSelf expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectOneOf expr) {
+ }
+
+ @Override
+ public void visit(OWLDataSomeValuesFrom expr) {
+ }
+
+ @Override
+ public void visit(OWLDataAllValuesFrom expr) {
+ }
+
+ @Override
+ public void visit(OWLDataHasValue expr) {
+ }
+
+ @Override
+ public void visit(OWLDataMinCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLDataExactCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLDataMaxCardinality expr) {
+ }
+
+ @Override
+ public void visit(OWLObjectInverseOf property) {
+ }
+
+}
Added: trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java 2013-04-19 14:04:20 UTC (rev 3924)
@@ -0,0 +1,568 @@
+package org.dllearner.utilities.owl;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+import org.aksw.commons.collections.diff.ModelDiff;
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.ToStringRenderer;
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLClassExpressionVisitor;
+import org.semanticweb.owlapi.model.OWLDataAllValuesFrom;
+import org.semanticweb.owlapi.model.OWLDataComplementOf;
+import org.semanticweb.owlapi.model.OWLDataExactCardinality;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLDataHasValue;
+import org.semanticweb.owlapi.model.OWLDataIntersectionOf;
+import org.semanticweb.owlapi.model.OWLDataMaxCardinality;
+import org.semanticweb.owlapi.model.OWLDataMinCardinality;
+import org.semanticweb.owlapi.model.OWLDataOneOf;
+import org.semanticweb.owlapi.model.OWLDataProperty;
+import org.semanticweb.owlapi.model.OWLDataPropertyExpression;
+import org.semanticweb.owlapi.model.OWLDataRange;
+import org.semanticweb.owlapi.model.OWLDataRangeVisitor;
+import org.semanticweb.owlapi.model.OWLDataSomeValuesFrom;
+import org.semanticweb.owlapi.model.OWLDataUnionOf;
+import org.semanticweb.owlapi.model.OWLDatatype;
+import org.semanticweb.owlapi.model.OWLDatatypeRestriction;
+import org.semanticweb.owlapi.model.OWLEntity;
+import org.semanticweb.owlapi.model.OWLIndividual;
+import org.semanticweb.owlapi.model.OWLLiteral;
+import org.semanticweb.owlapi.model.OWLObjectAllValuesFrom;
+import org.semanticweb.owlapi.model.OWLObjectComplementOf;
+import org.semanticweb.owlapi.model.OWLObjectExactCardinality;
+import org.semanticweb.owlapi.model.OWLObjectHasSelf;
+import org.semanticweb.owlapi.model.OWLObjectHasValue;
+import org.semanticweb.owlapi.model.OWLObjectIntersectionOf;
+import org.semanticweb.owlapi.model.OWLObjectInverseOf;
+import org.semanticweb.owlapi.model.OWLObjectMaxCardinality;
+import org.semanticweb.owlapi.model.OWLObjectMinCardinality;
+import org.semanticweb.owlapi.model.OWLObjectOneOf;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
+import org.semanticweb.owlapi.model.OWLObjectSomeValuesFrom;
+import org.semanticweb.owlapi.model.OWLObjectUnionOf;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+import org.semanticweb.owlapi.model.OWLPropertyExpression;
+import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitor;
+import org.semanticweb.owlapi.model.PrefixManager;
+import org.semanticweb.owlapi.util.DefaultPrefixManager;
+
+import uk.ac.manchester.cs.owl.owlapi.OWLDataFactoryImpl;
+import uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;
+
+import com.hp.hpl.jena.query.Query;
+import com.hp.hpl.jena.query.QueryFactory;
+import com.hp.hpl.jena.query.Syntax;
+
+public class OWLClassExpressionToSPARQLConverter implements OWLClassExpressionVisitor, OWLPropertyExpressionVisitor, OWLDataRangeVisitor{
+
+ private String sparql = "";
+ private Stack<String> variables = new Stack<String>();
+ private Map<OWLEntity, String> variablesMapping;
+
+ private int classCnt = 0;
+ private int propCnt = 0;
+ private int indCnt = 0;
+
+ private OWLDataFactory df = new OWLDataFactoryImpl();
+
+ public OWLClassExpressionToSPARQLConverter() {
+ }
+
+ public String convert(String rootVariable, OWLClassExpression expr){
+ reset();
+ variables.push(rootVariable);
+ expr.accept(this);
+ return sparql;
+ }
+
+ public String convert(String rootVariable, OWLPropertyExpression expr){
+ variables.push(rootVariable);
+ sparql = "";
+ expr.accept(this);
+ return sparql;
+ }
+
+ public Query asQuery(String rootVariable, OWLClassExpression expr){
+ String queryString = "SELECT " + rootVariable + " WHERE {";
+ queryString += convert(rootVariable, expr);
+ queryString += "}";System.out.println(queryString);
+ return QueryFactory.create(queryString, Syntax.syntaxARQ);
+ }
+
+ private void reset(){
+ variables.clear();
+ classCnt = 0;
+ propCnt = 0;
+ indCnt = 0;
+ sparql = "";
+ }
+
+ private String getVariable(OWLEntity entity){
+ String var = variablesMapping.get(entity);
+ if(var == null){
+ if(entity.isOWLClass()){
+ var = "?cls" + classCnt++;
+ } else if(entity.isOWLObjectProperty() || entity.isOWLDataProperty()){
+ var = "?p" + propCnt++;
+ } else if(entity.isOWLNamedIndividual()){
+ var = buildIndividualVariable();
+ }
+ variablesMapping.put(entity, var);
+ }
+ return var;
+ }
+
+ private String buildIndividualVariable(){
+ return "?s" + indCnt++;
+ }
+
+ private int modalDepth(){
+ return variables.size();
+ }
+
+ private String triple(String subject, String predicate, String object){
+ return (subject.startsWith("?") ? subject : "<" + subject + ">") + " " +
+ (predicate.startsWith("?") || predicate.equals("a") ? predicate : "<" + predicate + ">") + " " +
+ (object.startsWith("?") ? object : "<" + object + ">") + ".\n";
+ }
+
+ private String triple(String subject, String predicate, OWLLiteral object){
+ return (subject.startsWith("?") ? subject : "<" + subject + ">") + " " +
+ (predicate.startsWith("?") || predicate.equals("a") ? predicate : "<" + predicate + ">") + " " +
+ "\"" + object + "\"^^<" + object.getDatatype().toStringID() + ">.\n";
+ }
+
+ private String triple(String subject, String predicate, OWLIndividual object){
+ return (subject.startsWith("?") ? subject : "<" + subject + ">") + " " +
+ (predicate.startsWith("?") || predicate.equals("a") ? predicate : "<" + predicate + ">") + " " +
+ "<" + object.toStringID() + ">.\n";
+ }
+
+ @Override
+ public void visit(OWLObjectProperty property) {
+ }
+
+ @Override
+ public void visit(OWLObjectInverseOf property) {
+ }
+
+ @Override
+ public void visit(OWLDataProperty property) {
+ }
+
+ @Override
+ public void visit(OWLClass ce) {
+ sparql += triple(variables.peek(), "a", ce.toStringID());
+ }
+
+ @Override
+ public void visit(OWLObjectIntersectionOf ce) {
+ List<OWLClassExpression> operands = ce.getOperandsAsList();
+ for (OWLClassExpression operand : operands) {
+ operand.accept(this);
+ }
+ }
+
+ @Override
+ public void visit(OWLObjectUnionOf ce) {
+ List<OWLClassExpression> operands = ce.getOperandsAsList();
+ for (int i = 0; i < operands.size()-1; i++) {
+ sparql += "{";
+ operands.get(i).accept(this);
+ sparql += "}";
+ sparql += " UNION ";
+ }
+ sparql += "{";
+ operands.get(operands.size()-1).accept(this);
+ sparql += "}";
+ }
+
+ @Override
+ public void visit(OWLObjectComplementOf ce) {
+ }
+
+ @Override
+ public void visit(OWLObjectSomeValuesFrom ce) {
+ String objectVariable = buildIndividualVariable();
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(objectVariable, propertyExpression.getNamedProperty().toStringID(), variables.peek());
+ } else {
+ sparql += triple(variables.peek(), propertyExpression.getNamedProperty().toStringID(), objectVariable);
+ }
+ OWLClassExpression filler = ce.getFiller();
+ if(filler.isAnonymous()){
+ if(filler instanceof OWLObjectOneOf){
+ variables.push(objectVariable);
+ filler.accept(this);
+ variables.pop();
+ } else {
+ String var = buildIndividualVariable();
+ variables.push(var);
+ sparql += triple(objectVariable, "a", var);
+ filler.accept(this);
+ variables.pop();
+ }
+ } else {
+ sparql += triple(objectVariable, "a", filler.asOWLClass().toStringID());
+ }
+
+ }
+
+ @Override
+ public void visit(OWLObjectAllValuesFrom ce) {
+ String subject = variables.peek();
+ String objectVariable = buildIndividualVariable();
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ String predicate = propertyExpression.getNamedProperty().toStringID();
+ OWLClassExpression filler = ce.getFiller();
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(objectVariable, predicate, variables.peek());
+ } else {
+ sparql += triple(variables.peek(), predicate, objectVariable);
+ }
+
+ String var = buildIndividualVariable();
+ sparql += "{SELECT " + subject + " (COUNT(" + var + ") AS ?cnt1) WHERE {";
+ sparql += triple(subject, predicate, var);
+ variables.push(var);
+ filler.accept(this);
+ variables.pop();
+ sparql += "} GROUP BY " + subject + "}";
+
+ var = buildIndividualVariable();
+ sparql += "{SELECT " + subject + " (COUNT(" + var + ") AS ?cnt2) WHERE {";
+ sparql += triple(subject, predicate, var);
+ sparql += "} GROUP BY " + subject + "}";
+
+ sparql += "FILTER(?cnt1=?cnt2)";
+
+ }
+
+ @Override
+ public void visit(OWLObjectHasValue ce) {
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ OWLIndividual value = ce.getValue();
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(value.toStringID(), propertyExpression.getNamedProperty().toStringID(), variables.peek());
+ } else {
+ sparql += triple(variables.peek(), propertyExpression.getNamedProperty().toStringID(), value.toStringID());
+ }
+ }
+
+ @Override
+ public void visit(OWLObjectMinCardinality ce) {
+ String subjectVariable = variables.peek();
+ String objectVariable = buildIndividualVariable();
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ int cardinality = ce.getCardinality();
+ sparql += "{SELECT " + subjectVariable + " WHERE {";
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(objectVariable, propertyExpression.getNamedProperty().toStringID(), subjectVariable);
+ } else {
+ sparql += triple(subjectVariable, propertyExpression.getNamedProperty().toStringID(), objectVariable);
+ }
+ OWLClassExpression filler = ce.getFiller();
+ if(filler.isAnonymous()){
+ String var = buildIndividualVariable();
+ variables.push(var);
+ sparql += triple(objectVariable, "a", var);
+ filler.accept(this);
+ variables.pop();
+ } else {
+ sparql += triple(objectVariable, "a", filler.asOWLClass().toStringID());
+ }
+
+ sparql += "} GROUP BY " + subjectVariable + " HAVING(COUNT(" + objectVariable + ")>=" + cardinality + ")}";
+
+ }
+
+ @Override
+ public void visit(OWLObjectExactCardinality ce) {
+ String subjectVariable = variables.peek();
+ String objectVariable = buildIndividualVariable();
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ int cardinality = ce.getCardinality();
+ sparql += "{SELECT " + subjectVariable + " WHERE {";
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(objectVariable, propertyExpression.getNamedProperty().toStringID(), subjectVariable);
+ } else {
+ sparql += triple(subjectVariable, propertyExpression.getNamedProperty().toStringID(), objectVariable);
+ }
+ OWLClassExpression filler = ce.getFiller();
+ if(filler.isAnonymous()){
+ String var = buildIndividualVariable();
+ variables.push(var);
+ sparql += triple(objectVariable, "a", var);
+ filler.accept(this);
+ variables.pop();
+ } else {
+ sparql += triple(objectVariable, "a", filler.asOWLClass().toStringID());
+ }
+
+ sparql += "} GROUP BY " + subjectVariable + " HAVING(COUNT(" + objectVariable + ")=" + cardinality + ")}";
+ }
+
+ @Override
+ public void visit(OWLObjectMaxCardinality ce) {
+ String subjectVariable = variables.peek();
+ String objectVariable = buildIndividualVariable();
+ OWLObjectPropertyExpression propertyExpression = ce.getProperty();
+ int cardinality = ce.getCardinality();
+ sparql += "{SELECT " + subjectVariable + " WHERE {";
+ if(propertyExpression.isAnonymous()){
+ //property expression is inverse of a property
+ sparql += triple(objectVariable, propertyExpression.getNamedProperty().toStringID(), subjectVariable);
+ } else {
+ sparql += triple(subjectVariable, propertyExpression.getNamedProperty().toStringID(), objectVariable);
+ }
+ OWLClassExpression filler = ce.getFiller();
+ if(filler.isAnonymous()){
+ String var = buildIndividualVariable();
+ variables.push(var);
+ sparql += triple(objectVariable, "a", var);
+ filler.accept(this);
+ variables.pop();
+ } else {
+ sparql += triple(objectVariable, "a", filler.asOWLClass().toStringID());
+ }
+
+ sparql += "} GROUP BY " + subjectVariable + " HAVING(COUNT(" + objectVariable + ")<=" + cardinality + ")}";
+ }
+
+ @Override
+ public void visit(OWLObjectHasSelf ce) {
+ String subject = variables.peek();
+ OWLObjectPropertyExpression property = ce.getProperty();
+ sparql += triple(subject, property.getNamedProperty().toStringID(), subject);
+ }
+
+ @Override
+ public void visit(OWLObjectOneOf ce) {
+ String subject = variables.peek();
+ if(modalDepth() == 1){
+ sparql += triple(subject, "?p", "?o");
+ }
+ sparql += "FILTER(" + subject + " IN (";
+ String values = "";
+ for (OWLIndividual ind : ce.getIndividuals()) {
+ if(!values.isEmpty()){
+ values += ",";
+ }
+ values += "<" + ind.toStringID() + ">";
+ }
+ sparql += values;
+ sparql += ...
[truncated message content] |
