チェンジセット 248 : SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder

更新日時:

2015/03/24 18:18:00 (10 年 前)

更新者:

atsuko

ログメッセージ:

枝刈り，クラス順序変更(数字は下に)

パス:

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder

ファイル:

• OWL/EndpointAccess.java (追加)
• OWL/OWLClassGraph.java (変更) (16 diff)
• OWL/Path.java (変更) (2 diff)
• OWL/QueryPathGenerator.java (変更) (5 diff)
• www/CLServlet.java (変更) (5 diff)
• www/PLServlet.java (変更) (2 diff)
• www/SPServlet.java (変更) (1 diff)

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java

@@ -19 +19 @@
     List<String> nodeType;
     ArrayList<HashSet<Integer>> connectionTable;
-
+    String sparqlEndpoint;
+    Set<Integer> visited;
+    boolean askcheck;
+    List<Map<Integer, Integer>> edgeweight;
+    List<Integer> nodeweight;
+    
     public class LinkAndPath{
         String originalClassURI; // originalClasssURI -classLink.propertyURI-> classLink.linkedClassURL
@@ -46 +51 @@
     }
 
-/*
-    public OWLClassGraph(String startClass, String endClass){
-        super();
-        
-        // start & end
-        this.startClass = startClass;
-        this.endClass = endClass;
-        
-        // parameters
-        nsteps = 3;
-        limit = 1000;
-        th = 5;
-    }
-*/
-
-/*    
-    public OWLClassGraph(String startClass, String endClass, int th){
-        super();
-        
-        // start & end
-        this.startClass = startClass;
-        this.endClass = endClass;
-        // th of instances
-        this.th = th;
-        
-        // parameters
-        nsteps = 3;
-        limit = 1000;
-    }
-*/    
-
-    public OWLClassGraph(){
+    public OWLClassGraph(){ // not used
         super();
         nodeType = new LinkedList<String>();
-        //setClassGraph(rdfsa);
-        //connectionTable = createConnectionTable();
-    }
-    
-    
-    public OWLClassGraph(RDFSchemaAnalyzer rdfsa){
+    }
+        
+    public OWLClassGraph(RDFSchemaAnalyzer rdfsa){ // not used
         super();
         nodeType = new LinkedList<String>();
-        //setClassGraph(rdfsa);
-        //connectionTable = createConnectionTable();
-    }
-    
+    }
+    
+    public OWLClassGraph(RDFSchemaAnalyzer rdfsa, String sparqlEndpoint, String startClass, boolean askcheck){ // used
+        super();
+        nodeType = new LinkedList<String>();
+        this.askcheck = askcheck;
+        setPartClassGraph(rdfsa, sparqlEndpoint, startClass);
+    }
+
     public int getNumberOfEdge(String url){
         Integer node = labelednodes.get(url);
@@ -98 +74 @@
         }
         return adjlist.get(node).size();
+    }
+    
+    public boolean visitedNode(String classURI){
+        if ( visited.contains(labelednodes.get(classURI)) ){
+            return true;
+        }
+        return false;
     }
     
@@ -138 +121 @@
         return connectionTable.get(node);
     }
