コード例 #1
0
 protected OWLClass getFreshQueryClass(String base) {
   long cnt = 0;
   String iriString = base;
   while (m_ontologyOperator.getOntology().containsClassInSignature(IRI.create(iriString))) {
     iriString =
         base + (cnt++); // not guaranteed to succeed.. however |long| amount of possibilities
   }
   return OWLManager.getOWLDataFactory().getOWLClass(IRI.create(iriString));
 }
コード例 #2
0
public class ReasonerUtilUnsatTest {

  OWLDataFactory dataFactory = OWLManager.getOWLDataFactory();
  OWLOntologyManager manager;
  OWLOntology ont;
  OWLOntology unsatImport;
  ReasonerUtil util;

  @Before
  public void setup() throws Exception {
    String uri = Resources.getResource("ontologies/unsat_parent.owl").toURI().toString();
    IRI iri = IRI.create(uri);
    manager = OWLManager.createOWLOntologyManager();
    manager.addIRIMapper(
        new OWLOntologyIRIMapper() {
          @Override
          public IRI getDocumentIRI(IRI origIri) {
            String uri = null;
            try {
              uri = Resources.getResource("ontologies/unsat.owl").toURI().toString();
            } catch (URISyntaxException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            }
            return IRI.create(uri);
          }
        });
    ont = manager.loadOntologyFromOntologyDocument(iri);
    ReasonerConfiguration config = new ReasonerConfiguration();
    config.setFactory(ElkReasonerFactory.class.getCanonicalName());
    util = new ReasonerUtil(config, manager, ont);
  }

  @Test
  public void removesAxiomsInImportedOntologies() throws Exception {
    assertThat(util.getUnsatisfiableClasses(), is(not(empty())));
    util.removeUnsatisfiableClasses();
    assertThat(util.getUnsatisfiableClasses(), is(empty()));
    assertThat(util.reason(), is(true));
  }
}
コード例 #3
0
  protected void insertQueryAxiom(OWLClass queryClass) {
    //		Main.getOntologyManager().addAxiom(m_ontologyOperator.getOntology(),
    //				OWLManager.getOWLDataFactory().getOWLEquivalentClassesAxiom(queryClass,
    // m_referenceExpression));

    m_ontologyOperator
        .getOntology()
        .getOWLOntologyManager()
        .addAxiom(
            m_ontologyOperator.getOntology(),
            //				OWLManager.getOWLDataFactory().getOWLEquivalentClassesAxiom(
            OWLManager.getOWLDataFactory()
                .getOWLSubClassOfAxiom(
                    queryClass,
                    m_referenceExpression.accept(
                        m_ontologyOperator.getFlatteningTransformer().getVisitor())));
    m_ontologyOperator
        .getOntology()
        .getOWLOntologyManager()
        .applyChanges(m_ontologyOperator.getFlatteningTransformer().getVisitor().getChanges());
    m_ontologyOperator.getFlatteningTransformer().getVisitor().resetChangeList();
    m_ontologyOperator.ontologyChanged();
  }
コード例 #4
0
ファイル: TestData.java プロジェクト: omusico/BigData
/**
 * We share this data between all the tests. Note: take care, do not leave the content of these
 * object changed, for example remove your example ontology from the testDataManager
 */
public class TestData {

  private static final Logger log = LoggerFactory.getLogger(TestData.class);
  /** Constants (local resources) */
  static final String LOCAL_RESOURCE_FOAF = "foaf.rdf";

  static URL FOAF_LOCATION =
      TestData.class.getResource(System.getProperty("file.separator") + LOCAL_RESOURCE_FOAF);
  static final String LOCAL_RESOURCE_DBPEDIA = "dbpedia_3.6.owl";
  static URL DBPEDIA_LOCATION =
      TestData.class.getResource(System.getProperty("file.separator") + LOCAL_RESOURCE_DBPEDIA);

  static final String LOCAL_RESOURCE_TEST_1 = "test_1.owl";
  static URL TEST_1_LOCATION =
      TestData.class.getResource(System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_1);
  static final String LOCAL_RESOURCE_TEST_1_EXPECTED = "test_1_expected.owl";
  static URL TEST_1_expected_LOCATION =
      TestData.class.getResource(
          System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_1_EXPECTED);

  static final String LOCAL_RESOURCE_TEST_2 = "test_2.owl";
  static URL TEST_2_LOCATION =
      TestData.class.getResource(System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_2);
  static final String LOCAL_RESOURCE_TEST_2_EXPECTED = "test_2_expected.owl";
  static URL TEST_2_expected_LOCATION =
      TestData.class.getResource(
          System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_2_EXPECTED);

