001/* =========================================================== 002 * JFreeChart : a free chart library for the Java(tm) platform 003 * =========================================================== 004 * 005 * (C) Copyright 2000-2011, 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 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates. 025 * Other names may be trademarks of their respective owners.] 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 * 28-Apr-2009 : Fixed bug in legend shape display, and deprecated 039 * getLegendLine() and setLegendLine() - these methods 040 * are unnecessary because a mechanism already exists in the 041 * superclass for specifying a custom legend shape (DG); 042 * 043 */ 044 045package org.jfree.chart.renderer.xy; 046 047import java.awt.Graphics2D; 048import java.awt.Shape; 049import java.awt.geom.GeneralPath; 050import java.awt.geom.Line2D; 051import java.awt.geom.PathIterator; 052import java.awt.geom.Rectangle2D; 053import java.io.IOException; 054import java.io.ObjectInputStream; 055import java.io.ObjectOutputStream; 056import java.io.Serializable; 057 058import org.jfree.chart.axis.ValueAxis; 059import org.jfree.chart.event.RendererChangeEvent; 060import org.jfree.chart.plot.CrosshairState; 061import org.jfree.chart.plot.PlotOrientation; 062import org.jfree.chart.plot.PlotRenderingInfo; 063import org.jfree.chart.plot.XYPlot; 064import org.jfree.data.xy.XYDataset; 065import org.jfree.io.SerialUtilities; 066import org.jfree.ui.RectangleEdge; 067import org.jfree.util.PublicCloneable; 068import org.jfree.util.ShapeUtilities; 069 070/** 071 * A renderer that draws line charts. The renderer doesn't necessarily plot 072 * every data item - instead, it tries to plot only those data items that 073 * make a difference to the visual output (the other data items are skipped). 074 * This renderer is designed for use with the {@link XYPlot} class. 075 * 076 * @since 1.0.13 077 */ 078public class SamplingXYLineRenderer extends AbstractXYItemRenderer 079 implements XYItemRenderer, Cloneable, PublicCloneable, Serializable { 080 081 /** The shape that is used to represent a line in the legend. */ 082 private transient Shape legendLine; 083 084 /** 085 * Creates a new renderer. 086 */ 087 public SamplingXYLineRenderer() { 088 this.legendLine = new Line2D.Double(-7.0, 0.0, 7.0, 0.0); 089 setBaseLegendShape(this.legendLine); 090 setTreatLegendShapeAsLine(true); 091 } 092 093 /** 094 * Returns the shape used to represent a line in the legend. 095 * 096 * @return The legend line (never <code>null</code>). 097 * 098 * @see #setLegendLine(Shape) 099 * 100 * @deprecated As of version 1.0.14, this method is deprecated. You 101 * should use the {@link #getBaseLegendShape()} method instead. 102 */ 103 public Shape getLegendLine() { 104 return this.legendLine; 105 } 106 107 /** 108 * Sets the shape used as a line in each legend item and sends a 109 * {@link RendererChangeEvent} to all registered listeners. 110 * 111 * @param line the line (<code>null</code> not permitted). 112 * 113 * @see #getLegendLine() 114 * 115 * @deprecated As of version 1.0.14, this method is deprecated. You should 116 * use the {@link #setBaseLegendShape(java.awt.Shape)} method instead. 117 */ 118 public void setLegendLine(Shape line) { 119 if (line == null) { 120 throw new IllegalArgumentException("Null 'line' argument."); 121 } 122 this.legendLine = line; 123 fireChangeEvent(); 124 } 125 126 /** 127 * Returns the number of passes through the data that the renderer requires 128 * in order to draw the chart. Most charts will require a single pass, but 129 * some require two passes. 130 * 131 * @return The pass count. 132 */ 133 public int getPassCount() { 134 return 1; 135 } 136 137 /** 138 * Records the state for the renderer. This is used to preserve state 139 * information between calls to the drawItem() method for a single chart 140 * drawing. 141 */ 142 public static class State extends XYItemRendererState { 143 144 /** The path for the current series. */ 145 GeneralPath seriesPath; 146 147 /** 148 * A second path that draws vertical intervals to cover any extreme 149 * values. 150 */ 151 GeneralPath intervalPath; 152 153 /** 154 * The minimum change in the x-value needed to trigger an update to 155 * the seriesPath. 156 */ 157 double dX = 1.0; 158 159 /** The last x-coordinate visited by the seriesPath. */ 160 double lastX; 161 162 /** The initial y-coordinate for the current x-coordinate. */ 163 double openY = 0.0; 164 165 /** The highest y-coordinate for the current x-coordinate. */ 166 double highY = 0.0; 167 168 /** The lowest y-coordinate for the current x-coordinate. */ 169 double lowY = 0.0; 170 171 /** The final y-coordinate for the current x-coordinate. */ 172 double closeY = 0.0; 173 174 /** 175 * A flag that indicates if the last (x, y) point was 'good' 176 * (non-null). 177 */ 178 boolean lastPointGood; 179 180 /** 181 * Creates a new state instance. 182 * 183 * @param info the plot rendering info. 184 */ 185 public State(PlotRenderingInfo info) { 186 super(info); 187 } 188 189 /** 190 * This method is called by the {@link XYPlot} at the start of each 191 * series pass. We reset the state for the current series. 192 * 193 * @param dataset the dataset. 194 * @param series the series index. 195 * @param firstItem the first item index for this pass. 196 * @param lastItem the last item index for this pass. 197 * @param pass the current pass index. 198 * @param passCount the number of passes. 199 */ 200 public void startSeriesPass(XYDataset dataset, int series, 201 int firstItem, int lastItem, int pass, int passCount) { 202 this.seriesPath.reset(); 203 this.intervalPath.reset(); 204 this.lastPointGood = false; 205 super.startSeriesPass(dataset, series, firstItem, lastItem, pass, 206 passCount); 207 } 208 209 } 210 211 /** 212 * Initialises the renderer. 213 * <P> 214 * This method will be called before the first item is rendered, giving the 215 * renderer an opportunity to initialise any state information it wants to 216 * maintain. The renderer can do nothing if it chooses. 217 * 218 * @param g2 the graphics device. 219 * @param dataArea the area inside the axes. 220 * @param plot the plot. 221 * @param data the data. 222 * @param info an optional info collection object to return data back to 223 * the caller. 224 * 225 * @return The renderer state. 226 */ 227 public XYItemRendererState initialise(Graphics2D g2, 228 Rectangle2D dataArea, XYPlot plot, XYDataset data, 229 PlotRenderingInfo info) { 230 231 double dpi = 72; 232 // Integer dpiVal = (Integer) g2.getRenderingHint(HintKey.DPI); 233 // if (dpiVal != null) { 234 // dpi = dpiVal.intValue(); 235 // } 236 State state = new State(info); 237 state.seriesPath = new GeneralPath(); 238 state.intervalPath = new GeneralPath(); 239 state.dX = 72.0 / dpi; 240 return state; 241 } 242 243 /** 244 * Draws the visual representation of a single data item. 245 * 246 * @param g2 the graphics device. 247 * @param state the renderer state. 248 * @param dataArea the area within which the data is being drawn. 249 * @param info collects information about the drawing. 250 * @param plot the plot (can be used to obtain standard color 251 * information etc). 252 * @param domainAxis the domain axis. 253 * @param rangeAxis the range axis. 254 * @param dataset the dataset. 255 * @param series the series index (zero-based). 256 * @param item the item index (zero-based). 257 * @param crosshairState crosshair information for the plot 258 * (<code>null</code> permitted). 259 * @param pass the pass index. 260 */ 261 public void drawItem(Graphics2D g2, 262 XYItemRendererState state, 263 Rectangle2D dataArea, 264 PlotRenderingInfo info, 265 XYPlot plot, 266 ValueAxis domainAxis, 267 ValueAxis rangeAxis, 268 XYDataset dataset, 269 int series, 270 int item, 271 CrosshairState crosshairState, 272 int pass) { 273 274 // do nothing if item is not visible 275 if (!getItemVisible(series, item)) { 276 return; 277 } 278 RectangleEdge xAxisLocation = plot.getDomainAxisEdge(); 279 RectangleEdge yAxisLocation = plot.getRangeAxisEdge(); 280 281 // get the data point... 282 double x1 = dataset.getXValue(series, item); 283 double y1 = dataset.getYValue(series, item); 284 double transX1 = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation); 285 double transY1 = rangeAxis.valueToJava2D(y1, dataArea, yAxisLocation); 286 287 State s = (State) state; 288 // update path to reflect latest point 289 if (!Double.isNaN(transX1) && !Double.isNaN(transY1)) { 290 float x = (float) transX1; 291 float y = (float) transY1; 292 PlotOrientation orientation = plot.getOrientation(); 293 if (orientation == PlotOrientation.HORIZONTAL) { 294 x = (float) transY1; 295 y = (float) transX1; 296 } 297 if (s.lastPointGood) { 298 if ((Math.abs(x - s.lastX) > s.dX)) { 299 s.seriesPath.lineTo(x, y); 300 if (s.lowY < s.highY) { 301 s.intervalPath.moveTo((float) s.lastX, (float) s.lowY); 302 s.intervalPath.lineTo((float) s.lastX, (float) s.highY); 303 } 304 s.lastX = x; 305 s.openY = y; 306 s.highY = y; 307 s.lowY = y; 308 s.closeY = y; 309 } 310 else { 311 s.highY = Math.max(s.highY, y); 312 s.lowY = Math.min(s.lowY, y); 313 s.closeY = y; 314 } 315 } 316 else { 317 s.seriesPath.moveTo(x, y); 318 s.lastX = x; 319 s.openY = y; 320 s.highY = y; 321 s.lowY = y; 322 s.closeY = y; 323 } 324 s.lastPointGood = true; 325 } 326 else { 327 s.lastPointGood = false; 328 } 329 // if this is the last item, draw the path ... 330 if (item == s.getLastItemIndex()) { 331 // draw path 332 PathIterator pi = s.seriesPath.getPathIterator(null); 333 int count = 0; 334 while (!pi.isDone()) { 335 count++; 336 pi.next(); 337 } 338 g2.setStroke(getItemStroke(series, item)); 339 g2.setPaint(getItemPaint(series, item)); 340 g2.draw(s.seriesPath); 341 g2.draw(s.intervalPath); 342 } 343 } 344 345 /** 346 * Returns a clone of the renderer. 347 * 348 * @return A clone. 349 * 350 * @throws CloneNotSupportedException if the clone cannot be created. 351 */ 352 public Object clone() throws CloneNotSupportedException { 353 SamplingXYLineRenderer clone = (SamplingXYLineRenderer) super.clone(); 354 if (this.legendLine != null) { 355 clone.legendLine = ShapeUtilities.clone(this.legendLine); 356 } 357 return clone; 358 } 359 360 /** 361 * Tests this renderer for equality with an arbitrary object. 362 * 363 * @param obj the object (<code>null</code> permitted). 364 * 365 * @return <code>true</code> or <code>false</code>. 366 */ 367 public boolean equals(Object obj) { 368 if (obj == this) { 369 return true; 370 } 371 if (!(obj instanceof SamplingXYLineRenderer)) { 372 return false; 373 } 374 if (!super.equals(obj)) { 375 return false; 376 } 377 SamplingXYLineRenderer that = (SamplingXYLineRenderer) obj; 378 if (!ShapeUtilities.equal(this.legendLine, that.legendLine)) { 379 return false; 380 } 381 return true; 382 } 383 384 /** 385 * Provides serialization support. 386 * 387 * @param stream the input stream. 388 * 389 * @throws IOException if there is an I/O error. 390 * @throws ClassNotFoundException if there is a classpath problem. 391 */ 392 private void readObject(ObjectInputStream stream) 393 throws IOException, ClassNotFoundException { 394 stream.defaultReadObject(); 395 this.legendLine = SerialUtilities.readShape(stream); 396 } 397 398 /** 399 * Provides serialization support. 400 * 401 * @param stream the output stream. 402 * 403 * @throws IOException if there is an I/O error. 404 */ 405 private void writeObject(ObjectOutputStream stream) throws IOException { 406 stream.defaultWriteObject(); 407 SerialUtilities.writeShape(this.legendLine, stream); 408 } 409 410}