-    
-    public Path[] getPaths_old(RDFSchemaAnalyzer rdfsa, boolean countLink, String startClass, String endClass){
-        List<List<ClassLink>> paths = null;
-        paths = searchPathsbyVisitingNodes(rdfsa, countLink, startClass, endClass);
-        NavigableSet<Path> sortedpath = new TreeSet<Path>();
-        ListIterator<List<ClassLink>> pit = paths.listIterator();
-        int j = 0;
-        while ( pit.hasNext() ){
-            Path path = new Path();
-            path.setStartClass(startClass);
-            List<ClassLink> crrpath = pit.next();
-            path.setClassLinks(crrpath);
-            ListIterator<ClassLink> cit = crrpath.listIterator();
-            int min = Integer.MAX_VALUE;
-            while ( cit.hasNext() ){
-                ClassLink cl = cit.next();
-                if ( cl.getNumOfLinks() < min ){
-                    min = cl.getNumOfLinks();
-                }
-            }
-            path.setWidth(min);
-            sortedpath.add(path);
-            j++;
-        }
-        Path[] patharray = new Path[paths.size()];
-        Iterator<Path> pait = sortedpath.descendingIterator();
-        int i = 0;
-        while ( pait.hasNext() ){
-            patharray[i] = pait.next();
-            i++;
-        }
-        return patharray;
-    }
 
     private List<List<ClassLink>> searchPaths(String startClass, String endClass){
-
+        //int asked = 0;
+        Map<String,Boolean> checkedpaths = new HashMap<String, Boolean>();
         List<List<ClassLink>> paths = new ArrayList<>();
         List<List<Integer>> simplePaths = new LinkedList<>();
@@ -195 +146 @@
                     List<Integer> nextpath = new LinkedList<Integer>(crrpath); // copy
                     nextpath.add(nextnode);
+                    // tmp
+                    if ( i >= 1 ){
+                        int wn = nodeweight.get(crrnode);
+                        int in = edgeweight.get(crrpath.get(crrpath.size()-2)).get(crrnode);
+                        int out = edgeweight.get(nextnode).get(crrnode);
+                        if ( wn > in + out ){
+                            /*
+                            String key1 = nextnode.toString().concat("-").concat(crrpath.get(crrpath.size()-1).toString())
+                                .concat("-").concat(crrpath.get(crrpath.size()-2).toString());
+                            String key2 = crrpath.get(crrpath.size()-2).toString().concat("-").concat(crrpath.get(crrpath.size()-1).toString())
+                                .concat("-").concat(nextnode.toString());
+                            if ( checkedpaths.containsKey(key1) ){
+                                if ( checkedpaths.get(key1) == false ){
+                                   continue;
+                                }
+                            }else if ( checkedpaths.containsKey(key2) ){
+                                if ( checkedpaths.get(key2) == false ){
+                                   continue;
+                                }
+                            }else{                      
+                                boolean chk = EndpointAccess.check3SimplePathwithJoin(nextnode, crrpath.get(crrpath.size()-1),
+                                    crrpath.get(crrpath.size()-2), this, sparqlEndpoint);
+                                checkedpaths.put(key1, chk);
+                                if ( chk == false ){
+                                    continue;
+                                }
+                            }
+                            */
+                            continue;
+                        }
+                    }
                     if ( nextnode.equals(enode) ){
                         simplePaths.add(nextpath);
@@ -206 +188 @@
         
         ListIterator<List<Integer>> pit = simplePaths.listIterator();
+        //int i = 0;
+        //int j = 0;
+        System.out.println("SPATH:");
+        System.out.println(simplePaths.size());
         while( pit.hasNext()){
             List<Integer> spath = pit.next();
@@ -211 +197 @@
             paths.addAll(convertedPaths);
         }
+        System.out.println("PATH:");
+        System.out.println(paths.size());
         return paths;
     }
+
     
     private List<List<ClassLink>> convertSimplePathToPaths(List<Integer> simplePath){
         List<List<ClassLink>> paths = new LinkedList<List<ClassLink>>();
-        //List<List<LabeledEdge>> multiedges = new LinkedList<List<LabeledEdge>>();
         ListIterator<Integer> spit = simplePath.listIterator();
         Integer start = spit.next();
+        String startClass = this.labels.get(start);
         Integer end = spit.next();
         List<LabeledEdge> edges = gadjlist.get(start).get(end);
@@ -242 +231 @@
                     List<ClassLink> addedpath = new LinkedList<ClassLink>(basepath);
                     addedpath.add(cl);
-                    tmppaths.add(addedpath);
+                    // check
+                    //if ( EndpointAccess.checkPath(startClass, addedpath, sparqlEndpoint) ){
+                        tmppaths.add(addedpath);
+                    //}
                 }
             }
