差分発生行の前後
無視リスト:
更新日時:
2014/11/18 14:16:47 (10 年 前)
更新者:
atsuko
ログメッセージ:

サーブレット側でクラスをソート&パス検索を少し速く

ファイル:
1 変更

凡例:

変更なし
追加
削除
  • SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java

    r205 r206  
    1010 */ 
    1111import java.util.*; 
    12 //import java.util.LinkedList; 
    13 //import java.util.List; 
    14 //import java.util.ListIterator; 
    1512 
    1613public class OWLClassGraph extends LabeledMultiDigraph{ 
     
    2623        ClassLink classLink; 
    2724        List<ClassLink> path; 
     25        Set<String> classURIs; // apearing class URIs in the path 
    2826        //boolean converge; 
    2927         
     
    4038           //this.converge = converge; 
    4139        } 
    42     } 
    43          
     40 
     41        public LinkAndPath(ClassLink classLink, List<ClassLink> path, String originalClassURI, Set<String> classURIs){ 
     42           this.classLink = classLink; 
     43           this.path = path; 
     44           this.originalClassURI = originalClassURI; 
     45           this.classURIs = classURIs; 
     46           //this.converge = converge; 
     47        } 
     48    } 
     49 
    4450    public OWLClassGraph(String startClass, String endClass){ 
    4551        super(); 
     
    5258        nsteps = 3; 
    5359        limit = 1000; 
    54         prunecut = 100;         
     60        prunecut = 100; 
     61        th = 5; 
     62    } 
     63 
     64    public OWLClassGraph(String startClass, String endClass, int th){ 
     65        super(); 
     66         
     67        // start & end 
     68        this.startClass = startClass; 
     69        this.endClass = endClass; 
     70        // th of instances 
     71        this.th = th; 
     72         
     73        // parameters 
     74        nsteps = 3; 
     75        limit = 1000; 
     76        prunecut = 100; 
    5577    } 
    5678 
    5779    public Path[] getPaths(RDFSchemaAnalyzer rdfsa, boolean countLink){ 
    5880        List<List<ClassLink>> paths = null; 
    59         paths = searchPaths(rdfsa, countLink); 
     81        //paths = searchPaths(rdfsa, countLink); 
     82        paths = searchPathsbyVisitingNodes(rdfsa, countLink); 
    6083        NavigableSet<Path> sortedpath = new TreeSet<Path>(); 
    6184        ListIterator<List<ClassLink>> pit = paths.listIterator(); 
     
    114137                           crrlp.classLink.getDirection() != classLinks[j].getDirection() && 
    115138                           crrlp.originalClassURI.equals( classLinks[j].getLinkedClassURI()) ){ 
    116                               //System.out.println("P1"); 
    117                               continue; 
    118                           } 
    119                           if ( checkPruning(crrlp.classLink, classLinks[j]) ){ 
    120                               //System.out.println("P2"); 
    121139                              continue; 
    122140                          } 
     
    133151    } 
    134152 
    135     //private 
    136      
    137 /*     
     153    private List<List<ClassLink>> searchPathsbyVisitingNodes(RDFSchemaAnalyzer rdfsa, boolean countLinks){ 
     154        List<List<ClassLink>> paths = new ArrayList<>(); 
     155        List<LinkAndPath> lp = new LinkedList<>(); 
     156        Set<String> urls = new HashSet<String>(); 
     157        urls.add(startClass); 
     158        lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false),  
     159                                 new LinkedList<ClassLink>(), startClass, urls)); 
     160        try{ 
     161          for ( int i = 0; i < nsteps; i++ ){ 
     162              ListIterator<LinkAndPath> lit = lp.listIterator(); 
     163              List<LinkAndPath> nextlp = new LinkedList<>(); 
     164              while ( lit.hasNext() ){ 
     165                  LinkAndPath crrlp = lit.next(); 
     166                  ClassLink[] classLinks = rdfsa.getNextClass(null, crrlp.classLink.getLinkedClassURI(), limit, countLinks); 
     167                  // limit 
     168                  for ( int j = 0 ; j < classLinks.length; j++ ){ 
     169                      if (crrlp.classURIs.contains(classLinks[j].getLinkedClassURI()) ){ 
     170                          continue; // visited 
     171                      } 
     172                      List<ClassLink> crrpath = new LinkedList<>(crrlp.path); 
     173                      crrpath.add(classLinks[j]); 
     174                      Set<String> crrurls = new HashSet<String>(crrlp.classURIs); 
     175                      crrurls.add(classLinks[j].getLinkedClassURI()); 
     176                      if ( classLinks[j].getLinkedClassURI() == null ){ continue; } 
     177                      if ( classLinks[j].getNumOfLinks() <= th){ 
     178                          continue; 
     179                      } 
     180                      if ( classLinks[j].getLinkedClassURI().equals(endClass) ){ 
     181                          paths.add(new LinkedList<>(crrpath)); 
     182                          continue; 
     183                      } 
     184                      //crrlp.classURIs.add() 
     185                      nextlp.add(new LinkAndPath(classLinks[j], crrpath, crrlp.classLink.getLinkedClassURI(),crrurls)); 
     186                  } 
     187              } 
     188              lp = nextlp; 
     189          } 
     190        }catch(Exception e){  
     191            System.err.println(e); 
     192        } 
     193        return paths;   
     194    } 
     195     
     196    /* 
    138197    private List<List<ClassLink>> searchPathsWithCut(OWLQueryBuilderImpl qb){ 
    139198        List<List<ClassLink>> paths = new ArrayList<>(); 
     
    261320   } 
    262321    
    263     
     322   /* 
     323   public Path[] getPathsByWholeGraph(RDFSchemaAnalyzer rdfsa){ 
     324        setWholeGraph(rdfsa); 
     325        List<List<ClassLink>> paths = null; 
     326        //paths = searchPaths(rdfsa, countLink); 
     327        paths = searchPathsbyVisitingNodes(rdfsa, countLink); 
     328        NavigableSet<Path> sortedpath = new TreeSet<Path>(); 
     329        ListIterator<List<ClassLink>> pit = paths.listIterator(); 
     330        int j = 0; 
     331        while ( pit.hasNext() ){ 
     332            Path path = new Path(); 
     333            path.setStartClass(startClass); 
     334            List<ClassLink> crrpath = pit.next(); 
     335            path.setClassLinks(crrpath); 
     336            ListIterator<ClassLink> cit = crrpath.listIterator(); 
     337            int min = Integer.MAX_VALUE; 
     338            while ( cit.hasNext() ){ 
     339                ClassLink cl = cit.next(); 
     340                if ( cl.getNumOfLinks() < min ){ 
     341                    min = cl.getNumOfLinks(); 
     342                } 
     343            } 
     344            path.setWidth(min); 
     345            sortedpath.add(path); 
     346            j++; 
     347        } 
     348        Path[] patharray = new Path[paths.size()]; 
     349        Iterator<Path> pait = sortedpath.descendingIterator(); 
     350        int i = 0; 
     351        while ( pait.hasNext() ){ 
     352            patharray[i] = pait.next(); 
     353            i++; 
     354        } 
     355        return patharray; 
     356    } 
     357    */ 
    264358}