Java OWLClass类代码示例

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
private void buildTreeModel() {
  // first get all classes of the ontology
  Collection<OWLClass> classes = this.ontology.getClassesInSignature();
  // get the root of the tree model (the "Thing" OWL Class)
  DefaultMutableTreeNode root = null;
  for (OWLClass owlClass : classes) {
    if (owlClass.getIRI().getFragment().equals(rootConcept)) {
      root = new DefaultMutableTreeNode(owlClass);
      break;
    }
  }
  if (root == null) {
    return;
  }
  classes.remove(root.getUserObject());

  // now, add all remaining classes to the root by specialisation
  this.addSubClasses(root);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
public LinkedList<String> findEquivalentClasses(){
    
    LinkedList<String> equivalentClasses = new LinkedList<>();
            
    //Get all equivalent classes and set LinkedList equivalentClasses
    Set<OWLClass> classes = classifier.getEquivalentClasses(owlClass).getEntities();
    
    //For each equivalent class
    Iterator it = classes.iterator();
    while(it.hasNext()){
        OWLClass oClass = (OWLClass)it.next();
        //Add to LinkedList equivalentClasses
        if(!oClass.isOWLThing())
            equivalentClasses.add(oClass.getIRI().toString());
    }
    
    return equivalentClasses;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
public LinkedList<String> findIndirectSubclasses(){
    
    LinkedList<String> indirectSubclasses = new LinkedList<>();
    
    //Get all subclasses and add them to LinkedList "indirectSubclasses"
    Set<OWLClass> subClasses = classifier.getSubClasses(owlClass,false).getFlattened();
    Iterator it = subClasses.iterator();
    while(it.hasNext()){
        OWLClass oClass = (OWLClass)it.next();
        //If is not the element owl:Nothing, add to LinkedList indirectSubclasses
        if(!oClass.isOWLNothing())
            indirectSubclasses.add(oClass.getIRI().toString());
    }
    
    //Remove direct subclasses from LinkedList "indirectSubclasses"
    indirectSubclasses.removeAll(findDirectSubclasses());
    
    return indirectSubclasses;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
/**
 * Returns the most specific type of a given individual.
 * 
 * @param ind
 * @return
 */
private OWLClass getMostSpecificType(OWLIndividual ind) {
	logger.debug("Getting the most specific type of " + ind);
	String query = String.format("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \n"
			+ "select distinct ?type where {" + " <%s> a ?type ." + "?type rdfs:label []."
			// + "?type a owl:Class ." // too strict, thus currently omitted
			+ "filter not exists {?subtype ^a <%s> ; rdfs:subClassOf ?type .filter(?subtype != ?type)}}",
			ind.toStringID(), ind.toStringID());
	SortedSet<OWLClass> types = new TreeSet<OWLClass>();

	QueryExecution qe = qef.createQueryExecution(query);
	ResultSet rs = qe.execSelect();
	while (rs.hasNext()) {
		QuerySolution qs = rs.next();
		if (qs.get("type").isURIResource()) {
			types.add(new OWLClassImpl(IRI.create(qs.getResource("type").getURI())));
		}
	}
	qe.close();

	// of more than one type exists, we have to choose one
	// TODO

	return types.first();
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void initialize(UimaContext context) throws ResourceInitializationException {
	super.initialize(context);
	try {
		ontUtil = new OntologyUtil(ontologyFile);

		/*
		 * check that the term to remove is in the ontology -- if it is not,
		 * it could be a format issue
		 */
		OWLClass cls = ontUtil.getOWLClassFromId(termIdToRemove);
		if (cls == null) {
			String errorMessage = "Ontology term ID selected for removal is not in the given ontology. "
					+ "This could be a formatting issue. Term selected for removal: " + termIdToRemove
					+ " Example term ID from the ontology: " + ontUtil.getClassIterator().next().toStringID();
			throw new ResourceInitializationException(new IllegalArgumentException(errorMessage));
		}

	} catch (OWLOntologyCreationException e) {
		throw new ResourceInitializationException(e);
	}
	annotationDataExtractor = (AnnotationDataExtractor) ConstructorUtil
			.invokeConstructor(annotationDataExtractorClassName);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void addToOntology() {
  OWLObjectProperty property = featurePool.getExclusiveProperty(":propertyWithInfos");
  OWLClass range = featurePool.getExclusiveClass(":ClassWithInfos");
  OWLAnnotationProperty label = factory.getRDFSLabel();

  OWLAnnotation enAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("Label of a property", Locale.ENGLISH.getLanguage()));
  OWLAnnotation deAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("Bezeichnung einer Property", Locale.GERMAN.getLanguage()));
  OWLAnnotation jpAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("プロパティの指定", Locale.JAPANESE.getLanguage()));

  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), deAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), enAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), jpAnnotation));

  OWLAnnotation enClassAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("Label of a class", Locale.ENGLISH.getLanguage()));
  OWLAnnotation deClassAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("Bezeichnung einer Klasse", Locale.GERMAN.getLanguage()));
  OWLAnnotation jpClassAnnotation = factory.getOWLAnnotation(label, factory.getOWLLiteral("どうもありがとうミスターロボット", Locale.JAPANESE.getLanguage()));

  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), enClassAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), deClassAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), jpClassAnnotation));


  addToGenericDomainAndNewRange(property, range);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void addToOntology() {
  OWLObjectProperty property = featurePool.getExclusiveProperty(":propertyWithInfos");
  OWLClass range = featurePool.getExclusiveClass(":ClassWithInfos");
  OWLAnnotationProperty comment = factory.getRDFSComment();

  OWLAnnotation enAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("Comment of a property", Locale.ENGLISH.getLanguage()));
  OWLAnnotation deAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("Kommentar einer Property", Locale.GERMAN.getLanguage()));
  OWLAnnotation jpAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("プロパティのコメント", Locale.JAPANESE.getLanguage()));

  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), deAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), enAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(property.getIRI(), jpAnnotation));


  OWLAnnotation enClassAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("Comment of a class", Locale.ENGLISH.getLanguage()));
  OWLAnnotation deClassAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("Kommentar einer Klasse", Locale.GERMAN.getLanguage()));
  OWLAnnotation jpClassAnnotation = factory.getOWLAnnotation(comment, factory.getOWLLiteral("どうもありがとうミスターロボット", Locale.JAPANESE.getLanguage()));

  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), enClassAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), deClassAnnotation));
  addAxiomToOntology(factory.getOWLAnnotationAssertionAxiom(range.getIRI(), jpClassAnnotation));

  addToGenericDomainAndNewRange(property, range);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
