root/BH13SPARQLBuilder/src/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java @ 126

リビジョン 115, 8.2 KB (コミッタ: atsuko, 10 年 前)

getPath 改良

  • 属性 svn:mime-type の設定値 text/plain
行番号 
1/*
2 * To change this template, choose Tools | Templates
3 * and open the template in the editor.
4 */
5package org.biohackathon.SPARQLBuilder.OWL;
6
7/**
8 *
9 * @author atsuko
10 */
11import java.util.ArrayList;
12import java.util.LinkedList;
13import java.util.List;
14import java.util.ListIterator;
15
16public class OWLClassGraph extends LabeledMultiDigraph{
17    String startClass;
18    String endClass;
19    int nsteps;
20    int limit;
21    int th;
22    double concut;
23    double divcut;
24       
25    public class LinkAndPath{
26        String originalClassURI; // originalClasssURI -classLink.propertyURI-> classLink.linkedClassURL
27        ClassLink classLink;
28        List<ClassLink> path;
29        boolean converge;
30       
31        public LinkAndPath(ClassLink classLink, List<ClassLink> path){
32           this.classLink = classLink;
33           this.path = path;
34           this.converge = false;
35        }
36       
37        public LinkAndPath(ClassLink classLink, List<ClassLink> path, String originalClassURI, boolean converge){
38           this.classLink = classLink;
39           this.path = path;
40           this.originalClassURI = originalClassURI;
41           this.converge = converge;
42        }
43    }
44   
45    public OWLClassGraph(String startClass, String endClass){
46        super();
47        this.startClass = startClass;
48        addNode(startClass);
49        this.endClass = endClass;
50        addNode(endClass);
51        nsteps = 3;
52        limit = 1000;
53        //th = 0;
54        //concut = 2.0;
55        //divcut = - 2.0;
56    }
57       
58    public Path[] getPaths(RDFSchemaAnalyzer rdfsa, boolean countLink){
59        List<List<ClassLink>> paths = null;
60        paths = searchPaths(rdfsa, countLink);
61        Path[] patharray = new Path[paths.size()];
62        ListIterator<List<ClassLink>> pit = paths.listIterator();
63        int i = 0;
64        while ( pit.hasNext() ){
65            patharray[i] = new Path();
66            patharray[i].setStartClass(startClass);
67            List<ClassLink> path = pit.next();
68            patharray[i].setClassLinks(path);
69            ListIterator<ClassLink> cit = path.listIterator();
70            int min = Integer.MAX_VALUE;
71            while ( cit.hasNext() ){
72                ClassLink cl = cit.next();
73                if ( cl.getNumOfLinks() < min ){
74                    min = cl.getNumOfLinks();
75                }
76            }
77            patharray[i].setWidth(min);
78            i++;
79        }
80        return patharray;
81    }
82       
83    private List<List<ClassLink>> searchPaths(RDFSchemaAnalyzer rdfsa, boolean countLinks){
84        List<List<ClassLink>> paths = new ArrayList<>();
85        List<LinkAndPath> lp = new LinkedList<>();
86        lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false), new LinkedList<ClassLink>(), "", false));
87        try{
88          for ( int i = 0; i < nsteps; i++ ){
89              ListIterator<LinkAndPath> lit = lp.listIterator();
90              List<LinkAndPath> nextlp = new LinkedList<>();
91              while ( lit.hasNext() ){
92                  LinkAndPath crrlp = lit.next();
93                  ClassLink[] classLinks = rdfsa.getNextClass(null, crrlp.classLink.getLinkedClassURI(), limit, countLinks);
94                  for ( int j = 0 ; j < classLinks.length; j++ ){
95                      List<ClassLink> crrpath = new LinkedList<>(crrlp.path);
96                      crrpath.add(classLinks[j]);
97                      if ( classLinks[j].getLinkedClassURI().equals(endClass) ){
98                          paths.add(new LinkedList<>(crrpath));
99                          continue;
100                      }
101                      if ( countLinks == true && classLinks[j].getNumOfLinks() <= th){
102                          continue;
103                      }
104                      if ( i >= 2 ){
105                          if ( crrlp.classLink.getPropertyURI().equals(classLinks[j].getPropertyURI()) &&
106                           crrlp.classLink.getDirection() != classLinks[j].getDirection() &&
107                           crrlp.originalClassURI.equals( classLinks[j].getLinkedClassURI()) ){
108                              continue;
109                          }
110                      }
111                     
112                      nextlp.add(new LinkAndPath(classLinks[j], crrpath, crrlp.classLink.getLinkedClassURI(), false));
113                  }
114              }
115              lp = nextlp;
116          }
117        }catch(Exception e){
118            System.err.println(e);
119        }
120        return paths; 
121    }
122
123/*   
124    private List<List<ClassLink>> searchPathsWithCut(OWLQueryBuilderImpl qb){
125        List<List<ClassLink>> paths = new ArrayList<>();
126        ClassLink crrLink = new ClassLink(null,startClass,Direction.both,0,0,0,0,0);
127        List<LinkAndPath> lp = new LinkedList<>();
128        lp.add(new LinkAndPath(crrLink, new LinkedList<ClassLink>()));
129        try{
130          for ( int i = 0; i < nsteps; i++ ){
131              ListIterator<LinkAndPath> lit = lp.listIterator();
132              List<LinkAndPath> nextlp = new LinkedList<>();
133              while ( lit.hasNext() ){
134                  LinkAndPath crrlp = lit.next();
135                  ClassLink[] classLinks = null;
136                  classLinks = qb.getNextClass(null, crrlp.classLink.getLinkedClassURI(), limit, true);
137                  for ( int j = 0 ; j < classLinks.length; j++ ){
138                      if ( classLinks[j].getNumOfLinks() == 0 ){ continue; }
139                      List<ClassLink> crrpath = new LinkedList<>(crrlp.path);
140                      crrpath.add(classLinks[j]);
141                      if ( classLinks[j].getLinkedClassURI().equals(endClass) ){
142                          paths.add(new LinkedList<>(crrpath));
143                          continue;
144                      }
145                      if (classLinks[j].getNumOfLinks() <= th ){
146                          continue; //cut by the number of instances
147                      }
148                      // Divergence & Convergence Decision
149                      boolean con = false;
150                      boolean div = false;
151                      if ( decideConvergence(classLinks[j]) ){ // convergence
152                          con = true;
153                      }
154                      if ( decideDivergence(classLinks[j]) ){ // divergence
155                          div = true;
156                      }
157                      if ( crrlp.converge == true && div == true ){ // converge & 縲€diverge
158                          continue; // cut by the differences of entropies
159                      }
160                      // crr & next are the same arcs
161                      if ( crrlp.classLink.getPropertyURI().equals(classLinks[j].getPropertyURI()) &&
162                           crrlp.classLink.getDirection() != classLinks[j].getDirection() &&
163                           crrlp.originalClassURI.equals( classLinks[j].getLinkedClassURI()) ){
164                          continue;
165                      }
166                     
167                      nextlp.add(new LinkAndPath(classLinks[j], crrpath, crrlp.classLink.getLinkedClassURI(), con));
168                  }
169              }
170              lp = nextlp;
171          }
172        }catch(Exception e){
173            System.err.println(e);
174        }
175        return paths; 
176    }
177*/
178   
179/*   
180    private boolean decideConvergence(ClassLink classLink){
181        double con = getValueForConvergence(classLink.getNumOfOriginInstances(),
182                                              classLink.getNumOfLinkedInstances(),
183                                              classLink.getNumOfLinks());
184        if ( con > concut  ){
185            return true;
186        }
187        return false;
188    }
189*/
190   
191/*   
192    private boolean decideDivergence(ClassLink classLink){
193        double con = getValueForConvergence(classLink.getNumOfOriginInstances(),
194                                              classLink.getNumOfLinkedInstances(),
195                                              classLink.getNumOfLinks());
196        if ( con < divcut  ){
197            return true;
198        }
199        return false;
200    }
201*/
202   
203/*   
204    private double getValueForConvergence(int numOfOriginInstances, int numOfLinkedInstances, int numOfLinks){
205        //return (double) numOfLinks / (double) numOfLinkedInstances ;
206        // Convergence plus, Divergence minus
207        return Math.log((double)numOfOriginInstances) - Math.log((double)numOfLinkedInstances);
208    }
209    */
210}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。