Refine search
private void renderService(Graph g, Service service, Label label) { Node n = g.addNode(makeId(service.getId(), service.getLocation().getId())); if (label.equals(Label.ID)) n.addAttribute("ui.label", service.getId()); n.addAttribute("x", service.getLocation().getCoordinate().getX()); n.addAttribute("y", service.getLocation().getCoordinate().getY()); if (service.getType().equals("pickup")) n.setAttribute("ui.class", "pickup"); if (service.getType().equals("delivery")) n.setAttribute("ui.class", "delivery"); }
private void removeNodeAndBelongingEdges(String nodeId, VehicleRoute fromRoute) { Node node = graph.getNode(nodeId); markRemoved(node); Edge entering = getEnteringEdge(nodeId); removeEdge(entering.getId()); if (node.getLeavingEdgeSet().isEmpty()) { if (fromRoute.getVehicle().isReturnToDepot()) throw new IllegalStateException("leaving edge is missing"); return; } Edge leaving = getLeavingEdge(nodeId); removeEdge((leaving.getId())); Node from = entering.getNode0(); Node to = leaving.getNode1(); if (!fromRoute.getActivities().isEmpty()) { addEdge(makeEdgeId(from, to), from.getId(), to.getId()); } }
/** * The sigma value of the given node. * * @param node * Extract the sigma value of this node. * @return The sigma value. */ protected double sigma(Node node) { return node.getNumber(sigmaAttributeName); }
// let n be the clicked node... Iterator<Node> it = n.getBreadthFirstIterator(true); while(it.hasNext()){ Node m = it.next(); for(Edge e : m.getLeavingEdgeSet()) { e.setAttribute("ui.hide"); } if(n != m) { m.setAttribute("ui.hide"); } }
protected double findPath(LinkedList<Node> path, Node source, Node target) { LinkedList<Node> Q = new LinkedList<Node>(); Node u; int[] P = new int[source.getGraph().getNodeCount()]; double[] M = new double[source.getGraph().getNodeCount()]; double r; P[source.getIndex()] = -2; M[source.getIndex()] = Double.MAX_VALUE; Q.add(source); while (Q.size() > 0) { u = Q.pop(); for (int i = 0; i < u.getDegree(); i++) { Edge e = u.getEdge(i); Node v = e.getOpposite(u); if (r > 0 && P[v.getIndex()] == -1) { P[v.getIndex()] = u.getIndex(); M[v.getIndex()] = Math.min(M[u.getIndex()], r); path.addFirst(u); u = flowGraph.getNode(P[u.getIndex()]); } while (u != source); path.addFirst(u); return M[target.getIndex()];
public Iterator<Node> getBreadthFirstIterator(boolean directed) { LinkedList<Node> l = new LinkedList<Node>(); Iterator<Node> it; elementLock.lock(); sg.elementLock.lock(); it = wrappedElement.getBreadthFirstIterator(directed); while (it.hasNext()) l.add(sg.getNode(it.next().getIndex())); sg.elementLock.unlock(); elementLock.unlock(); return l.iterator(); }
public void compute() { Node source = flowGraph.getNode(sourceId); Node sink = flowGraph.getNode(sinkId); if (source == null) throw new ElementNotFoundException("node \"%s\"", sourceId); if (sink == null) throw new ElementNotFoundException("node \"%s\"", sinkId); checkArrays(); loadCapacitiesFromAttribute(); for (int i = 0; i < flowGraph.getEdgeCount(); i++) { Edge e = flowGraph.getEdge(i); setFlow(e.getNode0(), e.getNode1(), 0); setFlow(e.getNode1(), e.getNode0(), 0); } double minCf; LinkedList<Node> path = new LinkedList<Node>(); while ((minCf = findPath(path, source, sink)) > 0) { for (int i = 1; i < path.size(); i++) { Node u = path.get(i - 1); Node v = path.get(i); setFlow(u, v, getFlow(u, v) + minCf); setFlow(v, u, getFlow(v, u) - minCf); } path.clear(); } double flow = 0; for (int i = 0; i < source.getDegree(); i++) flow += getFlow(source, source.getEdge(i).getOpposite(source)); maximumFlow = flow; }
public void nodeAttributeChanged(String sourceId, long timeId, String nodeId, String attribute, Object oldValue, Object newValue) { Event e; e = new AttributeChanged(ElementType.NODE, nodeId, attribute, newValue, g.getNode(nodeId).getAttribute(attribute)); events.add(e); }
public void edgeRemoved(String sourceId, long timeId, String edgeId) { Edge edge = g.getEdge(edgeId); for (String key : edge.getAttributeKeySet()) edgeAttributeRemoved(sourceId, timeId, edgeId, key); Event e; e = new EdgeRemoved(edgeId, edge.getSourceNode().getId(), edge .getTargetNode().getId(), edge.isDirected()); events.add(e); }
public Iterator<Node> getNeighborNodeIterator() { ArrayList<Node> l; Iterator<Node> it; elementLock.lock(); sg.elementLock.lock(); l = new ArrayList<Node>(wrappedElement.getDegree()); it = wrappedElement.getNeighborNodeIterator(); while (it.hasNext()) l.add(sg.getNode(it.next().getIndex())); sg.elementLock.unlock(); elementLock.unlock(); return l.iterator(); }
public Collection<Edge> getEdgeSet() { ArrayList<Edge> l; Iterator<Edge> it; elementLock.lock(); l = new ArrayList<Edge>(wrappedElement.getDegree()); it = wrappedElement.getEachEdge().iterator(); while (it.hasNext()) l.add(sg.getEdge(it.next().getIndex())); elementLock.unlock(); return l; }
protected double findPath(LinkedList<Node> path, Node source, Node target) { path.addLast(source); if (source == target) return Double.MAX_VALUE; double minCf; for (int i = 0; i < source.getDegree(); i++) { Edge e = source.getEdge(i); Node o = e.getOpposite(source); if (getCapacity(source, o) - getFlow(source, o) > 0 && !path.contains(o)) { if ((minCf = findPath(path, o, target)) > 0) return Math.min(minCf, getCapacity(source, o) - getFlow(source, o)); } } path.removeLast(); return 0; } }
SynchronizedGraph(Graph g) { super(g); elementLock = new ReentrantLock(); synchronizedNodes = new HashMap<String, Node>(); synchronizedEdges = new HashMap<String, Edge>(); for (Node n : g.getEachNode()) synchronizedNodes.put(n.getId(), new SynchronizedNode(this, n)); for (Edge e : g.getEachEdge()) synchronizedEdges.put(e.getId(), new SynchronizedEdge(this, e)); }
/** * Increment the count of the given node and edge. * @param e The edge. * @param n The node. */ protected void addPass(Edge e, Node n) { e.setAttribute(context.passesAttribute, e.getNumber(context.passesAttribute) + 1); n.setAttribute(context.passesAttribute, n.getNumber(context.passesAttribute) + 1); }
public void nodeRemoved(String sourceId, long timeId, String nodeId) { // removed node will give equal parts of its rank to the others double part = graph.getNode(nodeId).getNumber(rankAttribute) / (graph.getNodeCount() - 1); for (Node node : graph) if (!node.getId().equals(nodeId)) node.addAttribute(rankAttribute, node.getNumber(rankAttribute) + part); upToDate = false; }
private void markPickup(String id) { graph.getNode(id).addAttribute("ui.class", "pickup"); }
protected void publishPositions() { for (Node n : internalGraph) { if (n.hasAttribute("changed")) { n.removeAttribute("changed"); sendNodeAttributeChanged(sourceId, n.getId(), "xyz", null, new double[] { n.getNumber("x"), n.getNumber("y"), 0 }); } } }
protected void setBox(Box box, Node node) { if (node.hasAttribute("box")) getBox(node).remove(node); box.add(node); node.setAttribute("box", box); if (!node.hasAttribute("children")) node.addAttribute("children", new Box(node, 1)); getChildrenBox(node).level = box.level + 1; }