public LinkedList<String> findIndirectSuperclasses(){
    
    LinkedList<String> indirectSuperclasses = new LinkedList<>();
    
    //Get all superclasses and add them to LinkedList "indirectSuperclasses"
    Set<OWLClass> superClasses = classifier.getSuperClasses(owlClass,false).getFlattened();
    Iterator it = superClasses.iterator();
    while(it.hasNext()){
        OWLClass oClass = (OWLClass)it.next();
        //If is not the element owl:Thing, add to LinkedList indirectSuperclasses
        if(!oClass.isOWLThing())
            indirectSuperclasses.add(oClass.getIRI().toString());
    }
    
    //Remove direct superclasses from LinkedList "indirectSuperclasses"
    indirectSuperclasses.removeAll(findDirectSuperclasses());
    
    return indirectSuperclasses;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void addToOntology() {
  OWLClass start = featurePool.getReusableClass();
  OWLClass middle = featurePool.getExclusiveClass(":PropertyChainMiddle");
  OWLClass end = featurePool.getExclusiveClass(":PropertyChainEnd");

  OWLObjectProperty singleStep = featurePool.getExclusiveProperty(":propertyChainProperty_SingleStep");
  OWLObjectProperty doubleStep = featurePool.getExclusiveProperty(":propertyChainProperty_DoubleStep");

  List<OWLObjectProperty> propertyChain = Arrays.asList(singleStep, singleStep);
  addAxiomToOntology(factory.getOWLSubPropertyChainOfAxiom(propertyChain, doubleStep));

  addProperty(end, singleStep, middle);
  addProperty(middle, singleStep, start);
  addProperty(end, doubleStep, start);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
/**
 * Returns a textual summary of the given entity.
 *
 * @return
 */
public Map<OWLIndividual, String> getSummaries(Set<OWLIndividual> individuals, OWLClass nc, String namespace,
		double threshold, Cooccurrence cooccurrence, HardeningType hType) {
	Map<OWLIndividual, String> entity2Summaries = new HashMap<OWLIndividual, String>();

	Map<OWLIndividual, List<NLGElement>> verbalize = verbalize(individuals, nc, namespace, threshold, cooccurrence,
			hType);
	for (Entry<OWLIndividual, List<NLGElement>> entry : verbalize.entrySet()) {
		OWLIndividual individual = entry.getKey();
		List<NLGElement> elements = entry.getValue();
		String summary = realize(elements);
		summary = summary.replaceAll("\\s?\\((.*?)\\)", "");
		summary = summary.replace(" , among others,", ", among others,");
		entity2Summaries.put(individual, summary);
	}

	return entity2Summaries;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
/**
 * Returns a list of synonymous expressions as subject for the given
 * resource.
 * 
 * @param resource
 *            the resource
 * @param resourceType
 *            the type of the resource
 * @param resourceGender
 *            the gender of the resource
 * @return list of synonymous expressions
 */
public List<NPPhraseSpec> generateSubjects(Resource resource, OWLClass resourceType, Gender resourceGender) {
	List<NPPhraseSpec> result = new ArrayList<NPPhraseSpec>();
	// the textual representation of the resource itself
	result.add(nlg.getNPPhrase(resource.getURI(), false, false));
	// the class, e.g. 'this book'
	NPPhraseSpec np = nlg.getNPPhrase(resourceType.toStringID(), false);
	np.addPreModifier("This");
	result.add(np);
	// the pronoun depending on the gender of the resource
	if (resourceGender.equals(Gender.MALE)) {
		result.add(nlg.nlgFactory.createNounPhrase("he"));
	} else if (resourceGender.equals(Gender.FEMALE)) {
		result.add(nlg.nlgFactory.createNounPhrase("she"));
	} else {
		result.add(nlg.nlgFactory.createNounPhrase("it"));
	}
	return result;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
public LinkedList<String> findDirectSuperclasses(){
    
    LinkedList<String> directSuperclasses = new LinkedList<>();
    
    //Get all direct superclasses and set LinkedList directSuperclasses
    Set<OWLClass> superClasses = classifier.getSuperClasses(owlClass,true).getFlattened();
    
    //For each direct superclass
    Iterator it = superClasses.iterator();
    while(it.hasNext()){
        OWLClass oClass = (OWLClass)it.next();
        //If is not the element owl:Thing, add to LinkedList directSuperclasses
        if(!oClass.isOWLThing())
            directSuperclasses.add(oClass.getIRI().toString());
    }
    
    return directSuperclasses;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public Set<OWLEntity> getParents(OWLEntity cpt) {
	if(!cpt.isOWLClass()) return new HashSet<OWLEntity>();

	Set<OWLEntity> entities = new HashSet<OWLEntity>();
	Set<OWLEntity> result = new HashSet<OWLEntity>();
	OWLClass localRootClass = cpt.asOWLClass();
	entities.addAll(reasoner.getSuperClasses(localRootClass, true).getFlattened());
	for(OWLEntity parentClass : entities) {
		// Only Class
		if(!parentClass.isOWLClass())
		{
			continue;
		}
		// Not Nothing
		if(parentClass.isOWLClass() && parentClass.asOWLClass().isOWLNothing())
		{
			continue;
		}
		result.add(parentClass);
	}
	return result;
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void sendEvent(SemanticEvent se) {
    Set<String> triggeredFilters = new HashSet<String>();
    // add event to ontology
    manager.addAxioms(ontology, se.getAxioms());
    // extract types event
    reasoner.flush();

    NodeSet<OWLClass> inferedClasses = reasoner.getTypes(se.getMessage(), false);
    for (OWLClass owlclss : inferedClasses.getFlattened()) {
        String clss = owlclss.getIRI().toString();
        if (eventDefinitions.contains(clss)) {
            triggeredFilters.add(clss);
        }
    }
    se.setTriggeredFilterIRIs(triggeredFilters);

    //send event back to engie
    obep.sendEvent(se);
}
 

import org.semanticweb.owlapi.model.OWLClass; //导入依赖的package包/类
@Override
public void addToOntology() {
  OWLClass domain = featurePool.getExclusiveClass(":DatatypeMapsDomain");
  OWLDatatype range = factory.getOWLDatatype(datatype);

  String namespace = datatype.getPrefixedName().split(":")[0];
  String name = datatype.getShortForm();
  String propertyIri = ":" + namespace + WordUtils.capitalize(name) + "Property";
  OWLDataProperty property = factory.getOWLDataProperty(propertyIri, pm);

  addProperty(domain, property, range);
}