コード例 #1
0
  private void _saveOntology() throws Exception {

    if (outputFile.toLowerCase().startsWith("file:")) {
      outputFile = outputFile.substring("file:".length());
    }
    File file = new File(outputFile);

    URI uri = URI.create("file:" + file.getAbsolutePath());

    // TODO NOTE: the format parameter is ignored by SKOAPI alpha; it always
    // uses RDFXMLOntologyFormat
    manager.save(dataset, SKOSFormatExt.RDFXML, uri);

    // To try other possible output format, the OWLAPI can be used directly:
    //		OWLOntologyFormat format =
    //			new RDFXMLOntologyFormat();
    //			new OWLXMLOntologyFormat();
    //			new TurtleOntologyFormat();
    //			new ManchesterOWLSyntaxOntologyFormat();
    //			new LatexOntologyFormat();
    //
    //		owlManager.saveOntology(owlOntology, format, uri);
  }
コード例 #2
0
ファイル: Example3.java プロジェクト: kodizant/java-skos-api
  public static void main(String[] args) {

    /*
     * This example recreates the SKOS dataset in Example2.java, but does so using some convenience methods in fewer lines of code
     *
     */

    try {

      SKOSManager manager = new SKOSManager();

      final String baseURI = "http://www.semanticweb.org/skos/example2.rdf";

      SKOSDataset dataset = manager.createSKOSDataset(URI.create(baseURI));

      SKOSDataFactory df = manager.getSKOSDataFactory();

      List<SKOSEntity> allEntities = new ArrayList<SKOSEntity>();

      // Create a concept scheme identified by a URI
      SKOSConceptScheme conceptScheme1 =
          df.getSKOSConceptScheme(URI.create(baseURI + "#conceptScheme1"));

      // create a set of concepts

      Set<SKOSConcept> concepts = new HashSet<SKOSConcept>();
      concepts.add(df.getSKOSConcept(URI.create(baseURI + "#conceptA")));
      concepts.add(df.getSKOSConcept(URI.create(baseURI + "#conceptB")));
      concepts.add(df.getSKOSConcept(URI.create(baseURI + "#conceptC")));
      concepts.add(df.getSKOSConcept(URI.create(baseURI + "#conceptD")));

      // add all the entities to this set
      allEntities.add(conceptScheme1);
      allEntities.addAll(concepts);

      List<SKOSEntityAssertion> entityAssertions = df.getSKOSEntityAssertions(allEntities);
      List<SKOSObjectRelationAssertion> relationAssertions =
          df.getSKOSObjectRelationAssertions(
              concepts, df.getSKOSInSchemeProperty(), conceptScheme1);

      List<SKOSChange> addAssertions = new ArrayList<SKOSChange>();

      for (SKOSEntityAssertion ass : entityAssertions) {
        addAssertions.add(new AddAssertion(dataset, ass));
      }

      for (SKOSObjectRelationAssertion ass : relationAssertions) {
        addAssertions.add(new AddAssertion(dataset, ass));
      }

      manager.applyChanges(addAssertions);

      manager.save(dataset, SKOSFormatExt.RDFXML, URI.create("file:/Users/simon/tmp/example3.rdf"));

    } catch (SKOSCreationException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    } catch (SKOSChangeException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    } catch (SKOSStorageException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    }
  }
