0

我正在使用耶拿框架来处理我的猫头鹰本体。

我想写一个方法来找到它所属的超类，它就在 Thing 类下面。

四个例子，如果有 5 级层次结构，假设第一级是 Thing，第二级是 secondAncestor，第三级是 ThirdAncestor，依此类推。如果我通过一个类 FifthAncestor，我想返回 SecondAncestor，因为 Thing 没有任何意义。如果我通过 ThirdAncestor，我想返回 SecondAncestor。换句话说，它属于最一般的类，但不是顶级的（事物）。

4

2 回答 2

1

方法一

这将取决于您的模型是否具有推理器，因为owl:Thing通常不会在模型中断言，因此不会出现在没有推理器的模型中。鉴于此，那么：

OntModel m = ... your OntModel ...;
OntClass thing = m.getOntClass( OWL.Thing.getURI() );
for (Iterator<OntClass> i = thing.listSubClasses(true); i.hasNext(); ) {
    OntClass hierarchyRoot = i.next();
    ....
}

注意调用中标志的direct = true使用listSubClasses()。

方法二

不需要推理机。

for (Iterator<OntClass> i = m.listHierarchyRootClasses(); i.hasNext(); ) {
    OntClass hierarchyRoot = i.next();
    ....
}

请注意，此方法将返回根类，即使它们是代表类表达式的匿名资源。出于 UI 目的，这通常不是您想要的（很难以有意义的方式向用户显示 bNode）。在这种情况下，请改用OntTools.namedHierarchyRoots。

更新

我现在明白 Alan 想要作为特定类的父类的根类，而namedHierarchyRoots将列出类层次结构的所有根类。请注意，一般来说，一个类在它和 之间可能有零个、一个或多个命名超类Thing。

无论如何，这就是我将如何解决这个问题。同样，此解决方案假定模型未使用推理器。有了推理器，它会容易得多：

private boolean hasSubClassTransitive( OntClass parent, OntClass child ) {
    return OntTools.findShortestPath( child.getOntModel(), child, parent,
                                      new OntTools.PredicateFilter( RDFS.subClassOf ) ) != null;
}

public List<OntClass> namedRootsOf( OntClass c ) {
    List<OntClass> cRoots = new ArrayList<OntClass>();
    for (OntClass root: OntTools.namedHierarchyRoots( c.getOntModel() )) {
        if (hasSubClassTransitive( root, c )) {
            cRoots.add( root );
        }
    }
    return cRoots;
}
于 2012-11-15T08:22:48.690 回答
0

我在不使用推理器的情况下以下列方式找到解决方案。这不是完美的解决方案，但它有效。如果您将未命名（匿名）类作为超类，此解决方案也可以解决问题。

首先，我创建了一个存储顶级类名的数组。

如果传递的参数是顶级类，则在我创建的数组中搜索的简单方法。

public Boolean IsTopClass(String ontologyClass)
  {
              //NS is URI of ontology
      String onClass=ontologyClass.replace(NS, "");

      for(String oClass: topLevelClassList)
      {
          if(oClass.equalsIgnoreCase(onClass))
              return true;
      }
      return false;

  }

然后是在事物下找到最通用类的主要方法：

      public String FindSuperClassUnderThing(OntClass subClass)
  {

     OntClass prevSubClass=subClass;
     OntClass prevprevSubClass=null;         

     String topClass="";

     String supClass=subClass.toString();
     ExtendedIterator<OntClass> superClassList=null;
    while(!this.IsTopClass(topClass))
    {   
        prevprevSubClass=prevSubClass;
        prevSubClass=prevSubClass.getSuperClass();
                    //if returned class is a anonymous class (not a named one)
                    //get list of superclasses and check if there is a topclass
                    //inside the super class list
        if(!prevSubClass.toString().startsWith(NS))
        {
            prevSubClass=prevprevSubClass;
             superClassList= prevSubClass.listSuperClasses();

             while(superClassList.hasNext())
                {
                   OntClass OntClassFromList= superClassList.next();
                    if(this.IsTopClass(OntClassFromList.toString()))
                    {
                    topClass= OntClassFromList.toString();
                    }
                }

        }
        else
        {
            if (this.IsTopClass(prevSubClass.toString()))
            {
                topClass= prevSubClass.toString();
            }
        }


    }

     return topClass;
}
于 2012-11-15T18:19:16.030 回答