public void setOntology(OWLOntology ont) {
    this.ont = ont;
    List<Object> data = new ArrayList<>();
    data.add(directImportsHeader);

    // @@TODO ordering
    for (OWLImportsDeclaration decl : ont.getImportsDeclarations()) {
      data.add(new OntologyImportItem(ont, decl, editorKit));
    }
    data.add(indirectImportsHeader);
    // @@TODO ordering
    try {
      for (OWLOntology ontRef :
          editorKit.getOWLModelManager().getOWLOntologyManager().getImportsClosure(ont)) {
        if (!ontRef.equals(ont)) {
          for (OWLImportsDeclaration dec : ontRef.getImportsDeclarations()) {
            if (!data.contains(dec)) {
              data.add(new OntologyImportItem(ontRef, dec, editorKit));
            }
          }
        }
      }
    } catch (UnknownOWLOntologyException e) {
      throw new OWLRuntimeException(e);
    }
    setListData(data.toArray());
  }
 public void writeOntologyHeader(OWLOntology ontology) {
   event = new RendererEvent(this, ontology);
   fireFrameRenderingPrepared(ONTOLOGY.toString());
   write(ONTOLOGY.toString());
   write(":");
   writeSpace();
   if (!ontology.isAnonymous()) {
     int indent = getIndent();
     writeFullURI(ontology.getOntologyID().getOntologyIRI().toString());
     writeNewLine();
     pushTab(indent);
     if (ontology.getOntologyID().getVersionIRI() != null) {
       writeFullURI(ontology.getOntologyID().getVersionIRI().toString());
     }
     popTab();
   }
   fireFrameRenderingStarted(ONTOLOGY.toString());
   writeNewLine();
   for (OWLImportsDeclaration decl : ontology.getImportsDeclarations()) {
     fireSectionItemPrepared(IMPORT.toString());
     write(IMPORT.toString());
     write(":");
     writeSpace();
     fireSectionRenderingStarted(IMPORT.toString());
     writeFullURI(decl.getURI().toString());
     writeNewLine();
     fireSectionRenderingFinished(IMPORT.toString());
   }
   writeNewLine();
   writeSection(ANNOTATIONS, ontology.getAnnotations(), ",", true);
   fireFrameRenderingFinished(ONTOLOGY.toString());
 }
  public void mergeOntologies() {
    List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>();
    for (OWLOntology ont : ontologies) {
      if (!ont.equals(targetOntology)) {

        // move the axioms
        for (OWLAxiom ax : ont.getAxioms()) {
          changes.add(new AddAxiom(targetOntology, ax));
        }

        // move ontology annotations
        for (OWLAnnotation annot : ont.getAnnotations()) {
          changes.add(new AddOntologyAnnotation(targetOntology, annot));
        }

        if (!targetOntology.getOntologyID().isAnonymous()) {
          // move ontology imports
          for (OWLImportsDeclaration decl : ont.getImportsDeclarations()) {
            if (ontologies.contains(ont.getOWLOntologyManager().getImportedOntology(decl))) {
              continue;
            }
            Optional<IRI> defaultDocumentIRI =
                targetOntology.getOntologyID().getDefaultDocumentIRI();
            if (defaultDocumentIRI.isPresent() && !decl.getIRI().equals(defaultDocumentIRI.get())) {
              changes.add(new AddImport(targetOntology, decl));
            } else {
              logger.warn(
                  "Merge: ignoring import declaration for ontology "
                      + targetOntology.getOntologyID()
                      + " (would result in target ontology importing itself).");
            }
          }
        }
      }
    }
    try {
      owlOntologyManager.applyChanges(changes);
    } catch (OWLOntologyChangeException e) {
      ErrorLogPanel.showErrorDialog(e);
    }
  }
 public void storeFromTo(OWLOntology from, HGDBOntology to) {
   final Set<OWLAxiom> axioms = from.getAxioms();
   int i = 0;
   for (OWLAxiom axiom : axioms) {
     to.applyChange(new AddAxiom(to, axiom));
     i++;
     if (i % 5000 == 0) {
       System.out.println("storeFromTo: Axioms: " + i);
     }
   }
   System.out.println("storeFromTo: Axioms: " + i);
   // manager.addAxioms(newOnto, axioms);
   // Add Ontology Annotations
   for (OWLAnnotation a : from.getAnnotations()) {
     to.applyChange(new AddOntologyAnnotation(to, a));
   }
   // Add Import Declarations
   for (OWLImportsDeclaration im : from.getImportsDeclarations()) {
     to.applyChange(new AddImport(to, im));
   }
 }