@@ -252 +244 @@
     
     /*
-    private List<List<ClassLink>> searchPaths(RDFSchemaAnalyzer rdfsa, boolean countLinks){
-        List<List<ClassLink>> paths = new ArrayList<>();
-        List<LinkAndPath> lp = new LinkedList<>();
-        lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false), new LinkedList<ClassLink>(), ""));
-        try{
-          for ( int i = 0; i < nsteps; i++ ){
-              ListIterator<LinkAndPath> lit = lp.listIterator();
-              List<LinkAndPath> nextlp = new LinkedList<>();
-              while ( lit.hasNext() ){
-                  LinkAndPath crrlp = lit.next();
-                  ClassLink[] classLinks = rdfsa.getNextClass(null, crrlp.classLink.getLinkedClassURI(), limit, countLinks);
-                  for ( int j = 0 ; j < classLinks.length; j++ ){
-                      List<ClassLink> crrpath = new LinkedList<>(crrlp.path);
-                      crrpath.add(classLinks[j]);
-                      if ( classLinks[j].getLinkedClassURI() == null ){ continue; }
-                      if ( classLinks[j].getLinkedClassURI().equals(endClass) ){
-                          paths.add(new LinkedList<>(crrpath));
-                          continue;
-                      }
-                      if ( countLinks == true && classLinks[j].getNumOfLinks() <= th){
-                          continue;
-                      }
-                      if ( i >= 2 ){
-                          if ( crrlp.classLink.getPropertyURI().equals(classLinks[j].getPropertyURI()) &&
-                           crrlp.classLink.getDirection() != classLinks[j].getDirection() &&
-                           crrlp.originalClassURI.equals( classLinks[j].getLinkedClassURI()) ){
-                              continue;
-                          }
-                      }
-                      nextlp.add(new LinkAndPath(classLinks[j], crrpath, crrlp.classLink.getLinkedClassURI()));
-                  }
-              }
-              lp = nextlp;
-          }
-        }catch(Exception e){ 
-            System.err.println(e);
-        }
-        return paths;  
-    }
-    */
-    
     private List<List<ClassLink>> searchPathsbyVisitingNodes(RDFSchemaAnalyzer rdfsa, boolean countLinks,
             String startClass, String endClass){
@@ -365 +316 @@
                        }
                        addEdge(i, n, classLinks[j]);
-                       /*
-                       ClassLink rev = new ClassLink( classLinks[j].getPropertyURI(),
-                               //classLinks[j].getLinkedClassURI(),
-                               classes[i].getClassURI(),
-                               classLinks[j].getLinkedLiteralDatatypeURI(),
-                               classLinks[j].getDirection(), classLinks[j].getNumOfLinks(), 
-                               classLinks[j].getNumOfOriginInstances(), classLinks[j].getNumOfLinkedInstances(),
-                               classLinks[j].getNumOfOriginClassInstances(), classLinks[j].getNumOfLinkedClassInstances(),
-                               classLinks[j].isDomainClassLimitedQ(), classLinks[j].isRangeClassLimitedQ() );
-                       rev.setDirection(Direction.reverse);
-                       addEdge(n, i, rev);
-                               */
                    }
                }
@@ -383 +322 @@
            }
        }       
-   }
-
-    public void setPartClassGraph(RDFSchemaAnalyzer rdfsa, String startClass){
-        // setNodes
+   }*/
+
+    public void setPartClassGraph(RDFSchemaAnalyzer rdfsa, String sparqlEndpoint, String startClass){
+        // set endpoint
+        this.sparqlEndpoint = sparqlEndpoint;
+        
+        visited = new HashSet<Integer>();
+        edgeweight = new LinkedList<Map<Integer,Integer>>();
+        nodeweight = new LinkedList<Integer>();
+        // setNodes for all classes
         SClass[] classes = null;
         try{
@@ -396 +341 @@
            addNode(classes[i].getClassURI());
            nodeType.add("class");
-        }
-        int nedge = 0;
+           edgeweight.add(new HashMap<Integer,Integer>());
+           nodeweight.add(classes[i].getNumOfInstances());
+        }
+        // setEdges
+        //int nedge = 0;
         Integer snode = labelednodes.get(startClass);
         Set<Integer> nodes = new HashSet<Integer>();
         nodes.add(snode);
