001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2009, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * ---------------------------
028 * SamplingXYLineRenderer.java
029 * ---------------------------
030 * (C) Copyright 2008, 2009, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * Changes:
036 * --------
037 * 02-Oct-2008 : Version 1 (DG);
038 *
039 */
040
041 package org.jfree.chart.renderer.xy;
042
043 import java.awt.Graphics2D;
044 import java.awt.Paint;
045 import java.awt.Shape;
046 import java.awt.geom.GeneralPath;
047 import java.awt.geom.Line2D;
048 import java.awt.geom.PathIterator;
049 import java.awt.geom.Rectangle2D;
050 import java.io.IOException;
051 import java.io.ObjectInputStream;
052 import java.io.ObjectOutputStream;
053 import java.io.Serializable;
054
055 import org.jfree.chart.LegendItem;
056 import org.jfree.chart.axis.ValueAxis;
057 import org.jfree.chart.event.RendererChangeEvent;
058 import org.jfree.chart.plot.CrosshairState;
059 import org.jfree.chart.plot.PlotOrientation;
060 import org.jfree.chart.plot.PlotRenderingInfo;
061 import org.jfree.chart.plot.XYPlot;
062 import org.jfree.data.xy.XYDataset;
063 import org.jfree.io.SerialUtilities;
064 import org.jfree.ui.RectangleEdge;
065 import org.jfree.util.PublicCloneable;
066 import org.jfree.util.ShapeUtilities;
067
068 /**
069 * A renderer that... This renderer is designed for use with the {@link XYPlot}
070 * class.
071 */
072 public class SamplingXYLineRenderer extends AbstractXYItemRenderer
073 implements XYItemRenderer, Cloneable, PublicCloneable, Serializable {
074
075 /** The shape that is used to represent a line in the legend. */
076 private transient Shape legendLine;
077
078 /**
079 * Creates a new renderer.
080 */
081 public SamplingXYLineRenderer() {
082 this.legendLine = new Line2D.Double(-7.0, 0.0, 7.0, 0.0);
083 }
084
085 /**
086 * Returns the shape used to represent a line in the legend.
087 *
088 * @return The legend line (never <code>null</code>).
089 *
090 * @see #setLegendLine(Shape)
091 */
092 public Shape getLegendLine() {
093 return this.legendLine;
094 }
095
096 /**
097 * Sets the shape used as a line in each legend item and sends a
098 * {@link RendererChangeEvent} to all registered listeners.
099 *
100 * @param line the line (<code>null</code> not permitted).
101 *
102 * @see #getLegendLine()
103 */
104 public void setLegendLine(Shape line) {
105 if (line == null) {
106 throw new IllegalArgumentException("Null 'line' argument.");
107 }
108 this.legendLine = line;
109 fireChangeEvent();
110 }
111
112 /**
113 * Returns the number of passes through the data that the renderer requires
114 * in order to draw the chart. Most charts will require a single pass, but
115 * some require two passes.
116 *
117 * @return The pass count.
118 */
119 public int getPassCount() {
120 return 1;
121 }
122
123 /**
124 * Records the state for the renderer. This is used to preserve state
125 * information between calls to the drawItem() method for a single chart
126 * drawing.
127 */
128 public static class State extends XYItemRendererState {
129
130 /** The path for the current series. */
131 GeneralPath seriesPath;
132
133 /**
134 * A second path that draws vertical intervals to cover any extreme
135 * values.
136 */
137 GeneralPath intervalPath;
138
139 /**
140 * The minimum change in the x-value needed to trigger an update to
141 * the seriesPath.
142 */
143 double dX = 1.0;
144
145 /** The last x-coordinate visited by the seriesPath. */
146 double lastX;
147
148 /** The initial y-coordinate for the current x-coordinate. */
149 double openY = 0.0;
150
151 /** The highest y-coordinate for the current x-coordinate. */
152 double highY = 0.0;
153
154 /** The lowest y-coordinate for the current x-coordinate. */
155 double lowY = 0.0;
156
157 /** The final y-coordinate for the current x-coordinate. */
158 double closeY = 0.0;
159
160 /**
161 * A flag that indicates if the last (x, y) point was 'good'
162 * (non-null).
163 */
164 boolean lastPointGood;
165
166 /**
167 * Creates a new state instance.
168 *
169 * @param info the plot rendering info.
170 */
171 public State(PlotRenderingInfo info) {
172 super(info);
173 }
174
175 /**
176 * This method is called by the {@link XYPlot} at the start of each
177 * series pass. We reset the state for the current series.
178 *
179 * @param dataset the dataset.
180 * @param series the series index.
181 * @param firstItem the first item index for this pass.
182 * @param lastItem the last item index for this pass.
183 * @param pass the current pass index.
184 * @param passCount the number of passes.
185 */
186 public void startSeriesPass(XYDataset dataset, int series,
187 int firstItem, int lastItem, int pass, int passCount) {
188 this.seriesPath.reset();
189 this.lastPointGood = false;
190 super.startSeriesPass(dataset, series, firstItem, lastItem, pass,
191 passCount);
192 }
193
194 }
195
196 /**
197 * Initialises the renderer.
198 * <P>
199 * This method will be called before the first item is rendered, giving the
200 * renderer an opportunity to initialise any state information it wants to
201 * maintain. The renderer can do nothing if it chooses.
202 *
203 * @param g2 the graphics device.
204 * @param dataArea the area inside the axes.
205 * @param plot the plot.
206 * @param data the data.
207 * @param info an optional info collection object to return data back to
208 * the caller.
209 *
210 * @return The renderer state.
211 */
212 public XYItemRendererState initialise(Graphics2D g2,
213 Rectangle2D dataArea, XYPlot plot, XYDataset data,
214 PlotRenderingInfo info) {
215
216 double dpi = 72;
217 // Integer dpiVal = (Integer) g2.getRenderingHint(HintKey.DPI);
218 // if (dpiVal != null) {
219 // dpi = dpiVal.intValue();
220 // }
221 State state = new State(info);
222 state.seriesPath = new GeneralPath();
223 state.intervalPath = new GeneralPath();
224 state.dX = 72.0 / dpi;
225 return state;
226 }
227
228 /**
229 * Draws the visual representation of a single data item.
230 *
231 * @param g2 the graphics device.
232 * @param state the renderer state.
233 * @param dataArea the area within which the data is being drawn.
234 * @param info collects information about the drawing.
235 * @param plot the plot (can be used to obtain standard color
236 * information etc).
237 * @param domainAxis the domain axis.
238 * @param rangeAxis the range axis.
239 * @param dataset the dataset.
240 * @param series the series index (zero-based).
241 * @param item the item index (zero-based).
242 * @param crosshairState crosshair information for the plot
243 * (<code>null</code> permitted).
244 * @param pass the pass index.
245 */
246 public void drawItem(Graphics2D g2,
247 XYItemRendererState state,
248 Rectangle2D dataArea,
249 PlotRenderingInfo info,
250 XYPlot plot,
251 ValueAxis domainAxis,
252 ValueAxis rangeAxis,
253 XYDataset dataset,
254 int series,
255 int item,
256 CrosshairState crosshairState,
257 int pass) {
258
259 // do nothing if item is not visible
260 if (!getItemVisible(series, item)) {
261 return;
262 }
263 RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
264 RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
265
266 // get the data point...
267 double x1 = dataset.getXValue(series, item);
268 double y1 = dataset.getYValue(series, item);
269 double transX1 = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation);
270 double transY1 = rangeAxis.valueToJava2D(y1, dataArea, yAxisLocation);
271
272 State s = (State) state;
273 // update path to reflect latest point
274 if (!Double.isNaN(transX1) && !Double.isNaN(transY1)) {
275 float x = (float) transX1;
276 float y = (float) transY1;
277 PlotOrientation orientation = plot.getOrientation();
278 if (orientation == PlotOrientation.HORIZONTAL) {
279 x = (float) transY1;
280 y = (float) transX1;
281 }
282 if (s.lastPointGood) {
283 if ((Math.abs(x - s.lastX) > s.dX)) {
284 s.seriesPath.lineTo(x, y);
285 if (s.lowY < s.highY) {
286 s.intervalPath.moveTo((float) s.lastX, (float) s.lowY);
287 s.intervalPath.lineTo((float) s.lastX, (float) s.highY);
288 }
289 s.lastX = x;
290 s.openY = y;
291 s.highY = y;
292 s.lowY = y;
293 s.closeY = y;
294 }
295 else {
296 s.highY = Math.max(s.highY, y);
297 s.lowY = Math.min(s.lowY, y);
298 s.closeY = y;
299 }
300 }
301 else {
302 s.seriesPath.moveTo(x, y);
303 s.lastX = x;
304 s.openY = y;
305 s.highY = y;
306 s.lowY = y;
307 s.closeY = y;
308 }
309 s.lastPointGood = true;
310 }
311 else {
312 s.lastPointGood = false;
313 }
314 // if this is the last item, draw the path ...
315 if (item == s.getLastItemIndex()) {
316 // draw path
317 PathIterator pi = s.seriesPath.getPathIterator(null);
318 int count = 0;
319 while (!pi.isDone()) {
320 count++;
321 pi.next();
322 }
323 g2.setStroke(getItemStroke(series, item));
324 g2.setPaint(getItemPaint(series, item));
325 g2.draw(s.seriesPath);
326 g2.draw(s.intervalPath);
327 }
328 }
329
330 /**
331 * Returns a legend item for the specified series.
332 *
333 * @param datasetIndex the dataset index (zero-based).
334 * @param series the series index (zero-based).
335 *
336 * @return A legend item for the series.
337 */
338 public LegendItem getLegendItem(int datasetIndex, int series) {
339
340 XYPlot plot = getPlot();
341 if (plot == null) {
342 return null;
343 }
344
345 LegendItem result = null;
346 XYDataset dataset = plot.getDataset(datasetIndex);
347 if (dataset != null) {
348 if (getItemVisible(series, 0)) {
349 String label = getLegendItemLabelGenerator().generateLabel(
350 dataset, series);
351 result = new LegendItem(label);
352 result.setLabelFont(lookupLegendTextFont(series));
353 Paint labelPaint = lookupLegendTextPaint(series);
354 if (labelPaint != null) {
355 result.setLabelPaint(labelPaint);
356 }
357 result.setSeriesKey(dataset.getSeriesKey(series));
358 result.setSeriesIndex(series);
359 result.setDataset(dataset);
360 result.setDatasetIndex(datasetIndex);
361 }
362 }
363 return result;
364
365 }
366
367 /**
368 * Returns a clone of the renderer.
369 *
370 * @return A clone.
371 *
372 * @throws CloneNotSupportedException if the clone cannot be created.
373 */
374 public Object clone() throws CloneNotSupportedException {
375 SamplingXYLineRenderer clone = (SamplingXYLineRenderer) super.clone();
376 if (this.legendLine != null) {
377 clone.legendLine = ShapeUtilities.clone(this.legendLine);
378 }
379 return clone;
380 }
381
382 /**
383 * Tests this renderer for equality with an arbitrary object.
384 *
385 * @param obj the object (<code>null</code> permitted).
386 *
387 * @return <code>true</code> or <code>false</code>.
388 */
389 public boolean equals(Object obj) {
390 if (obj == this) {
391 return true;
392 }
393 if (!(obj instanceof SamplingXYLineRenderer)) {
394 return false;
395 }
396 if (!super.equals(obj)) {
397 return false;
398 }
399 SamplingXYLineRenderer that = (SamplingXYLineRenderer) obj;
400 if (!ShapeUtilities.equal(this.legendLine, that.legendLine)) {
401 return false;
402 }
403 return true;
404 }
405
406 /**
407 * Provides serialization support.
408 *
409 * @param stream the input stream.
410 *
411 * @throws IOException if there is an I/O error.
412 * @throws ClassNotFoundException if there is a classpath problem.
413 */
414 private void readObject(ObjectInputStream stream)
415 throws IOException, ClassNotFoundException {
416 stream.defaultReadObject();
417 this.legendLine = SerialUtilities.readShape(stream);
418 }
419
420 /**
421 * Provides serialization support.
422 *
423 * @param stream the output stream.
424 *
425 * @throws IOException if there is an I/O error.
426 */
427 private void writeObject(ObjectOutputStream stream) throws IOException {
428 stream.defaultWriteObject();
429 SerialUtilities.writeShape(this.legendLine, stream);
430 }
431
432 }