Exemple #5
0
  private OWLOntology parseWithReasoner(OWLOntologyManager manager, OWLOntology ontology) {
    try {
      PelletOptions.load(new URL("http://" + cssLocation + "pellet.properties"));
      PelletReasoner reasoner = PelletReasonerFactory.getInstance().createReasoner(ontology);
      reasoner.getKB().prepare();
      List<InferredAxiomGenerator<? extends OWLAxiom>> generators =
          new ArrayList<InferredAxiomGenerator<? extends OWLAxiom>>();
      generators.add(new InferredSubClassAxiomGenerator());
      generators.add(new InferredClassAssertionAxiomGenerator());
      generators.add(new InferredDisjointClassesAxiomGenerator());
      generators.add(new InferredEquivalentClassAxiomGenerator());
      generators.add(new InferredEquivalentDataPropertiesAxiomGenerator());
      generators.add(new InferredEquivalentObjectPropertyAxiomGenerator());
      generators.add(new InferredInverseObjectPropertiesAxiomGenerator());
      generators.add(new InferredPropertyAssertionGenerator());
      generators.add(new InferredSubDataPropertyAxiomGenerator());
      generators.add(new InferredSubObjectPropertyAxiomGenerator());

      InferredOntologyGenerator iog = new InferredOntologyGenerator(reasoner, generators);

      OWLOntologyID id = ontology.getOntologyID();
      Set<OWLImportsDeclaration> declarations = ontology.getImportsDeclarations();
      Set<OWLAnnotation> annotations = ontology.getAnnotations();

      Map<OWLEntity, Set<OWLAnnotationAssertionAxiom>> entityAnnotations =
          new HashMap<OWLEntity, Set<OWLAnnotationAssertionAxiom>>();
      for (OWLClass aEntity : ontology.getClassesInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }
      for (OWLObjectProperty aEntity : ontology.getObjectPropertiesInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }
      for (OWLDataProperty aEntity : ontology.getDataPropertiesInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }
      for (OWLNamedIndividual aEntity : ontology.getIndividualsInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }
      for (OWLAnnotationProperty aEntity : ontology.getAnnotationPropertiesInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }
      for (OWLDatatype aEntity : ontology.getDatatypesInSignature()) {
        entityAnnotations.put(aEntity, aEntity.getAnnotationAssertionAxioms(ontology));
      }

      manager.removeOntology(ontology);
      OWLOntology inferred = manager.createOntology(id);
      iog.fillOntology(manager, inferred);

      for (OWLImportsDeclaration decl : declarations) {
        manager.applyChange(new AddImport(inferred, decl));
      }
      for (OWLAnnotation ann : annotations) {
        manager.applyChange(new AddOntologyAnnotation(inferred, ann));
      }
      for (OWLClass aEntity : inferred.getClassesInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }
      for (OWLObjectProperty aEntity : inferred.getObjectPropertiesInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }
      for (OWLDataProperty aEntity : inferred.getDataPropertiesInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }
      for (OWLNamedIndividual aEntity : inferred.getIndividualsInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }
      for (OWLAnnotationProperty aEntity : inferred.getAnnotationPropertiesInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }
      for (OWLDatatype aEntity : inferred.getDatatypesInSignature()) {
        applyAnnotations(aEntity, entityAnnotations, manager, inferred);
      }

      return inferred;
    } catch (FileNotFoundException e1) {
      return ontology;
    } catch (MalformedURLException e1) {
      return ontology;
    } catch (IOException e1) {
      return ontology;
    } catch (OWLOntologyCreationException e) {
      return ontology;
    }
  }
  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;
  }