@Override
public void run() {
final Node head = this.graph.getNodeAt(this.start);
if (head == null) {
throw new IllegalStateException("Start point not in graph");
}
final Node tail = this.graph.getNodeAt(this.end);
if (tail == null) {
throw new IllegalStateException("End point not in graph");
}
// Traverse through the graph, finding the shortest distance between
// any two nodes starting from 'head' until reaching 'tail'.
Node current = head;
HashSet<Node> workingSet = new HashSet<>();
do {
current = this.exploreNode(workingSet, current);
} while (!current.equals(tail));
// Reverse through the graph, finding the closest node (using
// shortest distances from above traversal) starting from 'tail'
// until reaching 'head'.
current = tail;
while (!current.equals(head)) {
this.resultantPath.add(0, current);
current = this.closestNode(this.graph.getConnectedNodes(current));
}
this.resultantPath.add(0, current);
}
/**
* Helper method to turn a Collection of "Paths" into a Collection of Routes
*
* @param source
* @param weights
* @param prevNodes
* @return
*/
private Map<Node, Route> makeRouteMap(
Node source, Map<Node, Integer> weights, Map<Node, Node> prevNodes) {
Map<Node, Route> routes = new HashMap<Node, Route>();
for (Map.Entry<Node, Integer> entry : weights.entrySet()) {
Integer hops = 1;
Node node = entry.getKey();
if (node.equals(source)) {
continue;
}
Route route = new Route();
route.setDistance(entry.getValue());
Node nextHop = node;
route.getPath().add(0, nextHop);
while ((nextHop = prevNodes.get(nextHop)) != null) {
if (nextHop.equals(source)) {
continue;
}
hops++;
route.getPath().add(0, nextHop);
}
route.setHops(hops);
routes.put(node, route);
}
return routes;
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
else if (obj instanceof DirectedNeighbor) {
return _neighbor.equals(((DirectedNeighbor) obj).getNeighbor());
} else if (obj instanceof Node) {
return _neighbor.equals((Node) obj);
} else return false;
}
/**
* Remove the element in position
*
* @param i
*/
public void remove(int position) {
Node<T> node = getNode(position);
if (first.equals(node)) {
removeFirst();
} else if (last.equals(node)) {
removeLast();
} else {
node.getBefore().setAfter(node.getAfter());
node.getAfter().setBefore(node.getBefore());
// node is free for gc
}
}
ReificationStatementMask(Triple t) {
mask = HasNada;
Node p = t.getPredicate();
if (p != null) {
if (p.equals(RDF.Nodes.subject)) mask = HasSubj;
else if (p.equals(RDF.Nodes.predicate)) mask = HasPred;
else if (p.equals(RDF.Nodes.object)) mask = HasObj;
else if (p.equals(RDF.Nodes.type)) {
Node o = t.getObject();
if (o.equals(RDF.Nodes.Statement)) mask = HasType;
}
}
}
public boolean equals(Object obj) {
if (!(obj instanceof Control)) {
return false;
}
Control c = ((Control) obj);
if (from == null) {
return c.from == null && to.equals(c.to);
}
if (to == null) {
return c.to == null && from.equals(c.from);
}
return from.equals(c.from) && to.equals(c.to);
}
/** Remove the current element. */
protected void remove(Node<T> t) {
if (t.equals(first) && t.equals(last)) {
first = null;
last = null;
} else if (t.equals(first)) {
first = t.getAfter();
first.setBefore(null);
} else if (t.equals(last)) {
last = t.getBefore();
last.setAfter(null);
} else {
t.getBefore().setAfter(t.getAfter());
t.getAfter().setBefore(t.getBefore());
}
}
/* initialize nodes and links. the graph is complete ! :) */
public void initCircleGraph(Integer xMax, Integer yMax, Integer nbNode) {
int xCenter = xMax / 2;
int yCenter = yMax / 2;
int rayon = Math.max(xMax, yMax) / 3;
double angle = Math.PI * 2 / nbNode;
/* init nodes around the circle */
for (Integer i = 0; i < nbNode; i++) {
double x = xCenter + rayon * Math.cos(angle * i);
double y = yCenter + rayon * Math.sin(angle * i);
Node n = new Node((int) x, (int) y);
nodes.add(n);
}
for (Node source : nodes) {
for (Node dest : nodes) {
if (!source.equals(dest)) {
Link link1 = new Link(source, dest);
source.getLinks().add(link1);
Link link2 = new Link(dest, source);
dest.getLinks().add(link2);
links.add(link1);
links.add(link2);
}
}
}
System.out.println("nb link générés = " + links.size());
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.CYAN);
// draw basic board
for (int i = 0, j = 0; j < 17; i += BLANK_WIDTH, j++) {
g.drawLine(0, i, 640, i);
g.drawLine(i, 0, i, 640);
}
// draw nodes
ArrayList<Node> nodeList = NodeList.getList();
for (Node point : nodeList) {
int x = (point.getX() - 1) * BLANK_WIDTH;
int y = (point.getY() - 1) * BLANK_WIDTH;
// draw black
if (point.getColor() == Node.BLACK) {
g.setColor(new Color(255, 192, 203));
}
// draw white
else if (point.getColor() == Node.WHITE) {
g.setColor(Color.WHITE);
}
g.fillOval(x - RADIUS, y - RADIUS, RADIUS * 2, RADIUS * 2);
// newly point
if (point.equals(NodeList.getLastNode())) {
g.setColor(Color.RED);
g.drawRect(x - RADIUS, y - RADIUS, RADIUS * 2, RADIUS * 2);
}
}
}
/** {@inheritDoc} */
@Override
public boolean remove(T value) {
// Find the node
Node<T> node = head;
while (node != null && (!node.value.equals(value))) {
node = node.nextNode;
}
if (node == null) return false;
// Update the tail, if needed
if (node.equals(tail)) tail = node.previousNode;
Node<T> prev = node.previousNode;
Node<T> next = node.nextNode;
if (prev != null && next != null) {
prev.nextNode = next;
next.previousNode = prev;
} else if (prev != null && next == null) {
prev.nextNode = null;
} else if (prev == null && next != null) {
// Node is the head
next.previousNode = null;
head = next;
} else {
// prev==null && next==null
head = null;
}
size--;
return true;
}
private void remClient(Client client) {
Node item = this.clients;
while (item != null) {
if (item.client.equals(client)) {
// Eliminar client i Node
// Si es el node cap, apuntar al seguent
if (item.equals(this.clients)) {
this.clients = item.getSeguent();
item = null;
return;
}
// Si no es el node cap, trobar anterior i apuntar al seguent
else {
Node anterior = this.clients;
while (anterior.getSeguent() != null) {
if (anterior.getSeguent().client.equals(client)) {
anterior.setSeguent(item.getSeguent());
item = null;
return;
}
}
}
}
item = item.getSeguent();
}
}
@Override
public void verify() throws TransformException {
ItemList targets = mod.nearest(NodeTarget.class).targets();
List<Node> references = mod.references();
ItemList records = mod.supplementQuery().all("sort-proxy");
assert targets.size() == references.size();
assert records.size() == references.size();
for (int i = 0; i < targets.size(); i++) {
Node target = targets.get(i).node();
Node restoredProxy = references.get(i);
ItemList items = query.runOn(mod.scope(target.query()));
if (items.size() != 1)
throw new TransformException(
"sort by corresponding node must select one node per target, but instead selected "
+ items.size()
+ ": "
+ items);
Node proxy = items.get(0).node();
if (!restoredProxy.equals(proxy)) throw new TransformException("computed proxy changed");
if (!proxy
.query()
.single(
"(count(preceding::*) + count(ancestor::*)) eq xs:integer($_1/@position)",
records.get(i))
.booleanValue()) throw new SortingException("computed proxy moved");
}
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || !(obj instanceof NumericalNode)) {
return false;
}
NumericalNode node = (NumericalNode) obj;
return attr == node.attr
&& split == node.split
&& loChild.equals(node.loChild)
&& hiChild.equals(node.hiChild);
}
/**
* This method is invoked when the builtin is called in a rule body.
*
* @param args the array of argument values for the builtin, this is an array of Nodes, some of
* which may be Node_RuleVariables.
* @param length the length of the argument list, may be less than the length of the args array
* for some rule engines
* @param context an execution context giving access to other relevant data
* @return return true if the buildin predicate is deemed to have succeeded in the current
* environment
*/
public boolean bodyCall(Node[] args, int length, RuleContext context) {
if (length != 3) {
throw new BuiltinException(
this, context, "builtin " + getName() + " requires 3 arguments but saw " + length);
}
Node obj = getArg(2, args, context);
Node subj = getArg(0, args, context);
// Allow variables in subject position to correspond to a wild card
if (subj.isVariable()) {
subj = null;
}
// Allow variables in the predicate position to correspond to a wild card
Node pred = getArg(1, args, context);
if (pred.isVariable()) {
pred = null;
}
boolean bContainsObj = context.contains(subj, pred, obj);
if (!bContainsObj) {
return false;
}
// does it contain anything else?
ClosableIterator<Triple> citr = context.find((Node) null, pred, obj);
boolean otherSubject = false;
while (citr.hasNext()) {
Object o = citr.next();
Node tmpSubj = ((Triple) o).getSubject();
if (!tmpSubj.equals(subj)) {
otherSubject = true;
break;
}
}
citr.close();
return !otherSubject;
}
/**
* Returns the node after the given one
*
* @param x node
* @return next node
* @throws HsqlException
*/
Node next(Node x) throws HsqlException {
if (x == null) {
return null;
}
Node r = x.getRight();
if (r != null) {
x = r;
Node l = x.getLeft();
while (l != null) {
x = l;
l = x.getLeft();
}
return x;
}
Node ch = x;
x = x.getParent();
while (x != null && ch.equals(x.getRight())) {
ch = x;
x = x.getParent();
}
return x;
}
public Node getOpen(int x, int y) {
for (Node node : OpenList) {
if (node.equals(x, y)) {
return node;
}
}
return null;
}
/**
* Tests whether a graph node exists in the graph
*
* @param node graph node
* @return true if node exists
*/
public boolean nodeExists(Node node) {
for (Node aNode : nodeList) {
if (aNode.equals(node)) {
return true;
}
}
return false;
}
public boolean containClose(int x, int y) {
for (Node node : CloseList) {
if (node.equals(x, y)) {
return true;
}
}
return false;
}
public boolean containOpen(int x, int y) {
for (Node node : OpenList) {
if (node.equals(x, y)) {
return true;
}
}
return false;
}
public Node[] jjtRemoveObject(Node node) throws VisitorException {
for (int i = 0; i < jjtGetNumChildren(); i++) {
if (node.equals(children[i])) {
return jjtRemoveChild(i);
}
}
return children;
}
/**
* @param map 地图 数据
* @param sx 开始 x 坐标
* @param sy 开始 y 坐标
* @param ex 结束 x 坐标
* @param ey 结束 y 坐标
* @param isPass 可通过的 数据集
* @return 路线
*/
public ArrayList<Node> find(int[][] map, int sx, int sy, int ex, int ey, int[] isPass) {
Node start = new Node(sx, sy);
Node end = new Node(ex, ey);
Node node = start;
CloseList.add(node);
boolean flag = true;
while (flag) {
for (int i = 0; i < 4; i++) {
int fx = node.x + XMove[i];
int fy = node.y + YMove[i];
if (fx >= map.length && fy >= map[0].length) {
continue;
}
if (end.equals(fx, fy)) {
end.parent = node;
flag = false;
break;
}
if (containClose(fx, fy)) {
continue;
}
if (containOpen(fx, fy)) {
Node node3 = getOpen(fx, fy);
if (node.G + 10 < node3.G) {
node3.parent = node;
node3.G = node.G + 10;
node3.F = node3.G + node3.H;
}
continue;
}
if (Arrays.binarySearch(isPass, map[fy][fx]) >= 0) {
Node node2 = new Node(fx, fy);
node2.parent = node;
node2.G = node.G + 10;
// 采用manhattan启发算法 两点中的直角 距离
node2.H = Math.abs((ex - fx + ey - fy) * 10);
node2.F = node2.G + node2.H;
OpenList.add(node2);
}
}
if (flag == false) {
break;
}
if (OpenList.size() == 0) {
return null;
}
node = MinF(OpenList);
OpenList.remove(node);
CloseList.add(node);
}
ArrayList<Node> Path = new ArrayList<Node>();
node = end;
while (node.parent != null) {
Path.add(node);
node = node.parent;
}
return Path;
}
void updateForDelete(Node node) {
try {
if (node.equals(nextnode)) {
nextnode = index.next(node);
}
} catch (Exception e) {
}
}
/**
* Simple A*. Computes shortest paths to all reachable nodes from the source node given. This
* method will cache the result so that if it is called later on the same node and nothing has
* been changed (no nodes added or removed), it will not compute the result again, but will return
* the cached value.
*
* @param source
* @return
*/
public Map<Node, Route> computeShortestRoutes(Node source) {
// Don't perform calculation if it's been done before and nothings changed
if (!dirty && (shortestRoutesCache.get(source) != null)) {
return shortestRoutesCache.get(source);
}
List<Node> nodes = new LinkedList<Node>();
Map<Node, Integer> weights = new HashMap<Node, Integer>();
Map<Node, Node> prevNodes = new HashMap<Node, Node>();
weights.put(source, 0);
// Initialize all nodes to have effectively infinite distance
for (Node node : allNodes) {
if (!node.equals(source)) {
weights.put(node, Integer.MAX_VALUE);
prevNodes.put(node, null);
}
nodes.add(node);
}
// A*
while (!nodes.isEmpty()) {
Node node = findMinimum(nodes, weights);
if (weights.get(node).equals(Integer.MAX_VALUE)) {
continue;
}
for (Node neighbor : node.getNeighbors()) {
Integer alternateWeight = weights.get(node) + node.getEdgeForNeighbor(neighbor).getWeight();
if (alternateWeight < weights.get(neighbor)) {
weights.put(neighbor, alternateWeight);
prevNodes.put(neighbor, node);
}
}
}
List<Node> unreachableNodes = new ArrayList<Node>();
for (Map.Entry<Node, Integer> entry : weights.entrySet()) {
if (entry.getValue().equals(Integer.MAX_VALUE)) {
unreachableNodes.add(entry.getKey());
}
}
for (Node unreachableNode : unreachableNodes) {
weights.remove(unreachableNode);
}
Map<Node, Route> routeMap = makeRouteMap(source, weights, prevNodes);
// Cache result
shortestRoutesCache.put(source, routeMap);
dirty = Boolean.FALSE;
return routeMap;
}
/** Add After */
protected void addAfter(Node<T> current, T element) {
if (current.equals(last)) {
addLast(element);
} else {
Node<T> node = new Node<T>(element, current, current.getAfter());
current.getAfter().setBefore(node);
current.setAfter(node);
}
}
/**
* determines if the provided Node is the parent, or parent's parent, etc. of this Spatial.
*
* @param ancestor the ancestor object to look for.
* @return true if the ancestor is found, false otherwise.
*/
public boolean hasAncestor(Node ancestor) {
if (parent == null) {
return false;
} else if (parent.equals(ancestor)) {
return true;
} else {
return parent.hasAncestor(ancestor);
}
}
/**
* Replies true if this way contains the node <code>node</code>, false otherwise. Replies false if
* <code>node</code> is null.
*
* @param node the node. May be null.
* @return true if this way contains the node <code>node</code>, false otherwise
* @since 1911
*/
public boolean containsNode(Node node) {
if (node == null) return false;
Node[] nodes = this.nodes;
for (Node n : nodes) {
if (n.equals(node)) return true;
}
return false;
}
/* initialize nodes and links. the graph is complete ! :) */
public void initRandomGraph(Integer xMax, Integer yMax, Integer nbNode) {
Random rand = new Random();
/* init nodes at random positions */
for (Integer i = 0; i < nbNode; i++) {
Integer x = rand.nextInt(xMax);
Integer y = rand.nextInt(yMax);
Node n = new Node(x, y);
nodes.add(n);
}
/* remove nodes that unfortunately spawned at the exact same position */
List<Node> doublons = new ArrayList<Node>();
for (Node source : nodes) {
for (Node dest : nodes) {
if (!source.equals(dest)
&& source.getX().equals(dest.getX())
&& source.getY().equals(dest.getY())) {
doublons.add(source);
}
}
}
if (!doublons.isEmpty()) {
nodes.removeAll(doublons);
System.out.println(
"Lors de la génération aléatoire du graphes, "
+ doublons.size()
+ " doublons ont étés supprimés");
}
/* init links for a complete graph */
for (Node source : nodes) {
for (Node dest : nodes) {
if (!source.equals(dest)) {
Link link1 = new Link(source, dest);
source.getLinks().add(link1);
Link link2 = new Link(dest, source);
dest.getLinks().add(link2);
links.add(link1);
links.add(link2);
}
}
}
}
/**
* Tests equality over another {@code NodeRef} based on {@link #getParentPath() parent path},
* {@link #getNode() node} name and id, and {@link #getMetadataId()}
*/
@Override
public boolean equals(Object o) {
if (!(o instanceof NodeRef)) {
return false;
}
NodeRef r = (NodeRef) o;
return parentPath.equals(r.parentPath)
&& node.equals(r.node)
&& getMetadataId().equals(r.getMetadataId());
}
// Override 'equals' to be DOM-based...
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (!(o instanceof DOMBased)) {
return super.equals(o);
}
DOMBased db = (DOMBased) o;
Node dbNode = db.getDOMNode();
return dbNode.equals(getDOMNode());
}
/**
* Replace two nodes
*
* @param x node
* @param n node
* @throws HsqlException
*/
private void replace(Session session, Node x, Node n) throws HsqlException {
if (x.equals(getRoot(session))) {
setRoot(session, n);
if (n != null) {
n.setParent(null);
}
} else {
set(x.getParent(), x.isFromLeft(), n);
}
}
