package prefuse.render;
import java.awt.Shape;
import java.awt.geom.GeneralPath;
import prefuse.Constants;
import prefuse.data.Schema;
import prefuse.util.GraphicsLib;
import prefuse.visual.VisualItem;
/**
* <p>Renderer for drawing a polygon, either as a closed shape, or as a
* series of potentially unclosed curves. VisualItems must have a data field
* containing an array of floats that tores the polyon. A {@link Float#NaN}
* value can be used to mark the end point of the polygon for float arrays
* larger than their contained points. By default, this renderer will
* create closed paths, joining the first and last points in the point
* array if necessary. The {@link #setClosePath(boolean)} method can be
* used to render open paths, such as poly-lines or poly-curves.</p>
*
* <p>A polygon edge type parameter (one of
* {@link prefuse.Constants#POLY_TYPE_LINE},
* {@link prefuse.Constants#POLY_TYPE_CURVE}, or
* {@link prefuse.Constants#POLY_TYPE_STACK}) determines how the
* edges of the polygon are drawn. The LINE type result in a standard polygon,
* with straight lines drawn between each sequential point. The CURVE type
* causes the edges of the polygon to be interpolated as a cardinal spline,
* giving a smooth blob-like appearance to the shape. The STACK type is similar
* to the curve type except that straight line segments (not curves) are used
* when the slope of the line between two adjacent points is zero or infinity.
* This is useful for drawing stacks of data with otherwise curved edges.</p>
*
* @author <a href="http://jheer.org">jeffrey heer</a>
*/
public class PolygonRenderer extends AbstractShapeRenderer {
/**
* Default data field for storing polygon (float array) values.
*/
public static final String POLYGON = "_polygon";
/**
* A Schema describing the polygon specification.
*/
public static final Schema POLYGON_SCHEMA = new Schema();
static {
POLYGON_SCHEMA.addColumn(POLYGON, float[].class);
}
private int m_polyType = Constants.POLY_TYPE_LINE;
private float m_slack = 0.08f;
private float m_epsilon = 0.1f;
private boolean m_closed = true;
private String m_polyfield = POLYGON;
private GeneralPath m_path = new GeneralPath();
/**
* Create a new PolygonRenderer supporting straight lines.
*/
public PolygonRenderer() {
this(Constants.EDGE_TYPE_LINE);
}
/**
* Create a new PolygonRenderer.
* @param polyType the polygon edge type, one of
* {@link prefuse.Constants#POLY_TYPE_LINE},
* {@link prefuse.Constants#POLY_TYPE_CURVE}, or
* {@link prefuse.Constants#POLY_TYPE_STACK}).
*/
public PolygonRenderer(int polyType) {
m_polyType = polyType;
}
/**
* Get the polygon line type.
* @return the polygon edge type, one of
* {@link prefuse.Constants#POLY_TYPE_LINE},
* {@link prefuse.Constants#POLY_TYPE_CURVE}, or
* {@link prefuse.Constants#POLY_TYPE_STACK}).
*/
public int getPolyType() {
return m_polyType;
}
/**
* Set the polygon line type.
* @param polyType the polygon edge type, one of
* {@link prefuse.Constants#POLY_TYPE_LINE},
* {@link prefuse.Constants#POLY_TYPE_CURVE}, or
* {@link prefuse.Constants#POLY_TYPE_STACK}).
*/
public void setPolyType(int polyType) {
if ( polyType < 0 || polyType >= Constants.POLY_TYPE_COUNT ) {
throw new IllegalArgumentException("Unknown edge type: "+polyType);
}
m_polyType = polyType;
}
/**
* Indicates if this renderer uses a closed or open path. If true,
* the renderer will draw closed polygons, if false, the renderer will
* draw poly-lines or poly-curves.
* @return true if paths are closed, false otherwise.
*/
public boolean isClosePath() {
return m_closed;
}
/**
* Sets if this renderer uses a closed or open path. If true,
* the renderer will draw closed polygons, if false, the renderer will
* @param closePath true to close paths, false otherwise.
*/
public void setClosePath(boolean closePath) {
m_closed = closePath;
}
/**
* Gets the slack parameter for curved lines. The slack parameter
* determines how tightly the curves are string between the points
* of the polygon. A value of zero results in straight lines. Values
* near 0.1 (0.08 is the default) typically result in visible curvature
* that still follows the polygon boundary nicely.
* @return the curve slack parameter
*/
public float getCurveSlack() {
return m_slack;
}
/**
* Sets the slack parameter for curved lines. The slack parameter
* determines how tightly the curves are string between the points
* of the polygon. A value of zero results in straight lines. Values
* near 0.1 (0.08 is the default) typically results in visible curvature
* that still follows the polygon boundary nicely.
* @param slack the curve slack parameter to use
*/
public void setCurveSlack(float slack) {
m_slack = slack;
}
/**
* @see prefuse.render.AbstractShapeRenderer#getRawShape(prefuse.visual.VisualItem)
*/
protected Shape getRawShape(VisualItem item) {
float[] poly = (float[])item.get(m_polyfield);
if ( poly == null ) { return null; }
float x = (float)item.getX();
float y = (float)item.getY();
// initialize the path
m_path.reset();
m_path.moveTo(x+poly[0],y+poly[1]);
if ( m_polyType == Constants.POLY_TYPE_LINE )
{
// create a polygon
for ( int i=2; i<poly.length; i+=2 ) {
if ( Float.isNaN(poly[i]) ) break;
m_path.lineTo(x+poly[i],y+poly[i+1]);
}
}
else if ( m_polyType == Constants.POLY_TYPE_CURVE )
{
// interpolate the polygon points with a cardinal spline
return GraphicsLib.cardinalSpline(m_path, poly,
m_slack, m_closed, x, y);
}
else if ( m_polyType == Constants.POLY_TYPE_STACK )
{
// used curved lines, except for non-sloping segments
return GraphicsLib.stackSpline(m_path, poly,
m_epsilon, m_slack, m_closed, x, y);
}
if ( m_closed ) m_path.closePath();
return m_path;
}
} // end of class PolygonRenderer