Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAccess.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAccess.java (revision 248) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAccess.java (revision 248) @@ -0,0 +1,198 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.OWL; + +import com.hp.hpl.jena.query.*; +import com.hp.hpl.jena.sparql.engine.http.QueryEngineHTTP; +import java.util.*; + +/** + * + * @author atsuko + */ +public class EndpointAccess { + static public boolean checkPath(String startClass, List classlinks, String sparqlEndpoint){ + // SPARQL Query construction + StringBuilder queryStr = new StringBuilder(); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("ASK { \n"); + + ListIterator cit = classlinks.listIterator(); + queryStr.append("?r0").append(" rdf:type <").append(startClass).append("> .\n"); + int i = 0; + while( cit.hasNext() ){ + ClassLink link = cit.next(); + //String next = link.getLinkedClassURI(); + String sval = "?r".concat(Integer.toString(i)); + String oval = "?r".concat(Integer.toString(i+1)); + queryStr.append(oval).append(" rdf:type <").append(link.getLinkedClassURI()).append("> .\n"); + if( link.getDirection() == Direction.forward ){ + queryStr.append(sval).append(" <").append(link.getPropertyURI()).append("> ") + .append(oval).append(" .\n"); + }else{ + queryStr.append(oval).append(" <").append(link.getPropertyURI()).append("> ") + .append(sval).append(" .\n"); + } + i++; + } + queryStr.append("} \n"); + + String sparqlQuery = queryStr.toString(); + Query query = QueryFactory.create(sparqlQuery, Syntax.syntaxARQ); + /* + QueryEngineHTTP httpQuery = new QueryEngineHTTP(sparqlEndpoint, query); + boolean res = httpQuery.execAsk(); + httpQuery.close(); + */ + QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); + boolean res = qexec.execAsk(); + qexec.close(); + return res; + } + + static public boolean checkSimplePath(List nodes, OWLClassGraph ocg, String sparqlEndpoint){ + // SPARQL Query construction + StringBuilder queryStr = new StringBuilder(); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("ASK { \n"); + + ListIterator cit = nodes.listIterator(); + queryStr.append("?r0").append(" rdf:type <").append(ocg.labels.get(cit.next())).append("> .\n"); + int i = 0; + while( cit.hasNext() ){ + String cURI = ocg.labels.get(cit.next()); + //String next = link.getLinkedClassURI(); + String sval = "?r".concat(Integer.toString(i)); + String pval = "?p".concat(Integer.toString(i)); + String oval = "?r".concat(Integer.toString(i+1)); + queryStr.append(oval).append(" rdf:type <").append(cURI).append("> .\n"); + queryStr.append("{{"); + queryStr.append(sval).append(" ").append(pval).append(" ") + .append(oval).append(" }\n UNION\n {"); + queryStr.append(oval).append(" ").append(pval).append(" ") + .append(sval).append(" }}\n"); + i++; + } + queryStr.append("} \n"); + + String sparqlQuery = queryStr.toString(); + System.out.println("Ask Simple"); + System.out.println(sparqlQuery); + Query query = QueryFactory.create(sparqlQuery, Syntax.syntaxARQ); + /* + QueryEngineHTTP httpQuery = new QueryEngineHTTP(sparqlEndpoint, query); + boolean res = httpQuery.execAsk(); + httpQuery.close(); + */ + QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); + boolean res = qexec.execAsk(); + qexec.close(); + return res; + } + + static public boolean check3SimplePath(Integer node1, Integer node2, Integer node3, OWLClassGraph ocg, String sparqlEndpoint){ + // SPARQL Query construction + StringBuilder queryStr = new StringBuilder(); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("ASK { \n"); + + queryStr.append("?n1").append(" rdf:type <").append(ocg.labels.get(node1)).append("> .\n"); + queryStr.append("?n2").append(" rdf:type <").append(ocg.labels.get(node2)).append("> .\n"); + queryStr.append("?n3").append(" rdf:type <").append(ocg.labels.get(node3)).append("> .\n"); + + queryStr.append("{{"); + queryStr.append("?n1").append(" ").append("?p1").append(" ") + .append("?n2").append(" }\n UNION\n {"); + queryStr.append("?n2").append(" ").append("?p1").append(" ") + .append("?n1").append(" }}\n"); + + queryStr.append("{{"); + queryStr.append("?n2").append(" ").append("?p2").append(" ") + .append("?n3").append(" }\n UNION\n {"); + queryStr.append("?n3").append(" ").append("?p2").append(" ") + .append("?n2").append(" }}\n"); + + queryStr.append("} \n"); + + String sparqlQuery = queryStr.toString(); + System.out.println("Ask Simple3"); + System.out.println(sparqlQuery); + Query query = QueryFactory.create(sparqlQuery, Syntax.syntaxARQ); + /* + QueryEngineHTTP httpQuery = new QueryEngineHTTP(sparqlEndpoint, query); + boolean res = httpQuery.execAsk(); + httpQuery.close(); + */ + QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); + boolean res = qexec.execAsk(); + qexec.close(); + return res; + } + + static public boolean check3SimplePathwithJoin(Integer node1, Integer node2, Integer node3, OWLClassGraph ocg, String sparqlEndpoint){ + StringBuilder queryStr = new StringBuilder(); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?n2 { \n"); + + queryStr.append("?n1").append(" rdf:type <").append(ocg.labels.get(node1)).append("> .\n"); + queryStr.append("?n2").append(" rdf:type <").append(ocg.labels.get(node2)).append("> .\n"); + + queryStr.append("{{"); + queryStr.append("?n1").append(" ").append("?p1").append(" ") + .append("?n2").append(" }\n UNION\n {"); + queryStr.append("?n2").append(" ").append("?p1").append(" ") + .append("?n1").append(" }}\n"); + + queryStr.append("} \n"); + + String sparqlQuery = queryStr.toString(); + System.out.println("SELECT Simple3 by Join"); + System.out.println(sparqlQuery); + Query query = QueryFactory.create(sparqlQuery, Syntax.syntaxARQ); + QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); + ResultSet res1 = qexec.execSelect(); + qexec.close(); + + queryStr = new StringBuilder(); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?n2 { \n"); + + queryStr.append("?n2").append(" rdf:type <").append(ocg.labels.get(node2)).append("> .\n"); + queryStr.append("?n3").append(" rdf:type <").append(ocg.labels.get(node3)).append("> .\n"); + + queryStr.append("{{"); + queryStr.append("?n2").append(" ").append("?p2").append(" ") + .append("?n3").append(" }\n UNION\n {"); + queryStr.append("?n3").append(" ").append("?p2").append(" ") + .append("?n2").append(" }}\n"); + + queryStr.append("} \n"); + + sparqlQuery = queryStr.toString(); + System.out.println("SELECT Simple3 by Join 2"); + System.out.println(sparqlQuery); + query = QueryFactory.create(sparqlQuery, Syntax.syntaxARQ); + qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); + ResultSet res2 = qexec.execSelect(); + qexec.close(); + + Set res1hash = new HashSet(); + while(res1.hasNext()){ + String resstr = res1.next().toString(); + res1hash.add(resstr); + } + while(res2.hasNext()){ + if ( res1hash.contains(res2.next().toString())){ + return true; + } + } + return false; + } +} Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java (revision 228) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassGraph.java (revision 248) @@ -19,5 +19,10 @@ List nodeType; ArrayList> connectionTable; - + String sparqlEndpoint; + Set visited; + boolean askcheck; + List> edgeweight; + List nodeweight; + public class LinkAndPath{ String originalClassURI; // originalClasssURI -classLink.propertyURI-> classLink.linkedClassURL @@ -46,50 +51,21 @@ } -/* - 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(); - //setClassGraph(rdfsa); - //connectionTable = createConnectionTable(); - } - - - public OWLClassGraph(RDFSchemaAnalyzer rdfsa){ + } + + public OWLClassGraph(RDFSchemaAnalyzer rdfsa){ // not used super(); nodeType = new LinkedList(); - //setClassGraph(rdfsa); - //connectionTable = createConnectionTable(); - } - + } + + public OWLClassGraph(RDFSchemaAnalyzer rdfsa, String sparqlEndpoint, String startClass, boolean askcheck){ // used + super(); + nodeType = new LinkedList(); + this.askcheck = askcheck; + setPartClassGraph(rdfsa, sparqlEndpoint, startClass); + } + public int getNumberOfEdge(String url){ Integer node = labelednodes.get(url); @@ -98,4 +74,11 @@ } return adjlist.get(node).size(); + } + + public boolean visitedNode(String classURI){ + if ( visited.contains(labelednodes.get(classURI)) ){ + return true; + } + return false; } @@ -138,40 +121,8 @@ return connectionTable.get(node); } - - public Path[] getPaths_old(RDFSchemaAnalyzer rdfsa, boolean countLink, String startClass, String endClass){ - List> paths = null; - paths = searchPathsbyVisitingNodes(rdfsa, countLink, startClass, endClass); - NavigableSet sortedpath = new TreeSet(); - ListIterator> pit = paths.listIterator(); - int j = 0; - while ( pit.hasNext() ){ - Path path = new Path(); - path.setStartClass(startClass); - List crrpath = pit.next(); - path.setClassLinks(crrpath); - ListIterator 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 pait = sortedpath.descendingIterator(); - int i = 0; - while ( pait.hasNext() ){ - patharray[i] = pait.next(); - i++; - } - return patharray; - } private List> searchPaths(String startClass, String endClass){ - + //int asked = 0; + Map checkedpaths = new HashMap(); List> paths = new ArrayList<>(); List> simplePaths = new LinkedList<>(); @@ -195,4 +146,35 @@ List nextpath = new LinkedList(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,4 +188,8 @@ ListIterator> pit = simplePaths.listIterator(); + //int i = 0; + //int j = 0; + System.out.println("SPATH:"); + System.out.println(simplePaths.size()); while( pit.hasNext()){ List spath = pit.next(); @@ -211,12 +197,15 @@ paths.addAll(convertedPaths); } + System.out.println("PATH:"); + System.out.println(paths.size()); return paths; } + private List> convertSimplePathToPaths(List simplePath){ List> paths = new LinkedList>(); - //List> multiedges = new LinkedList>(); ListIterator spit = simplePath.listIterator(); Integer start = spit.next(); + String startClass = this.labels.get(start); Integer end = spit.next(); List edges = gadjlist.get(start).get(end); @@ -242,5 +231,8 @@ List addedpath = new LinkedList(basepath); addedpath.add(cl); - tmppaths.add(addedpath); + // check + //if ( EndpointAccess.checkPath(startClass, addedpath, sparqlEndpoint) ){ + tmppaths.add(addedpath); + //} } } @@ -252,45 +244,4 @@ /* - private List> searchPaths(RDFSchemaAnalyzer rdfsa, boolean countLinks){ - List> paths = new ArrayList<>(); - List lp = new LinkedList<>(); - lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false), new LinkedList(), "")); - try{ - for ( int i = 0; i < nsteps; i++ ){ - ListIterator lit = lp.listIterator(); - List 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 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> searchPathsbyVisitingNodes(RDFSchemaAnalyzer rdfsa, boolean countLinks, String startClass, String endClass){ @@ -365,16 +316,4 @@ } 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,8 +322,14 @@ } } - } - - 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(); + edgeweight = new LinkedList>(); + nodeweight = new LinkedList(); + // setNodes for all classes SClass[] classes = null; try{ @@ -396,10 +341,13 @@ addNode(classes[i].getClassURI()); nodeType.add("class"); - } - int nedge = 0; + edgeweight.add(new HashMap()); + nodeweight.add(classes[i].getNumOfInstances()); + } + // setEdges + //int nedge = 0; Integer snode = labelednodes.get(startClass); Set nodes = new HashSet(); nodes.add(snode); - Set visited = new HashSet(); + visited.add(snode); for (int i = 0 ; i < nsteps; i++ ){ Iterator nit = nodes.iterator(); @@ -407,36 +355,16 @@ 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,8 +373,9 @@ } nodes = nextnodes; + visited.addAll(nodes); } } - private ArrayList> createConnectionTable(){ + private ArrayList> createConnectionTable(){ // not used ArrayList> ct = new ArrayList>(); for (int i = 0; i < labels.size(); i++ ){ // each node @@ -457,5 +386,5 @@ } - private HashSet createConnectionList(Integer node){ + private HashSet createConnectionList(Integer node){ // not used HashSet cl = new HashSet(); HashSet crrnodes = new HashSet(); @@ -482,3 +411,147 @@ return cl; } + + + private void updateWeight(Integer node1, Integer node2, ClassLink edge){ + Map 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> paths = null; + paths = searchPathsbyVisitingNodes(rdfsa, countLink, startClass, endClass); + NavigableSet sortedpath = new TreeSet(); + ListIterator> pit = paths.listIterator(); + int j = 0; + while ( pit.hasNext() ){ + Path path = new Path(); + path.setStartClass(startClass); + List crrpath = pit.next(); + path.setClassLinks(crrpath); + ListIterator 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 pait = sortedpath.descendingIterator(); + int i = 0; + while ( pait.hasNext() ){ + patharray[i] = pait.next(); + i++; + } + return patharray; + } + + private List> searchPaths_old(String startClass, String endClass){ + + List> paths = new ArrayList<>(); + List> simplePaths = new LinkedList<>(); + Integer snode = labelednodes.get(startClass); + Integer enode = labelednodes.get(endClass); + List> lp = new LinkedList<>(); + List ini = new LinkedList(); // initial path + ini.add(snode); + lp.add(ini); + for (int i = 0; i < nsteps; i++ ){ + ListIterator> lit = lp.listIterator(); + List> nextlp = new LinkedList<>(); + while ( lit.hasNext() ){ + List crrpath = lit.next(); + Integer crrnode = crrpath.get(crrpath.size()-1); + Set nexts = gadjlist.get(crrnode).keySet(); + Iterator nit = nexts.iterator(); + while( nit.hasNext() ){ + Integer nextnode = nit.next(); + if ( crrpath.contains(nextnode) ){ continue; } + List nextpath = new LinkedList(crrpath); // copy + nextpath.add(nextnode); + if ( nextnode.equals(enode) ){ + simplePaths.add(nextpath); + continue; + } + nextlp.add(nextpath); + } + } + lp = nextlp; + } + + ListIterator> pit = simplePaths.listIterator(); + while( pit.hasNext()){ + List spath = pit.next(); + List> convertedPaths = convertSimplePathToPaths(spath); + paths.addAll(convertedPaths); + } + return paths; + } + */ + /* + private List> searchPaths(RDFSchemaAnalyzer rdfsa, boolean countLinks){ + List> paths = new ArrayList<>(); + List lp = new LinkedList<>(); + lp.add(new LinkAndPath(new ClassLink("",startClass,null,Direction.both,0,0,0,0,0,false,false), new LinkedList(), "")); + try{ + for ( int i = 0; i < nsteps; i++ ){ + ListIterator lit = lp.listIterator(); + List 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 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; + } + */ + } Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 228) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 248) @@ -18,4 +18,5 @@ private RDFSchemaAnalyzer analyzer = null; private OWLClassGraph graph; + private boolean askcheck; private static final String CDIR = "cdata"; @@ -50,11 +51,15 @@ 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,4 +67,5 @@ setOWLClassGraph(); } + */ public SClass[] getClasses(String keyword){ @@ -79,12 +85,11 @@ } - 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,12 +140,14 @@ } + /* 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; } Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 221) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 248) @@ -86,7 +86,9 @@ 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,4 +141,3 @@ //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. } - } Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 221) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 248) @@ -74,4 +74,5 @@ String st = request.getParameter("startclass"); String en = request.getParameter("endclass"); + String ask = request.getParameter("ask"); HttpSession session = request.getSession(); @@ -81,5 +82,13 @@ } 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++){ Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 228) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 248) @@ -74,4 +74,5 @@ 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,4 +83,8 @@ 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,4 +93,9 @@ // continue; //} + if ( classURI != null ){ + if ( qpg.getOWLClassGraph().visitedNode(classURI) == false ){ + continue; + } + } Label[] labels = classes[i].getLabels(); String label = null; @@ -113,6 +123,23 @@ JsonArrayBuilder jab = jbfactory.createArrayBuilder(); Iterator cit = sortedClasses.iterator(); + List tmpclasses = new LinkedList(); + 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,5 +151,5 @@ job.add("number", data[1]); jab.add(job); - } + } JsonArray ja = jab.build(); out.print(ja); Index: SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/SPServlet.java =================================================================== --- SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/SPServlet.java (revision 229) +++ SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/SPServlet.java (revision 248) @@ -179,7 +179,5 @@ private String convertPath2SPARQL(Path path) throws Exception{ - - ArrayList classname =new ArrayList() ; - + ArrayList classname =new ArrayList() ; if( path == null ){ throw new Exception("Path is null.");