  static final String LOCAL_RESOURCE_TEST_3 = "test_3.owl";
  static URL TEST_3_LOCATION =
      TestData.class.getResource(System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_3);
  static final String LOCAL_RESOURCE_TEST_3_RULES = "test_3_rules.owl";
  static URL TEST_3_rules_LOCATION =
      TestData.class.getResource(
          System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_3_RULES);
  static final String LOCAL_RESOURCE_TEST_3_EXPECTED = "test_3_expected.owl";
  static URL TEST_3_expected_LOCATION =
      TestData.class.getResource(
          System.getProperty("file.separator") + LOCAL_RESOURCE_TEST_3_EXPECTED);

  /** Constants */
  // EXAMPLE
  static final String TEST_NS = "http://www.example.org/test/";

  static final String TEST_1_NS = TEST_NS + "1/";
  static final String TEST_1_expected_NS = TEST_1_NS + "expected/";
  static final String TEST_2_NS = TEST_NS + "2/";
  static final String TEST_2_expected_NS = TEST_2_NS + "expected/";
  static final String TEST_3_NS = TEST_NS + "3/";
  static final String TEST_3_rules_NS = TEST_3_NS + "rules/";
  static final String TEST_3_expected_NS = TEST_3_NS + "expected/";

  // FOAF
  static final String FOAF_NS = "http://xmlns.com/foaf/0.1/";

  /** Manager, factory */
  static final OWLOntologyManager manager = OWLManager.createOWLOntologyManager();

  static final OWLDataFactory factory = OWLManager.getOWLDataFactory();

  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());
    }
  }
}
コード例 #5
0
  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;
  }
コード例 #6
0
public class IdentifySplitConcepts extends AbstractAnalyzerAlgorithm {
  public static final MatchDescription SPLIT =
      new MatchDescription("Split Operation", MatchDescription.PRIMARY_MATCH_PRIORITY);
  public static final MatchDescription COPIED_FROM_SPLIT =
      new MatchDescription("Copied by split operation", MatchDescription.SECONDARY_MATCH_PRIORITY);
  public static final OWLDatatype STRING_DATATYPE =
      OWLManager.getOWLDataFactory().getOWLDatatype(XSDVocabulary.STRING.getIRI());

  public static final String SPLIT_FROM_ANNOTATION_PROPERTY = "split.from.annotation";

  private Changes changes;
  private OwlDiffMap diffMap;
  private CodeToEntityMapper mapper;
  private boolean disabled = false;
  private OWLAnnotationProperty splitFromProperty;

  public void initialise(Engine e) {
    this.changes = e.getChanges();
    this.diffMap = changes.getRawDiffMap();
    this.mapper = CodeToEntityMapper.get(e);
    OWLDataFactory factory = diffMap.getOWLDataFactory();
    String splitFromPropertyName = (String) e.getParameters().get(SPLIT_FROM_ANNOTATION_PROPERTY);
    if (splitFromPropertyName == null) {
      disabled = true;
      return;
    }
    splitFromProperty = factory.getOWLAnnotationProperty(IRI.create(splitFromPropertyName));
  }

  public void apply() {
    if (disabled) {
      return;
    }
    for (EntityBasedDiff diff : changes.getEntityBasedDiffs()) {
      apply(diff);
    }
  }

  private void apply(EntityBasedDiff diff) {
    IRI iriOfNewlyCreatedClass = null;
    String code = null;
    MatchedAxiom splitAxiomWithBadDescription = null;
    MatchedAxiom splitFrom = null;
    for (MatchedAxiom match : diff.getAxiomMatches()) {
      if (match.getDescription().equals(MatchedAxiom.AXIOM_ADDED)
          && isSplitFromAnnotationAssertion(match.getTargetAxiom())) {
        splitAxiomWithBadDescription = match;
        splitFrom = new MatchedAxiom(null, match.getTargetAxiom(), SPLIT);
        iriOfNewlyCreatedClass =
            (IRI) ((OWLAnnotationAssertionAxiom) match.getTargetAxiom()).getSubject();
        code =
            ((OWLLiteral) ((OWLAnnotationAssertionAxiom) match.getTargetAxiom()).getValue())
                .getLiteral();
        break;
      }
    }
    if (splitFrom != null) {
      changes.removeMatch(splitAxiomWithBadDescription);
      changes.addMatch(splitFrom);

      handleNewSplitAxioms(iriOfNewlyCreatedClass, code, diff);
    }
  }

  private boolean isSplitFromAnnotationAssertion(OWLAxiom axiom) {
    return axiom instanceof OWLAnnotationAssertionAxiom
        && ((OWLAnnotationAssertionAxiom) axiom).getProperty().equals(splitFromProperty)
        && diffMap.getUnmatchedTargetAxioms().contains(axiom)
        && ((OWLAnnotationAssertionAxiom) axiom).getSubject() instanceof IRI
        && ((OWLAnnotationAssertionAxiom) axiom).getValue() instanceof OWLLiteral
        && ((OWLLiteral) ((OWLAnnotationAssertionAxiom) axiom).getValue())
            .getDatatype()
            .equals(STRING_DATATYPE);
  }

