/**
* Initialise les composants du conteneur sémantique une fois les URI des ontologies dispatchées
* par OwlDistributionInitializer.
*/
public void semInit() throws ExceptionInInitializerError {
if (isInitialized()) {
/** Initialisation de l'ontologie locale. Cette ontologie n'est plus modifiée ensuite. */
// Initialisation du manager de l'ontologie locale. N'est utilisé qu'ici.
OWLOntologyManager localOntoManager = OWLManager.createOWLOntologyManager();
OWLOntologyIRIMapper localOntoMapper =
new SimpleIRIMapper(getOntologyIri(), getPhysicalIri());
localOntoManager.addIRIMapper(localOntoMapper);
// Initialisation de l'ontologie
try {
// On crée l'ontologie locale.
this.localOntology = localOntoManager.loadOntology(getPhysicalIri());
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
// System.out.println("localOntology : " + localOntology + " ; pyhsicalIri : " +
// getPhysicalIri().toString());
/**
* Initialisation de l'ontologie du reasoner, qui contiendra l'ontologie locale plus d'autres
* axiomes éventuels. On crée l'instance, qu'on rattache à un manager et un reasoner
* accessibles par des getters. L'instance reste la même, mais le contenu change.
*/
// Initialisation du manager de l'ontologie du reasoner
this.manager = OWLManager.createOWLOntologyManager();
// On crée une deuxième ontologie.
try {
IRI ontoName = IRI.create(this.nameSpace);
OWLOntologyID ontoId = new OWLOntologyID(ontoName);
this.reasoningOntology = this.manager.createOntology(ontoId);
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
// Initialisation du reasoner
PelletReasonerFactory reasonerFactory = PelletReasonerFactory.getInstance();
PelletOptions.USE_INCREMENTAL_CONSISTENCY = true;
PelletOptions.USE_COMPLETION_QUEUE = true;
// PelletReasoner reasoner = reasonerFactory.createReasoner(reasoningOntology);
PelletReasoner reasoner = reasonerFactory.createNonBufferingReasoner(reasoningOntology);
// add the reasoner as an ontology change listener
this.manager.addOntologyChangeListener(reasoner);
reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
/* reasoner.precomputeInferences(InferenceType.CLASS_ASSERTIONS);
reasoner.precomputeInferences(InferenceType.DATA_PROPERTY_HIERARCHY);
reasoner.precomputeInferences(InferenceType.DISJOINT_CLASSES);
reasoner.precomputeInferences(InferenceType.OBJECT_PROPERTY_HIERARCHY);
reasoner.precomputeInferences(InferenceType.SAME_INDIVIDUAL);
*/ this.reasoner = reasoner;
} else
throw new ExceptionInInitializerError(
"Paramètres de l'ontologie non initialisés ; ontoParamsInit = "
+ Reflection.getCallerClass(2));
// initOntoReasoner();
}
public OWLOntology getMergedOntology() {
final IRI mergedOntologyIRI =
IRI.create(queryOntology.getOntologyID().getDefaultDocumentIRI() + "-merged");
final OWLOntologyManager mm = controller.getOWLOntologyManager();
if (mm.contains(mergedOntologyIRI)) {
return mm.getOntology(mergedOntologyIRI);
} else {
try {
final OWLOntology mergedOntology = mm.createOntology(mergedOntologyIRI);
mm.setOntologyFormat(mergedOntology, new RDFXMLOntologyFormat());
final String mergedOntologyFileName =
mergedOntologyIRI
.toURI()
.toString()
.substring(mergedOntologyIRI.toURI().toString().lastIndexOf("/") + 1)
+ ".owl";
mm.setOntologyDocumentIRI(
mergedOntology,
IRI.create(
controller.getRuleSpec().getOutputDir().toURI() + "/" + mergedOntologyFileName));
mm.applyChange(
new AddImport(
mergedOntology,
mm.getOWLDataFactory()
.getOWLImportsDeclaration(
queryOntology.getOntologyID().getDefaultDocumentIRI())));
return mergedOntology;
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
}
@Override
protected boolean exec() {
Timer t = new Timer();
if (ontology == null) {
lSigExtractor = null;
return true;
}
if (integrateRangesFirst) {
OWLNormalization4MORe normalization =
new OWLNormalization4MORe(ontology, true, false, false);
Set<OWLAxiom> axioms = normalization.getNormalizedOntology();
try {
OWLOntologyManager manager = ontology.getOWLOntologyManager();
ontology = manager.createOntology();
manager.addAxioms(ontology, axioms);
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
lSigExtractor = null;
return true;
}
}
lSigExtractor.findLsignature(ontology, fragment);
if (!integrateRangesFirst) stats.updateNelkAxioms(lSigExtractor.nAxiomsInFragment());
Logger_MORe.logDebug(
t.duration() + "s to find Lsignature with integrateRangesFirst=" + integrateRangesFirst);
return true;
}
private TaxonStore getStore(String targetStr, String prefixStr, String formatStr) {
File targetFile = getSourceFile(targetStr);
if (targetFile.exists()) targetFile.delete();
if (OBOFORMATSTR.equals(formatStr)) {
return new OBOStore(
targetFile.getAbsolutePath(), prefixStr, prefixStr.toLowerCase() + NAMESPACESUFFIX);
}
if (OWLFORMATSTR.equals(formatStr)) {
try {
return new OWLStore(
targetFile.getAbsolutePath(), prefixStr, prefixStr.toLowerCase() + NAMESPACESUFFIX);
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// these source formats aren't storage formats (there's no ontology library for them) so the
// store is implementation dependent (currently OBO)
if (XREFFORMATSTR.equals(formatStr)
|| // XREF isn't a storage format, so the store is
COLUMNFORMATSTR.equals(formatStr)
|| SYNONYMFORMATSTR.equals(formatStr)
|| ALLCOLUMNSFORMATSTR.equals(formatStr)) {
return new OBOStore(
targetFile.getAbsolutePath(), prefixStr, prefixStr.toLowerCase() + NAMESPACESUFFIX);
}
logger.error("Format " + formatStr + " not supported for merging");
return null;
}
public static void main(String[] args) {
try {
SimpleRenderer renderer = new SimpleRenderer();
renderer.setShortFormProvider(
new DefaultPrefixManager("http://www.mindswap.org/ontologies/tambis-full.owl#"));
ToStringRenderer.getInstance().setRenderer(renderer);
OWLOntologyManager man = OWLManager.createOWLOntologyManager();
OWLOntology ont =
man.loadOntology(
IRI.create(
"http://owl.cs.manchester.ac.uk/repository/download?ontology=http://www.cs.manchester.ac.uk/owl/ontologies/tambis-patched.owl"));
System.out.println("Loaded!");
OWLReasonerFactory reasonerFactory = PelletReasonerFactory.getInstance();
OWLReasoner reasoner = reasonerFactory.createNonBufferingReasoner(ont);
reasoner.getUnsatisfiableClasses();
ExplanationBasedRootClassFinder rdr =
new ExplanationBasedRootClassFinder(man, reasoner, reasonerFactory);
for (OWLClass cls : rdr.getRootUnsatisfiableClasses()) System.out.println("ROOT! " + cls);
} catch (TimeOutException e) {
e.printStackTrace();
} catch (ReasonerInterruptedException e) {
e.printStackTrace();
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
}
@Test
public void test03() {
File file = new File("TestData/EliminateTransTest03.owl");
OWLOntologyManager man = OWLManager.createOWLOntologyManager();
OWLOntology ontology;
try {
ontology = man.loadOntologyFromOntologyDocument(file);
HornSHIQNormalizer normalizer = new HornSHIQNormalizer();
OWLOntology normalizedOnt = normalizer.normalize(ontology);
HornALCHIQTransNormalizer normalizer1 = new HornALCHIQTransNormalizer();
OWLOntology normalizedOnt1 = normalizer1.normalize(normalizedOnt);
HornALCHIQNormalizer normalizer2 = new HornALCHIQNormalizer();
OWLOntology normalizedOnt2 = normalizer2.normalize(normalizedOnt1);
man.saveOntology(
normalizedOnt2, IRI.create(new File("TestData/EliminateTransTest03Norm.owl")));
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (OWLOntologyStorageException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void runWithSeparateFiles() {
if (owlFile == null) {
throw new NullPointerException("You have to specify an ontology file!");
}
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
OWLOntology ontology = null;
OBDADataFactory obdaDataFactory = OBDADataFactoryImpl.getInstance();
try {
ontology = manager.loadOntologyFromOntologyDocument((new File(owlFile)));
if (disableReasoning) {
/*
* when reasoning is disabled, we extract only the declaration assertions for the vocabulary
*/
ontology = extractDeclarations(manager, ontology);
}
Collection<Predicate> predicates = new ArrayList<>();
for (OWLClass owlClass : ontology.getClassesInSignature()) {
Predicate predicate = obdaDataFactory.getClassPredicate(owlClass.getIRI().toString());
predicates.add(predicate);
}
for (OWLDataProperty owlDataProperty : ontology.getDataPropertiesInSignature()) {
Predicate predicate =
obdaDataFactory.getDataPropertyPredicate(owlDataProperty.getIRI().toString());
predicates.add(predicate);
}
for (OWLObjectProperty owlObjectProperty : ontology.getObjectPropertiesInSignature()) {
Predicate predicate =
obdaDataFactory.getObjectPropertyPredicate(owlObjectProperty.getIRI().toString());
predicates.add(predicate);
}
OBDAModel obdaModel = loadMappingFile(mappingFile);
Ontology inputOntology = OWLAPI3TranslatorUtility.translate(ontology);
obdaModel.declareAll(inputOntology.getVocabulary());
int numPredicates = predicates.size();
int i = 1;
for (Predicate predicate : predicates) {
System.err.println(String.format("Materializing %s (%d/%d)", predicate, i, numPredicates));
serializePredicate(ontology, inputOntology, obdaModel, predicate, outputFile, format);
i++;
}
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public PartOfOntology(String directory, String file) {
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
try {
ontology = manager.loadOntologyFromOntologyDocument(new File(directory, file));
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
log(LogLevel.DEBUG, "Failed to load file " + file + " from directory " + directory);
return;
}
success = true;
}
public LsignatureExtractorViaInverseRewritingLauncher(
OWLOntology ontology, LogicFragment fragment) {
this.ontology = null;
try {
manager = ontology.getOWLOntologyManager();
this.ontology = manager.createOntology();
manager.addAxioms(this.ontology, ontology.getAxioms());
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
this.fragment = fragment;
}
public LsignatureExtractorLauncher(
OWLOntology ontology, LogicFragment fragment, boolean integrateRangesFirst) {
this.ontology = null;
try {
OWLOntologyManager manager = ontology.getOWLOntologyManager();
this.ontology = manager.createOntology();
manager.addAxioms(this.ontology, ontology.getAxioms());
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
this.fragment = fragment;
this.integrateRangesFirst = integrateRangesFirst;
}
protected OWLOntology loadBigOntology(String filename) {
File file = new File(System.getenv("bigontosdir") + filename + ".owl");
OWLOntology ontology = null;
try {
ontology = OWLManager.createOWLOntologyManager().loadOntologyFromOntologyDocument(file);
} catch (OWLOntologyCreationException e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
return ontology;
}
@Override
public boolean test() {
// Load an example ontology.
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
OWLOntology ontology = null;
try {
ontology = manager.loadOntologyFromOntologyDocument(new File("model/mcs_ontology.owl"));
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// We need a reasoner to do our query answering
// These two lines are the only relevant difference between this code
// and the original example
// This example uses HermiT: http://hermit-reasoner.com/
OWLReasoner reasoner = new Reasoner.ReasonerFactory().createReasoner(ontology);
ShortFormProvider shortFormProvider = new SimpleShortFormProvider();
// Create the DLQueryPrinter helper class. This will manage the
// parsing of input and printing of results
DLQueryPrinter dlQueryPrinter =
new DLQueryPrinter(new DLQueryEngine(reasoner, shortFormProvider), shortFormProvider);
// Enter the query loop. A user is expected to enter class
// expression on the command line.
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
while (true) {
System.out.println(
"Type a class expression in Manchester Syntax and press Enter (or press x to exit):");
String classExpression = null;
try {
classExpression = br.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Check for exit condition
if (classExpression == null || classExpression.equalsIgnoreCase("x")) {
break;
}
dlQueryPrinter.askQuery(classExpression.trim());
System.out.println();
}
return true;
}
static {
try {
/** Configuration of the manager */
manager.setSilentMissingImportsHandling(true);
manager.addMissingImportListener(
new MissingImportListener() {
@Override
public void importMissing(MissingImportEvent event) {
log.warn("Missing import! URI was: {}", event.getImportedOntologyURI());
}
});
manager.addOntologyChangeListener(
new OWLOntologyChangeListener() {
@Override
public void ontologiesChanged(List<? extends OWLOntologyChange> arg0)
throws OWLException {
for (OWLOntologyChange change : arg0) {
log.debug("{} TO {}", change, change.getOntology());
}
}
});
/** Loading test ontologies once for all */
manager.loadOntologyFromOntologyDocument(FOAF_LOCATION.openStream());
manager.loadOntologyFromOntologyDocument(DBPEDIA_LOCATION.openStream());
// Test 1
manager.loadOntologyFromOntologyDocument(TEST_1_LOCATION.openStream());
manager.loadOntologyFromOntologyDocument(TEST_1_expected_LOCATION.openStream());
// Test 2
manager.loadOntologyFromOntologyDocument(TEST_2_LOCATION.openStream());
manager.loadOntologyFromOntologyDocument(TEST_2_expected_LOCATION.openStream());
// Test 3
manager.loadOntologyFromOntologyDocument(TEST_3_LOCATION.openStream());
manager.loadOntologyFromOntologyDocument(TEST_3_rules_LOCATION.openStream());
manager.loadOntologyFromOntologyDocument(TEST_3_expected_LOCATION.openStream());
} catch (OWLOntologyCreationException e) {
log.error(
"A {} have been thrown while creating the ontology" + ". Message was: {}",
e.getClass(),
e.getLocalizedMessage());
} catch (IOException e) {
log.error(
"A {} have been thrown while loading the ontology from the location {}",
e.getClass(),
FOAF_LOCATION.toString());
log.error("Message was: {}", e.getLocalizedMessage());
}
}
@Override
public boolean prepare() {
// Create the manager
manager = OWLManager.createOWLOntologyManager();
// File with an existing ontology - make sure it's there!
fClass = new File("model/mcs_ontology.owl");
// Load the ontology from the file
try {
ontology = manager.loadOntologyFromOntologyDocument(fClass);
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
factory = new MyFactory(ontology);
return true;
}
@Override
public boolean test() {
// Check if the ontology contains any axioms
System.out.println("Number of axioms: " + ontology.getAxiomCount());
// Every ontology has a unique ID.
System.out.println("Current Ontology ID: " + ontology.getOntologyID());
// test of CRUD
// test of Create
System.out.println("Number of children: " + factory.getAllChildInstances().size());
System.out.println("Create a new child ");
factory.createChild("Nicola");
System.out.println("Number of children: " + factory.getAllChildInstances().size());
// test of Read
Child c = factory.getChild("Nicola");
System.out.println(c.getOwlIndividual());
// TODO: test of Update
// test of Delete
c.delete();
System.out.println("Number of children: " + factory.getAllChildInstances().size());
// save ABox, TBox, RBox to separate files.
try {
ontlgAbox = manager.createOntology(ontology.getABoxAxioms(true));
ontlgTbox = manager.createOntology(ontology.getTBoxAxioms(true));
ontlgRbox = manager.createOntology(ontology.getRBoxAxioms(true));
} catch (OWLOntologyCreationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
manager.saveOntology(ontlgAbox, IRI.create(new File("individual/Abox.owl")));
manager.saveOntology(ontlgTbox, IRI.create(new File("individual/Tbox.owl")));
manager.saveOntology(ontlgRbox, IRI.create(new File("individual/Rbox.owl")));
} catch (OWLOntologyStorageException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
}
public Set<OWLClass> getRootUnsatisfiableClasses() {
// StructureBasedRootClassFinder srd = new StructureBasedRootClassFinder(this.baseReasoner);
StructuralRootDerivedReasoner srd =
new StructuralRootDerivedReasoner(this.manager, this.baseReasoner, this.reasonerFactory);
Set<OWLClass> estimatedRoots = srd.getRootUnsatisfiableClasses();
this.cls2JustificationMap = new HashMap<OWLClass, Set<Explanation>>();
Set<OWLAxiom> allAxioms = new HashSet<OWLAxiom>();
for (OWLOntology ont : this.baseReasoner.getRootOntology().getImportsClosure()) {
allAxioms.addAll(ont.getLogicalAxioms());
}
for (OWLClass cls : estimatedRoots) {
this.cls2JustificationMap.put(cls, new HashSet<Explanation>());
System.out.println("POTENTIAL ROOT: " + cls);
}
System.out.println("Finding real roots from " + estimatedRoots.size() + " estimated roots");
int done = 0;
this.roots.addAll(estimatedRoots);
for (OWLClass estimatedRoot : estimatedRoots) {
try {
PelletExplanationGenerator gen =
new PelletExplanationGenerator(manager.createOntology(allAxioms));
OWLDataFactory df = this.manager.getOWLDataFactory();
Set<Explanation> expls =
gen.getExplanations(df.getOWLSubClassOfAxiom(estimatedRoot, df.getOWLNothing()));
cls2JustificationMap.get(estimatedRoot).addAll(expls);
++done;
System.out.println("Done " + done);
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
}
for (OWLClass clsA : estimatedRoots) {
for (OWLClass clsB : estimatedRoots)
if (!clsA.equals(clsB)) {
Set<Explanation> clsAExpls = cls2JustificationMap.get(clsA);
Set<Explanation> clsBExpls = cls2JustificationMap.get(clsB);
boolean clsARootForClsB = false;
boolean clsBRootForClsA = false;
for (Explanation clsAExpl : clsAExpls) {
for (Explanation clsBExpl : clsBExpls)
if (isRootFor(clsAExpl, clsBExpl)) {
clsARootForClsB = true;
} else if (isRootFor(clsBExpl, clsAExpl)) {
clsBRootForClsA = true;
}
}
Explanation clsAExpl;
if ((!clsARootForClsB) || (!clsBRootForClsA))
if (clsARootForClsB) {
this.roots.remove(clsB);
} else if (clsBRootForClsA) this.roots.remove(clsA);
}
}
OWLClass clsA;
return this.roots;
}
public void testRenderAndParse() {
List<File> renderedFiles = new ArrayList<File>();
String dblocation = System.getProperty("java.io.tmpdir") + File.separator + "hgdbtest";
HGDBOntologyManager manager = HGOntologyManagerFactory.getOntologyManager(dblocation);
HGDBOntologyRepository repo = new HGDBOntologyRepository(dblocation);
VersionManager versionManager = manager.getVersionManager();
HyperGraph graph = manager.getOntologyRepository().getHyperGraph();
//
// IMPORT AND RENDER
//
try {
// repo.dropHypergraph();
repo.deleteAllOntologies();
// System.out.println("Running GC");
// CANNOT RUN GC nullHANDLE problem !!! repo.runGarbageCollector();
URL ontologyUrl = this.getClass().getResource("/sampleOntology.owl");
IRI targetIRI = ImportOntologies.importOntology(ontologyUrl, manager);
// IRI targetIRI = ImportOntologies.importOntology(f2, manager);
HGDBOntology o = (HGDBOntology) manager.loadOntologyFromOntologyDocument(targetIRI);
VersionedOntology vo = versionManager.versioned(o.getAtomHandle());
// MANIPULATE REMOVE CHANGED
Object[] axioms = o.getAxioms().toArray();
// remove all axioms 10.
for (int i = 0; i < axioms.length / 10; i++) {
int j = i;
for (; j < i + axioms.length / 100; j++) {
if (j < axioms.length) {
manager.applyChange(new RemoveAxiom(o, (OWLAxiom) axioms[j]));
}
}
i = j;
vo.commit("SameUser", " commit no " + i);
}
// RENDER VERSIONED ONTOLOGY, includes data
// TODO...
VOWLXMLRenderConfiguration c = new VOWLXMLRenderConfiguration();
VOWLXMLVersionedOntologyRenderer r = new VOWLXMLVersionedOntologyRenderer(manager);
File fx = new File(TESTFILE.getAbsolutePath() + " Revision-" + ".xml");
renderedFiles.add(fx);
Writer fwriter = new OutputStreamWriter(new FileOutputStream(fx), Charset.forName("UTF-8"));
r.render(vo, null, fwriter, c);
// for (int i = 0; i < vo.getArity(); i++)
// {
// VOWLXMLRenderConfiguration c = new VOWLXMLRenderConfiguration();
// //c.setLastRevisionIndex(i);
// VOWLXMLVersionedOntologyRenderer r = new VOWLXMLVersionedOntologyRenderer(manager);
// File fx = new File(TESTFILE.getAbsolutePath() + " Revision-" + i + ".xml");
// // File fx = new
// // File("C:\\_CiRM\\testontos\\CountyVersioned-Rev-"+ i +
// // ".vowlxml");
// renderedFiles.add(fx);
// // File fx = new File("C:\\_CiRM\\testontos\\1 csr-Rev-"+ i +
// // ".vowlxml");
// Writer fwriter = new OutputStreamWriter(new FileOutputStream(fx),
// Charset.forName("UTF-8"));
// // Full export
// r.render(vo, fwriter, c);
// }
System.out.println("DELETE ALL ONTOLOGIES");
repo.deleteAllOntologies();
GarbageCollector gc = new GarbageCollector(repo);
gc.runGarbageCollection(GarbageCollector.MODE_DELETED_ONTOLOGIES);
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (OWLRendererException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//
// PARSE
//
File f = new File(TESTFILE.getAbsolutePath() + " Revision-" + 10 + ".xml");
System.out.println("PARSING: " + f + " length: " + (f.length() / 1024) + " kB");
OWLOntologyDocumentSource source = new FileDocumentSource(f);
VOWLXMLParser parser = new VOWLXMLParser();
OWLOntologyEx onto = new OWLTempOntologyImpl(manager, new OWLOntologyID());
// must have onto for manager in super class
VOWLXMLDocument versionedOntologyRoot = new VOWLXMLDocument(onto);
//
// Create VersionedOntology Revision 10
try {
parser.parse(graph, source, versionedOntologyRoot, new OWLOntologyLoaderConfiguration());
System.out.println("PARSING FINISHED.");
} catch (OWLOntologyChangeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnloadableImportException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (OWLParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (versionedOntologyRoot.getRenderConfig().heads().isEmpty()
&& versionedOntologyRoot
.getRenderConfig()
.roots()
.contains(versionedOntologyRoot.getRenderConfig().firstRevision())) {
OWLOntologyID ontologyID = versionedOntologyRoot.getRevisionData().getOntologyID();
IRI documentIRI =
IRI.create("hgdb://" + ontologyID.getDefaultDocumentIRI().toString().substring(7));
HGPersistentHandle ontologyUUID =
repo.getHyperGraph().getHandleFactory().makeHandle(versionedOntologyRoot.getOntologyID());
try {
System.out.println("Storing ontology data for : " + ontologyUUID);
HGDBOntology o =
manager
.getOntologyRepository()
.createOWLOntology(ontologyID, documentIRI, ontologyUUID);
storeFromTo(versionedOntologyRoot.getRevisionData(), o);
} catch (HGDBOntologyAlreadyExistsByDocumentIRIException e) {
e.printStackTrace();
} catch (HGDBOntologyAlreadyExistsByOntologyIDException e) {
e.printStackTrace();
} catch (HGDBOntologyAlreadyExistsByOntologyUUIDException e) {
e.printStackTrace();
}
// Add version control with full matching history.
System.out.println("Adding version control history to : " + ontologyUUID);
// VersionedOntology voParsed = new VersionedOntology(versionedOntologyRoot.getRevisions(),
// versionedOntologyRoot.getChangesets(), graph);
// VHGDBOntologyRepository vrepo = (VHGDBOntologyRepository)
// manager.getOntologyRepository();
// System.out.println("Versioned Repository Contents: ");
// for (VersionedOntology vox : vrepo.getVersionControlledOntologies())
// {
// System.out.println("Versioned Ontology: " + vox.getWorkingSetData());
// System.out.println("Versioned Ontology Revs: " + vox.getNrOfRevisions());
// }
// //
// // Rendering FULL Versioned Ontology
// //
// System.out.println("Rendering full versioned ontology after parse and store: " +
// ontologyUUID);
// VOWLXMLVersionedOntologyRenderer r = new VOWLXMLVersionedOntologyRenderer(manager);
// File fx = new File(TESTFILE.getAbsolutePath() + "FULL-afterParse.xml");
// Writer fwriter;
// try
// {
// fwriter = new OutputStreamWriter(new FileOutputStream(fx), Charset.forName("UTF-8"));
// r.render(voParsed, fwriter);
// }
// catch (IOException e)
// {
// e.printStackTrace();
// }
// catch (OWLRendererException e)
// {
// e.printStackTrace();
// }
} else {
System.out.println("ERROR: EXPECTING COMPLETE VERSIONED ONTOLOGY");
}
// }
}
public OWLOntology findLsignature(
OWLOntology ontology, LogicFragment fragment, Statistics stats) {
Timer t = new Timer();
this.stats = stats;
Logger_MORe.logInfo("extracting " + fragment.toString() + "-signature");
OWLOntology ret = null;
OWLOntologyManager manager = ontology.getOWLOntologyManager();
try {
ret = manager.createOntology();
manager.addAxioms(ret, ontology.getAxioms());
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
}
lSignatureClasses = new HashSet<OWLClass>();
lSignatureOther = new HashSet<OWLEntity>();
compSignatureClasses = new HashSet<OWLClass>();
compSignatureOther = new HashSet<OWLEntity>();
LsignatureExtractorLauncher elkSignatureExtractorLauncher = null;
LsignatureExtractorLauncher elkSignatureExtractorIntegratingRangesLauncher = null;
LsignatureExtractorViaInverseRewritingLauncher elkSignatureExtractorRewritingInversesLauncher =
null;
ForkJoinPool executor = new ForkJoinPool();
elkSignatureExtractorLauncher =
new LsignatureExtractorLauncher(ontology, LogicFragment.ELK, false);
executor.execute(elkSignatureExtractorLauncher);
if (ret != null) {
// otherwise we have nowhere to return the axioms in the normalised ontologies necessary to
// really classify all the extra classses in the lSignature
if (rewriteInverses) {
elkSignatureExtractorRewritingInversesLauncher =
new LsignatureExtractorViaInverseRewritingLauncher(ontology, LogicFragment.ELK);
executor.execute(elkSignatureExtractorRewritingInversesLauncher);
}
if (integrateRanges) {
elkSignatureExtractorIntegratingRangesLauncher =
new LsignatureExtractorLauncher(ontology, LogicFragment.ELK, true);
executor.execute(elkSignatureExtractorIntegratingRangesLauncher);
}
// check the output of the normal ELKsignature and cancel the other threads if the lSig is the
// whole signature
initialiseLsignature((LsignatureExtractor) elkSignatureExtractorLauncher.join());
if (compSignatureClasses.isEmpty())
cancelTasks(
elkSignatureExtractorIntegratingRangesLauncher,
elkSignatureExtractorRewritingInversesLauncher);
else {
if (elkSignatureExtractorRewritingInversesLauncher != null
&& extendLsignature(
(LsignatureExtractor) elkSignatureExtractorRewritingInversesLauncher.join())
> 0) {
manager.addAxioms(
ret,
((LsignatureExtractorViaInverseRewritingLauncher)
elkSignatureExtractorRewritingInversesLauncher)
.getOntology()
.getAxioms());
}
if (compSignatureClasses.isEmpty())
cancelTasks(elkSignatureExtractorRewritingInversesLauncher);
else if (elkSignatureExtractorIntegratingRangesLauncher != null
&& extendLsignature(
(LsignatureExtractor) elkSignatureExtractorIntegratingRangesLauncher.join())
> 0) {
manager.addAxioms(
ret,
((LsignatureExtractorLauncher) elkSignatureExtractorIntegratingRangesLauncher)
.getOntology()
.getAxioms());
}
}
stats.updateLsignatureSize(lSignatureClasses.size(), true);
} else {
ret = ontology;
initialiseLsignature((LsignatureExtractor) elkSignatureExtractorLauncher.join());
}
Logger_MORe.logInfo(lSignatureClasses.size() + "classes in lSignature");
Logger_MORe.logDebug(lSignatureClasses.toString());
Logger_MORe.logInfo(compSignatureClasses.size() + "classes in compSignature");
// might be a good idea to try to isolate extra axioms in the normalisation/rewriting - is this
// possible/worth the effort?
// check the order in which we try to extend the lSignature with each of the rewritten
// ontologies and consider if one may be better that the other
Logger_MORe.logDebug(t.duration() + "s to find Lsignature");
return ret;
}
@Override
protected boolean exec() {
Timer t = new Timer();
if (ontology == null) {
extractor = null;
return true;
}
IRI iri =
IRI.create("http://www.cs.ox.ac.uk/isg/tools/MORe/ontologies/inverseRewritingModule.owl");
extractor.findLsignature(ontology, LogicFragment.SHOIQ);
if (containsNonInternalClasses(
extractor
.getCompSignature())) { // then the ontology goes beyond SHOIQ and we need to work
// with a SHOIQ module rather than the whole ontology
Set<OWLEntity> aux = getNonInternalClasses(extractor.getLsignature());
if (aux.isEmpty()) {
extractor = null;
Logger_MORe.logDebug(
t.duration()
+ "s to find Lsignature with inverseRewriting (failed - empty SHOIQ-signature)");
return true;
}
SyntacticLocalityModuleExtractor moduleExtractor =
new SyntacticLocalityModuleExtractor(manager, ontology, ModuleType.BOT);
try {
// ontology = manager.createOntology(iri);
// manager.addAxioms(ontology, moduleExtractor.extract(aux));
ontology = moduleExtractor.extractAsOntology(aux, iri);
} catch (OWLOntologyCreationException e1) {
extractor = null;
e1.printStackTrace();
Logger_MORe.logDebug(
t.duration()
+ "s to find Lsignature with inverseRewriting (failed - exception creating a SHOIQ module)");
return true;
}
}
// if we get this far then we have a nonempty ontology (maybe module) that we need to
// normalize and then rewrite
OWLNormalization4MORe normalization = new OWLNormalization4MORe(ontology, true, true, true);
Rewriter rewriter =
new Rewriter(normalization.getNormalizedOntology(), normalization.getSortedGCIs());
if (manager.contains(iri)) manager.removeOntology(ontology);
Set<OWLAxiom> rewrittenAxioms = rewriter.getRewrittenOntology();
if (!rewriter.anyRewrittenRoles()) {
extractor = null;
Logger_MORe.logDebug(
t.duration()
+ "s to find Lsignature with inverseRewriting (failed - could not rewrite any roles)");
return true;
}
try {
ontology = manager.createOntology();
manager.addAxioms(ontology, rewrittenAxioms);
extractor = new LsignatureExtractor_reducedGreedyness();
extractor.findLsignature(ontology, fragment);
} catch (OWLOntologyCreationException e1) {
extractor = null;
e1.printStackTrace();
Logger_MORe.logDebug(
t.duration()
+ "s to find Lsignature with inverseRewriting (failed - exception creating ontology for rewritten axioms)");
return true;
}
Logger_MORe.logDebug(t.duration() + "s to find Lsignature with inverseRewriting");
return true;
}
@SuppressWarnings("unchecked")
public String execute() {
String sawsdlExt = ".sawsdl";
String wsdlExt = ".wsdl";
String sawadlExt = ".sawadl";
String wadlExt = ".wadl";
StringBuffer buf = new StringBuffer();
SAXBuilder sbuilder = new SAXBuilder();
Document doc = null;
@SuppressWarnings("rawtypes")
Map session = ActionContext.getContext().getSession();
String importURL = "";
errormsg = "";
String filename = "";
System.out.println("wsloc = " + wsloc);
if (WSFile != null) System.out.println("OWLFile size = " + WSFile.getTotalSpace());
try {
XMLParser wsParser = null;
session.remove("wsname");
session.remove("wsdlparser");
session.remove("wadlparser");
if (wsloc.indexOf("http:") != -1) {
importURL = wsloc;
if (wsloc.equalsIgnoreCase(wsdlExt) || wsloc.equalsIgnoreCase(sawsdlExt)) {
doc = sbuilder.build(importURL);
wsParser = new SAWSDLParser(doc);
session.put("wsdlparser", wsParser);
session.remove("wadlparser");
int start = importURL.lastIndexOf("/");
filename = importURL.substring(start, importURL.length());
session.put("wsname", filename);
} else if (wsloc.equalsIgnoreCase(wadlExt) || wsloc.equalsIgnoreCase(sawadlExt)) {
doc = sbuilder.build(importURL);
wsParser = new WADLParser(doc);
session.put("wadlparser", wsParser);
session.remove("wsdlparser");
int start = importURL.lastIndexOf("/");
filename = importURL.substring(start, importURL.length());
session.put("wsname", filename);
}
} else {
if (WSFile != null) {
if (wsloc.endsWith(wsdlExt) || wsloc.endsWith(sawsdlExt)) {
doc = sbuilder.build(WSFile);
wsParser = new SAWSDLParser(doc);
session.put("wsdlparser", wsParser);
filename = wsloc;
session.put("wsname", filename);
} else if (wsloc.endsWith(wadlExt) || wsloc.endsWith(sawadlExt)) {
doc = sbuilder.build(WSFile);
wsParser = new WADLParser(doc);
session.put("wadlparser", wsParser);
filename = wsloc;
session.put("wsname", filename);
} else {
errormsg = "File is not wsdl or wadl file.";
}
} else {
errormsg = "WSDL file lost.";
}
}
if (wsParser == null) {
errormsg = "WSDL is invalidate";
return ERROR;
}
if (isWSDL(doc)) {
boolean hasSAWSDLNS = false;
@SuppressWarnings("rawtypes")
List nameSpaces = doc.getRootElement().getAdditionalNamespaces();
for (int i = 0; i < nameSpaces.size(); i++) {
Namespace ns = (Namespace) nameSpaces.get(i);
if (ns.getURI().equalsIgnoreCase(SAWSDLParser.sawsdlNS.getURI())) {
hasSAWSDLNS = true;
break;
}
}
if (!hasSAWSDLNS) {
doc.getRootElement().addNamespaceDeclaration(SAWSDLParser.sawsdlNS);
}
boolean wsdlV1 = ((SAWSDLParser) wsParser).isWsdlV1();
if (wsdlV1 == true) {
LoadWSDLTree.loadWSDL((SAWSDLParser) wsParser, buf, filename);
} else {
// not implement yet
}
innerTreeHtml = buf.toString();
type = "wsdl";
} else if (isWADL(doc)) {
// not implement yet
LoadWADLTree.loadWADL((WADLParser) wsParser, buf, wsloc);
innerTreeHtml = buf.toString();
type = "wadl";
}
} catch (IOException e) {
e.printStackTrace();
errormsg = e.toString();
} catch (URISyntaxException e) {
e.printStackTrace();
errormsg = e.toString();
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
errormsg = e.toString();
} catch (JDOMException e) {
e.printStackTrace();
errormsg = e.toString();
} catch (Exception e) {
e.printStackTrace();
errormsg = e.toString();
}
System.out.println("errormsg = " + errormsg);
System.out.println("draw finish");
return SUCCESS;
}
public static void main(String[] args) {
try {
// Create our ontology manager in the usual way.
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
// Load a copy of the people+pets ontology. We'll load the ontology from the web (it's
// acutally located
// in the TONES ontology repository).
IRI docIRI = IRI.create(DOCUMENT_IRI);
// We load the ontology from a document - our IRI points to it directly
OWLOntology ont = manager.loadOntologyFromOntologyDocument(docIRI);
System.out.println("Loaded " + ont.getOntologyID());
// We need to create an instance of OWLReasoner. An OWLReasoner provides the basic
// query functionality that we need, for example the ability obtain the subclasses
// of a class etc. To do this we use a reasoner factory.
// Create a reasoner factory. In this case, we will use HermiT, but we could also
// use FaCT++ (http://code.google.com/p/factplusplus/) or
// Pellet(http://clarkparsia.com/pellet)
// Note that (as of 03 Feb 2010) FaCT++ and Pellet OWL API 3.0.0 compatible libraries are
// expected to be available in the near future).
// For now, we'll use HermiT
// HermiT can be downloaded from http://hermit-reasoner.com
// Make sure you get the HermiT library and add it to your class path. You can then
// instantiate the HermiT reasoner factory:
// Comment out the first line below and uncomment the second line below to instantiate
// the HermiT reasoner factory. You'll also need to import the
// org.semanticweb.HermiT.Reasoner
// package.
OWLReasonerFactory reasonerFactory = null;
// OWLReasonerFactory reasonerFactory = new Reasoner.ReasonerFactory();
// We'll now create an instance of an OWLReasoner (the implementation being provided by HermiT
// as
// we're using the HermiT reasoner factory). The are two categories of reasoner, Buffering
// and
// NonBuffering. In our case, we'll create the buffering reasoner, which is the default kind
// of reasoner.
// We'll also attach a progress monitor to the reasoner. To do this we set up a configuration
// that
// knows about a progress monitor.
// Create a console progress monitor. This will print the reasoner progress out to the
// console.
ConsoleProgressMonitor progressMonitor = new ConsoleProgressMonitor();
// Specify the progress monitor via a configuration. We could also specify other setup
// parameters in
// the configuration, and different reasoners may accept their own defined parameters this
// way.
OWLReasonerConfiguration config = new SimpleConfiguration(progressMonitor);
// Create a reasoner that will reason over our ontology and its imports closure. Pass in the
// configuration.
OWLReasoner reasoner = reasonerFactory.createReasoner(ont, config);
// Ask the reasoner to do all the necessary work now
reasoner.precomputeInferences();
// We can determine if the ontology is actually consistent (in this case, it should be).
boolean consistent = reasoner.isConsistent();
System.out.println("Consistent: " + consistent);
System.out.println("\n");
// We can easily get a list of unsatisfiable classes. (A class is unsatisfiable if it
// can't possibly have any instances). Note that the getUnsatisfiableClasses method
// is really just a convenience method for obtaining the classes that are equivalent
// to owl:Nothing. In our case there should be just one unsatisfiable class - "mad_cow"
// We ask the reasoner for the unsatisfiable classes, which returns the bottom node
// in the class hierarchy (an unsatisfiable class is a subclass of every class).
Node<OWLClass> bottomNode = reasoner.getUnsatisfiableClasses();
// This node contains owl:Nothing and all the classes that are equivalent to owl:Nothing -
// i.e. the unsatisfiable classes.
// We just want to print out the unsatisfiable classes excluding owl:Nothing, and we can
// used a convenience method on the node to get these
Set<OWLClass> unsatisfiable = bottomNode.getEntitiesMinusBottom();
if (!unsatisfiable.isEmpty()) {
System.out.println("The following classes are unsatisfiable: ");
for (OWLClass cls : unsatisfiable) {
System.out.println(" " + cls);
}
} else {
System.out.println("There are no unsatisfiable classes");
}
System.out.println("\n");
// Now we want to query the reasoner for all descendants of vegetarian. Vegetarians are
// defined in the
// ontology to be animals that don't eat animals or parts of animals.
OWLDataFactory fac = manager.getOWLDataFactory();
// Get a reference to the vegetarian class so that we can as the reasoner about it.
// The full IRI of this class happens to be:
// <http://owl.man.ac.uk/2005/07/sssw/people#vegetarian>
OWLClass vegPizza =
fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#vegetarian"));
// Now use the reasoner to obtain the subclasses of vegetarian.
// We can ask for the direct subclasses of vegetarian or all of the (proper) subclasses of
// vegetarian.
// In this case we just want the direct ones (which we specify by the "true" flag).
NodeSet<OWLClass> subClses = reasoner.getSubClasses(vegPizza, true);
// The reasoner returns a NodeSet, which represents a set of Nodes.
// Each node in the set represents a subclass of vegetarian pizza. A node of classes contains
// classes,
// where each class in the node is equivalent. For example, if we asked for the
// subclasses of some class A and got back a NodeSet containing two nodes {B, C} and {D}, then
// A would have
// two proper subclasses. One of these subclasses would be equivalent to the class D, and the
// other would
// be the class that is equivalent to class B and class C.
// In this case, we don't particularly care about the equivalences, so we will flatten this
// set of sets and print the result
Set<OWLClass> clses = subClses.getFlattened();
System.out.println("Subclasses of vegetarian: ");
for (OWLClass cls : clses) {
System.out.println(" " + cls);
}
System.out.println("\n");
// In this case, we should find that the classes, cow, sheep and giraffe are vegetarian. Note
// that in this
// ontology only the class cow had been stated to be a subclass of vegetarian. The fact that
// sheep and
// giraffe are subclasses of vegetarian was implicit in the ontology (through other things we
// had said)
// and this illustrates why it is important to use a reasoner for querying an ontology.
// We can easily retrieve the instances of a class. In this example we'll obtain the
// instances of
// the class pet. This class has a full IRI of <http://owl.man.ac.uk/2005/07/sssw/people#pet>
// We need to obtain a reference to this class so that we can ask the reasoner about it.
OWLClass country =
fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#pet"));
// Ask the reasoner for the instances of pet
NodeSet<OWLNamedIndividual> individualsNodeSet = reasoner.getInstances(country, true);
// The reasoner returns a NodeSet again. This time the NodeSet contains individuals.
// Again, we just want the individuals, so get a flattened set.
Set<OWLNamedIndividual> individuals = individualsNodeSet.getFlattened();
System.out.println("Instances of pet: ");
for (OWLNamedIndividual ind : individuals) {
System.out.println(" " + ind);
}
System.out.println("\n");
// Again, it's worth noting that not all of the individuals that are returned were explicitly
// stated
// to be pets.
// Finally, we can ask for the property values (property assertions in OWL speak) for a given
// individual
// and property.
// Let's get the property values for the individual Mick, the full IRI of which is
// <http://owl.man.ac.uk/2005/07/sssw/people#Mick>
// Get a reference to the individual Mick
OWLNamedIndividual mick =
fac.getOWLNamedIndividual(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#Mick"));
// Let's get the pets of Mick
// Get hold of the has_pet property which has a full IRI of
// <http://owl.man.ac.uk/2005/07/sssw/people#has_pet>
OWLObjectProperty hasPet =
fac.getOWLObjectProperty(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#has_pet"));
// Now ask the reasoner for the has_pet property values for Mick
NodeSet<OWLNamedIndividual> petValuesNodeSet = reasoner.getObjectPropertyValues(mick, hasPet);
Set<OWLNamedIndividual> values = petValuesNodeSet.getFlattened();
System.out.println("The has_pet property values for Mick are: ");
for (OWLNamedIndividual ind : values) {
System.out.println(" " + ind);
}
// Notice that Mick has a pet Rex, which wasn't asserted in the ontology.
// Finally, let's print out the class hierarchy.
// Get hold of the top node in the class hierarchy (containing owl:Thing)
// Now print the hierarchy out
Node<OWLClass> topNode = reasoner.getTopClassNode();
print(topNode, reasoner, 0);
} catch (UnsupportedOperationException exception) {
System.out.println("Unsupported reasoner operation.");
} catch (OWLOntologyCreationException e) {
System.out.println("Could not load the pizza ontology: " + e.getMessage());
}
}
private IRI executeRule(final Rule r, final IRI inputIRI) {
try {
PelletOptions.USE_ANNOTATION_SUPPORT = true;
PelletOptions.TREAT_ALL_VARS_DISTINGUISHED = controller.isTreatAllVariablesDistinguished();
QueryEngineType type = (QueryEngineType) controller.getQueryEngineType();
final QueryExecution qe;
final ByteArrayOutputStream w = new ByteArrayOutputStream();
final Query qSelect = getSelectExampleQuery(r.getQuery());
if (type.toPellet() != null) {
final OWLOntology queryOntology = getInputOntologyForRule(inputIRI);
final PelletReasoner reasoner =
PelletReasonerFactory.getInstance().createReasoner(queryOntology);
log.info("Ontology size: " + reasoner.getKB().getInfo());
final Dataset ds = kb2ds(reasoner.getKB());
final QueryExecution qeSelect =
SparqlDLExecutionFactory.create(qSelect, ds, null, type.toPellet());
final ResultSet rs = qeSelect.execSelect();
controller.setSelect(r, rs.getResultVars(), ResultSetFormatter.toList(rs));
qe =
SparqlDLExecutionFactory.create(
r.getQuery(), kb2ds(reasoner.getKB()), null, type.toPellet());
qe.execConstruct().write(w);
} else {
final ByteArrayOutputStream w2 = new ByteArrayOutputStream();
final Model model = ModelFactory.createDefaultModel();
try {
controller
.getOWLOntologyManager()
.saveOntology(queryOntology, new TurtleOntologyFormat(), w2);
model.read(new ByteArrayInputStream(w2.toByteArray()), "", "TURTLE");
final QueryExecution qeSelect = QueryExecutionFactory.create(qSelect, model);
final ResultSet rs = qeSelect.execSelect();
controller.setSelect(r, rs.getResultVars(), ResultSetFormatter.toList(rs));
qe = QueryExecutionFactory.create(r.getQuery(), model);
qe.execConstruct().write(w);
} catch (OWLOntologyStorageException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
final IRI outputIRI = getOntologyIRIForRuleName(r.getName());
// loaded generated ontology
final OWLOntology generatedOntology =
controller
.getOWLOntologyManager()
.loadOntologyFromOntologyDocument(new ByteArrayInputStream(w.toByteArray()));
controller.updateOntology(
generatedOntology,
outputIRI,
inputIRI,
controller.getRuleSpec().getResultFile(r).toURI());
controller.setStatus("Rule " + r.getName() + " successfully executed");
return outputIRI;
} catch (OWLOntologyCreationException e1) {
controller.setStatus(e1.getMessage());
return null;
}
}