コード例 #3
0
  private void _createNewOntology() throws Exception {

    assert namespace.matches(".*(/|#)");

    String baseUri = namespace.replaceAll("(/|#)+$", ""); // removing any trailing slash/hash

    manager = new SKOSManager();

    if (namespace.endsWith("#")) {
      // Ok, OWLAPI v2 works fine with hash separator:
      dataset = manager.createSKOSDataset(URI.create(baseUri));
    } else {
      /////////////////////////////////////////////////////////////////////////////////////////////
      // TODO NOTE: workaround for bug in OWLAPI v2:
      // Instead of using a baseUri without separator,
      // use the namespace itself (ie, w/ fragment separator):
      dataset = manager.createSKOSDataset(URI.create(namespace));
      // In this way, the resulting ontology looks OK except that the xml:base is
      // written with the separator:
      //
      //		<rdf:RDF xmlns="http://mmisw.org/ont/mmi/cf/parameter/"
      //		     xml:base="http://mmisw.org/ont/mmi/cf/parameter/"    <<<--- WITH trailing slash
      //		     xmlns:owl2xml="http://www.w3.org/2006/12/owl2-xml#"
      //		     xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
      //		     xmlns:owl2="http://www.w3.org/2006/12/owl2#"
      //		     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
      //		     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      //		     xmlns:owl="http://www.w3.org/2002/07/owl#"
      //		     xmlns:skos="http://www.w3.org/2004/02/skos/core#">
      //		    <owl:Ontology rdf:about=""/>
      //		...
      //	    <!-- http://mmisw.org/ont/mmi/cf/parameter/CfStdName -->
      //
      //	        <skos:ConceptScheme rdf:about="CfStdName"/>
      //
      //
      //	        <!-- http://mmisw.org/ont/mmi/cf/parameter/age_of_stratospheric_air -->
      //
      //	        <skos:Concept rdf:about="age_of_stratospheric_air">
      //	            <skos:inScheme rdf:resource="CfStdName"/>
      //	        </skos:Concept>
      //
      //
      //	        <!-- http://mmisw.org/ont/mmi/cf/parameter/air_density -->
      //
      //	        <skos:Concept rdf:about="air_density">
      //	            <skos:inScheme rdf:resource="CfStdName"/>
      //	        </skos:Concept>
      //
      //		...
      /////////////////////////////////////////////////////////////////////////////////////////////
    }

    SAXBuilder builder = new SAXBuilder();
    Document document = builder.build(new StringReader(inputContents));

    standard_name_table = document.getRootElement();

    _getProperty(standard_name_table, "version_number");
    _getProperty(standard_name_table, "last_modified");
    _getProperty(standard_name_table, "institution");
    _getProperty(standard_name_table, "contact");

    // TODO assign version_number, last_modified as some properties to the ontology itself.

    dataFactory = manager.getSKOSDataFactory();

    allEntities = new ArrayList<SKOSEntity>();
    conceptScheme = dataFactory.getSKOSConceptScheme(URI.create(namespace + CONCEPT_SCHEME));
    concepts = new HashSet<SKOSConcept>();

    URI topConceptUri = URI.create(namespace + TOP_CONCEPT);
    topConcept = dataFactory.getSKOSConcept(topConceptUri);
    concepts.add(topConcept);

    objectRelationAssertions = new ArrayList<SKOSObjectRelationAssertion>();
    dataRelationAssertions = new ArrayList<SKOSDataRelationAssertion>();

    // skos:hasTopConcept
    objectRelationAssertions.add(
        dataFactory.getSKOSObjectRelationAssertion(
            conceptScheme, dataFactory.getSKOSHasTopConceptProperty(), topConcept));

    /////////////////////////////////////////////////
    // OWL API stuff
    owlManager = manager.getOWLManger();
    owlOntology = owlManager.getOntology(URI.create(namespace));
    owlDataFactory = owlManager.getOWLDataFactory();

    canonicalUnitsProp =
        owlDataFactory.getOWLDataProperty(URI.create(namespace + "canonical_units"));
    gribProp = owlDataFactory.getOWLDataProperty(URI.create(namespace + "grib"));
    amipProp = owlDataFactory.getOWLDataProperty(URI.create(namespace + "amip"));

    rdfsLabel =
        owlDataFactory.getOWLDataProperty(URI.create("http://www.w3.org/2000/01/rdf-schema#label"));
    rdfsComment =
        owlDataFactory.getOWLDataProperty(
            URI.create("http://www.w3.org/2000/01/rdf-schema#comment"));

    owlChanges = new ArrayList<AddAxiom>();

    _addOwlChange(topConceptUri, TOP_CONCEPT.replace('_', ' '), "", null, null, null);
  }
コード例 #4
0
  private void _convert() throws Exception {

    List<?> list = standard_name_table.getChildren("entry");
    for (Iterator<?> iterator = list.iterator(); iterator.hasNext(); ) {
      Element ele = (Element) iterator.next();

      numEntries++;

      String id = ele.getAttribute("id").getValue().trim();

      String canonicalUnits = ele.getChildTextNormalize("canonical_units");
      String grib = ele.getChildTextNormalize("grib");
      String amip = ele.getChildTextNormalize("amip");

      String description = ele.getChildTextNormalize("description");

      String prefLabel = id.replace('_', ' ');

      URI conceptUri = URI.create(namespace + id);

      SKOSConcept concept = dataFactory.getSKOSConcept(conceptUri);
      concepts.add(concept);

      // skos:narrower
      objectRelationAssertions.add(
          dataFactory.getSKOSObjectRelationAssertion(
              topConcept, dataFactory.getSKOSNarrowerProperty(), concept));

      // skos:prefLabel
      dataRelationAssertions.add(
          dataFactory.getSKOSDataRelationAssertion(
              concept, dataFactory.getSKOSPrefLabelProperty(), prefLabel));

      ////////////////////////////////////////////////
      // OWL API stuff
      _addOwlChange(conceptUri, id, description, canonicalUnits, grib, amip);
    }

    props.put("entries", String.valueOf(numEntries));
    props.put("concepts", String.valueOf(concepts.size()));

    allEntities.add(conceptScheme);
    allEntities.addAll(concepts);

    List<SKOSChange> skosChanges = new ArrayList<SKOSChange>();

    // entities:
    List<SKOSEntityAssertion> entityAssertions = dataFactory.getSKOSEntityAssertions(allEntities);
    for (SKOSEntityAssertion ass : entityAssertions) {
      skosChanges.add(new AddAssertion(dataset, ass));
    }

    // skos:inScheme
    objectRelationAssertions.addAll(
        dataFactory.getSKOSObjectRelationAssertions(
            concepts, dataFactory.getSKOSInSchemeProperty(), conceptScheme));

    // object relations:
    for (SKOSObjectRelationAssertion assertion : objectRelationAssertions) {
      skosChanges.add(new AddAssertion(dataset, assertion));
    }

    // data relations:
    for (SKOSDataRelationAssertion assertion : dataRelationAssertions) {
      skosChanges.add(new AddAssertion(dataset, assertion));
    }

    manager.applyChanges(skosChanges);

    ////////////////////////////////////////////////////
    // OWL API assertions
    owlManager.applyChanges(owlChanges);
  }