Example usage for com.google.common.graph EndpointPair nodeV

Introduction

In this page you can find the example usage for com.google.common.graph EndpointPair nodeV.

Prototype

N nodeV

To view the source code for com.google.common.graph EndpointPair nodeV.

Click Source Link

Usage

From source file:org.jgrapht.graph.guava.MutableGraphAdapter.java

@Override
public boolean removeEdge(EndpointPair<V> e) {
    if (e == null) {
        return false;
    }/*from  w  w w .java  2s.  com*/
    return graph.removeEdge(e.nodeU(), e.nodeV());
}

---

From source file:edu.uci.ics.jung.visualization.renderers.ReshapingEdgeRenderer.java

/**
 * Draws the edge <code>e</code>, whose endpoints are at <code>(x1,y1)</code> and <code>(x2,y2)
 * </code>, on the graphics context <code>g</code>. The <code>Shape</code> provided by the <code>
 * EdgeShapeFunction</code> instance is scaled in the x-direction so that its width is equal to
 * the distance between <code>(x1,y1)</code> and <code>(x2,y2)</code>.
 *///from   w w w .  j  a  v  a 2  s .c o  m
protected void drawSimpleEdge(RenderContext<N, E> renderContext, VisualizationModel<N, E> visualizationModel,
        E e) {

    TransformingGraphics g = (TransformingGraphics) renderContext.getGraphicsContext();
    Network<N, E> graph = visualizationModel.getNetwork();
    EndpointPair<N> endpoints = graph.incidentNodes(e);
    N v1 = endpoints.nodeU();
    N v2 = endpoints.nodeV();
    Point p1 = visualizationModel.getLayoutModel().apply(v1);
    Point p2 = visualizationModel.getLayoutModel().apply(v2);
    Point2D p12d = renderContext.getMultiLayerTransformer().transform(Layer.LAYOUT,
            new Point2D.Double(p1.x, p1.y));
    Point2D p22d = renderContext.getMultiLayerTransformer().transform(Layer.LAYOUT,
            new Point2D.Double(p2.x, p2.y));
    float x1 = (float) p12d.getX();
    float y1 = (float) p12d.getY();
    float x2 = (float) p22d.getX();
    float y2 = (float) p22d.getY();

    float flatness = 0;
    MutableTransformer transformer = renderContext.getMultiLayerTransformer().getTransformer(Layer.VIEW);
    if (transformer instanceof LensTransformer) {
        LensTransformer ht = (LensTransformer) transformer;
        RectangularShape lensShape = ht.getLens().getLensShape();
        if (lensShape.contains(x1, y1) || lensShape.contains(x2, y2)) {
            flatness = .05f;
        }
    }

    boolean isLoop = v1.equals(v2);
    Shape s2 = renderContext.getNodeShapeFunction().apply(v2);
    Shape edgeShape = renderContext.getEdgeShapeFunction().apply(Context.getInstance(graph, e));

    AffineTransform xform = AffineTransform.getTranslateInstance(x1, y1);

    if (isLoop) {
        // this is a self-loop. scale it is larger than the node
        // it decorates and translate it so that its nadir is
        // at the center of the node.
        Rectangle2D s2Bounds = s2.getBounds2D();
        xform.scale(s2Bounds.getWidth(), s2Bounds.getHeight());
        xform.translate(0, -edgeShape.getBounds2D().getWidth() / 2);
    } else {
        // this is a normal edge. Rotate it to the angle between
        // node endpoints, then scale it to the distance between
        // the nodes
        float dx = x2 - x1;
        float dy = y2 - y1;
        float thetaRadians = (float) Math.atan2(dy, dx);
        xform.rotate(thetaRadians);
        float dist = (float) Math.sqrt(dx * dx + dy * dy);
        xform.scale(dist, 1.0);
    }

    edgeShape = xform.createTransformedShape(edgeShape);

    Paint oldPaint = g.getPaint();

    // get Paints for filling and drawing
    // (filling is done first so that drawing and label use same Paint)
    Paint fill_paint = renderContext.getEdgeFillPaintFunction().apply(e);
    if (fill_paint != null) {
        g.setPaint(fill_paint);
        g.fill(edgeShape, flatness);
    }
    Paint draw_paint = renderContext.getEdgeDrawPaintFunction().apply(e);
    if (draw_paint != null) {
        g.setPaint(draw_paint);
        g.draw(edgeShape, flatness);
    }

    float scalex = (float) g.getTransform().getScaleX();
    float scaley = (float) g.getTransform().getScaleY();
    // see if arrows are too small to bother drawing
    if (scalex < .3 || scaley < .3) {
        return;
    }

    if (renderContext.renderEdgeArrow()) {

        Shape destNodeShape = renderContext.getNodeShapeFunction().apply(v2);

        AffineTransform xf = AffineTransform.getTranslateInstance(x2, y2);
        destNodeShape = xf.createTransformedShape(destNodeShape);

        AffineTransform at = edgeArrowRenderingSupport.getArrowTransform(renderContext,
                new GeneralPath(edgeShape), destNodeShape);
        if (at == null) {
            return;
        }
        Shape arrow = renderContext.getEdgeArrow();
        arrow = at.createTransformedShape(arrow);
        g.setPaint(renderContext.getArrowFillPaintFunction().apply(e));
        g.fill(arrow);
        g.setPaint(renderContext.getArrowDrawPaintFunction().apply(e));
        g.draw(arrow);

        if (!graph.isDirected()) {
            Shape nodeShape = renderContext.getNodeShapeFunction().apply(v1);
            xf = AffineTransform.getTranslateInstance(x1, y1);
            nodeShape = xf.createTransformedShape(nodeShape);

            at = edgeArrowRenderingSupport.getReverseArrowTransform(renderContext, new GeneralPath(edgeShape),
                    nodeShape, !isLoop);
            if (at == null) {
                return;
            }
            arrow = renderContext.getEdgeArrow();
            arrow = at.createTransformedShape(arrow);
            g.setPaint(renderContext.getArrowFillPaintFunction().apply(e));
            g.fill(arrow);
            g.setPaint(renderContext.getArrowDrawPaintFunction().apply(e));
            g.draw(arrow);
        }
    }
    // use existing paint for text if no draw paint specified
    if (draw_paint == null) {
        g.setPaint(oldPaint);
    }

    // restore old paint
    g.setPaint(oldPaint);
}