  private void handleNewSplitAxioms(IRI iriOfNewlyCreatedClass, String code, EntityBasedDiff diff) {
    OWLDataFactory factory = diffMap.getOWLDataFactory();
    OWLClass newlyCreatedClass = factory.getOWLClass(iriOfNewlyCreatedClass);
    OWLClass classThatWasSplit = getClassThatWasSplit(code);
    if (classThatWasSplit != null) {
      handleNewSplitAxioms(newlyCreatedClass, classThatWasSplit, diff);
    }
  }

  private void handleNewSplitAxioms(
      OWLClass newlyCreatedClass, OWLClass classThatWasSplit, EntityBasedDiff diff) {
    OWLOntology sourceOntology = diffMap.getSourceOntology();
    Map<OWLEntity, IRI> newTargetToSplitSource =
        Collections.singletonMap((OWLEntity) newlyCreatedClass, classThatWasSplit.getIRI());
    OWLObjectDuplicator duplicator =
        new OWLObjectDuplicator(newTargetToSplitSource, diffMap.getOWLDataFactory());
    Set<OWLClassExpression> inferredParents = getInferredParents(sourceOntology, classThatWasSplit);
    for (MatchedAxiom match : new ArrayList<MatchedAxiom>(diff.getAxiomMatches())) {
      if (match.getDescription().equals(MatchedAxiom.AXIOM_ADDED)
          && cameFromSourceOntology(
              (OWLAxiom) duplicator.duplicateObject(match.getTargetAxiom()),
              sourceOntology,
              classThatWasSplit,
              inferredParents)) {
        MatchedAxiom modifiedBySplit =
            new MatchedAxiom(null, match.getTargetAxiom(), COPIED_FROM_SPLIT);
        changes.removeMatch(match);
        changes.addMatch(modifiedBySplit);
      }
    }
  }

  private boolean cameFromSourceOntology(
      OWLAxiom axiom,
      OWLOntology sourceOntology,
      OWLClass child,
      Set<OWLClassExpression> inferredParents) {
    if (sourceOntology.containsAxiom(axiom)) {
      return true;
    } else if (axiom instanceof OWLSubClassOfAxiom) {
      return ((OWLSubClassOfAxiom) axiom).getSubClass().equals(child)
          && inferredParents.contains(((OWLSubClassOfAxiom) axiom).getSuperClass());
    } else {
      return false;
    }
  }

  private Set<OWLClassExpression> getInferredParents(OWLOntology sourceOntology, OWLClass child) {
    return getInferredParents(sourceOntology, child, new TreeSet<OWLClass>());
  }

  private Set<OWLClassExpression> getInferredParents(
      OWLOntology sourceOntology, OWLClass child, Set<OWLClass> viewed) {
    Set<OWLClassExpression> result = new TreeSet<OWLClassExpression>();
    if (!viewed.contains(child)) {
      viewed.add(child);
      Set<OWLClassExpression> parents = new TreeSet<OWLClassExpression>();
      parents.addAll(child.getSuperClasses(sourceOntology));
      parents.addAll(child.getEquivalentClasses(sourceOntology));
      for (OWLClassExpression parent : parents) {
        if (parent instanceof OWLClass) {
          result.add(parent);
          result.addAll(getInferredParents(sourceOntology, (OWLClass) parent, viewed));
        } else if (parent instanceof OWLObjectIntersectionOf) {
          Set<OWLClassExpression> inferredParents =
              ((OWLObjectIntersectionOf) parent).getOperands();
          result.addAll(inferredParents);
          for (OWLClassExpression inferredParent : inferredParents) {
            if (inferredParent instanceof OWLClass) {
              result.addAll(getInferredParents(sourceOntology, (OWLClass) inferredParent, viewed));
            }
          }
        } else {
          result.add(parent);
        }
      }
    }
    return result;
  }

  private OWLClass getClassThatWasSplit(String code) {
    if (code == null) {
      return null;
    }
    Collection<OWLEntity> possiblySplitEntities = mapper.getTargetEntities(code);
    OWLClass classThatWasSplit = null;
    for (OWLEntity possiblySplityEntity : possiblySplitEntities) {
      if (possiblySplityEntity instanceof OWLClass) {
        if (classThatWasSplit != null) {
          return null;
        } else {
          classThatWasSplit = (OWLClass) possiblySplityEntity;
          EntityBasedDiff classThatWasSplitDiff = changes.getTargetDiffMap().get(classThatWasSplit);
          if (classThatWasSplitDiff != null) {
            classThatWasSplit =
                (OWLClass)
                    classThatWasSplitDiff
                        .getSourceEntity(); // if it was created we do really want null
          }
        }
      }
    }
    return classThatWasSplit;
  }
}