• Home
• de.invation.code
• TOVAL
• 1.0.2
• source code
• ScatterChartPanel.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

de.invation.code.toval.graphic.diagrams.panels.ScatterChartPanel Maven / Gradle / Ivy

package de.invation.code.toval.graphic.diagrams.panels;


import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.util.ArrayList;
import java.util.HashMap;

import javax.swing.JPanel;

import de.invation.code.toval.graphic.component.DisplayFrame;
import de.invation.code.toval.graphic.diagrams.models.ChartModel;
import de.invation.code.toval.graphic.diagrams.models.ChartModel.ValueDimension;
import de.invation.code.toval.graphic.util.GraphicUtils;



/**
 * Basic panel for 2-dimensional diagrams.

 * Values for different coordinate axes are kept separately.
 * This gives users the chance to define different kinds of diagrams by changing the way
 * values are depicted inside the diagram itself.
 * The standard behavior defined in this class is that the coordinates of depicted points 
 * directly correspond to the given value sets.
 * Diagram panels can basically operate in two different modes: zero-based or not zero-based.
 * In zero-based mode the coordinate axes always start at zero and end near the highest value for the corresponding dimensions.
 * In non-zero mode the axes start near the smallest values.
 * 
 * @author Thomas Stocker
 */
@SuppressWarnings("serial")
public class ScatterChartPanel extends JPanel {
	
	/**
	 * Spaces between the top, bottom, left and right side of the enclosing panel and the painting area of the diagram itself.
	 */
	protected Insets spacing = new Insets(40,40,40,40);
	/**
	 * Default text distance (i.e. between text and coordinate axes).
	 */
	protected int textSpacing = 5;
	/**
	 * Indicates if the diagram is painted in a zero-based way.

	 * If zero-based, the coordinates always start with zero (possibly discarding values lower than zero) 
	 * and end approximately with the highest value for the corresponding dimension.
	 * Otherwise it will start with the lowest value.
	 */
	protected boolean zeroBased = true;
	/**
	 * Indicates what kind of tick values are valid.

	 * The default behavior is to use floating-point values.
	 */
	private HashMap onlyIntegerTicks = new HashMap();
	/**
	 * Defines the painting region of the diagram (where axes and values are drawed on).

	 * It is calculated out of the available space of the diagram panel and its spacing.
	 */
	private PaintingRegion paintingRegion = new PaintingRegion();
	/**
	 * Tick information (description information) for coordinate axes.

	 * TickInfo-objects encapsulate helpful information about tick values,
	 * such as the first and last tick, tick range and the format used for printing/drawing tick values.
	 */
	protected HashMap tickInfo = new HashMap(2);
	/**
	 * Indicates for which dimensions axes are painted.
	 */
	private HashMap paintDimAxis = new HashMap();
	/**
	 * Indicates if lines are painted between values.
	 */
	private boolean paintLines = false;
	/**
	 * Underlying diagram.
	 */
	protected ChartModel diagram;
	
	/**
	 * Generates a new diagram using the given values for coordinate axes X and Y.
	 */
	public ScatterChartPanel(ChartModel diagram) {
		this(diagram, true);
	}
	
	/**
	 * Generates a new diagram using the given values for coordinate axes X and Y.
	 * @param zeroBased Operation mode
	 * @see #zeroBased
	 */
	public ScatterChartPanel(ChartModel diagram, boolean zeroBased) {
		this(diagram, zeroBased, false, false);
	}
	
	/**
	 * Generates a new diagram using the given values for coordinate axes X and Y.
	 * @param zeroBased Operation mode
	 * @param onlyIntegerTicksX If true only integers are allowed as tick values
	 * @param onlyIntegerTicksY If true only integers are allowed as tick values
	 * @see #zeroBased
	 */
	public ScatterChartPanel(ChartModel diagram, boolean zeroBased, boolean onlyIntegerTicksX, boolean onlyIntegerTicksY) {
		this(diagram, zeroBased, onlyIntegerTicksX, onlyIntegerTicksY, true, true);
	}
	