---

From source file:org.jgrapht.graph.guava.BaseGraphAdapter.java

@Override
public double getEdgeWeight(EndpointPair<V> e) {
    if (e == null) {
        throw new NullPointerException();
    } else if (!graph.hasEdgeConnecting(e.nodeU(), e.nodeV())) {
        throw new IllegalArgumentException("no such edge in graph: " + e.toString());
    } else {// w  w w  .  j  ava  2 s. c  o m
        return Graph.DEFAULT_EDGE_WEIGHT;
    }
}

---

From source file:org.jgrapht.graph.guava.MutableDoubleValueGraphAdapter.java

@Override
public void setEdgeWeight(EndpointPair<V> e, double weight) {
    if (e == null) {
        throw new NullPointerException();
    }/*from   w w  w.  j  a  v a  2  s . c  o  m*/
    if (!containsEdge(e)) {
        throw new IllegalArgumentException("no such edge in graph: " + e.toString());
    }
    super.valueGraph.putEdgeValue(e.nodeU(), e.nodeV(), weight);
}

---

From source file:edu.uci.ics.jung.layout.algorithms.FRLayoutAlgorithm.java

protected void calcAttraction(EndpointPair<N> endpoints) {
    N node1 = endpoints.nodeU();//  w  w  w  .  j a v a  2  s .  com
    N node2 = endpoints.nodeV();
    boolean v1_locked = layoutModel.isLocked(node1);
    boolean v2_locked = layoutModel.isLocked(node2);

    if (v1_locked && v2_locked) {
        // both locked, do nothing
        return;
    }
    Point p1 = layoutModel.apply(node1);
    Point p2 = layoutModel.apply(node2);
    if (p1 == null || p2 == null) {
        return;
    }
    double xDelta = p1.x - p2.x;
    double yDelta = p1.y - p2.y;

    double deltaLength = Math.max(EPSILON, Math.sqrt((xDelta * xDelta) + (yDelta * yDelta)));

    double force = (deltaLength * deltaLength) / attraction_constant;

    Preconditions.checkState(!Double.isNaN(force),
            "Unexpected mathematical result in FRLayout:calcPositions [force]");

    double dx = (xDelta / deltaLength) * force;
    double dy = (yDelta / deltaLength) * force;
    if (v1_locked == false) {
        Point fvd1 = getFRData(node1);
        frNodeData.put(node1, fvd1.add(-dx, -dy));
    }
    if (v2_locked == false) {
        Point fvd2 = getFRData(node2);
        frNodeData.put(node2, fvd2.add(dx, dy));
    }
}

---

From source file:edu.uci.ics.jung.visualization.renderers.BasicEdgeRenderer.java

@Override
public void paintEdge(RenderContext<N, E> renderContext, VisualizationModel<N, E> visualizationModel, E e) {
    GraphicsDecorator g2d = renderContext.getGraphicsContext();
    if (!renderContext.getEdgeIncludePredicate().test(e)) {
        return;//from  ww  w.  j  a  v a2s . c  o  m
    }

    // don't draw edge if either incident node is not drawn
    EndpointPair<N> endpoints = visualizationModel.getNetwork().incidentNodes(e);
    N u = endpoints.nodeU();
    N v = endpoints.nodeV();
    Predicate<N> nodeIncludePredicate = renderContext.getNodeIncludePredicate();
    if (!nodeIncludePredicate.test(u) || !nodeIncludePredicate.test(v)) {
        return;
    }

    Stroke new_stroke = renderContext.edgeStrokeFunction().apply(e);
    Stroke old_stroke = g2d.getStroke();
    if (new_stroke != null) {
        g2d.setStroke(new_stroke);
    }

    drawSimpleEdge(renderContext, visualizationModel, e);

    // restore paint and stroke
    if (new_stroke != null) {
        g2d.setStroke(old_stroke);
    }
}

