@Test
public void testTripleRelationshipGraph() {
/* Layout
* ___
* (a)---(b)===(c)---(d)
*/
graph.makeEdge("a", "b");
graph.makeEdge("b", "c");
graph.makeEdge("b", "c");
graph.makeEdge("b", "c");
graph.makeEdge("c", "d");
PathFinder<Path> finder = instantiatePathFinder(10);
Iterable<Path> paths = finder.findAllPaths(graph.getNode("a"), graph.getNode("d"));
assertPaths(
paths,
"a,b,c,d",
"a,b,c,d",
"a,b,c,d",
"a,b,c,b,c,d",
"a,b,c,b,c,d",
"a,b,c,b,c,d",
"a,b,c,b,c,d",
"a,b,c,b,c,d",
"a,b,c,b,c,d");
}
@Test
public void testSingle() {
PathFinder<Path> finder = newFinder();
Path path = finder.findSinglePath(graph.getNode("SOURCE"), graph.getNode("TARGET"));
assertNotNull(path);
assertPathDef(path, "SOURCE", "z", "9", "0", "TARGET");
}
@Test
public void testCircularGraph() {
/* Layout
*
* (a)---(b)===(c)---(e)
* \ /
* (d)
*/
graph.makeEdge("a", "b");
graph.makeEdge("b", "c");
graph.makeEdge("b", "c");
graph.makeEdge("b", "d");
graph.makeEdge("c", "d");
graph.makeEdge("c", "e");
PathFinder<Path> finder = instantiatePathFinder(10);
Iterable<Path> paths = finder.findAllPaths(graph.getNode("a"), graph.getNode("e"));
assertPaths(
paths,
"a,b,c,e",
"a,b,c,e",
"a,b,d,c,e",
"a,b,c,d,b,c,e",
"a,b,c,d,b,c,e",
"a,b,c,b,d,c,e",
"a,b,c,b,d,c,e",
"a,b,d,c,b,c,e",
"a,b,d,c,b,c,e");
}
@SuppressWarnings("rawtypes")
public PathRepresentation findSinglePath(long startId, long endId, Map<String, Object> map) {
FindParams findParams = new FindParams(startId, endId, map).invoke();
PathFinder finder = findParams.getFinder();
Node startNode = findParams.getStartNode();
Node endNode = findParams.getEndNode();
Path path = finder.findSinglePath(startNode, endNode);
if (path == null) {
throw new NotFoundException();
}
return findParams.pathRepresentationOf(path);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public ListRepresentation findPaths(long startId, long endId, Map<String, Object> map) {
final FindParams findParams = new FindParams(startId, endId, map).invoke();
PathFinder finder = findParams.getFinder();
Node startNode = findParams.getStartNode();
Node endNode = findParams.getEndNode();
Iterable paths = finder.findAllPaths(startNode, endNode);
IterableWrapper<PathRepresentation, Path> pathRepresentations =
new IterableWrapper<PathRepresentation, Path>(paths) {
@Override
protected PathRepresentation underlyingObjectToObject(Path path) {
return findParams.pathRepresentationOf(path);
}
};
return new ListRepresentation(RepresentationType.PATH, pathRepresentations);
}
private static Iterator<Node> findPath(Node s, Node e) {
Iterator<Node> it;
try (Transaction tx = graphDb.beginTx()) {
PathFinder<Path> finder =
GraphAlgoFactory.shortestPath(
PathExpanders.forTypeAndDirection(RelTypes.STD, Direction.OUTGOING), 15);
Iterable<Path> paths = finder.findAllPaths(s, e);
Path path = paths.iterator().next();
it = path.nodes().iterator();
if (it.hasNext()) {
System.out.println(it.next().getProperty("name"));
}
if (it.hasNext()) {
System.out.println(it.next().getProperty("name"));
}
if (it.hasNext()) {
System.out.println(it.next().getProperty("name"));
}
tx.success();
}
return it;
}
public Double shortestPath() {
s1nodes = Neo4jGraphUtils.getSourceNodes(graph, s1);
s2nodes = Neo4jGraphUtils.getSourceNodes(graph, s2);
log.info(
"Compute pairwise cheapest path: S{} ({} nodes), S{} ({} nodes)",
s1.getSnippetId(),
s1nodes.size(),
s2.getSnippetId(),
s2nodes.size());
int pathLenghtSum = 0;
int pathCount = 0;
int commonNodeCount = 0;
int cacheCounter = 0;
for (Vertex v1 : s1nodes) {
for (Vertex v2 : s2nodes) {
Long v1id = (Long) (v1.getId());
Long v2id = (Long) (v2.getId());
if (v1id.compareTo(v2id) == 0) {
commonNodeCount++;
// pathCount++;
// pathLenghtSum += 0
continue;
}
log.debug("Processing Node {} and Node {}", v1id, v2id);
Node n1 = graph.getRawGraph().getNodeById(v1id);
Node n2 = graph.getRawGraph().getNodeById(v2id);
// Get shortest path
Integer pathLen = null; // p.length();
Tuple<Integer, Double> path = pathCache.getPath(v1id, v2id, log.isDebugEnabled());
if (path != null) {
pathLen = path.k;
cacheCounter++;
log.debug(
"Path between Node{} and Node{} found, Length {}, Weight {} (from mysql cache)",
v1id,
v2id,
pathLen);
} else {
log.debug("Start ShortestPath Node {} and Node {}", v1id, v2id);
PathFinder<Path> shortestPathAlgo =
GraphAlgoFactory.shortestPath(
(PathExpander<?>) Traversal.expanderForAllTypes(), maxPathLen.intValue());
Path shortestPath = shortestPathAlgo.findSinglePath(n1, n2);
StringBuffer shorestPathSteps = null;
if (shortestPath != null) {
pathLen = shortestPath.length();
// Constructing path for debug logging
if (log.isDebugEnabled()) {
Iterator<PropertyContainer> iter = shortestPath.iterator();
shorestPathSteps = new StringBuffer();
while (iter.hasNext()) {
Object e = iter.next();
if (e instanceof NodeProxy) {
Node n = (Node) e;
shorestPathSteps.append("(" + n.getProperty("label") + ")");
} else if (e instanceof RelationshipProxy) {
Relationship r = (Relationship) e;
shorestPathSteps.append("-[" + r.getType() + "]-");
} else {
log.error("ERROR");
}
}
log.debug(
"Path between Node{} and Node{} found, Length {}, Path {}",
v1id,
v2id,
pathLen,
shorestPathSteps);
}
} else {
log.debug("Path between Node{} and Node{} not found.", v1id, v2id);
}
// Update mysql db cache
if (log.isDebugEnabled()) {
pathCache.setPath(v1id, v2id, pathLen, null, shorestPathSteps);
} else {
pathCache.setPath(v1id, v2id, pathLen, null);
}
}
// Getting shortest path data
if (pathLen != null) {
if (pathLen <= maxPathLen) {
pathLenghtSum += pathLen;
pathCount++;
}
}
}
}
log.info(
"Similarity measures S{}, S{}: CommonNodes {}, PathCnt {}, MaxTheoPathCnt {}, SumPathLen {}, CacheCnt {}",
s1.getSnippetId(),
s2.getSnippetId(),
commonNodeCount,
pathCount,
s1nodes.size() * s2nodes.size(),
pathLenghtSum,
cacheCounter);
// log.info("Total path score S{}, S{}: {}", s1.getSnippetId(), s2.getSnippetId(), sim);
return Double.valueOf(pathLenghtSum);
}
@Override
public Map<String, Set<Long>> extract(
List<DocGraph> docGraphs,
DocGraphFilterFunction filterFunc,
Set<String> resourceClasses,
Set<String> documentClasses) {
// pattern-document graph associations R_D
Map<String, Set<Long>> associations = new HashMap<String, Set<Long>>();
// init path finder
initFinder();
// G_D(filtered) <- G_D.where({G_d|filter(G_D)})
Set<DocGraph> filteredDocGraphs = new HashSet<DocGraph>();
if (filterFunc == null) {
filteredDocGraphs.addAll(docGraphs);
} else {
for (DocGraph docGraph : docGraphs) {
if (filterFunc.filter(docGraph)) {
filteredDocGraphs.add(docGraph);
}
}
}
Set<Node> relevantResources = null;
Set<Node> relevantDocuments = null;
String r = null;
Node v_p = null;
boolean validPath = true;
int pCnt = 0;
log.info(String.format("Starting analysis of %d document graphs", filteredDocGraphs.size()));
for (DocGraph docGraph : filteredDocGraphs) {
log.info(
String.format(
"Analyzing DocGraph[%d] (%d, %d)",
docGraph.getId(), docGraph.getNodeCount(), docGraph.getEdgeCount()));
pCnt = 0;
// V_R <- G_d.V.where({v|tau(mu(v)) in C_R})
relevantResources = filterNodesByClass(docGraph.getNodes(), resourceClasses);
// V_R <- G_d.V.where({v|tau(mu(v)) in C_D})
relevantDocuments = filterNodesByClass(docGraph.getNodes(), documentClasses);
preProcessGraph(docGraph, resourceClasses);
try (Transaction tx = graphDB.beginTx()) {
for (Node v_r : relevantResources) {
for (Node v_d : relevantDocuments) {
// P <- G_d.paths(v_R,v_D)
for (Path p : finder.findAllPaths(v_r, v_d)) {
validPath = true;
r = String.format("%s", v_r.getProperty(Constants.ID_KEY));
v_p = v_r;
for (Relationship e : p.relationships()) {
if (e.getStartNode().getId() == v_p.getId()) {
if (getNodeSuperClass(e.getEndNode())
.equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)) {
validPath = false;
break;
}
r =
String.format(
"%s-%s->%s", r, e.getType().name(), getNodeClass(e.getEndNode()));
v_p = e.getEndNode();
} else {
if (getNodeSuperClass(e.getStartNode())
.equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)) {
validPath = false;
break;
}
r =
String.format(
"%s<-%s-%s", r, e.getType().name(), getNodeClass(e.getStartNode()));
v_p = e.getStartNode();
}
}
// R_D.add(<r, G_d>)
if (validPath) {
associations = addPatternDocGraphAssociation(associations, r, docGraph);
pCnt++;
}
}
}
}
tx.success();
}
log.info(String.format("%d patterns in DocGraph[%d]", pCnt, docGraph.getId()));
}
return associations;
}