-        Set<Integer> visited = new HashSet<Integer>();
+        visited.add(snode);
         for (int i = 0 ; i < nsteps; i++ ){
             Iterator<Integer> nit = nodes.iterator();
@@ -407 +355 @@
             while ( nit.hasNext() ){
                 Integer crr = nit.next();
-                visited.add(crr);
                 try{
                     ClassLink[] classLinks = rdfsa.getNextClass(null, labels.get(crr), limit, true);
                     for (int j = 0 ; j < classLinks.length; j++){
                         Integer nn = labelednodes.get(classLinks[j].getLinkedClassURI());
+                        if ( nn == null ){
+                            continue;
+                        }
                         if ( !visited.contains(nn) ){
                             nextnodes.add(nn);
                         }
-                        if ( nn != null ){
-                            addEdge(crr, nn, classLinks[j]);
-                        /*
-                        }else{
-                            nn = labelednodes.get(classLinks[j].getLinkedLiteralDatatypeURI());
-                            if ( nn == null ){
-                                addNode(classLinks[j].getLinkedLiteralDatatypeURI());
-                                n = nodeType.size();
-                                nodeType.add("literal");
-                            }
-                            addEdge(i, n, classLinks[j]);
-                            /*
-                            ClassLink rev = new ClassLink( classLinks[j].getPropertyURI(),
-                               //classLinks[j].getLinkedClassURI(),
-                               classes[i].getClassURI(),
-                               classLinks[j].getLinkedLiteralDatatypeURI(),
-                               classLinks[j].getDirection(), classLinks[j].getNumOfLinks(), 
-                               classLinks[j].getNumOfOriginInstances(), classLinks[j].getNumOfLinkedInstances(),
-                               classLinks[j].getNumOfOriginClassInstances(), classLinks[j].getNumOfLinkedClassInstances(),
-                               classLinks[j].isDomainClassLimitedQ(), classLinks[j].isRangeClassLimitedQ() );
-                            rev.setDirection(Direction.reverse);
-                            addEdge(n, i, rev);
-                        */     
-                        }
+                        addEdge(crr, nn, classLinks[j]);
+                        updateWeight(crr, nn, classLinks[j]);
                     }
                 }catch(Exception e){
@@ -445 +373 @@
             }
             nodes = nextnodes;
+            visited.addAll(nodes);
         }
     }
    