	/**
	 * Generates a new diagram using the given values for coordinate axes X and Y.
	 * @param zeroBased Operation mode
	 * @param paintDimAxisX Indicates if an axis is painted for dimension X
	 * @param paintDimAxisY Indicates if an axis is painted for dimension Y
	 * @param onlyIntegerTicksX If true only integers are allowed as tick values
	 * @param onlyIntegerTicksY If true only integers are allowed as tick values
	 * @see #zeroBased
	 */
	public ScatterChartPanel(ChartModel diagram, boolean zeroBased, boolean onlyIntegerTicksX, boolean onlyIntegerTicksY, boolean paintDimAxisX, boolean paintDimAxisY) {
		this.diagram = diagram;
		this.zeroBased = zeroBased;
		onlyIntegerTicks.put(ValueDimension.X, onlyIntegerTicksX);
		onlyIntegerTicks.put(ValueDimension.Y, onlyIntegerTicksY);
		tickInfo.put(ValueDimension.X, new TickInfo(diagram.getValues(ValueDimension.X).min().doubleValue(), diagram.getValues(ValueDimension.X).max().doubleValue(), zeroBased));
		tickInfo.put(ValueDimension.Y, new TickInfo(diagram.getValues(ValueDimension.Y).min().doubleValue(), diagram.getValues(ValueDimension.Y).max().doubleValue(), zeroBased));
		paintDimAxis.put(ValueDimension.X, paintDimAxisX);
		paintDimAxis.put(ValueDimension.Y, paintDimAxisY);
		if(onlyIntegerTicksX){
			setTickSpacing(ValueDimension.X, 1, false);
		}
		if(onlyIntegerTicksY){
			setTickSpacing(ValueDimension.Y, 1, false);
		}
		setBackground(getBackground());
	}
	
	@Override
	public Color getBackground() {
		return Color.white;
	}
	
	/**
	 * Returns the range of the maintained values for the given dimension.
	 * @param dim Reference dimension for range extraction
	 * @return Range of the maintained values for the given dimension
	 */
	protected double getRange(ValueDimension dim) {
		return zeroBased ? diagram.getValues(dim).max().doubleValue() : diagram.getValues(dim).range();
	}
	
	/**
	 * Returns the minimum value of the maintained values for the given dimension.
	 * @param dim Reference dimension for minimum extraction
	 * @return Minimum of the maintained values for the given dimension
	 */
	protected double getMinValue(ValueDimension dim) {
		return zeroBased ? 0.0 : diagram.getValues(dim).min().doubleValue();
	}
	
	/**
	 * Returns the maximum value of the maintained values for the given dimension.
	 * @param key Reference dimension for maximum extraction
	 * @return Maximum of the maintained values for the given dimension
	 */
	protected double getMaxValue(ValueDimension key) {
		return diagram.getValues(key).max().doubleValue();
	}

	/**
	 * Returns the painting region of the diagram (where axes and values are drawed on).

	 * It is calculated out of the available space of the diagram panel and its spacing.
	 * @return Region used for drawing axes and values
	 */
	protected PaintingRegion getPaintingRegion() {
		return paintingRegion;
	}
	
	/**
	 * Returns the text distance (i.e. between text and coordinate axes).
	 * @return Distance between text and other diagram-components
	 */
	protected int getTextSpacing() {
		return textSpacing;
	}
	
	/**
	 * Returns the preferred size of this diagram which is calculated on the basis of the 
	 * required space for ticks and the diagram spacing.
	 */
	@Override
	public Dimension getPreferredSize() {
		return new Dimension(getRequiredPoints(ValueDimension.X) + spacing.left + spacing.right, 
						   	 getRequiredPoints(ValueDimension.Y) + spacing.top + spacing.bottom);
	}
	
	/**
	 * Returns tick information for coordinate axes of the given dimension.
	 * @param dim Reference dimension for tick information
	 * @return tick information for the given dimension
	 */
	protected TickInfo getTickInfo(ValueDimension dim) {
		return tickInfo.get(dim);
	}
	
	/**
	 * Sets the tick spacing for the coordinate axis of the given dimension.

	 * minorTickSpacing sets the minor tick spacing,
	 * major tick spacing is a multiple of minor tick spacing and determined with the help of a multiplicator.
	 * @param dim Reference dimension for calculation
	 * @param minorTickSpacing Minor tick spacing
	 * @see TickInfo#getTickMultiplicator()
	 */
	public void setTickSpacing(ValueDimension dim, double minorTickSpacing, boolean repaint) {
		setTickSpacing(dim, minorTickSpacing, getTickInfo(dim).getTickMultiplicator(), repaint);
	}
	