---

From source file:org.jgrapht.graph.guava.BaseValueGraphAdapter.java

@Override
public double getEdgeWeight(EndpointPair<V> e) {
    if (e == null) {
        throw new NullPointerException();
    } else if (!valueGraph.hasEdgeConnecting(e.nodeU(), e.nodeV())) {
        throw new IllegalArgumentException("no such edge in graph: " + e.toString());
    } else {/*  w ww. j  av  a  2  s  .c  o  m*/
        return valueGraph.edgeValue(e.nodeU(), e.nodeV()).map(valueConverter::applyAsDouble)
                .orElse(Graph.DEFAULT_EDGE_WEIGHT);
    }
}

---

From source file:edu.uci.ics.jung.layout.algorithms.SpringLayoutAlgorithm.java

protected void relaxEdges() {
    Graph<N> graph = layoutModel.getGraph();
    try {/* ww  w .ja  v a 2s.  c  om*/
        for (EndpointPair<N> endpoints : layoutModel.getGraph().edges()) {
            N node1 = endpoints.nodeU();
            N node2 = endpoints.nodeV();

            Point p1 = this.layoutModel.get(node1);
            Point p2 = this.layoutModel.get(node2);
            if (p1 == null || p2 == null) {
                continue;
            }
            double vx = p1.x - p2.x;
            double vy = p1.y - p2.y;
            double len = Math.sqrt(vx * vx + vy * vy);

            double desiredLen = lengthFunction.apply(endpoints);

            // round from zero, if needed [zero would be Bad.].
            len = (len == 0) ? .0001 : len;

            double f = force_multiplier * (desiredLen - len) / len;
            f = f * Math.pow(stretch, (graph.degree(node1) + graph.degree(node2) - 2));

            // the actual movement distance 'dx' is the force multiplied by the
            // distance to go.
            double dx = f * vx;
            double dy = f * vy;
            SpringNodeData v1D, v2D;
            v1D = springNodeData.getUnchecked(node1);
            v2D = springNodeData.getUnchecked(node2);
            v1D.edgedx += dx;
            v1D.edgedy += dy;
            v2D.edgedx += -dx;
            v2D.edgedy += -dy;
        }
    } catch (ConcurrentModificationException cme) {
        relaxEdges();
    }
}

---

From source file:org.jgrapht.graph.guava.MutableValueGraphAdapter.java

@Override
public boolean removeEdge(EndpointPair<V> e) {
    if (e == null) {
        return false;
    }/*from w  w  w  .j  a va 2 s . c  om*/
    return valueGraph.removeEdge(e.nodeU(), e.nodeV()) != null;
}

---

From source file:edu.uci.ics.jung.layout.algorithms.DAGLayoutAlgorithm.java

/**
 * Overridden relaxEdges. This one reduces the effect of edges between greatly different levels.
 *///  ww  w. ja va2 s.c om
@Override
protected void relaxEdges() {
    Graph<N> graph = layoutModel.getGraph();
    for (EndpointPair<N> endpoints : graph.edges()) {
        N node1 = endpoints.nodeU();
        N node2 = endpoints.nodeV();

        Point p1 = layoutModel.apply(node1);
        Point p2 = layoutModel.apply(node2);
        double vx = p1.x - p2.x;
        double vy = p1.y - p2.y;
        double len = Math.sqrt(vx * vx + vy * vy);

        // JY addition.
        int level1 = minLevels.get(node1).intValue();
        int level2 = minLevels.get(node2).intValue();

        double desiredLen = lengthFunction.apply(endpoints);

        // round from zero, if needed [zero would be Bad.].
        len = (len == 0) ? .0001 : len;

        // force factor: optimal length minus actual length,
        // is made smaller as the current actual length gets larger.
        // why?

        double f = force_multiplier * (desiredLen - len) / len;

        f = f * Math.pow(stretch / 100.0, (graph.degree(node1) + graph.degree(node2) - 2));

        // JY addition. If this is an edge which stretches a long way,
        // don't be so concerned about it.
        if (level1 != level2) {
            f = f / Math.pow(Math.abs(level2 - level1), 1.5);
        }

        // the actual movement distance 'dx' is the force multiplied by the
        // distance to go.
        double dx = f * vx;
        double dy = f * vy;
        SpringNodeData v1D, v2D;
        v1D = springNodeData.getUnchecked(node1);
        v2D = springNodeData.getUnchecked(node2);

        v1D.edgedx += dx;
        v1D.edgedy += dy;
        v2D.edgedx += -dx;
        v2D.edgedy += -dy;
    }
}

---

• «
• 1
• 2
• 3
• »