-   private ArrayList<HashSet<Integer>> createConnectionTable(){
+   private ArrayList<HashSet<Integer>> createConnectionTable(){ // not used
        ArrayList<HashSet<Integer>> ct = new ArrayList<HashSet<Integer>>();
        for (int i = 0; i < labels.size(); i++ ){ // each node
@@ -457 +386 @@
    }
    
-   private HashSet<Integer> createConnectionList(Integer node){
+   private HashSet<Integer> createConnectionList(Integer node){ // not used 
        HashSet<Integer> cl = new HashSet<Integer>();
        HashSet<Integer> crrnodes = new HashSet<Integer>();
@@ -482 +411 @@
        return cl;
    }
+   
+   
+   private void updateWeight(Integer node1, Integer node2, ClassLink edge){
+       Map<Integer, Integer> weight = edgeweight.get(node1);
+       Integer crr = weight.get(node2);
+       if (crr == null ){
+           crr = edge.getNumOfLinkedClassInstances();
+           weight.put(node2, crr);           
+       }
+       if ( crr < edge.getNumOfLinkedClassInstances() ){
+           crr = edge.getNumOfLinkedClassInstances();
+           weight.put(node2, crr);
+       }
+       weight = edgeweight.get(node2);
+       crr = weight.get(node1);
+       if (crr == null ){
+           crr = edge.getNumOfOriginClassInstances();
+           weight.put(node2, crr);           
+       }
+       if ( crr < edge.getNumOfOriginClassInstances() ){
+           crr = edge.getNumOfOriginInstances();
+           weight.put(node1, crr);
+       }
+   }
+   
+   // old codes
+   /*
+    public Path[] getPaths_old(RDFSchemaAnalyzer rdfsa, boolean countLink, String startClass, String endClass){
+        List<List<ClassLink>> paths = null;
+        paths = searchPathsbyVisitingNodes(rdfsa, countLink, startClass, endClass);
+        NavigableSet<Path> sortedpath = new TreeSet<Path>();
+        ListIterator<List<ClassLink>> pit = paths.listIterator();
+        int j = 0;
+        while ( pit.hasNext() ){
+            Path path = new Path();
+            path.setStartClass(startClass);
+            List<ClassLink> crrpath = pit.next();
+            path.setClassLinks(crrpath);
+            ListIterator<ClassLink> cit = crrpath.listIterator();
+            int min = Integer.MAX_VALUE;
+            while ( cit.hasNext() ){
+                ClassLink cl = cit.next();
+                if ( cl.getNumOfLinks() < min ){
+                    min = cl.getNumOfLinks();
+                }
+            }
+            path.setWidth(min);
+            sortedpath.add(path);
+            j++;
+        }
+        Path[] patharray = new Path[paths.size()];
+        Iterator<Path> pait = sortedpath.descendingIterator();
+        int i = 0;
+        while ( pait.hasNext() ){
+            patharray[i] = pait.next();
+            i++;
+        }
+        return patharray;
+    }
+
+    private List<List<ClassLink>> searchPaths_old(String startClass, String endClass){
+
+        List<List<ClassLink>> paths = new ArrayList<>();
+        List<List<Integer>> simplePaths = new LinkedList<>();
+        Integer snode = labelednodes.get(startClass);
+        Integer enode = labelednodes.get(endClass);
+        List<List<Integer>> lp = new LinkedList<>();
+        List<Integer> ini = new LinkedList<Integer>(); // initial path
+        ini.add(snode);
+        lp.add(ini);
+        for (int i = 0; i < nsteps; i++ ){
+            ListIterator<List<Integer>> lit = lp.listIterator();
+            List<List<Integer>> nextlp = new LinkedList<>();
+            while ( lit.hasNext() ){ 
+                List<Integer> crrpath = lit.next();
+                Integer crrnode = crrpath.get(crrpath.size()-1);
+                Set<Integer> nexts = gadjlist.get(crrnode).keySet();
+                Iterator<Integer> nit = nexts.iterator();
+                while( nit.hasNext() ){
+                    Integer nextnode = nit.next();
+                    if ( crrpath.contains(nextnode) ){ continue; }
+                    List<Integer> nextpath = new LinkedList<Integer>(crrpath); // copy
+                    nextpath.add(nextnode);
+                    if ( nextnode.equals(enode) ){
+                        simplePaths.add(nextpath);
+                        continue;
+                    }
+                    nextlp.add(nextpath);
+                }
+            }
+            lp = nextlp;
+        }
+        
+        ListIterator<List<Integer>> pit = simplePaths.listIterator();
+        while( pit.hasNext()){
+            List<Integer> spath = pit.next();
+            List<List<ClassLink>> convertedPaths = convertSimplePathToPaths(spath);
+            paths.addAll(convertedPaths);
+        }
+        return paths;
+    }   
+    */
+       /*
+    private List<List<ClassLink>> searchPaths(RDFSchemaAnalyzer rdfsa, boolean countLinks){
+        List<List<ClassLink>> paths = new ArrayList<>();
+        List<LinkAndPath> lp = new LinkedList<>();
+        lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false), new LinkedList<ClassLink>(), ""));
+        try{
+          for ( int i = 0; i < nsteps; i++ ){
+              ListIterator<LinkAndPath> lit = lp.listIterator();
+              List<LinkAndPath> nextlp = new LinkedList<>();
+              while ( lit.hasNext() ){
+                  LinkAndPath crrlp = lit.next();
+                  ClassLink[] classLinks = rdfsa.getNextClass(null, crrlp.classLink.getLinkedClassURI(), limit, countLinks);
+                  for ( int j = 0 ; j < classLinks.length; j++ ){
+                      List<ClassLink> crrpath = new LinkedList<>(crrlp.path);
+                      crrpath.add(classLinks[j]);
+                      if ( classLinks[j].getLinkedClassURI() == null ){ continue; }
+                      if ( classLinks[j].getLinkedClassURI().equals(endClass) ){
+                          paths.add(new LinkedList<>(crrpath));
+                          continue;
+                      }
+                      if ( countLinks == true && classLinks[j].getNumOfLinks() <= th){
+                          continue;
+                      }
+                      if ( i >= 2 ){
+                          if ( crrlp.classLink.getPropertyURI().equals(classLinks[j].getPropertyURI()) &&
+                           crrlp.classLink.getDirection() != classLinks[j].getDirection() &&
+                           crrlp.originalClassURI.equals( classLinks[j].getLinkedClassURI()) ){
+                              continue;
+                          }
+                      }
+                      nextlp.add(new LinkAndPath(classLinks[j], crrpath, crrlp.classLink.getLinkedClassURI()));
+                  }
+              }
+              lp = nextlp;
+          }
+        }catch(Exception e){ 
+            System.err.println(e);
+        }
+        return paths;  
+    }
+    */
+
 }

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java

@@ -86 +86 @@
                                 json_str+= classLinks.get(i).toJSONString3(classes);
                         }
-                        json_str+="]";
+                        json_str+="]";                        
                 }
