예제 #1
0
 public void mergeAndCompare(String dirPath) throws Exception {
   File dir = new File(dirPath);
   File[] files = dir.listFiles();
   OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
   OWLOntologyMerger merger = new OWLOntologyMerger(manager);
   for (File f : files) manager.loadOntologyFromOntologyDocument(IRI.create(f));
   String s = "norm-merged-base+300.owl";
   IRI iri = IRI.create(new File(s));
   OWLOntology mergedOntology = merger.createMergedOntology(manager, iri);
   manager.saveOntology(mergedOntology, iri);
   System.out.println("Done creating merged ontology");
   //		precomputeAndCheckResults(mergedOntology);
 }
 private OWLOntology getFromOntoMgr() throws IOException {
   try {
     Scope scope = null;
     synchronized (onManager) {
       scope = onManager.getScope(this.scopeId);
     }
     if (scope == null) {
       log.error("Scope {} cannot be retrieved", this.scopeId);
       throw new IOException("Scope " + this.scopeId + " cannot be retrieved");
     }
     Session session = null;
     if (sessionManager != null)
       synchronized (sessionManager) {
         session = sessionManager.getSession(sessionId);
       }
     if (session == null) log.warn("Session {} cannot be retrieved. Ignoring.", this.sessionId);
     final Set<OWLOntology> set = new HashSet<OWLOntology>();
     set.add(scope.export(OWLOntology.class, true));
     if (session != null) set.add(session.export(OWLOntology.class, true));
     if (set.size() == 1) return set.iterator().next();
     OWLOntologyMerger merger =
         new OWLOntologyMerger(
             new OWLOntologySetProvider() {
               @Override
               public Set<OWLOntology> getOntologies() {
                 return set;
               }
             });
     return merger.createMergedOntology(
         createOWLOntologyManager(), IRI.create("reasoners:input-" + System.currentTimeMillis()));
   } catch (OWLOntologyCreationException e) {
     String message = "The network for scope/session cannot be retrieved";
     log.error(message + ":", e);
     throw new IllegalArgumentException(message);
   }
 }
  protected OWLOntology getOntologyAsOWLOntology(
      OWLOntologyID ontologyId, boolean merge, IRI universalPrefix) {
    // if (merge) throw new UnsupportedOperationException("Merge not implemented yet for
    // OWLOntology.");

    // Remove the check below. It might be an unmanaged dependency (TODO remove from collector and
    // reintroduce check?).
    // if (!hasOntology(ontologyIri)) return null;
    OWLOntology o;
    o = ontologyProvider.getStoredOntology(ontologyId, OWLOntology.class, merge);

    if (merge) {
      final Set<OWLOntology> set = new HashSet<OWLOntology>();
      log.debug("Merging {} with its imports, if any.", o);
      set.add(o);
      // Actually, if the provider already performed the merge, this won't happen
      for (OWLOntology impo : o.getImportsClosure()) {
        log.debug("Imported ontology {} will be merged with {}.", impo, o);
        set.add(impo);
      }
      OWLOntologySetProvider provider =
          new OWLOntologySetProvider() {
            @Override
            public Set<OWLOntology> getOntologies() {
              return set;
            }
          };
      OWLOntologyMerger merger = new OWLOntologyMerger(provider);
      try {
        o =
            merger.createMergedOntology(
                OWLManager.createOWLOntologyManager(), ontologyId.getOntologyIRI());
      } catch (OWLOntologyCreationException e) {
        log.error("Failed to merge imports for ontology " + ontologyId, e);
        // do not reassign the root ontology
      }
    } else {
      // Rewrite import statements
      List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
      OWLDataFactory df = OWLManager.getOWLDataFactory();

      /*
       * TODO manage import rewrites better once the container ID is fully configurable (i.e. instead of
       * going upOne() add "session" or "ontology" if needed). But only do this if we keep considering
       * imported ontologies as *not* managed.
       */
      for (OWLImportsDeclaration oldImp : o.getImportsDeclarations()) {
        changes.add(new RemoveImport(o, oldImp));
        String s = oldImp.getIRI().toString();
        // FIXME Ugly way to check, but we'll get through with it
        if (s.contains("::")) s = s.substring(s.indexOf("::") + 2, s.length());
        boolean managed = managedOntologies.contains(oldImp.getIRI());
        // For space, always go up at least one

        String tid = getID();
        if (backwardPathLength > 0) tid = tid.split("/")[0];

        IRI target =
            IRI.create(
                (managed
                        ? universalPrefix + "/" + tid + "/"
                        : URIUtils.upOne(universalPrefix) + "/")
                    + s);
        changes.add(new AddImport(o, df.getOWLImportsDeclaration(target)));
      }
      o.getOWLOntologyManager().applyChanges(changes);
    }

    return o;
  }
  /**
   * This method has no conversion calls, to it can be invoked by subclasses that wish to modify it
   * afterwards.
   *
   * <p>FIXME not merging yet FIXME not including imported ontologies unless they are merged
   * *before* storage.
   *
   * @param merge
   * @return
   */
  protected OWLOntology exportToOWLOntology(boolean merge, IRI prefix) {

    long before = System.currentTimeMillis();

    // Create a new ontology
    OWLOntology root;
    OWLOntologyManager ontologyManager = OWLManager.createOWLOntologyManager();
    IRI iri = IRI.create(prefix + _id);
    try {
      root = ontologyManager.createOntology(iri);
    } catch (OWLOntologyAlreadyExistsException e) {
      // It should be impossible, but just in case.
      ontologyManager.removeOntology(ontologyManager.getOntology(iri));
      try {
        root = ontologyManager.createOntology(iri);
      } catch (OWLOntologyAlreadyExistsException e1) {
        root = ontologyManager.getOntology(iri);
      } catch (OWLOntologyCreationException e1) {
        log.error("Failed to assemble root ontology for scope " + iri, e);
        root = null;
      }
    } catch (OWLOntologyCreationException e) {
      log.error("Failed to assemble root ontology for scope " + _id, e);
      root = null;
    }

    // Add the import declarations for directly managed ontologies.
    if (root != null) {

      if (merge) {

        final Set<OWLOntology> set = new HashSet<OWLOntology>();
        log.debug("Merging {} with its imports.", root);
        set.add(root);

        for (OWLOntologyID ontologyId : managedOntologies) {
          log.debug("Merging {} with {}.", ontologyId, root);
          set.add(getOntology(ontologyId, OWLOntology.class, true));
        }

        OWLOntologySetProvider provider =
            new OWLOntologySetProvider() {
              @Override
              public Set<OWLOntology> getOntologies() {
                return set;
              }
            };
        OWLOntologyMerger merger = new OWLOntologyMerger(provider);
        try {
          root = merger.createMergedOntology(OWLManager.createOWLOntologyManager(), iri);

        } catch (OWLOntologyCreationException e) {
          log.error("Failed to merge imports for ontology " + iri, e);
          root = null;
        }

      } else {
        // Add the import declarations for directly managed ontologies.
        List<OWLOntologyChange> changes = new LinkedList<OWLOntologyChange>();
        OWLDataFactory df = ontologyManager.getOWLDataFactory();

        String base = prefix + getID();
        for (int i = 0; i < backwardPathLength; i++)
          base = URIUtils.upOne(URI.create(base)).toString();
        base += "/";

        // The key set of managedOntologies contains the ontology IRIs, not their storage keys.
        for (OWLOntologyID ontologyId : managedOntologies) {
          // XXX some day the versionIRI will be the only physical reference for the ontology
          IRI physIRI = IRI.create(base + OntologyUtils.encode(ontologyId));
          changes.add(new AddImport(root, df.getOWLImportsDeclaration(physIRI)));
        }
        ontologyManager.applyChanges(changes);
      }
    }
    log.debug("OWL export of {} completed in {} ms.", getID(), System.currentTimeMillis() - before);

    return root;
  }