/*
* @(#)PlotMarkAlgorithm.java 2.6.0 22 August 2007
*
* Copyright 2007
* College of Computer and Information Science
* Northeastern University
* Boston, MA 02115
*
* The Java Power Tools software may be used for educational
* purposes as long as this copyright notice is retained intact
* at the top of all source files.
*
* To discuss possible commercial use of this software,
* contact Richard Rasala at Northeastern University,
* College of Computer and Information Science,
* 617-373-2462 or rasala@ccs.neu.edu.
*
* The Java Power Tools software has been designed and built
* in collaboration with Viera Proulx and Jeff Raab.
*
* Should this software be modified, the words "Modified from
* Original" must be included as a comment below this notice.
*
* All publication rights are retained. This software or its
* documentation may not be published in any media either
* in whole or in part without explicit permission.
*
* This software was created with support from Northeastern
* University and from NSF grant DUE-9950829.
*/
package edu.neu.ccs.gui;
import edu.neu.ccs.*;
import java.awt.*;
import java.awt.geom.*;
/**
* Class PlotMarkAlgorithm defines the requirements for an
* algorithm that will produce a scalable shape defined in the neighborhood
* of a given point. This class is intended to be used in constructors for
* the class PlotMark.
*
* This class provides several static instances of itself.
*
* The following changes were made in 2.6.0:
*
*
* - The minimum
size parameter was reduced from
* 1 to 0 to permit the base case of each shape to be created.
*
* - A new circle algorithm named
BetterCircle was
* introduced that produces elegant, symmetrical circles for
* small values of the size parameter.
*
* - The methods
QuarterCircleData and
* BetterCirclePath on which the algorithm
* BetterCircle is based are made available as
* public static methods.
*
* - The earlier circle algorithm was renamed as
*
JavaCircle and is still available.
*
* - Algorithms for a “slider thumb” shape have been
* added.
*
*
*
* @author Richard Rasala
* @version 2.6.0
* @since 2.4.0
*/
public abstract class PlotMarkAlgorithm
{
/**
* Returns a shape constructed in the neighborhood of the given point
* and scaled with the given size.
*
* If the given point is null, returns an empty shape.
*
* Otherwise calls makeShape(double, double, int).
*
* @param p the point defining where to place the shape
* @param size the scale size
*/
public final Shape makeShape(Point2D p, int size) {
if (p == null)
return new GeneralPath();
return makeShape(p.getX(), p.getY(), size);
}
/**
* Returns a shape constructed in the neighborhood of the given point
* and scaled with the given size.
*
* When defined this method may return an empty shape but should not
* return null.
*
* The scale size should be forced to at least 0 before building the
* shape.
*
* @param x the x-coordinate of the point defining where
* to place the shape
* @param y the y-coordinate of the point defining where
* to place the shape
* @param size the scale size
*/
public abstract Shape makeShape(double x, double y, int size);
/**
* The horizontal bar algorithm.
*
* Produces the line segment path
* (x-size,y) to (x+size,y).
*
* When used in a PlotMark, the fill setting should
* be false.
*/
public static final PlotMarkAlgorithm HBar = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) (x - s), (float) y);
path.lineTo((float) (x + s), (float) y);
return path;
}
};
/**
* The vertical bar algorithm.
*
* Produces the line segment path
* (x,y-size) to (x,y+size).
*
* When used in a PlotMark, the fill setting should
* be false.
*/
public static final PlotMarkAlgorithm VBar = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) (y - s));
path.lineTo((float) x, (float) (y + s));
return path;
}
};
/**
* The plus sign algorithm.
*
* Produces the combined path with 2 line segments:
*
*
* (x-size,y) to (x+size,y)(x,y-size) to (x,y+size)
*
* When used in a PlotMark, the fill setting should
* be false.
*/
public static final PlotMarkAlgorithm Plus = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) (x - s), (float) y);
path.lineTo((float) (x + s), (float) y);
path.moveTo((float) x, (float) (y - s));
path.lineTo((float) x, (float) (y + s));
return path;
}
};
/**
* The cross sign algorithm.
*
* Produces the combined path with 2 line segments:
*
*
* (x-size,y-size) to (x+size,y+size)(x+size,y-size) to (x-size,y+size)
*
* When used in a PlotMark, the fill setting should
* be false.
*/
public static final PlotMarkAlgorithm Cross = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) (x - s), (float) (y - s));
path.lineTo((float) (x + s), (float) (y + s));
path.moveTo((float) (x + s), (float) (y - s));
path.lineTo((float) (x - s), (float) (y + s));
return path;
}
};
/**
* The asterisk algorithm.
*
* Produces the combined path with 4 line segments:
*
*
* (x-size,y) to (x+size,y)(x,y-size) to (x,y+size)(x-size,y-size) to (x+size,y+size)(x+size,y-size) to (x-size,y+size)
*
* When used in a PlotMark, the fill setting should
* be false.
*/
public static final PlotMarkAlgorithm Asterisk = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) (x - s), (float) y);
path.lineTo((float) (x + s), (float) y);
path.moveTo((float) x, (float) (y - s));
path.lineTo((float) x, (float) (y + s));
path.moveTo((float) (x - s), (float) (y - s));
path.lineTo((float) (x + s), (float) (y + s));
path.moveTo((float) (x + s), (float) (y - s));
path.lineTo((float) (x - s), (float) (y + s));
return path;
}
};
/**
* The square algorithm.
*
* Returns new XSquare(x, y, size).
*/
public static final PlotMarkAlgorithm Square = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
return new XSquare(x, y, size);
}
};
/**
* The diamond algorithm.
*
* Produces the closed path with 4 vertices:
*
*
* (x,y-size)(x+size,y)(x,y+size)(x-size,y)
*/
public static final PlotMarkAlgorithm Diamond = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) (y - s));
path.lineTo((float) (x + s), (float) y);
path.lineTo((float) x, (float) (y + s));
path.lineTo((float) (x - s), (float) y);
path.closePath();
return path;
}
};
/**
* The better circle algorithm for creation of plot marks.
*
* Uses the method BetterCirclePath which is
* in turn based on the method QuarterCircleData.
* The path produced has 8-fold symmetry about the horizontal,
* vertical, and two diagonal axes. Its appearance for small
* values of size is much better than that given
* by Java's algorithm.
*
* On the other hand, for large values of size,
* this algorithm is more computationally intensive than the
* JavaCircle technique.
*
* If size > 16384, this algorithm will
* revert to the JavaCircle algorithm.
*/
public static PlotMarkAlgorithm BetterCircle = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size > 16384)
return JavaCircle.makeShape(x, y, size);
int a = (int) Math.round(x);
int b = (int) Math.round(y);
return BetterCirclePath(a, b, size);
}
};
/**
* The Java circle algorithm.
*
* Returns:
*
* new XCircle(x, y, size)
*
* This is equivalent to the pure Java call:
*
* new Ellipse2D.Double(x-size, y-size, 2*size, 2*size)
*
* Warning: For small values of size, the circle
* constructed by Java does not have 8-fold symmetry about the
* horizontal, vertical, and two diagonal axes. The circle is
* therefore not very pleasing aesthetically.
*
* See BetterCircle.
*/
public static final PlotMarkAlgorithm JavaCircle = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
return new XCircle(x, y, size);
}
};
/**
* The wedge-facing-north algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+size,y+(2*size))(x-size,y+(2*size))
*/
public static final PlotMarkAlgorithm WedgeN = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y + d));
path.lineTo((float) (x - s), (float) (y + d));
path.closePath();
return path;
}
};
/**
* The wedge-facing-east algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-(2*size),y+size)(x-(2*size),y-size)
*/
public static final PlotMarkAlgorithm WedgeE = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - d), (float) (y + s));
path.lineTo((float) (x - d), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The wedge-facing-south algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-size,y-(2*size))(x+size,y-(2*size))
*/
public static final PlotMarkAlgorithm WedgeS = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y - d));
path.lineTo((float) (x + s), (float) (y - d));
path.closePath();
return path;
}
};
/**
* The wedge-facing-west algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+(2*size),y-size)(x+(2*size),y+size)
*/
public static final PlotMarkAlgorithm WedgeW = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + d), (float) (y - s));
path.lineTo((float) (x + d), (float) (y + s));
path.closePath();
return path;
}
};
/**
* The blunt-wedge-facing-north algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+size,y+size)(x-size,y+size)
*/
public static final PlotMarkAlgorithm BluntWedgeN = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y + s));
path.lineTo((float) (x - s), (float) (y + s));
path.closePath();
return path;
}
};
/**
* The blunt-wedge-facing-east algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-size,y+size)(x-size,y-size)
*/
public static final PlotMarkAlgorithm BluntWedgeE = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y + s));
path.lineTo((float) (x - s), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The blunt-wedge-facing-south algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-size,y-size)(x+size,y-size)
*/
public static final PlotMarkAlgorithm BluntWedgeS = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y - s));
path.lineTo((float) (x + s), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The blunt-wedge-facing-west algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+size,y-size)(x+size,y+size)
*/
public static final PlotMarkAlgorithm BluntWedgeW = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y - s));
path.lineTo((float) (x + s), (float) (y + s));
path.closePath();
return path;
}
};
/**
* The sharp-wedge-facing-north algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+size,y+(3*size))(x-size,y+(3*size))
*/
public static final PlotMarkAlgorithm SharpWedgeN = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 3 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y + d));
path.lineTo((float) (x - s), (float) (y + d));
path.closePath();
return path;
}
};
/**
* The sharp-wedge-facing-east algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-(3*size),y+size)(x-(3*size),y-size)
*/
public static final PlotMarkAlgorithm SharpWedgeE = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 3 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - d), (float) (y + s));
path.lineTo((float) (x - d), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The sharp-wedge-facing-south algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x-size,y-(3*size))(x+size,y-(3*size))
*/
public static final PlotMarkAlgorithm SharpWedgeS = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 3 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y - d));
path.lineTo((float) (x + s), (float) (y - d));
path.closePath();
return path;
}
};
/**
* The sharp-wedge-facing-west algorithm.
*
* Produces the closed path with 3 vertices:
*
*
* (x,y)(x+(3*size),y-size)(x+(3*size),y+size)
*/
public static final PlotMarkAlgorithm SharpWedgeW = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 3 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + d), (float) (y - s));
path.lineTo((float) (x + d), (float) (y + s));
path.closePath();
return path;
}
};
/**
* The thumb-facing-north algorithm.
*
* Produces the closed path with 5 vertices:
*
*
* (x,y)(x+size,y+size)(x+size,y+(2*size))(x-size,y+(2*size))(x-size,y+size)
*/
public static final PlotMarkAlgorithm ThumbN = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y + s));
path.lineTo((float) (x + s), (float) (y + d));
path.lineTo((float) (x - s), (float) (y + d));
path.lineTo((float) (x - s), (float) (y + s));
path.closePath();
return path;
}
};
/**
* The thumb-facing-east algorithm.
*
* Produces the closed path with 5 vertices:
*
*
* (x,y)(x-size,y+size)(x-(2*size),y+size)(x-(2*size),y-size)(x-size,y-size)
*/
public static final PlotMarkAlgorithm ThumbE = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y + s));
path.lineTo((float) (x - d), (float) (y + s));
path.lineTo((float) (x - d), (float) (y - s));
path.lineTo((float) (x - s), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The thumb-facing-south algorithm.
*
* Produces the closed path with 5 vertices:
*
*
* (x,y)(x-size,y-size)(x-size,y-(2*size))(x+size,y-(2*size))(x+size,y-size)
*/
public static final PlotMarkAlgorithm ThumbS = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x - s), (float) (y - s));
path.lineTo((float) (x - s), (float) (y - d));
path.lineTo((float) (x + s), (float) (y - d));
path.lineTo((float) (x + s), (float) (y - s));
path.closePath();
return path;
}
};
/**
* The thumb-facing-west algorithm.
*
* Produces the closed path with 5 vertices:
*
*
* (x,y)(x+size,y-size)(x+(2*size),y-size)(x+(2*size),y+size)(x+size,y+size)
*/
public static final PlotMarkAlgorithm ThumbW = new PlotMarkAlgorithm() {
public Shape makeShape(double x, double y, int size) {
if (size < 0)
size = 0;
int s = size;
int d = 2 * size;
GeneralPath path = new GeneralPath();
path.moveTo((float) x, (float) y);
path.lineTo((float) (x + s), (float) (y - s));
path.lineTo((float) (x + d), (float) (y - s));
path.lineTo((float) (x + d), (float) (y + s));
path.lineTo((float) (x + s), (float) (y + s));
path.closePath();
return path;
}
};
/**
* Returns the data for construction of a quarter circle
* path of the given radius.
*
* Assume that the int[][] returned has the
* name data. Then data is
* normally of size 2. Let:
*
* int[] xx = data[0];
* int[] yy = data[1];
*
* Then, the array xx contains the
* x-coordinates of desired data points
* and the array yy the corresponding
* y-coordinates. In particular, the arrays have
* the same length, say, k. The ends
* of the arrays are as follows:
*
* xx[0] equals radius.
*
* yy[0] equals 0.
*
* xx[k-1] equals 0.
*
* yy[k-1] equals radius.
*
* More generally, the data is constructed to include
* the boundary points (x,y) whose distance
* from the origin is less than or equal to
* radius+0.5. A horizontal or vertical run
* of boundary points is represented by the two endpoints
* of the run.
*
* The path associated with the quarter circle data is
* designed to be symmetrical relative to the main diagonal.
*
* Note that:
*
*
* - If
radius <= 0 returns
* the array { { 0 }, { 0 } }
*
* - If
radius > 16384 returns
* null.
*
*
*
* The latter constraint is due to a desire to do all
* internal computations in integer arithmetic.
*
* @param radius the radius of the desired quarter circle
*/
public static int[][] QuarterCircleData(int radius) {
if (radius <= 0)
return new int[][] { { 0 }, { 0 } };
if (radius > 16384)
return null;
// largest integer < square of (radius + 0.5).
int square = radius * radius + radius;
// adequate length for internal arrays
int length = 2 * (radius + 1);
// create internal arrays
int[] x = new int[length];
int[] y = new int[length];
// initialize first point
int a = radius;
int b = 0;
x[0] = a;
y[0] = b;
int k = 1;
// create first eighth of circle
while (b < a) {
int limit = square - a * a;
int c = b;
while (c * c <= limit)
c++;
c--;
// vertical step
if (a < c)
c = a;
if (b < c) {
b = c;
x[k] = a;
y[k] = b;
k++;
}
// diagonal step
a--;
b++;
if (b <= a) {
x[k] = a;
y[k] = b;
k++;
}
}
// create second eighth of circle
int s = k - 1;
if (x[s] == y[s])
s--;
while (s >= 0) {
x[k] = y[s];
y[k] = x[s];
k++;
s--;
}
// create minimal arrays
int[] xx = new int[k];
int[] yy = new int[k];
for (int i = 0; i < k; i++) {
xx[i] = x[i];
yy[i] = y[i];
}
return new int[][] { xx, yy };
}
/**
* Returns a full circle path with the given center
* (x,y) and the given radius using the method
* QuarterCircleData for the computation.
* Since that method provides only a quarter of a
* circle, the remaining path points are generated via
* symmetry. In particular, 8-fold symmetry about the
* horizontal, vertical, and two diagonal axes is
* therefore guaranteed.
*
* If radius > 16384, the method
* QuarterCircleData cannot be used so
* this method returns an XCircle-based
* path instead.
*
* @param x the circle x-center
* @param y the circle y-center
* @param radius the circle radius
*/
public static Shape BetterCirclePath(int x, int y, int radius) {
GeneralPath path = new GeneralPath();
if (radius <= 0) {
path.moveTo(x, y);
path.lineTo(x, y);
path.closePath();
return path;
}
int[][] data = QuarterCircleData(radius);
if (data == null)
return new XCircle(x, y, radius);
int[] xx = data[0];
int[] yy = data[1];
int k = xx.length;
path.moveTo(x + xx[0], y + yy[0]);
for (int i = 1; i < k; i++)
path.lineTo(x + xx[i], y + yy[i]);
for (int i = (k - 2); i >= 0; i--)
path.lineTo(x - xx[i], y + yy[i]);
for (int i = 1; i < k; i++)
path.lineTo(x - xx[i], y - yy[i]);
for (int i = (k - 2); i >= 0; i--)
path.lineTo(x + xx[i], y - yy[i]);
path.closePath();
return path;
}
}