protected Concept getParentConcept(
      OWLOntology o, OWLClass ontologyClass, File inDir, Authorizations authorizations)
      throws IOException {
    Set<OWLClassExpression> superClasses = ontologyClass.getSuperClasses(o);
    if (superClasses.size() == 0) {
      return getEntityConcept();
    } else if (superClasses.size() == 1) {
      OWLClassExpression superClassExpr = superClasses.iterator().next();
      OWLClass superClass = superClassExpr.asOWLClass();
      String superClassUri = superClass.getIRI().toString();
      Concept parent = getConceptByIRI(superClassUri);
      if (parent != null) {
        return parent;
      }

      parent = importOntologyClass(o, superClass, inDir, authorizations);
      if (parent == null) {
        throw new LumifyException("Could not find or create parent: " + superClass);
      }
      return parent;
    } else {
      throw new LumifyException(
          "Unhandled multiple super classes. Found " + superClasses.size() + ", expected 0 or 1.");
    }
  }
  protected void importDataProperty(OWLOntology o, OWLDataProperty dataTypeProperty) {
    String propertyIRI = dataTypeProperty.getIRI().toString();
    String propertyDisplayName = getLabel(o, dataTypeProperty);
    PropertyType propertyType = getPropertyType(o, dataTypeProperty);
    boolean userVisible = getUserVisible(o, dataTypeProperty);
    boolean searchable = getSearchable(o, dataTypeProperty);
    Boolean displayTime = getDisplayTime(o, dataTypeProperty);
    Double boost = getBoost(o, dataTypeProperty);
    if (propertyType == null) {
      throw new LumifyException("Could not get property type on data property " + propertyIRI);
    }

    for (OWLClassExpression domainClassExpr : dataTypeProperty.getDomains(o)) {
      OWLClass domainClass = domainClassExpr.asOWLClass();
      String domainClassUri = domainClass.getIRI().toString();
      Concept domainConcept = getConceptByIRI(domainClassUri);
      checkNotNull(domainConcept, "Could not find class with uri: " + domainClassUri);

      LOGGER.info("Adding data property " + propertyIRI + " to class " + domainConcept.getTitle());

      ArrayList<PossibleValueType> possibleValues = getPossibleValues(o, dataTypeProperty);
      Collection<TextIndexHint> textIndexHints = getTextIndexHints(o, dataTypeProperty);
      addPropertyTo(
          domainConcept,
          propertyIRI,
          propertyDisplayName,
          propertyType,
          possibleValues,
          textIndexHints,
          userVisible,
          searchable,
          displayTime,
          boost);
    }
  }
Exemplo n.º 3
0
  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();
    }
  }
  private Iterable<Concept> getDomainsConcepts(OWLOntology o, OWLObjectProperty objectProperty) {
    String uri = objectProperty.getIRI().toString();
    if (objectProperty.getDomains(o).size() == 0) {
      throw new LumifyException("Invalid number of domain properties on " + uri);
    }

    List<Concept> domains = new ArrayList<Concept>();
    for (OWLClassExpression rangeClassExpr : objectProperty.getDomains(o)) {
      OWLClass rangeClass = rangeClassExpr.asOWLClass();
      String rangeClassUri = rangeClass.getIRI().toString();
      Concept ontologyClass = getConceptByIRI(rangeClassUri);
      checkNotNull(ontologyClass, "Could not find class with uri: " + rangeClassUri);
      domains.add(ontologyClass);
    }
    return domains;
  }
  protected Concept importOntologyClass(
      OWLOntology o, OWLClass ontologyClass, File inDir, Authorizations authorizations)
      throws IOException {
    String uri = ontologyClass.getIRI().toString();
    if ("http://www.w3.org/2002/07/owl#Thing".equals(uri)) {
      return getEntityConcept();
    }

    String label = getLabel(o, ontologyClass);
    checkNotNull(label, "label cannot be null or empty: " + uri);
    LOGGER.info("Importing ontology class " + uri + " (label: " + label + ")");

    Concept parent = getParentConcept(o, ontologyClass, inDir, authorizations);
    Concept result = getOrCreateConcept(parent, uri, label);

    String color = getColor(o, ontologyClass);
    if (color != null) {
      result.setProperty(
          OntologyLumifyProperties.COLOR.getPropertyName(),
          color,
          OntologyRepository.VISIBILITY.getVisibility(),
          authorizations);
    }

    String displayType = getDisplayType(o, ontologyClass);
    if (displayType != null) {
      result.setProperty(
          OntologyLumifyProperties.DISPLAY_TYPE.getPropertyName(),
          displayType,
          OntologyRepository.VISIBILITY.getVisibility(),
          authorizations);
    }

    String titleFormula = getTitleFormula(o, ontologyClass);
    if (titleFormula != null) {
      result.setProperty(
          OntologyLumifyProperties.TITLE_FORMULA.getPropertyName(),
          titleFormula,
          OntologyRepository.VISIBILITY.getVisibility(),
          authorizations);
    }

    String subtitleFormula = getSubtitleFormula(o, ontologyClass);
    if (subtitleFormula != null) {
      result.setProperty(
          OntologyLumifyProperties.SUBTITLE_FORMULA.getPropertyName(),
          subtitleFormula,
          OntologyRepository.VISIBILITY.getVisibility(),
          authorizations);
    }

    String timeFormula = getTimeFormula(o, ontologyClass);
    if (timeFormula != null) {
      result.setProperty(
          OntologyLumifyProperties.TIME_FORMULA.getPropertyName(),
          timeFormula,
          OntologyRepository.VISIBILITY.getVisibility(),
          authorizations);
    }

    boolean userVisible = getUserVisible(o, ontologyClass);
    result.setProperty(
        OntologyLumifyProperties.USER_VISIBLE.getPropertyName(),
        userVisible,
        OntologyRepository.VISIBILITY.getVisibility(),
        authorizations);

    String glyphIconFileName = getGlyphIconFileName(o, ontologyClass);
    setIconProperty(
        result,
        inDir,
        glyphIconFileName,
        LumifyProperties.GLYPH_ICON.getPropertyName(),
        authorizations);

    String mapGlyphIconFileName = getMapGlyphIconFileName(o, ontologyClass);
    setIconProperty(
        result,
        inDir,
        mapGlyphIconFileName,
        LumifyProperties.MAP_GLYPH_ICON.getPropertyName(),
        authorizations);

    return result;
  }