package prefuse.render; import java.awt.BasicStroke; import java.awt.Graphics2D; import java.awt.Polygon; import java.awt.Shape; import java.awt.geom.AffineTransform; import java.awt.geom.CubicCurve2D; import java.awt.geom.Line2D; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import prefuse.Constants; import prefuse.util.ColorLib; import prefuse.util.GraphicsLib; import prefuse.util.StrokeLib; import prefuse.visual.EdgeItem; import prefuse.visual.VisualItem; /** *
Renderer that draws edges as lines connecting nodes. Both * straight and curved lines are supported. Curved lines are drawn using * cubic Bezier curves. Subclasses can override the * {@link #getCurveControlPoints(EdgeItem, Point2D[], double, double, double, double)} * method to provide custom control point assignment for such curves.
* *This class also supports arrows for directed edges. See the * {@link #setArrowType(int)} method for more.
* * @version 1.0 * @author jeffrey heer */ public class EdgeRenderer extends AbstractShapeRenderer { public static final String EDGE_TYPE = "edgeType"; protected static final double HALF_PI = Math.PI / 2; protected Line2D m_line = new Line2D.Float(); protected CubicCurve2D m_cubic = new CubicCurve2D.Float(); protected int m_edgeType = Constants.EDGE_TYPE_LINE; protected int m_xAlign1 = Constants.CENTER; protected int m_yAlign1 = Constants.CENTER; protected int m_xAlign2 = Constants.CENTER; protected int m_yAlign2 = Constants.CENTER; protected double m_width = 1; protected float m_curWidth = 1; protected Point2D m_tmpPoints[] = new Point2D[2]; protected Point2D m_ctrlPoints[] = new Point2D[2]; protected Point2D m_isctPoints[] = new Point2D[2]; // arrow head handling protected int m_edgeArrow = Constants.EDGE_ARROW_FORWARD; protected int m_arrowWidth = 8; protected int m_arrowHeight = 12; protected Polygon m_arrowHead = updateArrowHead( m_arrowWidth, m_arrowHeight); protected AffineTransform m_arrowTrans = new AffineTransform(); protected Shape m_curArrow; /** * Create a new EdgeRenderer. */ public EdgeRenderer() { m_tmpPoints[0] = new Point2D.Float(); m_tmpPoints[1] = new Point2D.Float(); m_ctrlPoints[0] = new Point2D.Float(); m_ctrlPoints[1] = new Point2D.Float(); m_isctPoints[0] = new Point2D.Float(); m_isctPoints[1] = new Point2D.Float(); } /** * Create a new EdgeRenderer with the given edge type. * @param edgeType the edge type, one of * {@link prefuse.Constants#EDGE_TYPE_LINE} or * {@link prefuse.Constants#EDGE_TYPE_CURVE}. */ public EdgeRenderer(int edgeType) { this(edgeType, Constants.EDGE_ARROW_FORWARD); } /** * Create a new EdgeRenderer with the given edge and arrow types. * @param edgeType the edge type, one of * {@link prefuse.Constants#EDGE_TYPE_LINE} or * {@link prefuse.Constants#EDGE_TYPE_CURVE}. * @param arrowType the arrow type, one of * {@link prefuse.Constants#EDGE_ARROW_FORWARD}, * {@link prefuse.Constants#EDGE_ARROW_REVERSE}, or * {@link prefuse.Constants#EDGE_ARROW_NONE}. * @see #setArrowType(int) */ public EdgeRenderer(int edgeType, int arrowType) { this(); setEdgeType(edgeType); setArrowType(arrowType); } /** * @see prefuse.render.AbstractShapeRenderer#getRenderType(prefuse.visual.VisualItem) */ public int getRenderType(VisualItem item) { return RENDER_TYPE_DRAW; } /** * @see prefuse.render.AbstractShapeRenderer#getRawShape(prefuse.visual.VisualItem) */ protected Shape getRawShape(VisualItem item) { EdgeItem edge = (EdgeItem)item; VisualItem item1 = edge.getSourceItem(); VisualItem item2 = edge.getTargetItem(); int type = m_edgeType; getAlignedPoint(m_tmpPoints[0], item1.getBounds(), m_xAlign1, m_yAlign1); getAlignedPoint(m_tmpPoints[1], item2.getBounds(), m_xAlign2, m_yAlign2); m_curWidth = (float)(m_width * getLineWidth(item)); // create the arrow head, if needed EdgeItem e = (EdgeItem)item; if ( e.isDirected() && m_edgeArrow != Constants.EDGE_ARROW_NONE ) { // get starting and ending edge endpoints boolean forward = (m_edgeArrow == Constants.EDGE_ARROW_FORWARD); Point2D start = null, end = null; start = m_tmpPoints[forward?0:1]; end = m_tmpPoints[forward?1:0]; // compute the intersection with the target bounding box VisualItem dest = forward ? e.getTargetItem() : e.getSourceItem(); int i = GraphicsLib.intersectLineRectangle(start, end, dest.getBounds(), m_isctPoints); if ( i > 0 ) end = m_isctPoints[0]; // create the arrow head shape AffineTransform at = getArrowTrans(start, end, m_curWidth); m_curArrow = at.createTransformedShape(m_arrowHead); // update the endpoints for the edge shape // need to bias this by arrow head size Point2D lineEnd = m_tmpPoints[forward?1:0]; lineEnd.setLocation(0, -m_arrowHeight); at.transform(lineEnd, lineEnd); } else { m_curArrow = null; } // create the edge shape Shape shape = null; double n1x = m_tmpPoints[0].getX(); double n1y = m_tmpPoints[0].getY(); double n2x = m_tmpPoints[1].getX(); double n2y = m_tmpPoints[1].getY(); switch ( type ) { case Constants.EDGE_TYPE_LINE: m_line.setLine(n1x, n1y, n2x, n2y); shape = m_line; break; case Constants.EDGE_TYPE_CURVE: getCurveControlPoints(edge, m_ctrlPoints,n1x,n1y,n2x,n2y); m_cubic.setCurve(n1x, n1y, m_ctrlPoints[0].getX(), m_ctrlPoints[0].getY(), m_ctrlPoints[1].getX(), m_ctrlPoints[1].getY(), n2x, n2y); shape = m_cubic; break; default: throw new IllegalStateException("Unknown edge type"); } // return the edge shape return shape; } /** * @see prefuse.render.Renderer#render(java.awt.Graphics2D, prefuse.visual.VisualItem) */ public void render(Graphics2D g, VisualItem item) { // render the edge line super.render(g, item); // render the edge arrow head, if appropriate if ( m_curArrow != null ) { g.setPaint(ColorLib.getColor(item.getFillColor())); g.fill(m_curArrow); } } /** * Returns an affine transformation that maps the arrowhead shape * to the position and orientation specified by the provided * line segment end points. */ protected AffineTransform getArrowTrans(Point2D p1, Point2D p2, double width) { m_arrowTrans.setToTranslation(p2.getX(), p2.getY()); m_arrowTrans.rotate(-HALF_PI + Math.atan2(p2.getY()-p1.getY(), p2.getX()-p1.getX())); if ( width > 1 ) { double scalar = width/4; m_arrowTrans.scale(scalar, scalar); } return m_arrowTrans; } /** * Update the dimensions of the arrow head, creating a new * arrow head if necessary. The return value is also set * as the member variablem_arrowHead
* @param w the width of the untransformed arrow head base, in pixels
* @param h the height of the untransformed arrow head, in pixels
* @return the untransformed arrow head shape
*/
protected Polygon updateArrowHead(int w, int h) {
if ( m_arrowHead == null ) {
m_arrowHead = new Polygon();
} else {
m_arrowHead.reset();
}
m_arrowHead.addPoint(0, 0);
m_arrowHead.addPoint(-w/2, -h);
m_arrowHead.addPoint( w/2, -h);
m_arrowHead.addPoint(0, 0);
return m_arrowHead;
}
/**
* @see prefuse.render.AbstractShapeRenderer#getTransform(prefuse.visual.VisualItem)
*/
protected AffineTransform getTransform(VisualItem item) {
return null;
}
/**
* @see prefuse.render.Renderer#locatePoint(java.awt.geom.Point2D, prefuse.visual.VisualItem)
*/
public boolean locatePoint(Point2D p, VisualItem item) {
Shape s = getShape(item);
if ( s == null ) {
return false;
} else {
double width = Math.max(2, getLineWidth(item));
double halfWidth = width/2.0;
return s.intersects(p.getX()-halfWidth,
p.getY()-halfWidth,
width,width);
}
}
/**
* @see prefuse.render.Renderer#setBounds(prefuse.visual.VisualItem)
*/
public void setBounds(VisualItem item) {
if ( !m_manageBounds ) return;
Shape shape = getShape(item);
if ( shape == null ) {
item.setBounds(item.getX(), item.getY(), 0, 0);
return;
}
GraphicsLib.setBounds(item, shape, getStroke(item));
if ( m_curArrow != null ) {
Rectangle2D bbox = (Rectangle2D)item.get(VisualItem.BOUNDS);
Rectangle2D.union(bbox, m_curArrow.getBounds2D(), bbox);
}
}
/**
* Returns the line width to be used for this VisualItem. By default,
* returns the base width value set using the {@link #setDefaultLineWidth(double)}
* method, scaled by the item size returned by
* {@link VisualItem#getSize()}. Subclasses can override this method to
* perform custom line width determination, however, the preferred
* method is to change the item size value itself.
* @param item the VisualItem for which to determine the line width
* @return the desired line width, in pixels
*/
protected double getLineWidth(VisualItem item) {
return item.getSize();
}
/**
* Returns the stroke value returned by {@link VisualItem#getStroke()},
* scaled by the current line width
* determined by the {@link #getLineWidth(VisualItem)} method. Subclasses
* may override this method to perform custom stroke assignment, but should
* respect the line width paremeter stored in the {@link #m_curWidth}
* member variable, which caches the result of getLineWidth
.
* @see prefuse.render.AbstractShapeRenderer#getStroke(prefuse.visual.VisualItem)
*/
protected BasicStroke getStroke(VisualItem item) {
return StrokeLib.getDerivedStroke(item.getStroke(), m_curWidth);
}
/**
* Determines the control points to use for cubic (Bezier) curve edges.
* Override this method to provide custom curve specifications.
* To reduce object initialization, the entries of the Point2D array are
* already initialized, so use the Point2D.setLocation() method rather than
* new Point2D.Double() to more efficiently set custom control points.
* @param eitem the EdgeItem we are determining the control points for
* @param cp array of Point2D's (length >= 2) in which to return the control points
* @param x1 the x co-ordinate of the first node this edge connects to
* @param y1 the y co-ordinate of the first node this edge connects to
* @param x2 the x co-ordinate of the second node this edge connects to
* @param y2 the y co-ordinate of the second node this edge connects to
*/
protected void getCurveControlPoints(EdgeItem eitem, Point2D[] cp,
double x1, double y1, double x2, double y2)
{
double dx = x2-x1, dy = y2-y1;
cp[0].setLocation(x1+2*dx/3,y1);
cp[1].setLocation(x2-dx/8,y2-dy/8);
}
/**
* Helper method, which calculates the top-left co-ordinate of a rectangle
* given the rectangle's alignment.
*/
protected static void getAlignedPoint(Point2D p, Rectangle2D r, int xAlign, int yAlign) {
double x = r.getX(), y = r.getY(), w = r.getWidth(), h = r.getHeight();
if ( xAlign == Constants.CENTER ) {
x = x+(w/2);
} else if ( xAlign == Constants.RIGHT ) {
x = x+w;
}
if ( yAlign == Constants.CENTER ) {
y = y+(h/2);
} else if ( yAlign == Constants.BOTTOM ) {
y = y+h;
}
p.setLocation(x,y);
}
/**
* Returns the type of the drawn edge. This is one of
* {@link prefuse.Constants#EDGE_TYPE_LINE} or
* {@link prefuse.Constants#EDGE_TYPE_CURVE}.
* @return the edge type
*/
public int getEdgeType() {
return m_edgeType;
}
/**
* Sets the type of the drawn edge. This must be one of
* {@link prefuse.Constants#EDGE_TYPE_LINE} or
* {@link prefuse.Constants#EDGE_TYPE_CURVE}.
* @param type the new edge type
*/
public void setEdgeType(int type) {
if ( type < 0 || type >= Constants.EDGE_TYPE_COUNT )
throw new IllegalArgumentException(
"Unrecognized edge curve type: "+type);
m_edgeType = type;
}
/**
* Returns the type of the drawn edge. This is one of
* {@link prefuse.Constants#EDGE_ARROW_FORWARD},
* {@link prefuse.Constants#EDGE_ARROW_REVERSE}, or
* {@link prefuse.Constants#EDGE_ARROW_NONE}.
* @return the edge type
*/
public int getArrowType() {
return m_edgeArrow;
}
/**
* Sets the type of the drawn edge. This is either
* {@link prefuse.Constants#EDGE_ARROW_NONE} for no edge arrows,
* {@link prefuse.Constants#EDGE_ARROW_FORWARD} for arrows from source to
* target on directed edges, or
* {@link prefuse.Constants#EDGE_ARROW_REVERSE} for arrows from target to
* source on directed edges.
* @param type the new arrow type
*/
public void setArrowType(int type) {
if ( type < 0 || type >= Constants.EDGE_ARROW_COUNT )
throw new IllegalArgumentException(
"Unrecognized edge arrow type: "+type);
m_edgeArrow = type;
}
/**
* Sets the dimensions of an arrow head for a directed edge. This specifies
* the pixel dimensions when both the zoom level and the size factor
* (a combination of item size value and default stroke width) are 1.0.
* @param width the untransformed arrow head width, in pixels. This
* specifies the span of the base of the arrow head.
* @param height the untransformed arrow head height, in pixels. This
* specifies the distance from the point of the arrow to its base.
*/
public void setArrowHeadSize(int width, int height) {
m_arrowWidth = width;
m_arrowHeight = height;
m_arrowHead = updateArrowHead(width, height);
}
/**
* Get the height of the untransformed arrow head. This is the distance,
* in pixels, from the tip of the arrow to its base.
* @return the default arrow head height
*/
public int getArrowHeadHeight() {
return m_arrowHeight;
}
/**
* Get the width of the untransformed arrow head. This is the length,
* in pixels, of the base of the arrow head.
* @return the default arrow head width
*/
public int getArrowHeadWidth() {
return m_arrowWidth;
}
/**
* Get the horizontal aligment of the edge mount point with the first node.
* @return the horizontal alignment, one of {@link prefuse.Constants#LEFT},
* {@link prefuse.Constants#RIGHT}, or {@link prefuse.Constants#CENTER}.
*/
public int getHorizontalAlignment1() {
return m_xAlign1;
}
/**
* Get the vertical aligment of the edge mount point with the first node.
* @return the vertical alignment, one of {@link prefuse.Constants#TOP},
* {@link prefuse.Constants#BOTTOM}, or {@link prefuse.Constants#CENTER}.
*/
public int getVerticalAlignment1() {
return m_yAlign1;
}
/**
* Get the horizontal aligment of the edge mount point with the second
* node.
* @return the horizontal alignment, one of {@link prefuse.Constants#LEFT},
* {@link prefuse.Constants#RIGHT}, or {@link prefuse.Constants#CENTER}.
*/
public int getHorizontalAlignment2() {
return m_xAlign2;
}
/**
* Get the vertical aligment of the edge mount point with the second node.
* @return the vertical alignment, one of {@link prefuse.Constants#TOP},
* {@link prefuse.Constants#BOTTOM}, or {@link prefuse.Constants#CENTER}.
*/
public int getVerticalAlignment2() {
return m_yAlign2;
}
/**
* Set the horizontal aligment of the edge mount point with the first node.
* @param align the horizontal alignment, one of
* {@link prefuse.Constants#LEFT}, {@link prefuse.Constants#RIGHT}, or
* {@link prefuse.Constants#CENTER}.
*/
public void setHorizontalAlignment1(int align) {
m_xAlign1 = align;
}
/**
* Set the vertical aligment of the edge mount point with the first node.
* @param align the vertical alignment, one of
* {@link prefuse.Constants#TOP}, {@link prefuse.Constants#BOTTOM}, or
* {@link prefuse.Constants#CENTER}.
*/
public void setVerticalAlignment1(int align) {
m_yAlign1 = align;
}
/**
* Set the horizontal aligment of the edge mount point with the second
* node.
* @param align the horizontal alignment, one of
* {@link prefuse.Constants#LEFT}, {@link prefuse.Constants#RIGHT}, or
* {@link prefuse.Constants#CENTER}.
*/
public void setHorizontalAlignment2(int align) {
m_xAlign2 = align;
}
/**
* Set the vertical aligment of the edge mount point with the second node.
* @param align the vertical alignment, one of
* {@link prefuse.Constants#TOP}, {@link prefuse.Constants#BOTTOM}, or
* {@link prefuse.Constants#CENTER}.
*/
public void setVerticalAlignment2(int align) {
m_yAlign2 = align;
}
/**
* Sets the default width of lines. This width value will
* be scaled by the value of an item's size data field. The default
* base width is 1.
* @param w the desired default line width, in pixels
*/
public void setDefaultLineWidth(double w) {
m_width = w;
}
/**
* Gets the default width of lines. This width value that will
* be scaled by the value of an item's size data field. The default
* base width is 1.
* @return the default line width, in pixels
*/
public double getDefaultLineWidth() {
return m_width;
}
} // end of class EdgeRenderer