Source for org.jfree.chart.ChartUtilities

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