/** * Method to find the Euler Tour based on the Hierholzer's algorithm. * * @param g : Input graph for which the tour is to be found. * @return : Returns a list of edges that comprises of the Euler Tour. */ public static List<Edge> findEulerTour(Graph<Vertex> g) { Vertex start = g.verts.get(1); Stack<Edge> forward = new Stack<Edge>(); Stack<Edge> backtrack = new Stack<Edge>(); Edge e = getUnvisitedEdge(start); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } while (!(forward.isEmpty())) { e = forward.pop(); backtrack.push(e); e = getUnvisitedEdge(e.From); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } } List<Edge> path = new LinkedList<Edge>(); while (!backtrack.isEmpty()) { Edge edge = backtrack.pop(); path.add(edge); } return path; }
/** * Sets the covariance for the a<->b edge to the given covariance, if within range. Otherwise does * nothing. * * @param a a <-> b * @param b a <-> b * @param covar The covariance of a <-> b. * @return true if the coefficent was set (i.e. was within range), false if not. */ public boolean setErrorCovariance(Node a, Node b, final double covar) { Edge edge = Edges.bidirectedEdge(semGraph.getExogenous(a), semGraph.getExogenous(b)); if (edgeParameters.get(edge) == null) { throw new IllegalArgumentException("Not a covariance parameter in this model: " + edge); } if (editingEdge == null || !edge.equals(editingEdge)) { range = getParameterRange(edge); editingEdge = edge; } if (covar > range.getLow() && covar < range.getHigh()) { edgeParameters.put(edge, covar); return true; } else { return false; } // if (!paramInBounds(edge, coef)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, coef); // return true; // if (!paramInBounds(edge, covar)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, covar); // return true; }
public List<Lockset> getLockSets(Lockset ls) { for (Edge edge : edges) { if (edge.getEntry_lockset().equals(ls)) return edge.getExit_locksets(); } return null; }
@Override public void paintComponent(Graphics g) { super.paintComponent(g); // render all of the edges for (Edge e : graphEdges) e.render(g); }
/** Specified in Node */ protected Node removeNeighbour(Node neighbour) { Iterator it = edges.iterator(); Edge next; while (it.hasNext()) { next = (Edge) it.next(); if (next.to == neighbour) { it.remove(); break; } } // collapse this node if it has degree 2 after removal of neighbour if (edges.size() == 2) { Edge e1 = (Edge) edges.getFirst(); Edge e2 = (Edge) edges.getLast(); Edge ne1, ne2; ne1 = e1.to.addNeighbour(e2.to); ne2 = e2.to.addNeighbour(e1.to); ne1.backedge = ne2; ne2.backedge = ne1; e1.to.removeNeighbour(this); return e2.to.removeNeighbour(this); } return this; }
public void testAddingSelfLoops() { Graph graph = graphTest.getGraphInstance(); if (graphTest.allowsSelfLoops) { List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); graph.addEdge(null, v1, v1, convertId("is_self")); graph.addEdge(null, v2, v2, convertId("is_self")); graph.addEdge(null, v3, v3, convertId("is_self")); if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graphTest.supportsEdgeIteration) { assertEquals(3, count(graph.getEdges())); int counter = 0; for (Edge edge : graph.getEdges()) { counter++; assertEquals(edge.getInVertex(), edge.getOutVertex()); assertEquals(edge.getInVertex().getId(), edge.getOutVertex().getId()); } assertEquals(counter, 3); } } graph.shutdown(); }
/** This scales all the x values to be between 0 and 1. */ private void scaleByMax() { // ammendment to what i may have commented before // this takes the lowest x and highest x and uses that as the scaling // factor double l_x = 5000, h_x = -5000; for (int noa = 0; noa < m_groupNum; noa++) { if (l_x > m_groups[noa].m_left) { l_x = m_groups[noa].m_left; } if (h_x < m_groups[noa].m_right) { h_x = m_groups[noa].m_right; } } Edge e; Node r, s; double m_scale = h_x - l_x + 1; if (m_groupNum > 0) { r = m_groups[0].m_p; r.setCenter((r.getCenter() - l_x) / m_scale); // System.out.println("from scaler " + l_x + " " + m_scale); for (int noa = 0; noa < m_groupNum; noa++) { r = m_groups[noa].m_p; for (int nob = 0; (e = r.getChild(nob)) != null; nob++) { s = e.getTarget(); if (s.getParent(0) == e) { s.setCenter((s.getCenter() - l_x) / m_scale); } } } } }
@Override public boolean hasNext() { // Multiple hasNext calls with no next...hasNext still true if (nextEdge != null) return true; while (internalIterator.hasNext()) { Edge edge = internalIterator.next(); Object edgeType = edge.getType(); if (negate) { // When edgeType or type is null compare them directly. Otherwise compare them using equals if ((edgeType != null && !edgeType.equals(type)) || (edgeType == null && edgeType != type)) { nextEdge = edge; return true; } // When edgeType or type is null compare them directly. Otherwise compare them using equals } else if ((edgeType != null && edgeType.equals(type)) || (edgeType == null && edgeType == type)) { nextEdge = edge; return true; } } return false; }
/** * It returns the sum of the <code>characteristic</code> given value in the Edges of the path. * * @param characteristic The characteristic. * @return Sum of the characteristics. */ public Double getPathWeight(String characteristic) { double d = 0; for (Edge l : edgePath) { d += (Double) l.getAttribute(characteristic, Number.class); } return d; }
private void saveMenuItemActionPerformed( java.awt.event.ActionEvent evt) { // GEN-FIRST:event_saveMenuItemActionPerformed this.jTextStatus.setText(""); if (this.pnGraph.listEdges.isEmpty() && this.pnGraph.listVertexs.isEmpty()) { this.jTextStatus.setText("Empty graph, not save"); return; } if (this.jSaveFileChooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) { File file = this.jSaveFileChooser.getSelectedFile(); try { BufferedWriter output = new BufferedWriter(new FileWriter(file)); try { for (Vertex Vertex : this.pnGraph.listVertexs) { output.write( String.format( "Vertex:%d:%d:%d", Vertex.getData(), Vertex.getX_cor(), Vertex.getY_cor())); output.newLine(); } for (Edge edge : this.pnGraph.listEdges) { output.write( String.format( "Edge:%d:%d:%d", edge.getHead().getData(), edge.getTail().getData(), edge.getLength())); output.newLine(); } this.jTextStatus.setText("Save graph successfully"); } finally { output.close(); } } catch (IOException e) { } } } // GEN-LAST:event_saveMenuItemActionPerformed
protected JPanel getMainPanel() { JPanel panel = new JPanel(); String cols = "5dlu, fill:pref:grow, 5dlu, fill:pref:grow, 5dlu"; String rows = "5dlu, pref, 5dlu, pref, 5dlu"; FormLayout layout = new FormLayout(cols, rows); panel.setLayout(layout); CellConstraints cc = new CellConstraints(); panel.add(new JLabel("Weight for edge:"), cc.xy(2, 2)); String text = edge.getWS(); tf = new JTextField(text); tf.addActionListener(this); panel.add(tf, cc.xy(4, 2)); jcbAnchored.addActionListener(this); jcbAnchored.setSelected(edge.isFixed()); if (!Configuration.getInstance().getGeneralConfig().getUnAnchor()) { panel.add(jcbAnchored, cc.xyw(2, 4, 3)); } return panel; }
/** * Get the nodes at the other ends of outgoing edges of this node. * * @return a list of child nodes */ public List<Node> getChildNodes() { LinkedList<Node> childNodes = new LinkedList<Node>(); for (Edge edge : leavingEdges) { childNodes.add(edge.getToNode()); } return childNodes; }
@Test public void testDistance() { Node n1 = new Node(0, 0, 0); Node n2 = new Node(0, 1, 1); Edge e1 = new Edge(n1, n2); Assert.assertEquals(e1.getDistance(), 1, DELTA); n1 = new Node(0, 0, 0); n2 = new Node(0, 0, 1); Edge e2 = new Edge(n1, n2); Assert.assertEquals(e2.getDistance(), 0, DELTA); n1 = new Node(2, -1, 0); n2 = new Node(-2, 2, 1); Edge e3 = new Edge(n1, n2); Assert.assertEquals(e3.getDistance(), 5, DELTA); n1 = new Node(3, 5, 0); n2 = new Node(1, 2, 1); Edge e4 = new Edge(n1, n2); Assert.assertEquals(e4.getDistance(), 4, DELTA); n1 = new Node(3, 5, 0); n2 = new Node(1, 1, 1); Edge e5 = new Edge(n1, n2); Assert.assertEquals(e5.getDistance(), 4, DELTA); }
@Override public Boolean call() throws Exception { GraphManager manager = factory.createEdgeManager(scope); final long startTime = System.currentTimeMillis(); for (long i = 0; i < writeLimit || System.currentTimeMillis() - startTime < minExecutionTime; i++) { Edge edge = generator.newEdge(); Edge returned = manager.writeEdge(edge).toBlocking().last(); assertNotNull("Returned has a version", returned.getTimestamp()); writeMeter.mark(); writeCounter.incrementAndGet(); if (i % 1000 == 0) { logger.info(" Wrote: " + i); } } return true; }
@Override public void remove(I targetVertexId) { // Note that this is very expensive (deserializes all edges). ByteArrayEdgeIterator iterator = new ByteArrayEdgeIterator(); List<Integer> foundStartOffsets = new LinkedList<Integer>(); List<Integer> foundEndOffsets = new LinkedList<Integer>(); int lastStartOffset = 0; while (iterator.hasNext()) { Edge<I, E> edge = iterator.next(); if (edge.getTargetVertexId().equals(targetVertexId)) { foundStartOffsets.add(lastStartOffset); foundEndOffsets.add(iterator.extendedDataInput.getPos()); --edgeCount; } lastStartOffset = iterator.extendedDataInput.getPos(); } foundStartOffsets.add(serializedEdgesBytesUsed); Iterator<Integer> foundStartOffsetIter = foundStartOffsets.iterator(); Integer foundStartOffset = foundStartOffsetIter.next(); for (Integer foundEndOffset : foundEndOffsets) { Integer nextFoundStartOffset = foundStartOffsetIter.next(); System.arraycopy( serializedEdges, foundEndOffset, serializedEdges, foundStartOffset, nextFoundStartOffset - foundEndOffset); serializedEdgesBytesUsed -= foundEndOffset - foundStartOffset; foundStartOffset = nextFoundStartOffset; } }
/** * Returns the edge between a and b, if one exists and it is live. Returns null otherwise * * @param a Int specifying a node * @param b Int specifying a node * @return The live edge between a and b. If one does not exist then null is returned */ public Edge getLiveEdge(int a, int b) { Edge e = getEdge(a, b); if (e == null || !e.isLive() || !this.isNodeAlive(a) || !this.isNodeAlive(b)) { return null; } return e; }
@Override public void addEdge(Edge edge) { checkInTransaction(); if (edge == null) { throw new IllegalArgumentException("edge must not be null"); } Vertex source = edge.getSource(); Vertex target = edge.getTarget(); // Validate to ensure the model does not become corrupted. int si = vertexList.indexOf(source); int ti = vertexList.indexOf(target); if (si == -1 || ti == -1 || si >= adjacencies.size() || ti >= adjacencies.size()) { throw new IllegalStateException("vertices not in model"); } if (source.equals(target)) { throw new IllegalStateException("edge endpoints are same"); } if (findEdge(source, target) != null || (!edge.isDirected() && findEdge(target, source) != null)) { throw new IllegalArgumentException("edge already exists"); } // Add the new edge to the list and make the source vertex // adjacent to the target vertex. If the edge is undirected, // then make target adjacent to source, as well. edgeList.add(edge); addAdjacency(source, target); if (!edge.isDirected()) { addAdjacency(target, source); } fireModelEvent(new ModelEvent(this, ModelEventType.EDGE_ADDED)); fireUndoableEdit(new EdgeAddUndoableEdit(this, edge)); }
// min costs or -1 if flow not feasible // graph is changed int getMinCostFlow(Map<Integer, Edge>[] graph, int start, int goal, int flowSize) { int res = 0; while (flowSize > 0) { ShortestWayResult shortest = getShortestWay(graph, start, goal); if (shortest == null) // Fehler, flow not feasible return -1; // Update way int newFlow = Math.min(shortest.minCapacity, flowSize); flowSize -= newFlow; res += shortest.costForOne * newFlow; Iterator<Integer> it = shortest.way.iterator(); int akt = it.next(); while (it.hasNext()) { int next = it.next(); Edge e = graph[akt].remove(next); e.capacity -= newFlow; if (e.capacity > 0) graph[akt].put(next, e); Edge edge = graph[next].get(akt); if (edge == null) { Edge newEdge = new Edge(newFlow, -e.cost); graph[next].put(akt, newEdge); } else { edge.capacity += newFlow; } akt = next; } } return res; }
/** * This will set initial places for the x coord of the nodes. * * @param start The `number for the first group to start on (I think). */ private void xPlacer(int start) { // this can be one of a few x_placers (the first) // it will work by placing 1 space inbetween each node // ie the first at 0 the second at 1 and so on // then it will add to this value the place of the parent // node - half of the size // i will break this up into several functions // first the gap setter; // then the shifter // it will require a vector shift function added to the node class // i will write an additional shifter for the untangler // for its particular situation Node r; Edge e; if (m_groupNum > 0) { m_groups[0].m_p.setCenter(0); for (int noa = start; noa < m_groupNum; noa++) { int nob, alter = 0; double c = m_groups[noa].m_gap; r = m_groups[noa].m_p; for (nob = 0; (e = r.getChild(nob)) != null; nob++) { if (e.getTarget().getParent(0) == e) { e.getTarget().setCenter(nob * c); } else { alter++; } } m_groups[noa].m_size = (nob - 1 - alter) * c; xShift(noa); } } }
private void visit(Set<Edge> visited) { boolean fixpoint = false; while (!fixpoint) { fixpoint = true; Vector<Vector<Edge>> newPaths = new Vector<Vector<Edge>>(); Vector<Vector<Edge>> delPaths = new Vector<Vector<Edge>>(); for (Vector<Edge> path : paths) { Edge e = path.lastElement(); boolean pathExtended = false; for (Edge succ : e.getTarget().getSucc()) { if (!visited.contains(succ)) { Vector<Edge> newPath = new Vector<Edge>(); newPath.addAll(path); newPath.add(succ); newPaths.add(newPath); visited.add(succ); pathExtended = true; fixpoint = false; } } if (pathExtended) delPaths.add(path); } for (Vector<Edge> path : delPaths) paths.remove(path); paths.addAll(newPaths); } }
/** * This scales the x values to between 0 and 1 for each individual line rather than doing them all * at once. */ private void scaleByInd() { // ammendment to what i may have commented before // this takes the lowest x and highest x on each line and uses that for // the line in question double l_x, h_x; Edge e; Node r, s; r = m_groups[0].m_p; r.setCenter(.5); double m_scale; for (int noa = 0; noa < m_levelNum; noa++) { l_x = m_groups[m_levels[noa].m_start].m_left; h_x = m_groups[m_levels[noa].m_end].m_right; m_scale = h_x - l_x + 1; for (int nob = m_levels[noa].m_start; nob <= m_levels[noa].m_end; nob++) { r = m_groups[nob].m_p; for (int noc = 0; (e = r.getChild(noc)) != null; noc++) { s = e.getTarget(); if (s.getParent(0) == e) { s.setCenter((s.getCenter() - l_x) / m_scale); } } } } }
public void drawEdges(Graphics2D g) { synchronized (edges) { for (Edge e : edges) { e.drawLine(g); } } }
private void writeEdges(Writer writer, List<Edge> edges, Map<Vertex, Integer> ids) throws IOException { for (Edge e : edges) { writeEdgeProperties( writer, e, ids.get(e.getVertex(Direction.OUT)), ids.get(e.getVertex(Direction.IN))); } }
Site rightRegion(Halfedge he, Site bottomMostSite) { Edge edge = he.edge; if (edge == null) { return bottomMostSite; } return edge.site(LR.other(he.leftRight)); }
private Graph condense(Graph mimStructure, Graph mimbuildStructure) { // System.out.println("Uncondensed: " + mimbuildStructure); Map<Node, Node> substitutions = new HashMap<Node, Node>(); for (Node node : mimbuildStructure.getNodes()) { for (Node _node : mimStructure.getNodes()) { if (node.getName().startsWith(_node.getName())) { substitutions.put(node, _node); break; } substitutions.put(node, node); } } HashSet<Node> nodes = new HashSet<Node>(substitutions.values()); Graph graph = new EdgeListGraph(new ArrayList<Node>(nodes)); for (Edge edge : mimbuildStructure.getEdges()) { Node node1 = substitutions.get(edge.getNode1()); Node node2 = substitutions.get(edge.getNode2()); if (node1 == node2) continue; if (graph.isAdjacentTo(node1, node2)) continue; graph.addEdge(new Edge(node1, node2, edge.getEndpoint1(), edge.getEndpoint2())); } // System.out.println("Condensed: " + graph); return graph; }
public Graph orient() { Graph skeleton = GraphUtils.undirectedGraph(getPattern()); Graph graph = new EdgeListGraph(skeleton.getNodes()); List<Node> nodes = skeleton.getNodes(); // Collections.shuffle(nodes); if (isR1Done()) { ruleR1(skeleton, graph, nodes); } for (Edge edge : skeleton.getEdges()) { if (!graph.isAdjacentTo(edge.getNode1(), edge.getNode2())) { graph.addUndirectedEdge(edge.getNode1(), edge.getNode2()); } } if (isR2Done()) { ruleR2(skeleton, graph); } if (isMeekDone()) { new MeekRules().orientImplied(graph); } return graph; }
@Override public boolean next() { /* --- create the next extension */ Node s, d, p[]; /* to traverse/access the nodes */ Edge e; /* to traverse/access the edges */ /* --- continue an old extension --- */ if (((this.mode & EQVARS) != 0) && (this.pos1 >= 0) /* if there is another equivalent */ && this.variant()) /* variant of the previous ring, */ return true; /* return "extension successful" */ if (((this.mode & RING) != 0) && (this.all != 0) /* if there is another ring flag */ && this.ring()) /* and some ring is admissible, */ return true; /* return "extension successful" */ if (((this.mode & CHAIN) != 0) && (this.size == 0) /* if last extension was an edge and */ && this.chain()) /* it can be extended into a chain, */ return true; /* return "extension successful" */ /* --- find a new extension --- */ p = this.emb.nodes; /* get the nodes of the embedding */ s = p[this.src]; /* and the current anchor node */ while (true) { /* find the next unprocessed edge */ while (++this.idx >= s.deg) { if (++this.src >= p.length) { this.emb.mark(-1); /* if node's last edge is processed, */ return false; /* go to the next extendable node */ } /* and if there is none, abort */ s = p[this.src]; /* get the new anchor node and */ this.idx = -1; /* start with the first edge */ } e = s.edges[this.idx]; /* get the next edge of this node */ if (e.mark != -1) /* if the edge is in the embedding */ continue; /* or excluded, it cannot be added */ d = (s != e.src) ? e.src : e.dst; if ((d.mark < 0) /* if node is not in the embedding */ && (p.length + this.frag.chcnt >= this.max)) continue; /* check whether a new node is ok */ this.dst = (d.mark < 0) ? p.length : d.mark; if (this.dst <= this.src) /* skip edges closing a ring that */ continue; /* lead "backward" in the fragment */ this.nodes[0] = s; /* note the anchor node and the */ this.edges[0] = e; /* (first) edge of the extension */ this.nodes[1] = d; /* note the destination node */ if (e.isInRing() /* if a ring extension is possible */ && ((this.mode & RING) != 0)) { this.all = e.getRings(); /* note the ring flags and */ this.curr = 1; /* init. the current ring flag */ if (this.ring()) return true; continue; /* if some ring is admissible, */ } /* return "extension successful" */ if ((this.mode & EDGE) == 0) continue; /* check for edge extensions */ this.nodecnt = (d.mark < 0) ? 1 : 0; this.edgecnt = 1; /* zero/one new node, one new edge */ this.size = 0; /* clear the extension size */ this.chcnt = this.frag.chcnt; return true; /* copy the chain counter and */ } /* return "extension successful" */ } /* next() */
private void cornerEdgeCollision(Corner corner, Edge edge) { // check for the uphill vector of both edges being too similar (parallel // edges) // also rejects e == corner.nextL or corner.prevL // updated to take into account vertical edges - will always have same // uphill! - (so we check edge direction too) if ((edge.uphill.angle(corner.prevL.uphill) < 0.0001 && edge.direction().angle(corner.prevL.uphill) < 0.0001) || (edge.uphill.angle(corner.nextL.uphill) < 0.0001 && edge.direction().angle(corner.nextL.uphill) < 0.0001)) return; Tuple3d res = null; try { // sometimes locks up here if edge.linear form has NaN components. if (corner.prevL.linearForm.hasNaN() || corner.nextL.linearForm.hasNaN() || edge.linearForm.hasNaN()) throw new Error(); res = edge.linearForm.collide(corner.prevL.linearForm, corner.nextL.linearForm); } catch (Throwable f) { // trying to collide parallel-ish faces, don't bother // System.err.println( "didn't like colliding " + edge + " and " + // corner.prevL + " and " + corner.nextL ); return; } if (res != null) { // cheap reject: if collision is equal or below (not the correct // place to check) the corner, don't bother with it if (res.z < corner.z || res.z < edge.start.z) return; EdgeCollision ec = new EdgeCollision(new Point3d(res), corner.prevL, corner.nextL, edge); if (!skel.seen.contains(ec)) faceEvents.offer(ec); } }
public GraphIndex(Graph graph) { LOG.info("Indexing graph..."); for (String feedId : graph.getFeedIds()) { for (Agency agency : graph.getAgencies(feedId)) { Map<String, Agency> agencyForId = agenciesForFeedId.getOrDefault(feedId, new HashMap<>()); agencyForId.put(agency.getId(), agency); this.agenciesForFeedId.put(feedId, agencyForId); } } Collection<Edge> edges = graph.getEdges(); /* We will keep a separate set of all vertices in case some have the same label. * Maybe we should just guarantee unique labels. */ Set<Vertex> vertices = Sets.newHashSet(); for (Edge edge : edges) { vertices.add(edge.getFromVertex()); vertices.add(edge.getToVertex()); if (edge instanceof TablePatternEdge) { TablePatternEdge patternEdge = (TablePatternEdge) edge; TripPattern pattern = patternEdge.getPattern(); patternForId.put(pattern.code, pattern); } } for (Vertex vertex : vertices) { vertexForId.put(vertex.getLabel(), vertex); if (vertex instanceof TransitStop) { TransitStop transitStop = (TransitStop) vertex; Stop stop = transitStop.getStop(); stopForId.put(stop.getId(), stop); stopVertexForStop.put(stop, transitStop); stopsForParentStation.put(stop.getParentStation(), stop); } } for (TransitStop stopVertex : stopVertexForStop.values()) { Envelope envelope = new Envelope(stopVertex.getCoordinate()); stopSpatialIndex.insert(envelope, stopVertex); } for (TripPattern pattern : patternForId.values()) { patternsForFeedId.put(pattern.getFeedId(), pattern); patternsForRoute.put(pattern.route, pattern); for (Trip trip : pattern.getTrips()) { patternForTrip.put(trip, pattern); tripForId.put(trip.getId(), trip); } for (Stop stop : pattern.getStops()) { patternsForStop.put(stop, pattern); } } for (Route route : patternsForRoute.asMap().keySet()) { routeForId.put(route.getId(), route); } // Copy these two service indexes from the graph until we have better ones. calendarService = graph.getCalendarService(); serviceCodes = graph.serviceCodes; this.graph = graph; LOG.info("Done indexing graph."); }
/** * Sets the coefficient for the a->b edge to the given coefficient, if within range. Otherwise * does nothing. * * @param a a -> b * @param b a -> b * @param coef The coefficient of a -> b. * @return true if the coefficent was set (i.e. was within range), false if not. */ public boolean setEdgeCoefficient(Node a, Node b, final double coef) { Edge edge = Edges.directedEdge(a, b); if (edgeParameters.get(edge) == null) { throw new NullPointerException("Not a coefficient parameter in this model: " + edge); } if (editingEdge == null || !edge.equals(editingEdge)) { range = getParameterRange(edge); editingEdge = edge; } if (coef > range.getLow() && coef < range.getHigh()) { edgeParameters.put(edge, coef); return true; } return false; // if (!paramInBounds(edge, coef)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, coef); // return true; }