-                json_str+="}";
+                json_str += ",";
+                json_str +="\"score\":\""+width+"\"";
+                json_str +="}";
                 
                 return json_str;
@@ -139 +141 @@
         //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
     }
-
 }

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java

@@ -18 +18 @@
     private RDFSchemaAnalyzer analyzer = null;
     private OWLClassGraph graph;
+    private boolean askcheck;
     
     private static final String CDIR = "cdata";
@@ -50 +51 @@
         factory = new RDFSchemaAnalyzerFactory(CDIR);
     }
-    
+
     public QueryPathGenerator(String sparqlEndpoint){
         factory = new RDFSchemaAnalyzerFactory(CDIR);
         setSPARQLendpoint(sparqlEndpoint);
-        setOWLClassGraph();
     }
-
+    
+    public void setOWLClassGraph(String startClass){
+        graph = new OWLClassGraph(analyzer, sparqlEndpoint, startClass, askcheck);
+    }
+    
+/*
     public QueryPathGenerator(String sparqlEndpoint, String crawlFileName){
         factory = new RDFSchemaAnalyzerFactory(crawlFileName);
@@ -62 +67 @@
         setOWLClassGraph();
     }
+    */
     
     public SClass[] getClasses(String keyword){
@@ -79 +85 @@
     } 
     
-    public Path[] getPaths(String startClass, String endClass, boolean countLink){
+    public Path[] getPaths(String startClass, String endClass, boolean askcheck){
+        this.askcheck = askcheck;
         if ( graph == null ){
-            setOWLClassGraph();
+            //System.err.println("Class graph is null."); 
+            setOWLClassGraph(startClass);
         }
-        graph.setPartClassGraph(analyzer, startClass);
         return graph.getPaths(startClass, endClass);
-        //return graph.getPaths(startClass, endClass, analyzer);
-        //return graph.getPaths_old(analyzer, true, startClass, endClass);
     }
     
@@ -135 +140 @@
     }
     
