| DoubleData.java |
package graphics.charts;
/**
* DoubleData is the base class which is required in order to draw any graphs.
* It contains all the utility methods to calculate the necessary graphics.graph
* data for drawing.
* Constants include:
* <UL>
* <LI> BIGNUM: an upper bound used in calculating the minimum value in passed data
* <LI> LITTLENUM: a lower bound used in calculating the maximum value in passed data
* <LI> X_OFFSET: a constant used to correct for the portion of the image frame taken
* up by the GUI elements
* <LI> Y_OFFSET: a constant used to correct for the portion of the image frame taken up
* by the GUI elements (with offsets set to 0, the axes are drawn off-screen)
* </UL>
* Passed parameters set with defaults include:
* <UL>
* <LI> width: the width of the drawn image
* <LI> height: the height of the drawn image
* <LI> xVals: the X data to be graphed; the primary data for the pie graphics.graph
* <LI> yVals: the Y data to be graphed; the primary data for the bar graphics.graph
* <LI> labels: the labels for the pie graphics.graph data elements
* <LI> isGridOn: whether or not a grid should be drawn
* <LI> isTicksOn: whether or not ticks should be drawn along the axes
* <LI> xLabel: title for the X axis
* <LI> yLabel: title for the Y axis
* <LI> title: title for the graphics.graph
* </UL>
*
* @author Allison McHenry
* @author Douglas Lyon, PhD
* @since JDK 1.3
*/
public class DoubleData {
//BEGIN GLOBAL VARIABLE DECLARATIONS
private static final double BIGNUM = 32768;
private static final double LITTLENUM = -32768;
protected static final int X_OFFSET = 10;
protected static final int Y_OFFSET = 10;
private int width = 300;
private int height = 300;
private double xVals[] = {1, 2, 3, 4};
private double yVals[] = {10, -20, -40, 80};
private boolean isGridOn = true;
private boolean isTicksOn = true;
private String xLabel = "This is the X axis";
private String yLabel = "This is the Y axis";
private String title = "This is the Title";
/**
* Default constructor, used particularly to instantiate an instance of DoubleData by
* the LineGraph, PieGraph and BarGraph classes
*/
public DoubleData(int w, int h) {
setWidth(w);
setHeight(h);
}
/**
* Sets image width.
*
* @param _width image width (not frame width)
*/
public void setWidth(int _width) {
width = _width;
}
/**
* Sets image height.
*
* @param _height image height (not frame height)
*/
public void setHeight(int _height) {
height = _height;
}
/**
* Sets x-axis label on bar graphs and line graphs.
*
* @param _xLabel x-axis label
*/
public void setXLabel(String _xLabel) {
xLabel = _xLabel;
}
/**
* Sets y-axis label on bar graphs and line graphs.
*
* @param _yLabel y-axis label
*/
public void setYLabel(String _yLabel) {
yLabel = _yLabel;
}
/**
* Sets title of all graphs.
*
* @param _title Graph title
*/
public void setTitle(String _title) {
title = _title;
}
/**
* Sets whether or not a grid (lines the height and breadth of the image indicating
* increment size) should be drawn on line graphs and bar graphs.
*
* @param _isGridOn whether a grid should be drawn
*/
public void setGrid(boolean _isGridOn) {
isGridOn = _isGridOn;
}
/**
* Sets whether ticks (small marks on the x and y axis to indicate increment size)
* should be drawn on line graphs and bar graphs.
*
* @param _isTicksOn whether ticks should be drawn
*/
public void setTicks(boolean _isTicksOn) {
isTicksOn = _isTicksOn;
}
/**
*
* @param _xVals array of x data values
*/
public void setXVals(double _xVals[]) {
xVals = _xVals;
}
/**
* Sets Y data values - indicate height of bars for bar graphics.graph. Not set for pie.
*
* @param _yVals array of y data values
*/
public void setYVals(double _yVals[]) {
yVals = _yVals;
}
//BEGIN GETTER METHODS
/**
* Gets image width.
*
* @return width image width (not frame width)
*/
public int getWidth() {
return width;
}
/**
* Gets image height.
*
* @return height image height (not frame height)
*/
public int getHeight() {
return height;
}
/**
* Gets x-axis label on bar graphs and line graphs.
*
* @return xLabel x-axis label
*/
public String getXLabel() {
return xLabel;
}
/**
* Gets y-axis label on bar graphs and line graphs.
*
* @return yLabel y-axis label
*/
public String getYLabel() {
return yLabel;
}
/**
* Gets title of all graphs.
*
* @return title Graph title
*/
public String getTitle() {
return title;
}
/**
* Gets whether or not a grid (lines the height and breadth of the image indicating
* increment size) should be drawn on line graphs and bar graphs.
*
* @return isGridOn whether a grid should be drawn
*/
public boolean isGridOn() {
return isGridOn;
}
/**
* Gets whether ticks (small marks on the x and y axis to indicate increment size)
* should be drawn on line graphs and bar graphs.
*
* @return isTicksOn whether ticks should be drawn
*/
public boolean isTicksOn() {
return isTicksOn;
}
/**
* Gets X data values - the only values which are set for pie graphs.
*
* @return xVals array of x data values
*/
public double[] getXVals() {
return xVals;
}
/**
* Gets Y data values - indicate height of bars for bar graphics.graph. Not set for pie.
*
* @return yVals array of y data values
*/
public double[] getYVals() {
return yVals;
}
//BEGIN UTILITY METHODS
/**
* Calculates the maximum value in a given array.
*
* @param _vals The array to find the maximum number of
* @return largestVal The maximum value contained in the array
* @see #getYAxisCoord
* @see #getXAxisCoord
*/
protected double getMax(double vals[]) {
double largestVal = LITTLENUM;
for (int i = 0; i < vals.length; i++) {
if (vals[i] > largestVal) {
largestVal = vals[i];
}
}
return largestVal;
}
/**
* Calculates the maximum absolute value contained in a given array.
*
* @param vals The array whose absolute value maximum should be found
* @return largestVal The maximum absolute value contained in the array
* @see #getIncrementNew
*/
protected double getAbsMax(double vals[]) {
double largestVal = LITTLENUM;
for (int i = 0; i < vals.length; i++) {
if (Math.abs(vals[i]) > largestVal) {
largestVal = Math.abs(vals[i]);
}
}
return largestVal;
}
/**
* Calculates the minimum value in a given array.
*
* @param _vals The array to find the minimum number of
* @return smallestVal The minimum value contained in the array
* @see #getYAxisCoord
* @see #getXAxisCoord
*/
protected double getMin(double vals[]) {
double smallestVal = BIGNUM;
for (int i = 0; i < vals.length; i++) {
if (vals[i] < smallestVal) {
smallestVal = vals[i];
}
}
return smallestVal;
}
/**
* Calculates the minimum absolute value contained in a given array.
*
* @param vals The array whose absolute value minimum should be found
* @return smallestVal The minimum absolute value contained in the array
* @see #getYAxisCoord
*/
protected double getAbsMin(double vals[]) {
double smallestVal = BIGNUM;
for (int i = 0; i < vals.length; i++) {
if (Math.abs(vals[i]) < smallestVal) {
smallestVal = vals[i];
}
}
return smallestVal;
}
/**
* Calculates the difference between the two numbers passed to the function.
*
* @param min The number to subtract
* @param max The number to subtract from
* @return delta The difference between the two numbers
* @see #getIncrementNew
* @see #getNumTicks
* @see #getDeltaY
* @see #getDeltaX
*/
protected double getDelta(double min, double max) {
double delta;
delta = max - min;
return delta;
}
/**
* Calculates the difference between the smallest and largest values in the
* array initialized as xVals
*
* @return deltaX The difference between the smallest X value and the largest
* @see #getXOrigin
* @see LineGraph.#getXScreenCoords2
*/
protected double getDeltaX() {
double deltaX = getDelta(getMin(getXVals()), getMax(getXVals()));
return deltaX;
}
/**
* Calculates the difference between the smallest and largest values in the
* array initialized as yVals
*
* @return deltaY The difference between the smallest Y value and the largest
* @see LineGraph.#getYScreenCoords2
* @see #getYOrigin
*/
protected double getDeltaY() {
double deltaY = getDelta(getMin(yVals), getMax(yVals));
return deltaY;
}
/**
* Calculates the increment (building block) size for a given image size and delta
*
* @param size The available image size in this direction (width OR height)
* @param delta Distance between largest and smallest values along this axis
* @return increment The "building block" size
* @see #getXIncrement
* @see #getYIncrement
* @see #getNumTicks
*/
protected double getIncrement(int size, double delta) {
double increment;
if (delta == 0) {
increment = 0;
} else {
increment = (size / delta);
}
return increment;
}
/**
* Calculates the increment (building block) size for a given image size and delta
* Overridden with an int delta for convenience' sake in drawing bar graphics.graph
*
* @param size The available image size in this direction (width OR height)
* @param delta Distance between largest and smallest values along this axis
* @return increment The "building block" size
* @see BarGraph.#drawGraph
*/
protected int getIncrement(int size, int delta) {
int increment;
if (delta == 0) {
increment = 0;
} else {
increment = (size / delta);
}
return increment;
}
/**
* Calculates the increment (building block) size for a given image size and array of values
*
* @param vals The values to find the increment for
* @param size Image size in this direction
* @return increment The "building block" size
* @see LineGraph.#getXScreenCoords2
*/
protected double getIncrementNew(double[] vals, int size) {
double absMax = getAbsMax(vals);
double max = getMax(vals);
double minNum = getMin(vals);
double increment;
if (absMax == 0) {
increment = 0;
} else if (minNum < 0 && max > 0) {
double delta = getDelta(minNum, getMax(vals));
increment = getIncrement(size, delta);
} else if (max < 0) {
increment = -(size / absMax);
} else {
increment = (size / absMax);
}
return increment;
}
/**
* Calculates the Y increment (building block) size, given the
* values for Y held in yVals and the image size held in height
*
* @return yIncrement The "building block" size
* @see LineGraph.#getYScreenCoords2
* @see #getYAxisCoord
* @see BarGraph.#drawGraph
* @see DrawUtil.#drawTicks
*/
protected double getYIncrement() {
double yIncrement = getIncrement(getHeight(), getDeltaY());
return yIncrement;
}
/**
* Calculates the X increment (building block) size, given the
* values for X held in xVals and the image size held in width
*
* @return xIncrement The "building block" size
* @see LineGraph.#getYScreenCoords2
* @see #getXAxisCoord
*/
protected double getXIncrement() {
double xIncrement = getIncrement(getWidth(), getDeltaX());
return xIncrement;
}
/**
* Calculates the x value of the x axis, correcting for the
* GUI offset. If the smallest X value is greater than zero, the X axis is simply
* placed at zero plus the offset. If the smallest X value is less than zero,
* x axis is placed to the right the amount of the smallest value.
*
* @param xVals The data which should be used to calculate the origin
* @return xOrigin The x-axis location
* @see LineGraph.#getXScreenCoords2
* @see #getXOrigin
* @see BarGraph.#drawGraph
* @see DrawUtil.#drawTicks
* @see DrawUtil.#drawAxes2
* @see DrawUtil.#drawYLabel
*/
protected double getXAxisCoord() {
double deltaX = getDeltaX();
double xIncrement = getXIncrement();
double getMinX = getMin(xVals);
double getMaxX = getMax(xVals);
double xAxisCoord = (getMin(xVals) * xIncrement);
if (xAxisCoord >= 0) {
xAxisCoord = 0 + X_OFFSET;
} else if (getMinX < 0 && getMaxX > 0) {
xAxisCoord = Math.abs(xAxisCoord); //+X_OFFSET
} else {
xAxisCoord = width - X_OFFSET;
}
return xAxisCoord;
}
/**
* Calculates the y value of the y axis, correcting for the
* GUI offset. If the smallest Y value is greater than zero, the Y axis is simply
* placed at the height of the maximum data point times the increment (which
* works out to approximately the image height). If the smallest Y value is
* less than zero, the y axis is placed towards the center of the image
* the amount of the smallest value.
*
* @param yVals The data which should be used to calculate the origin
* @return yOrigin The y-axis location
* @see LineGraph.#getYScreenCoords2
* @see BarGraph.#getYCoord
* @see BarGraph.#drawGraph
* @see DrawUtil.#drawXLabel
*/
protected double getYAxisCoord() {
double deltaY = getDeltaY();
double yIncrement = getYIncrement();
double minY = getMin(yVals);
double absMaxY = getAbsMax(yVals);
double maxY = getMax(yVals);
double yAxisCoord = (absMaxY * yIncrement);
if (minY < 0 && maxY > 0) {
yAxisCoord = yAxisCoord - getAbsMin(yVals);
} else if (minY < 0 && maxY < 0) {
yAxisCoord = 30;
}
return yAxisCoord;
}
/**
* Integer version of the getXOrigin method; used in draw methods which take
* integer arguments
* @return xOrigin the value of the x-axis x coordinate
* @see #getXOrigin(double)
* @see DrawUtil.#drawTicks
* @see DrawUtil.#drawAxes2
*/
protected int getXOrigin() {
double xOrigin = getXAxisCoord();
return (int) xOrigin;
}
/**
* Integer version of the getYOrigin method; used in draw methods which take
* integer arguments
* @return yOrigin the value of the y-axis y coordinate
* @see #getYOrigin(double)
* @see DrawUtil.#drawTicks
* @see DrawUtil.#drawAxes2
*/
protected int getYOrigin() {
double yOrigin = getYAxisCoord();
return (int) yOrigin;
}
/**
* Method used to calculate how many increments there are altogether, used
* for drawing ticks and grid
* @param vals The data that is being measured
* @param size The size (avaialble height OR width) of the image
* @return numIncrements The number of increments in this data in this size image
* @see DrawUtil.#drawTicks
* @see DrawUtil.#drawGrid
*/
protected int getNumTicks(double[] vals, int size) {
double delta = getDelta(getMin(vals), getMax(vals));
double increment = getIncrement(size, delta);
int numIncrements = (int) (size / increment);
return numIncrements;
}
}