	/**
	 * Sets the tick spacing for the coordinate axis of the given dimension.

	 * minorTickSpacing sets the minor tick spacing,
	 * major tick spacing is a multiple of minor tick spacing and determined with the help of multiplicator
	 * @param dim Reference dimension for calculation
	 * @param minorTickSpacing Minor tick spacing
	 * @param multiplicator Multiplicator for detrermining the major tick spacing.
	 */
	public void setTickSpacing(ValueDimension dim, double minorTickSpacing, int multiplicator, boolean repaint) {
		double tickSpacing = minorTickSpacing;
		if(onlyIntegerTicks.get(dim)) {
			tickSpacing = (int) tickSpacing;
			if (tickSpacing == 0) tickSpacing = 1;
		}
		getTickInfo(dim).setTickSpacing(tickSpacing, multiplicator);
		if(repaint){
			revalidate();
			repaint();
		}
	}
	
	/**
	 * Sets the operation mode.
	 * In zero-based mode coordinate axes always start at 0 and end near the maximum value of the corresponding dimension.
	 * Otherwise axes start at the minimum value.
	 * @param zeroBased Operation mode
	 */
	public void setZeroBased(boolean zeroBased) {
		if(zeroBased != this.zeroBased) {
			this.zeroBased = zeroBased;
			for(ValueDimension dim: tickInfo.keySet())
				tickInfo.get(dim).setZeroBased(zeroBased);
		}
	}
	
	/**
	 * Sets the painting lines mode.
	 * If set to true, plines between values are painted.
	 * @param paintLines
	 */
	public void setPaintLines(boolean paintLines){
		this.paintLines = paintLines;
	}
	
	/**
	 * Determines the required space (in points) for painting ticks for the coordinate axis of the given dimension.
	 * The basic assumption here is, that the first dimension (X) is drawed horizontally and the second dimension (Y) is drawed vertically.
	 * @param dim Reference dimension for space calculation
	 * @return Required points for painting tick information
	 */
	protected int getRequiredPoints(ValueDimension dim) {
		int requiredPointsPerTick = getGraphics().getFontMetrics().getHeight();
		if(dim == ValueDimension.X) {
			int first = getGraphics().getFontMetrics().stringWidth(String.format(getTickInfo(dim).getFormat(), getTickInfo(dim).getFirstTick()));
			int last = getGraphics().getFontMetrics().stringWidth(String.format(getTickInfo(dim).getFormat(), getTickInfo(dim).getLastTick()));
			requiredPointsPerTick = Math.max(first, last)+2;
		} 
		return requiredPointsPerTick*getTickInfo(dim).getTickNumber();
	}
	