+    /*
     private void setOWLClassGraph(){
-        graph = new OWLClassGraph(analyzer); 
-    }
+        //graph = new OWLClassGraph(analyzer);
+        graph = new OWLClassGraph();
+    }*/
     
     public OWLClassGraph getOWLClassGraph(){
-        if ( graph == null ){
+        /*if ( graph == null ){
             graph = new OWLClassGraph(analyzer);             
-        }
+        }*/
         return graph;
     }

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java

@@ -74 +74 @@
         PrintWriter out = response.getWriter();
         String ep = request.getParameter("ep");
+        String classURI = request.getParameter("class");
         HttpSession session = request.getSession();
         QueryPathGenerator qpg = (QueryPathGenerator)session.getAttribute("qpg");
@@ -82 +83 @@
         qpg.setSPARQLendpoint(ep);
         //OWLClassGraph ocg = qpg.getOWLClassGraph();
+        if ( classURI != null ){
+            qpg.setOWLClassGraph(classURI);
+        }
+        
         SClass[] classes = qpg.getClasses(null);
         for (int i = 0 ; i < classes.length; i++ ){
@@ -88 +93 @@
             //    continue;
             //}
+            if ( classURI != null ){
+                if ( qpg.getOWLClassGraph().visitedNode(classURI) == false ){
+                    continue;
+                }
+            }
             Label[] labels = classes[i].getLabels();
             String label = null;
@@ -113 +123 @@
         JsonArrayBuilder jab = jbfactory.createArrayBuilder();
         Iterator<String> cit = sortedClasses.iterator();
+        List<String> tmpclasses = new LinkedList<String>();
+        JsonObjectBuilder job = jbfactory.createObjectBuilder();
         while( cit.hasNext() ){
-            JsonObjectBuilder job = jbfactory.createObjectBuilder();
+            String classinfo = cit.next();
+            String[] data = classinfo.split("  "); 
+            if (data.length != 3 ){
+                System.out.println("data is wrong?");
+            }
+            if (data[0].matches("^[0-9]*$")){
+                tmpclasses.add(classinfo);
+            }else{
+                job.add("uri", data[2]);
+                job.add("label", data[0]);
+                job.add("number", data[1]);
+                jab.add(job);
+            }
+        }
+        cit = tmpclasses.iterator();
+        while( cit.hasNext() ){
             String classinfo = cit.next();
             String[] data = classinfo.split("  "); 
@@ -124 +151 @@
             job.add("number", data[1]);
             jab.add(job);
-        }
+        }       
         JsonArray ja = jab.build();
         out.print(ja);

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java

@@ -74 +74 @@
         String st = request.getParameter("startclass");
         String en = request.getParameter("endclass");
+        String ask = request.getParameter("ask");
         
         HttpSession session = request.getSession();
@@ -81 +82 @@
         }
         SClass[] classes = qpg.getClasses(null);
-        Path[] paths = qpg.getPaths(st, en, true);
+        Path[] paths = null;
+        if ( ask == null ){
+            paths = qpg.getPaths(st, en, false);
+        }else if ( ask.equalsIgnoreCase("true")){
+            paths = qpg.getPaths(st, en, true);            
+        }else{
+            paths = qpg.getPaths(st, en, false);            
+        }
+            
         String jsonstr = "[";
         for(int i = 0; i< paths.length; i++){

SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/SPServlet.java

@@ -179 +179 @@
     
     private String convertPath2SPARQL(Path path) throws Exception{
-        
-         ArrayList<String> classname =new ArrayList<String>() ;
-                
+        ArrayList<String> classname =new ArrayList<String>() ;
         if( path == null ){
                         throw new Exception("Path is null.");