Source for org.jfree.chart.ChartUtilities

   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:  * ChartUtilities.java
  29:  * -------------------
  30:  * (C) Copyright 2001-2007, by Object Refinery Limited and Contributors.
  31:  *
  32:  * Original Author:  David Gilbert (for Object Refinery Limited);
  33:  * Contributor(s):   Wolfgang Irler;
  34:  *                   Richard Atkinson;
  35:  *                   Xavier Poinsard;
  36:  *
  37:  * Changes
  38:  * -------
  39:  * 11-Dec-2001 : Version 1.  The JPEG method comes from Wolfgang Irler's 
  40:  *               JFreeChartServletDemo class (DG);
  41:  * 23-Jan-2002 : Changed saveChartAsXXX() methods to pass IOExceptions back to 
  42:  *               caller (DG);
  43:  * 26-Jun-2002 : Added image map methods (DG);
  44:  * 05-Aug-2002 : Added writeBufferedImage methods
  45:  *               Modified writeImageMap method to support flexible image 
  46:  *               maps (RA);
  47:  * 26-Aug-2002 : Added saveChartAsJPEG and writeChartAsJPEG methods with info 
  48:  *               objects (RA);
  49:  * 05-Sep-2002 : Added writeImageMap() method to support OverLIB
  50:  *               - http://www.bosrup.com/web/overlib (RA);
  51:  * 26-Sep-2002 : Fixed errors reported by Checkstyle (DG);
  52:  * 17-Oct-2002 : Exposed JPEG quality setting and PNG compression level as 
  53:  *               parameters (DG);
  54:  * 25-Oct-2002 : Fixed writeChartAsJPEG() empty method bug (DG);
  55:  * 13-Mar-2003 : Updated writeImageMap method as suggested by Xavier Poinsard 
  56:  *               (see Feature Request 688079) (DG);
  57:  * 12-Aug-2003 : Added support for custom image maps using 
  58:  *               ToolTipTagFragmentGenerator and URLTagFragmentGenerator (RA);
  59:  * 02-Sep-2003 : Separated PNG encoding from writing chart to an 
  60:  *               OutputStream (RA);
  61:  * 04-Dec-2003 : Chart draw() method modified to include anchor point (DG);
  62:  * 20-Feb-2004 : Edited Javadocs and added argument checking (DG);
  63:  * 05-Apr-2004 : Fixed problem with buffered image type (DG);
  64:  * 01-Aug-2004 : Modified to use EncoderUtil for all image encoding (RA);
  65:  * 02-Aug-2004 : Delegated image map related functionality to ImageMapUtil (RA);
  66:  * 13-Jan-2005 : Renamed ImageMapUtil --> ImageMapUtilities, removed method
  67:  *               writeImageMap(PrintWriter, String, ChartRenderingInfo) which 
  68:  *               exists in ImageMapUtilities (DG);
  69:  * ------------- JFREECHART 1.0.x ---------------------------------------------
  70:  * 06-Feb-2006 : API doc update (DG);
  71:  * 19-Mar-2007 : Use try-finally to close output stream in saveChartAsXXX() 
  72:  *               methods (DG);
  73:  *
  74:  */
  75: 
  76: package org.jfree.chart;
  77: 
  78: import java.awt.Graphics2D;
  79: import java.awt.geom.AffineTransform;
  80: import java.awt.geom.Rectangle2D;
  81: import java.awt.image.BufferedImage;
  82: import java.io.BufferedOutputStream;
  83: import java.io.File;
  84: import java.io.FileOutputStream;
  85: import java.io.IOException;
  86: import java.io.OutputStream;
  87: import java.io.PrintWriter;
  88: 
  89: import org.jfree.chart.encoders.EncoderUtil;
  90: import org.jfree.chart.encoders.ImageFormat;
  91: import org.jfree.chart.imagemap.ImageMapUtilities;
  92: import org.jfree.chart.imagemap.OverLIBToolTipTagFragmentGenerator;
  93: import org.jfree.chart.imagemap.StandardToolTipTagFragmentGenerator;
  94: import org.jfree.chart.imagemap.StandardURLTagFragmentGenerator;
  95: import org.jfree.chart.imagemap.ToolTipTagFragmentGenerator;
  96: import org.jfree.chart.imagemap.URLTagFragmentGenerator;
  97: 
  98: /**
  99:  * A collection of utility methods for JFreeChart.  Includes methods for 
 100:  * converting charts to image formats (PNG and JPEG) plus creating simple HTML 
 101:  * image maps.
 102:  * 
 103:  * @see ImageMapUtilities
 104:  */
 105: public abstract class ChartUtilities {
 106: 
 107:     /**
 108:      * Writes a chart to an output stream in PNG format.
 109:      *
 110:      * @param out  the output stream (<code>null</code> not permitted).
 111:      * @param chart  the chart (<code>null</code> not permitted).
 112:      * @param width  the image width.
 113:      * @param height  the image height.
 114:      *
 115:      * @throws IOException if there are any I/O errors.
 116:      */
 117:     public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
 118:             int width, int height) throws IOException {
 119: 
 120:         // defer argument checking...
 121:         writeChartAsPNG(out, chart, width, height, null);
 122: 
 123:     }
 124: 
 125:     /**
 126:      * Writes a chart to an output stream in PNG format.
 127:      *
 128:      * @param out  the output stream (<code>null</code> not permitted).
 129:      * @param chart  the chart (<code>null</code> not permitted).
 130:      * @param width  the image width.
 131:      * @param height  the image height.
 132:      * @param encodeAlpha  encode alpha?
 133:      * @param compression  the compression level (0-9).
 134:      *
 135:      * @throws IOException if there are any I/O errors.
 136:      */
 137:     public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
 138:             int width, int height, boolean encodeAlpha, int compression) 
 139:             throws IOException {
 140: 
 141:         // defer argument checking...
 142:         ChartUtilities.writeChartAsPNG(out, chart, width, height, null, 
 143:                 encodeAlpha, compression);
 144: 
 145:     }
 146: 
 147:     /**
 148:      * Writes a chart to an output stream in PNG format.  This method allows 
 149:      * you to pass in a {@link ChartRenderingInfo} object, to collect 
 150:      * information about the chart dimensions/entities.  You will need this 
 151:      * info if you want to create an HTML image map.
 152:      *
 153:      * @param out  the output stream (<code>null</code> not permitted).
 154:      * @param chart  the chart (<code>null</code> not permitted).
 155:      * @param width  the image width.
 156:      * @param height  the image height.
 157:      * @param info  the chart rendering info (<code>null</code> permitted).
 158:      *
 159:      * @throws IOException if there are any I/O errors.
 160:      */
 161:     public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
 162:             int width, int height,  ChartRenderingInfo info) 
 163:             throws IOException {
 164: 
 165:         if (chart == null) {
 166:             throw new IllegalArgumentException("Null 'chart' argument.");
 167:         }
 168:         BufferedImage bufferedImage 
 169:                 = chart.createBufferedImage(width, height, info);
 170:         EncoderUtil.writeBufferedImage(bufferedImage, ImageFormat.PNG, out);
 171:     }
 172: 
 173:     /**
 174:      * Writes a chart to an output stream in PNG format.  This method allows 
 175:      * you to pass in a {@link ChartRenderingInfo} object, to collect 
 176:      * information about the chart dimensions/entities.  You will need this 
 177:      * info if you want to create an HTML image map.
 178:      *
 179:      * @param out  the output stream (<code>null</code> not permitted).
 180:      * @param chart  the chart (<code>null</code> not permitted).
 181:      * @param width  the image width.
 182:      * @param height  the image height.
 183:      * @param info  carries back chart rendering info (<code>null</code> 
 184:      *              permitted).
 185:      * @param encodeAlpha  encode alpha?
 186:      * @param compression  the PNG compression level (0-9).
 187:      *
 188:      * @throws IOException if there are any I/O errors.
 189:      */
 190:     public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
 191:             int width, int height, ChartRenderingInfo info,
 192:             boolean encodeAlpha, int compression) throws IOException {
 193: 
 194:         if (out == null) {
 195:             throw new IllegalArgumentException("Null 'out' argument.");
 196:         }
 197:         if (chart == null) {
 198:             throw new IllegalArgumentException("Null 'chart' argument.");
 199:         }
 200:         BufferedImage chartImage = chart.createBufferedImage(width, height, 
 201:                 BufferedImage.TYPE_INT_ARGB, info);
 202:         ChartUtilities.writeBufferedImageAsPNG(out, chartImage, encodeAlpha, 
 203:                 compression);
 204: 
 205:     }
 206: 
 207:     /**
 208:      * Writes a scaled version of a chart to an output stream in PNG format.
 209:      *
 210:      * @param out  the output stream (<code>null</code> not permitted).
 211:      * @param chart  the chart (<code>null</code> not permitted).
 212:      * @param width  the unscaled chart width.
 213:      * @param height  the unscaled chart height.
 214:      * @param widthScaleFactor  the horizontal scale factor.
 215:      * @param heightScaleFactor  the vertical scale factor.
 216:      *
 217:      * @throws IOException if there are any I/O problems.
 218:      */
 219:     public static void writeScaledChartAsPNG(OutputStream out,
 220:             JFreeChart chart, int width, int height, int widthScaleFactor,
 221:             int heightScaleFactor) throws IOException {
 222: 
 223:         if (out == null) {
 224:             throw new IllegalArgumentException("Null 'out' argument.");
 225:         }
 226:         if (chart == null) {
 227:             throw new IllegalArgumentException("Null 'chart' argument.");
 228:         }
 229: 
 230:         double desiredWidth = width * widthScaleFactor;
 231:         double desiredHeight = height * heightScaleFactor;
 232:         double defaultWidth = width;
 233:         double defaultHeight = height;
 234:         boolean scale = false;
 235: 
 236:         // get desired width and height from somewhere then...
 237:         if ((widthScaleFactor != 1) || (heightScaleFactor != 1)) {
 238:             scale = true;
 239:         }
 240: 
 241:         double scaleX = desiredWidth / defaultWidth;
 242:         double scaleY = desiredHeight / defaultHeight;
 243: 
 244:         BufferedImage image = new BufferedImage((int) desiredWidth, 
 245:                 (int) desiredHeight, BufferedImage.TYPE_INT_ARGB);
 246:         Graphics2D g2 = image.createGraphics();
 247: 
 248:         if (scale) {
 249:             AffineTransform saved = g2.getTransform();
 250:             g2.transform(AffineTransform.getScaleInstance(scaleX, scaleY));
 251:             chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth, 
 252:                     defaultHeight), null, null);
 253:             g2.setTransform(saved);
 254:             g2.dispose();
 255:         }
 256:         else {
 257:             chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth, 
 258:                     defaultHeight), null, null);
 259:         }
 260:         out.write(encodeAsPNG(image));
 261: 
 262:     }
 263: 
 264:     /**
 265:      * Saves a chart to the specified file in PNG format.
 266:      *
 267:      * @param file  the file name (<code>null</code> not permitted).
 268:      * @param chart  the chart (<code>null</code> not permitted).
 269:      * @param width  the image width.
 270:      * @param height  the image height.
 271:      *
 272:      * @throws IOException if there are any I/O errors.
 273:      */
 274:     public static void saveChartAsPNG(File file, JFreeChart chart,
 275:             int width, int height) throws IOException {
 276: 
 277:         // defer argument checking...
 278:         saveChartAsPNG(file, chart, width, height, null);
 279: 
 280:     }
 281: 
 282:     /**
 283:      * Saves a chart to a file in PNG format.  This method allows you to pass 
 284:      * in a {@link ChartRenderingInfo} object, to collect information about the 
 285:      * chart dimensions/entities.  You will need this info if you want to 
 286:      * create an HTML image map.
 287:      *
 288:      * @param file  the file (<code>null</code> not permitted).
 289:      * @param chart  the chart (<code>null</code> not permitted).
 290:      * @param width  the image width.
 291:      * @param height  the image height.
 292:      * @param info  the chart rendering info (<code>null</code> permitted).
 293:      *
 294:      * @throws IOException if there are any I/O errors.
 295:      */
 296:     public static void saveChartAsPNG(File file, JFreeChart chart,
 297:             int width, int height, ChartRenderingInfo info) 
 298:         throws IOException {
 299: 
 300:         if (file == null) {
 301:             throw new IllegalArgumentException("Null 'file' argument.");
 302:         }
 303:         OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
 304:         try {
 305:             ChartUtilities.writeChartAsPNG(out, chart, width, height, info);
 306:         }
 307:         finally {
 308:             out.close();
 309:         }
 310:     }
 311: 
 312:     /**
 313:      * Saves a chart to a file in PNG format.  This method allows you to pass 
 314:      * in a {@link ChartRenderingInfo} object, to collect information about the 
 315:      * chart dimensions/entities.  You will need this info if you want to 
 316:      * create an HTML image map.
 317:      *
 318:      * @param file  the file (<code>null</code> not permitted).
 319:      * @param chart  the chart (<code>null</code> not permitted).
 320:      * @param width  the image width.
 321:      * @param height  the image height.
 322:      * @param info  the chart rendering info (<code>null</code> permitted).
 323:      * @param encodeAlpha  encode alpha?
 324:      * @param compression  the PNG compression level (0-9).
 325:      *
 326:      * @throws IOException if there are any I/O errors.
 327:      */
 328:     public static void saveChartAsPNG(File file, JFreeChart chart,
 329:            int width, int height, ChartRenderingInfo info, boolean encodeAlpha,
 330:            int compression) throws IOException {
 331: 
 332:         if (file == null) {
 333:             throw new IllegalArgumentException("Null 'file' argument.");
 334:         }
 335:         if (chart == null) {
 336:             throw new IllegalArgumentException("Null 'chart' argument.");
 337:         }
 338: 
 339:         OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
 340:         try {
 341:             writeChartAsPNG(out, chart, width, height, info, encodeAlpha, 
 342:                     compression);
 343:         }
 344:         finally {
 345:             out.close();
 346:         }
 347: 
 348:     }
 349: 
 350:     /**
 351:      * Writes a chart to an output stream in JPEG format.  Please note that
 352:      * JPEG is a poor format for chart images, use PNG if possible.
 353:      * 
 354:      * @param out  the output stream (<code>null</code> not permitted).
 355:      * @param chart  the chart (<code>null</code> not permitted).
 356:      * @param width  the image width.
 357:      * @param height  the image height.
 358:      *
 359:      * @throws IOException if there are any I/O errors.
 360:      */
 361:     public static void writeChartAsJPEG(OutputStream out,
 362:             JFreeChart chart, int width, int height) throws IOException {
 363: 
 364:         // defer argument checking...
 365:         writeChartAsJPEG(out, chart, width, height, null);
 366: 
 367:     }
 368: 
 369:     /**
 370:      * Writes a chart to an output stream in JPEG format.  Please note that
 371:      * JPEG is a poor format for chart images, use PNG if possible.
 372:      *
 373:      * @param out  the output stream (<code>null</code> not permitted).
 374:      * @param quality  the quality setting.
 375:      * @param chart  the chart (<code>null</code> not permitted).
 376:      * @param width  the image width.
 377:      * @param height  the image height.
 378:      *
 379:      * @throws IOException if there are any I/O errors.
 380:      */
 381:     public static void writeChartAsJPEG(OutputStream out, float quality,
 382:             JFreeChart chart, int width, int height) throws IOException {
 383: 
 384:         // defer argument checking...
 385:         ChartUtilities.writeChartAsJPEG(out, quality, chart, width, height, 
 386:                 null);
 387: 
 388:     }
 389: 
 390:     /**
 391:      * Writes a chart to an output stream in JPEG format. This method allows 
 392:      * you to pass in a {@link ChartRenderingInfo} object, to collect 
 393:      * information about the chart dimensions/entities.  You will need this 
 394:      * info if you want to create an HTML image map.
 395:      *
 396:      * @param out  the output stream (<code>null</code> not permitted).
 397:      * @param chart  the chart (<code>null</code> not permitted).
 398:      * @param width  the image width.
 399:      * @param height  the image height.
 400:      * @param info  the chart rendering info (<code>null</code> permitted).
 401:      *
 402:      * @throws IOException if there are any I/O errors.
 403:      */
 404:     public static void writeChartAsJPEG(OutputStream out, JFreeChart chart,
 405:             int width, int height, ChartRenderingInfo info) 
 406:             throws IOException {
 407: 
 408:         if (chart == null) {
 409:             throw new IllegalArgumentException("Null 'chart' argument.");
 410:         }
 411:         BufferedImage image = chart.createBufferedImage(width, height, info);
 412:         EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out);
 413: 
 414:     }
 415: 
 416:     /**
 417:      * Writes a chart to an output stream in JPEG format.  This method allows 
 418:      * you to pass in a {@link ChartRenderingInfo} object, to collect 
 419:      * information about the chart dimensions/entities.  You will need this 
 420:      * info if you want to create an HTML image map.
 421:      *
 422:      * @param out  the output stream (<code>null</code> not permitted).
 423:      * @param quality  the output quality (0.0f to 1.0f).
 424:      * @param chart  the chart (<code>null</code> not permitted).
 425:      * @param width  the image width.
 426:      * @param height  the image height.
 427:      * @param info  the chart rendering info (<code>null</code> permitted).
 428:      *
 429:      * @throws IOException if there are any I/O errors.
 430:      */
 431:     public static void writeChartAsJPEG(OutputStream out, float quality,
 432:             JFreeChart chart, int width, int height, ChartRenderingInfo info) 
 433:             throws IOException {
 434: 
 435:         if (chart == null) {
 436:             throw new IllegalArgumentException("Null 'chart' argument.");
 437:         }
 438:         BufferedImage image = chart.createBufferedImage(width, height, info);
 439:         EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
 440: 
 441:     }
 442: 
 443:     /**
 444:      * Saves a chart to a file in JPEG format.
 445:      *
 446:      * @param file  the file (<code>null</code> not permitted).
 447:      * @param chart  the chart (<code>null</code> not permitted).
 448:      * @param width  the image width.
 449:      * @param height  the image height.
 450:      *
 451:      * @throws IOException if there are any I/O errors.
 452:      */
 453:     public static void saveChartAsJPEG(File file, JFreeChart chart,
 454:             int width, int height) throws IOException {
 455: 
 456:         // defer argument checking...
 457:         saveChartAsJPEG(file, chart, width, height, null);
 458: 
 459:     }
 460: 
 461:     /**
 462:      * Saves a chart to a file in JPEG format.
 463:      *
 464:      * @param file  the file (<code>null</code> not permitted).
 465:      * @param quality  the JPEG quality setting.
 466:      * @param chart  the chart (<code>null</code> not permitted).
 467:      * @param width  the image width.
 468:      * @param height  the image height.
 469:      *
 470:      * @throws IOException if there are any I/O errors.
 471:      */
 472:     public static void saveChartAsJPEG(File file, float quality,
 473:             JFreeChart chart, int width, int height) throws IOException {
 474: 
 475:         // defer argument checking...
 476:         saveChartAsJPEG(file, quality, chart, width, height, null);
 477: 
 478:     }
 479: 
 480:     /**
 481:      * Saves a chart to a file in JPEG format.  This method allows you to pass 
 482:      * in a {@link ChartRenderingInfo} object, to collect information about the 
 483:      * chart dimensions/entities.  You will need this info if you want to 
 484:      * create an HTML image map.
 485:      *
 486:      * @param file  the file name (<code>null</code> not permitted).
 487:      * @param chart  the chart (<code>null</code> not permitted).
 488:      * @param width  the image width.
 489:      * @param height  the image height.
 490:      * @param info  the chart rendering info (<code>null</code> permitted).
 491:      *
 492:      * @throws IOException if there are any I/O errors.
 493:      */
 494:     public static void saveChartAsJPEG(File file, JFreeChart chart,
 495:             int width, int height, ChartRenderingInfo info) throws IOException {
 496: 
 497:         if (file == null) {
 498:             throw new IllegalArgumentException("Null 'file' argument.");
 499:         }
 500:         if (chart == null) {
 501:             throw new IllegalArgumentException("Null 'chart' argument.");
 502:         }
 503:         OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
 504:         try {
 505:             writeChartAsJPEG(out, chart, width, height, info);
 506:         }
 507:         finally {
 508:             out.close();
 509:         }
 510: 
 511:     }
 512: 
 513:     /**
 514:      * Saves a chart to a file in JPEG format.  This method allows you to pass 
 515:      * in a {@link ChartRenderingInfo} object, to collect information about the 
 516:      * chart dimensions/entities.  You will need this info if you want to 
 517:      * create an HTML image map.
 518:      *
 519:      * @param file  the file name (<code>null</code> not permitted).
 520:      * @param quality  the quality setting.
 521:      * @param chart  the chart (<code>null</code> not permitted).
 522:      * @param width  the image width.
 523:      * @param height  the image height.
 524:      * @param info  the chart rendering info (<code>null</code> permitted).
 525:      *
 526:      * @throws IOException if there are any I/O errors.
 527:      */
 528:     public static void saveChartAsJPEG(File file, float quality,
 529:             JFreeChart chart, int width, int height,
 530:             ChartRenderingInfo info) throws IOException {
 531: 
 532:         if (file == null) {
 533:             throw new IllegalArgumentException("Null 'file' argument.");
 534:         }
 535:         if (chart == null) {
 536:             throw new IllegalArgumentException("Null 'chart' argument.");
 537:         }
 538:         
 539:         OutputStream out = new BufferedOutputStream(new FileOutputStream(
 540:                 file));
 541:         try {
 542:             writeChartAsJPEG(out, quality, chart, width, height, info);
 543:         }
 544:         finally {
 545:             out.close();
 546:         }
 547: 
 548:     }
 549: 
 550:     /**
 551:      * Writes a {@link BufferedImage} to an output stream in JPEG format.
 552:      *
 553:      * @param out  the output stream (<code>null</code> not permitted).
 554:      * @param image  the image (<code>null</code> not permitted).
 555:      *
 556:      * @throws IOException if there are any I/O errors.
 557:      */
 558:     public static void writeBufferedImageAsJPEG(OutputStream out, 
 559:             BufferedImage image) throws IOException {
 560: 
 561:         // defer argument checking...
 562:         writeBufferedImageAsJPEG(out, 0.75f, image);
 563: 
 564:     }
 565: 
 566:     /**
 567:      * Writes a {@link BufferedImage} to an output stream in JPEG format.
 568:      *
 569:      * @param out  the output stream (<code>null</code> not permitted).
 570:      * @param quality  the image quality (0.0f to 1.0f).
 571:      * @param image  the image (<code>null</code> not permitted).
 572:      *
 573:      * @throws IOException if there are any I/O errors.
 574:      */
 575:     public static void writeBufferedImageAsJPEG(OutputStream out, float quality,
 576:             BufferedImage image) throws IOException {
 577: 
 578:         EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
 579: 
 580:     }
 581: 
 582:     /**
 583:      * Writes a {@link BufferedImage} to an output stream in PNG format.
 584:      *
 585:      * @param out  the output stream (<code>null</code> not permitted).
 586:      * @param image  the image (<code>null</code> not permitted).
 587:      *
 588:      * @throws IOException if there are any I/O errors.
 589:      */
 590:     public static void writeBufferedImageAsPNG(OutputStream out, 
 591:             BufferedImage image) throws IOException {
 592: 
 593:         EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out);
 594: 
 595:     }
 596: 
 597:     /**
 598:      * Writes a {@link BufferedImage} to an output stream in PNG format.
 599:      *
 600:      * @param out  the output stream (<code>null</code> not permitted).
 601:      * @param image  the image (<code>null</code> not permitted).
 602:      * @param encodeAlpha  encode alpha?
 603:      * @param compression  the compression level (0-9).
 604:      *
 605:      * @throws IOException if there are any I/O errors.
 606:      */
 607:     public static void writeBufferedImageAsPNG(OutputStream out,
 608:             BufferedImage image, boolean encodeAlpha, int compression) 
 609:             throws IOException {
 610: 
 611:         EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out, 
 612:                 compression, encodeAlpha);
 613:     }
 614: 
 615:     /**
 616:      * Encodes a {@link BufferedImage} to PNG format.
 617:      *
 618:      * @param image  the image (<code>null</code> not permitted).
 619:      *
 620:      * @return A byte array in PNG format.
 621:      * 
 622:      * @throws IOException if there is an I/O problem.
 623:      */
 624:     public static byte[] encodeAsPNG(BufferedImage image) throws IOException {
 625:         return EncoderUtil.encode(image, ImageFormat.PNG);
 626:     }
 627: 
 628:     /**
 629:      * Encodes a {@link BufferedImage} to PNG format.
 630:      *
 631:      * @param image  the image (<code>null</code> not permitted).
 632:      * @param encodeAlpha  encode alpha?
 633:      * @param compression  the PNG compression level (0-9).
 634:      *
 635:      * @return The byte array in PNG format.
 636:      * 
 637:      * @throws IOException if there is an I/O problem.
 638:      */
 639:     public static byte[] encodeAsPNG(BufferedImage image, boolean encodeAlpha, 
 640:                                      int compression) 
 641:             throws IOException {
 642:         return EncoderUtil.encode(image, ImageFormat.PNG, compression, 
 643:                 encodeAlpha);
 644:     }
 645: 
 646:     /**
 647:      * Writes an image map to an output stream.
 648:      *
 649:      * @param writer  the writer (<code>null</code> not permitted).
 650:      * @param name  the map name (<code>null</code> not permitted).
 651:      * @param info  the chart rendering info (<code>null</code> not permitted).
 652:      * @param useOverLibForToolTips  whether to use OverLIB for tooltips
 653:      *                               (http://www.bosrup.com/web/overlib/).
 654:      *
 655:      * @throws IOException if there are any I/O errors.
 656:      */
 657:     public static void writeImageMap(PrintWriter writer,
 658:                                      String name,
 659:                                      ChartRenderingInfo info,
 660:                                      boolean useOverLibForToolTips) 
 661:         throws IOException {
 662: 
 663:         ToolTipTagFragmentGenerator toolTipTagFragmentGenerator = null;
 664:         if (useOverLibForToolTips) {
 665:             toolTipTagFragmentGenerator 
 666:                     = new OverLIBToolTipTagFragmentGenerator();
 667:         }
 668:         else {
 669:             toolTipTagFragmentGenerator 
 670:                     = new StandardToolTipTagFragmentGenerator();
 671:         }
 672:         ImageMapUtilities.writeImageMap(writer, name, info, 
 673:                 toolTipTagFragmentGenerator, 
 674:                 new StandardURLTagFragmentGenerator());
 675: 
 676:     }
 677: 
 678:     /**
 679:      * Writes an image map to the specified writer.
 680:      *
 681:      * @param writer  the writer (<code>null</code> not permitted).
 682:      * @param name  the map name (<code>null</code> not permitted).
 683:      * @param info  the chart rendering info (<code>null</code> not permitted).
 684:      * @param toolTipTagFragmentGenerator  a generator for the HTML fragment
 685:      *     that will contain the tooltip text (<code>null</code> not permitted 
 686:      *     if <code>info</code> contains tooltip information).
 687:      * @param urlTagFragmentGenerator  a generator for the HTML fragment that
 688:      *     will contain the URL reference (<code>null</code> not permitted if 
 689:      *     <code>info</code> contains URLs).
 690:      *
 691:      * @throws IOException if there are any I/O errors.
 692:      */
 693:     public static void writeImageMap(PrintWriter writer, String name, 
 694:             ChartRenderingInfo info, 
 695:             ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
 696:             URLTagFragmentGenerator urlTagFragmentGenerator) 
 697:             throws IOException {
 698: 
 699:         writer.println(ImageMapUtilities.getImageMap(name, info, 
 700:                 toolTipTagFragmentGenerator, urlTagFragmentGenerator));
 701:     }
 702: 
 703:     /**
 704:      * Creates an HTML image map.  This method maps to 
 705:      * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo, 
 706:      * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}, using default 
 707:      * generators.
 708:      *
 709:      * @param name  the map name (<code>null</code> not permitted).
 710:      * @param info  the chart rendering info (<code>null</code> not permitted).
 711:      *
 712:      * @return The map tag.
 713:      */
 714:     public static String getImageMap(String name, ChartRenderingInfo info) {
 715:         return ImageMapUtilities.getImageMap(name, info,
 716:                 new StandardToolTipTagFragmentGenerator(),
 717:                 new StandardURLTagFragmentGenerator());
 718:     }
 719: 
 720:     /**
 721:      * Creates an HTML image map.  This method maps directly to
 722:      * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo, 
 723:      * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}.
 724:      *
 725:      * @param name  the map name (<code>null</code> not permitted).
 726:      * @param info  the chart rendering info (<code>null</code> not permitted).
 727:      * @param toolTipTagFragmentGenerator  a generator for the HTML fragment
 728:      *     that will contain the tooltip text (<code>null</code> not permitted 
 729:      *     if <code>info</code> contains tooltip information).
 730:      * @param urlTagFragmentGenerator  a generator for the HTML fragment that
 731:      *     will contain the URL reference (<code>null</code> not permitted if 
 732:      *     <code>info</code> contains URLs).
 733:      *
 734:      * @return The map tag.
 735:      */
 736:     public static String getImageMap(String name, ChartRenderingInfo info,
 737:             ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
 738:             URLTagFragmentGenerator urlTagFragmentGenerator) {
 739: 
 740:         return ImageMapUtilities.getImageMap(name, info, 
 741:                 toolTipTagFragmentGenerator, urlTagFragmentGenerator);
 742:         
 743:     }
 744: 
 745: }