	/**
	 * Overrides the super-method paintComponent to incorporate axes, ticks and values.
	 */
	@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		getPaintingRegion().update();
		paintAxes(g);
		paintTicks(g);
		paintValues(g, paintLines);
	}
	 
	/**
	 * Paints axes for all maintained dimensions (in this case two).

	 * Has to be overridden by subclasses, if more than two dimensions have to be considered.
	 * @param g Graphics context.
	 */
	protected void paintAxes(Graphics g) {
		Point origin = getPaintingRegion().getBottomLeft();
		if(isAxisPaintedfor(ValueDimension.X)) {
			Point xEnd = getXAxisEnd();
			g.drawLine(origin.x, origin.y, xEnd.x, xEnd.y);
		}
		if(isAxisPaintedfor(ValueDimension.Y)) {
			Point yEnd = getYAxisEnd();
			g.drawLine(origin.x, origin.y, yEnd.x, yEnd.y);
		}
	}
	
	public boolean isAxisPaintedfor(ValueDimension dim) {
		return paintDimAxis.get(dim);
	}
	
	/**
	 * Paints tick information for all maintained dimensions (in this case two)
	 * @param g Graphics context
	 */
	protected void paintTicks(Graphics g) {
		if(isAxisPaintedfor(ValueDimension.X))
			paintTicks(g, ValueDimension.X);
		if(isAxisPaintedfor(ValueDimension.Y))
			paintTicks(g, ValueDimension.Y);
	}
	
	/**
	 * Paints tick information for the coordinate axis of the given dimension.
	 * @param g Graphics context
	 * @param dim Reference dimension for tick painting
	 */
	protected void paintTicks(Graphics g, ValueDimension dim) {
		for(int i=0; i
	 * This number is equal for each dimension.
	 */
	protected int getValueCount() {
		return diagram.getValueCount(ValueDimension.X);
	}
	
	/**
	 * Returns the end-point of the X-axis (axis for the first dimension).
	 * Starting-point is always the painting regions' bottom left edge.

	 * Default is the bottom right edge of the painting region. This method can be overridden
	 * to introduce additional spacing.
	 * @return End-point used for painting the X-axis
	 */
	protected Point getXAxisEnd() {
		return getPaintingRegion().getBottomRight();
	}
	
	/**
	 * Returns the end-point of the Y-axis (axis for the second dimension).
	 * Starting-point is always the painting regions' bottom left edge.

	 * Default is the top left edge of the painting region. This method can be overridden
	 * to introduce additional spacing.
	 * @return End-point used for painting the X-axis
	 */
	protected Point getYAxisEnd() {
		return getPaintingRegion().getTopLeft();
	}
	
	/**
	 * Determines the point coordinates for a given value-vector on the base of the maintained dimensions.

	 * Given two dimensions X and Y with values x1,...,xn and y1,...,yn this method just returns a point 
	 * P(xi,yi) which matches the desired behavior of a standard 2-dimensional diagrams such as graph-plots.

	 * For changing the way these points are determined it is recommended to override the methods {@link #getXFor(Number)} and {@link #getXFor(Number)} rather than this method,
	 * since it simply combines the values of these two methods.
	 * @param index Index for values within the maintained value lists for different dimensions
	 * @return Point determined on the basis of maintained values
	 * @see #getXFor(Number)
	 * @see #getYFor(Number)
	 */
	protected Point getPointFor(int index) {
		return new Point(getXFor(diagram.getValue(ValueDimension.X, index)), getYFor(diagram.getValue(ValueDimension.Y, index)));
	}
	
	/**
	 * Returns the X-coordinate for a given value of the first dimension (X),
	 * considering the actual operation-mode {@link #zeroBased}.

	 * This implementation simply returns a value that reflects the position of the given value with respect to the coordinate axis X.
	 * @param value Value of the maintained X-dimension
	 * @return X-coordinate for the given value
	 */
	protected Integer getXFor(Number value) {
		double offset = zeroBased ? 0.0 : getTickInfo(ValueDimension.X).getFirstTick();
		return getPaintingRegion().getBottomLeft().x + (int) Math.round((value.doubleValue()-offset)*getPaintingRegion().getUnit(ValueDimension.X));
	}
	
	/**
	 * Returns the Y-coordinate for a given value of the second dimension (Y),
	 * considering the actual operation-mode {@link #zeroBased}.

	 * This implementation simply returns a value that reflects the position of the given value with respect to the coordinate axis Y.
	 * @param value Value of the maintained Y-dimension
	 * @return Y-coordinate for the given value
	 */
	protected Integer getYFor(Number value) {
		double offset = zeroBased ? 0.0 : getTickInfo(ValueDimension.Y).getFirstTick();
		return getPaintingRegion().getBottomLeft().y - (int) Math.round((value.doubleValue()-offset)*getPaintingRegion().getUnit(ValueDimension.Y));
	}
	
	/**
	 * Displays the diagram as content of a newly generated JFrame-instance.
	 */
	public void asFrame() {
		new DisplayFrame(this, false);
	}
	
	/**
	 * Returns an adjustable version of this chart.
	 * @return An adjustable version of this chart
	 * @see AdjustableDiagramPanel
	 */
	public AdjustableDiagramPanel adjustableVersion() {
		return new AdjustableDiagramPanel(this);
	}
	
	/**
	 * Class for managing properties of the painting region of a diagram panel.
	 * @author Thomas Stocker
	 */
	protected class PaintingRegion {
		/**
		 * Top left corner of the painting region.
		 */
		private Point topLeft;
		/**
		 * Top right corner of the painting region.
		 */
		private Point topRight;
		/**
		 * Bottom left corner of the painting region.
		 */
		private Point bottomLeft;
		/**
		 * Bottom right corner of the painting region.
		 */
		private Point bottomRight;
		/**
		 * Center of the painting region.
		 */
		private Point center;
		/**
		 * Width of the painting region.
		 */
		private int width;
		/**
		 * Height of the painting region.
		 */
		private int height;
		
		/**
		 * Keeps measures depending on the actual size of the painting area.

		 * 
		 * 
		 *  
		 * 
		 *  
		 * 
		 * 
Index 0:
unit
Points(pixels) per value-unit
Index 1:
valueDistance
Points(pixels) per value-entry
Index 2:
text position (for X a Y-value and vice versa)
		 * Index 1: 
		 * 			Points(pixels) per value-entry
		 * Index 2: text position (for X a Y-value and vice versa)
		 */
		private HashMap> measures = new HashMap>(2);
		
		/**
		 * Creates a new PaintingRegion.
		 */
		public PaintingRegion() {
			measures.put(ValueDimension.X, new ArrayList(3));
			measures.put(ValueDimension.Y, new ArrayList(3));
		}
		
		/**
		 * Updates the stored measures based on the actual size of the diagram.

		 * Because measures depend on diagram dimensions they have to be recalculated
		 * on resize events.
		 */
		public void update() {
			width = getWidth()-(spacing.right+spacing.left);
			height = getHeight()-(spacing.top+spacing.bottom);
			topLeft = new Point(spacing.left, spacing.top);
			topRight = new Point(topLeft.x+width, topLeft.y);
			bottomLeft = new Point(topLeft.x, topLeft.y+height);
			bottomRight = new Point(topRight.x, bottomLeft.y);
			center = new Point(topLeft.x+(int)(width/2.0), topLeft.y+(int)(height/2.0));
			measures.get(ValueDimension.X).clear();
			measures.get(ValueDimension.Y).clear();
			measures.get(ValueDimension.X).add(width/getTickInfo(ValueDimension.X).getTickRange());
			measures.get(ValueDimension.Y).add(height/getTickInfo(ValueDimension.Y).getTickRange());
			measures.get(ValueDimension.X).add(width/(getValueCount() - 1.0));
			measures.get(ValueDimension.Y).add(height/(getValueCount() - 1.0));
			measures.get(ValueDimension.X).add(bottomLeft.y + getTextSpacing() + getGraphics().getFontMetrics().getHeight() + 0.0);
			measures.get(ValueDimension.Y).add(bottomLeft.x - getTextSpacing() + 0.0);
		}
		
		/**
		 * Returns the top left corner of the painting region.
		 * @return The top left corner of the painting region
		 */
		public Point getTopLeft() {
			return topLeft;
		}
		
		/**
		 * Returns the top right corner of the painting region.
		 * @return The top right corner of the painting region
		 */
		public Point getTopRight() {
			return topRight;
		}
		
		/**
		 * Returns the bottom left corner of the painting region.
		 * @return The bottom left corner of the painting region
		 */
		public Point getBottomLeft() {
			return bottomLeft;
		}
		
		/**
		 * Returns the bottom right corner of the painting region.
		 * @return The bottom right corner of the painting region
		 */
		public Point getBottomRight() {
			return bottomRight;
		}
		
		/**
		 * Returns the center of the painting region.
		 * @return The center of the painting region
		 */
		public Point getCenter() {
			return center;
		}
		
		/**
		 * Returns the unit-measure (i.e. the points/pixels per value/unit) for the given dimension.

		 * The unit specifies the per-value space of a dimension in pixels and is based on the value range.

		 * If there is a value range of 10.2 and there are 200 pixels available for this dimension,
		 * the unit would be 200/10.2
		 * @param dim Reference dimension for calculation
		 * @return The per/value unit in pixels for the given dimension
		 */
		public double getUnit(ValueDimension dim) {
			return measures.get(dim).get(0);
		}
		
		/**
		 * Returns the value distance in pixels for the given dimension.

		 * This measure describes how much space in pixels lies between one value and another
		 * if they are arranged with equal distance on a line with a total length of the
		 * available space for a dimension.
 
		 * If there are 200 pixels available for the given dimension and there are 20 values to display,
		 * the value distance is 200/(20-1).
		 * @param dim Reference dimension for calculation
		 * @return Value distance for the given dimension
		 */
		public int getValueDistance(ValueDimension dim) {
			return (int) Math.round(measures.get(dim).get(1));
		}
		
		/**
		 * Returns the Position of the given description string according to the given dimension and reference point.

		 * If i.e. there is a value for the X-coordinate at position x0, that has a description (the value itself as string or another textual description),
		 * this method returns the x-Position where the description "desc" can be drawed.
		 * In this implementation it places the descriptions centered relating to the given reference point.
		 * @param dim Reference dimension for calculation
		 * @param str String that has to be drawn
		 * @param ref Reference position (dimension dependent)
		 * @return The position of str according to the given dimension dim.
		 */
		public Point getDescriptionPos(ValueDimension dim, String str, int ref) {
			switch(dim) {
				case X: return new Point(ref-getGraphics().getFontMetrics().stringWidth(str)/2, (int) Math.round(measures.get(dim).get(2)));
				case Y: return new Point((int) Math.round(measures.get(dim).get(2)-getGraphics().getFontMetrics().stringWidth(str)), ref-getGraphics().getFontMetrics().getHeight()/2+8);
				default: return null;
			}
		}
		
	}

}