Source for org.jfree.chart.axis.ColorBar

   1: /* ===========================================================
   2:  * JFreeChart : a free chart library for the Java(tm) platform
   3:  * ===========================================================
   4:  *
   5:  * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors.
   6:  *
   7:  * Project Info:  http://www.jfree.org/jfreechart/index.html
   8:  *
   9:  * This library is free software; you can redistribute it and/or modify it 
  10:  * under the terms of the GNU Lesser General Public License as published by 
  11:  * the Free Software Foundation; either version 2.1 of the License, or 
  12:  * (at your option) any later version.
  13:  *
  14:  * This library is distributed in the hope that it will be useful, but 
  15:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
  16:  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
  17:  * License for more details.
  18:  *
  19:  * You should have received a copy of the GNU Lesser General Public
  20:  * License along with this library; if not, write to the Free Software
  21:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
  22:  * USA.  
  23:  *
  24:  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
  25:  * in the United States and other countries.]
  26:  *
  27:  * -------------
  28:  * ColorBar.java
  29:  * -------------
  30:  * (C) Copyright 2002-2007, by David M. O'Donnell and Contributors.
  31:  *
  32:  * Original Author:  David M. O'Donnell;
  33:  * Contributor(s):   David Gilbert (for Object Refinery Limited);
  34:  *
  35:  * Changes
  36:  * -------
  37:  * 26-Nov-2002 : Version 1 contributed by David M. O'Donnell (DG);
  38:  * 14-Jan-2003 : Changed autoRangeMinimumSize from Number --> double (DG);
  39:  * 17-Jan-2003 : Moved plot classes to separate package (DG);
  40:  * 20-Jan-2003 : Removed unnecessary constructors (DG);
  41:  * 26-Mar-2003 : Implemented Serializable (DG);
  42:  * 09-Jul-2003 : Changed ColorBar from extending axis classes to enclosing 
  43:  *               them (DG);
  44:  * 05-Aug-2003 : Applied changes in bug report 780298 (DG);
  45:  * 14-Aug-2003 : Implemented Cloneable (DG);
  46:  * 08-Sep-2003 : Changed ValueAxis API (DG);
  47:  * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
  48:  * ------------- JFREECHART 1.0.x ---------------------------------------------
  49:  * 31-Jan-2007 : Deprecated (DG);
  50:  *
  51:  */
  52: 
  53: package org.jfree.chart.axis;
  54: 
  55: import java.awt.BasicStroke;
  56: import java.awt.Graphics2D;
  57: import java.awt.Paint;
  58: import java.awt.RenderingHints;
  59: import java.awt.Stroke;
  60: import java.awt.geom.Line2D;
  61: import java.awt.geom.Rectangle2D;
  62: import java.io.Serializable;
  63: 
  64: import org.jfree.chart.plot.ColorPalette;
  65: import org.jfree.chart.plot.ContourPlot;
  66: import org.jfree.chart.plot.Plot;
  67: import org.jfree.chart.plot.RainbowPalette;
  68: import org.jfree.chart.plot.XYPlot;
  69: import org.jfree.chart.renderer.xy.XYBlockRenderer;
  70: import org.jfree.ui.RectangleEdge;
  71: 
  72: /**
  73:  * A color bar.
  74:  *
  75:  * @deprecated This class is no longer supported (as of version 1.0.4).  If 
  76:  *     you are creating contour plots, please try to use {@link XYPlot} and 
  77:  *     {@link XYBlockRenderer}.
  78:  */
  79: public class ColorBar implements Cloneable, Serializable {
  80: 
  81:     /** For serialization. */
  82:     private static final long serialVersionUID = -2101776212647268103L;
  83:     
  84:     /** The default color bar thickness. */
  85:     public static final int DEFAULT_COLORBAR_THICKNESS = 0;
  86: 
  87:     /** The default color bar thickness percentage. */
  88:     public static final double DEFAULT_COLORBAR_THICKNESS_PERCENT = 0.10;
  89: 
  90:     /** The default outer gap. */
  91:     public static final int DEFAULT_OUTERGAP = 2;
  92: 
  93:     /** The axis. */
  94:     private ValueAxis axis;
  95:     
  96:     /** The color bar thickness. */
  97:     private int colorBarThickness = DEFAULT_COLORBAR_THICKNESS;
  98: 
  99:     /** 
 100:      * The color bar thickness as a percentage of the height of the data area. 
 101:      */
 102:     private double colorBarThicknessPercent 
 103:             = DEFAULT_COLORBAR_THICKNESS_PERCENT;
 104: 
 105:     /** The color palette. */
 106:     private ColorPalette colorPalette = null;
 107: 
 108:     /** The color bar length. */
 109:     private int colorBarLength = 0; // default make height of plotArea
 110: 
 111:     /** The amount of blank space around the colorbar. */
 112:     private int outerGap;
 113: 
 114:     /**
 115:      * Constructs a horizontal colorbar axis, using default values where 
 116:      * necessary.
 117:      *
 118:      * @param label  the axis label.
 119:      */
 120:     public ColorBar(String label) {
 121:    
 122:         NumberAxis a = new NumberAxis(label);
 123:         a.setAutoRangeIncludesZero(false);
 124:         this.axis = a;
 125:         this.axis.setLowerMargin(0.0);
 126:         this.axis.setUpperMargin(0.0);
 127: 
 128:         this.colorPalette = new RainbowPalette();
 129:         this.colorBarThickness = DEFAULT_COLORBAR_THICKNESS;
 130:         this.colorBarThicknessPercent = DEFAULT_COLORBAR_THICKNESS_PERCENT;
 131:         this.outerGap = DEFAULT_OUTERGAP;
 132:         this.colorPalette.setMinZ(this.axis.getRange().getLowerBound());
 133:         this.colorPalette.setMaxZ(this.axis.getRange().getUpperBound());
 134: 
 135:     }
 136: 
 137:     /**
 138:      * Configures the color bar.
 139:      * 
 140:      * @param plot  the plot.
 141:      */
 142:     public void configure(ContourPlot plot) {
 143:         double minZ = plot.getDataset().getMinZValue();
 144:         double maxZ = plot.getDataset().getMaxZValue();
 145:         setMinimumValue(minZ);
 146:         setMaximumValue(maxZ);
 147:     }
 148:     
 149:     /**
 150:      * Returns the axis.
 151:      * 
 152:      * @return The axis.
 153:      */
 154:     public ValueAxis getAxis() {
 155:         return this.axis;
 156:     }
 157:     
 158:     /**
 159:      * Sets the axis.
 160:      * 
 161:      * @param axis  the axis.
 162:      */
 163:     public void setAxis(ValueAxis axis) {
 164:         this.axis = axis;
 165:     }
 166:     
 167:     /**
 168:      * Rescales the axis to ensure that all data are visible.
 169:      */
 170:     public void autoAdjustRange() {
 171:         this.axis.autoAdjustRange();
 172:         this.colorPalette.setMinZ(this.axis.getLowerBound());
 173:         this.colorPalette.setMaxZ(this.axis.getUpperBound());
 174:     }
 175: 
 176:     /**
 177:      * Draws the plot on a Java 2D graphics device (such as the screen or a 
 178:      * printer).
 179:      *
 180:      * @param g2  the graphics device.
 181:      * @param cursor  the cursor.
 182:      * @param plotArea  the area within which the chart should be drawn.
 183:      * @param dataArea  the area within which the plot should be drawn (a
 184:      *                  subset of the drawArea).
 185:      * @param reservedArea  the reserved area.
 186:      * @param edge  the color bar location.
 187:      * 
 188:      * @return The new cursor location.
 189:      */
 190:     public double draw(Graphics2D g2, double cursor,
 191:                        Rectangle2D plotArea, Rectangle2D dataArea, 
 192:                        Rectangle2D reservedArea, RectangleEdge edge) {
 193: 
 194: 
 195:         Rectangle2D colorBarArea = null;
 196:         
 197:         double thickness = calculateBarThickness(dataArea, edge);
 198:         if (this.colorBarThickness > 0) {
 199:             thickness = this.colorBarThickness;  // allow fixed thickness
 200:         }
 201: 
 202:         double length = 0.0;
 203:         if (RectangleEdge.isLeftOrRight(edge)) {
 204:             length = dataArea.getHeight();
 205:         }
 206:         else {
 207:             length = dataArea.getWidth();
 208:         }
 209:         
 210:         if (this.colorBarLength > 0) {
 211:             length = this.colorBarLength;
 212:         }
 213: 
 214:         if (edge == RectangleEdge.BOTTOM) {
 215:             colorBarArea = new Rectangle2D.Double(dataArea.getX(), 
 216:                     plotArea.getMaxY() + this.outerGap, length, thickness);
 217:         }
 218:         else if (edge == RectangleEdge.TOP) {
 219:             colorBarArea = new Rectangle2D.Double(dataArea.getX(), 
 220:                     reservedArea.getMinY() + this.outerGap, length, thickness);
 221:         }
 222:         else if (edge == RectangleEdge.LEFT) {
 223:             colorBarArea = new Rectangle2D.Double(plotArea.getX() - thickness 
 224:                     - this.outerGap, dataArea.getMinY(), thickness, length);
 225:         }
 226:         else if (edge == RectangleEdge.RIGHT) {
 227:             colorBarArea = new Rectangle2D.Double(plotArea.getMaxX() 
 228:                     + this.outerGap, dataArea.getMinY(), thickness, length);
 229:         }
 230:         
 231:         // update, but dont draw tick marks (needed for stepped colors)
 232:         this.axis.refreshTicks(g2, new AxisState(), colorBarArea, edge);
 233: 
 234:         drawColorBar(g2, colorBarArea, edge);
 235: 
 236:         AxisState state = null;
 237:         if (edge == RectangleEdge.TOP) {
 238:             cursor = colorBarArea.getMinY();
 239:             state = this.axis.draw(g2, cursor, reservedArea, colorBarArea, 
 240:                     RectangleEdge.TOP, null);
 241:         } 
 242:         else if (edge == RectangleEdge.BOTTOM) {
 243:             cursor = colorBarArea.getMaxY();
 244:             state = this.axis.draw(g2, cursor, reservedArea, colorBarArea, 
 245:                     RectangleEdge.BOTTOM, null);
 246:         } 
 247:         else if (edge == RectangleEdge.LEFT) {
 248:             cursor = colorBarArea.getMinX();
 249:             state = this.axis.draw(g2, cursor, reservedArea, colorBarArea, 
 250:                     RectangleEdge.LEFT, null);
 251:         } 
 252:         else if (edge == RectangleEdge.RIGHT) {
 253:             cursor = colorBarArea.getMaxX();
 254:             state = this.axis.draw(g2, cursor, reservedArea, colorBarArea, 
 255:                     RectangleEdge.RIGHT, null);
 256:         }
 257:         return state.getCursor();
 258:         
 259:     }
 260: 
 261:     /**
 262:      * Draws the plot on a Java 2D graphics device (such as the screen or a 
 263:      * printer).
 264:      *
 265:      * @param g2  the graphics device.
 266:      * @param colorBarArea  the area within which the axis should be drawn.
 267:      * @param edge  the location.
 268:      */
 269:     public void drawColorBar(Graphics2D g2, Rectangle2D colorBarArea, 
 270:                              RectangleEdge edge) {
 271: 
 272:         Object antiAlias = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
 273:         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 274:                             RenderingHints.VALUE_ANTIALIAS_OFF);
 275: 
 276:         // setTickValues was missing from ColorPalette v. 0.96
 277:         //colorPalette.setTickValues(this.axis.getTicks());
 278: 
 279:         Stroke strokeSaved = g2.getStroke();
 280:         g2.setStroke(new BasicStroke(1.0f));
 281: 
 282:         if (RectangleEdge.isTopOrBottom(edge)) {
 283:             double y1 = colorBarArea.getY();
 284:             double y2 = colorBarArea.getMaxY();
 285:             double xx = colorBarArea.getX();
 286:             Line2D line = new Line2D.Double();
 287:             while (xx <= colorBarArea.getMaxX()) {
 288:                 double value = this.axis.java2DToValue(xx, colorBarArea, edge);
 289:                 line.setLine(xx, y1, xx, y2);
 290:                 g2.setPaint(getPaint(value));
 291:                 g2.draw(line);
 292:                 xx += 1;
 293:             }
 294:         }
 295:         else {
 296:             double y1 = colorBarArea.getX();
 297:             double y2 = colorBarArea.getMaxX();
 298:             double xx = colorBarArea.getY();
 299:             Line2D line = new Line2D.Double();
 300:             while (xx <= colorBarArea.getMaxY()) {
 301:                 double value = this.axis.java2DToValue(xx, colorBarArea, edge);
 302:                 line.setLine(y1, xx, y2, xx);
 303:                 g2.setPaint(getPaint(value));
 304:                 g2.draw(line);
 305:                 xx += 1;
 306:             }            
 307:         }
 308: 
 309:         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antiAlias);
 310:         g2.setStroke(strokeSaved);
 311: 
 312:     }
 313: 
 314:     /**
 315:      * Returns the color palette.
 316:      *
 317:      * @return The color palette.
 318:      */
 319:     public ColorPalette getColorPalette() {
 320:         return this.colorPalette;
 321:     }
 322: 
 323:     /**
 324:      * Returns the Paint associated with a value.
 325:      *
 326:      * @param value  the value.
 327:      *
 328:      * @return The paint.
 329:      */
 330:     public Paint getPaint(double value) {
 331:         return this.colorPalette.getPaint(value);
 332:     }
 333: 
 334:     /**
 335:      * Sets the color palette.
 336:      *
 337:      * @param palette  the new palette.
 338:      */
 339:     public void setColorPalette(ColorPalette palette) {
 340:         this.colorPalette = palette;
 341:     }
 342: 
 343:     /**
 344:      * Sets the maximum value.
 345:      *
 346:      * @param value  the maximum value.
 347:      */
 348:     public void setMaximumValue(double value) {
 349:         this.colorPalette.setMaxZ(value);
 350:         this.axis.setUpperBound(value);
 351:     }
 352: 
 353:     /**
 354:      * Sets the minimum value.
 355:      *
 356:      * @param value  the minimum value.
 357:      */
 358:     public void setMinimumValue(double value) {
 359:         this.colorPalette.setMinZ(value);
 360:         this.axis.setLowerBound(value);
 361:     }
 362: 
 363:     /**
 364:      * Reserves the space required to draw the color bar.
 365:      *
 366:      * @param g2  the graphics device.
 367:      * @param plot  the plot that the axis belongs to.
 368:      * @param plotArea  the area within which the plot should be drawn.
 369:      * @param dataArea  the data area.
 370:      * @param edge  the axis location.
 371:      * @param space  the space already reserved.
 372:      *
 373:      * @return The space required to draw the axis in the specified plot area.
 374:      */
 375:     public AxisSpace reserveSpace(Graphics2D g2, Plot plot, 
 376:                                   Rectangle2D plotArea,
 377:                                   Rectangle2D dataArea, RectangleEdge edge, 
 378:                                   AxisSpace space) {
 379: 
 380:         AxisSpace result = this.axis.reserveSpace(g2, plot, plotArea, edge, 
 381:                 space);
 382:         double thickness = calculateBarThickness(dataArea, edge);
 383:         result.add(thickness + 2 * this.outerGap, edge);
 384:         return result;
 385: 
 386:     }
 387:     
 388:     /**
 389:      * Calculates the bar thickness.
 390:      * 
 391:      * @param plotArea  the plot area.
 392:      * @param edge  the location.
 393:      * 
 394:      * @return The thickness.
 395:      */
 396:     private double calculateBarThickness(Rectangle2D plotArea, 
 397:                                          RectangleEdge edge) {
 398:         double result = 0.0;
 399:         if (RectangleEdge.isLeftOrRight(edge)) {
 400:             result = plotArea.getWidth() * this.colorBarThicknessPercent;
 401:         }
 402:         else {
 403:             result = plotArea.getHeight() * this.colorBarThicknessPercent;
 404:         }
 405:         return result;  
 406:     }
 407: 
 408:     /**
 409:      * Returns a clone of the object.
 410:      * 
 411:      * @return A clone.
 412:      * 
 413:      * @throws CloneNotSupportedException if some component of the color bar 
 414:      *         does not support cloning.
 415:      */
 416:     public Object clone() throws CloneNotSupportedException {
 417:     
 418:         ColorBar clone = (ColorBar) super.clone();
 419:         clone.axis = (ValueAxis) this.axis.clone();
 420:         return clone;
 421:             
 422:     }
 423:     
 424:     /**
 425:      * Tests this object for equality with another.
 426:      * 
 427:      * @param obj  the object to test against.
 428:      * 
 429:      * @return A boolean.
 430:      */
 431:     public boolean equals(Object obj) {
 432: 
 433:         if (obj == this) {
 434:             return true;
 435:         }
 436:         if (!(obj instanceof ColorBar)) {
 437:             return false;   
 438:         }
 439:         ColorBar that = (ColorBar) obj;
 440:         if (!this.axis.equals(that.axis)) {
 441:             return false;
 442:         }
 443:         if (this.colorBarThickness != that.colorBarThickness) {
 444:             return false;
 445:         }
 446:         if (this.colorBarThicknessPercent != that.colorBarThicknessPercent) {
 447:             return false;
 448:         }
 449:         if (!this.colorPalette.equals(that.colorPalette)) {
 450:             return false;
 451:         }
 452:         if (this.colorBarLength != that.colorBarLength) {
 453:             return false;
 454:         }
 455:         if (this.outerGap != that.outerGap) {
 456:             return false;
 457:         }
 458:         return true;
 459:         
 460:     }
 461:     
 462:     /**
 463:      * Returns a hash code for this object.
 464:      * 
 465:      * @return A hash code.
 466:      */
 467:     public int hashCode() {
 468:         return this.axis.hashCode();
 469:     }
 470:     
 471: }