    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
    006     *
    007     * Project Info:  http://www.jfree.org/jfreechart/index.html
    008     *
    009     * This library is free software; you can redistribute it and/or modify it
    010     * under the terms of the GNU Lesser General Public License as published by
    011     * the Free Software Foundation; either version 2.1 of the License, or
    012     * (at your option) any later version.
    013     *
    014     * This library is distributed in the hope that it will be useful, but
    015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
    017     * License for more details.
    018     *
    019     * You should have received a copy of the GNU Lesser General Public
    020     * License along with this library; if not, write to the Free Software
    021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
    022     * USA.
    023     *
    024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
    025     * in the United States and other countries.]
    026     *
    027     * -------------------
    028     * ChartUtilities.java
    029     * -------------------
    030     * (C) Copyright 2001-2008, by Object Refinery Limited and Contributors.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   Wolfgang Irler;
    034     *                   Richard Atkinson;
    035     *                   Xavier Poinsard;
    036     *
    037     * Changes
    038     * -------
    039     * 11-Dec-2001 : Version 1.  The JPEG method comes from Wolfgang Irler's
    040     *               JFreeChartServletDemo class (DG);
    041     * 23-Jan-2002 : Changed saveChartAsXXX() methods to pass IOExceptions back to
    042     *               caller (DG);
    043     * 26-Jun-2002 : Added image map methods (DG);
    044     * 05-Aug-2002 : Added writeBufferedImage methods
    045     *               Modified writeImageMap method to support flexible image
    046     *               maps (RA);
    047     * 26-Aug-2002 : Added saveChartAsJPEG and writeChartAsJPEG methods with info
    048     *               objects (RA);
    049     * 05-Sep-2002 : Added writeImageMap() method to support OverLIB
    050     *               - http://www.bosrup.com/web/overlib (RA);
    051     * 26-Sep-2002 : Fixed errors reported by Checkstyle (DG);
    052     * 17-Oct-2002 : Exposed JPEG quality setting and PNG compression level as
    053     *               parameters (DG);
    054     * 25-Oct-2002 : Fixed writeChartAsJPEG() empty method bug (DG);
    055     * 13-Mar-2003 : Updated writeImageMap method as suggested by Xavier Poinsard
    056     *               (see Feature Request 688079) (DG);
    057     * 12-Aug-2003 : Added support for custom image maps using
    058     *               ToolTipTagFragmentGenerator and URLTagFragmentGenerator (RA);
    059     * 02-Sep-2003 : Separated PNG encoding from writing chart to an
    060     *               OutputStream (RA);
    061     * 04-Dec-2003 : Chart draw() method modified to include anchor point (DG);
    062     * 20-Feb-2004 : Edited Javadocs and added argument checking (DG);
    063     * 05-Apr-2004 : Fixed problem with buffered image type (DG);
    064     * 01-Aug-2004 : Modified to use EncoderUtil for all image encoding (RA);
    065     * 02-Aug-2004 : Delegated image map related functionality to ImageMapUtil (RA);
    066     * 13-Jan-2005 : Renamed ImageMapUtil --> ImageMapUtilities, removed method
    067     *               writeImageMap(PrintWriter, String, ChartRenderingInfo) which
    068     *               exists in ImageMapUtilities (DG);
    069     * ------------- JFREECHART 1.0.x ---------------------------------------------
    070     * 06-Feb-2006 : API doc update (DG);
    071     * 19-Mar-2007 : Use try-finally to close output stream in saveChartAsXXX()
    072     *               methods (DG);
    073     * 10-Jan-2008 : Fix bug 1868251 - don't create image with transparency when
    074     *               saving to JPEG format (DG);
    075     *
    076     */
    077
    078    package org.jfree.chart;
    079
    080    import java.awt.Graphics2D;
    081    import java.awt.geom.AffineTransform;
    082    import java.awt.geom.Rectangle2D;
    083    import java.awt.image.BufferedImage;
    084    import java.io.BufferedOutputStream;
    085    import java.io.File;
    086    import java.io.FileOutputStream;
    087    import java.io.IOException;
    088    import java.io.OutputStream;
    089    import java.io.PrintWriter;
    090
    091    import org.jfree.chart.encoders.EncoderUtil;
    092    import org.jfree.chart.encoders.ImageFormat;
    093    import org.jfree.chart.imagemap.ImageMapUtilities;
    094    import org.jfree.chart.imagemap.OverLIBToolTipTagFragmentGenerator;
    095    import org.jfree.chart.imagemap.StandardToolTipTagFragmentGenerator;
    096    import org.jfree.chart.imagemap.StandardURLTagFragmentGenerator;
    097    import org.jfree.chart.imagemap.ToolTipTagFragmentGenerator;
    098    import org.jfree.chart.imagemap.URLTagFragmentGenerator;
    099
    100    /**
    101     * A collection of utility methods for JFreeChart.  Includes methods for
    102     * converting charts to image formats (PNG and JPEG) plus creating simple HTML
    103     * image maps.
    104     *
    105     * @see ImageMapUtilities
    106     */
    107    public abstract class ChartUtilities {
    108
    109        /**
    110         * Writes a chart to an output stream in PNG format.
    111         *
    112         * @param out  the output stream (<code>null</code> not permitted).
    113         * @param chart  the chart (<code>null</code> not permitted).
    114         * @param width  the image width.
    115         * @param height  the image height.
    116         *
    117         * @throws IOException if there are any I/O errors.
    118         */
    119        public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
    120                int width, int height) throws IOException {
    121
    122            // defer argument checking...
    123            writeChartAsPNG(out, chart, width, height, null);
    124
    125        }
    126
    127        /**
    128         * Writes a chart to an output stream in PNG format.
    129         *
    130         * @param out  the output stream (<code>null</code> not permitted).
    131         * @param chart  the chart (<code>null</code> not permitted).
    132         * @param width  the image width.
    133         * @param height  the image height.
    134         * @param encodeAlpha  encode alpha?
    135         * @param compression  the compression level (0-9).
    136         *
    137         * @throws IOException if there are any I/O errors.
    138         */
    139        public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
    140                int width, int height, boolean encodeAlpha, int compression)
    141                throws IOException {
    142
    143            // defer argument checking...
    144            ChartUtilities.writeChartAsPNG(out, chart, width, height, null,
    145                    encodeAlpha, compression);
    146
    147        }
    148
    149        /**
    150         * Writes a chart to an output stream in PNG format.  This method allows
    151         * you to pass in a {@link ChartRenderingInfo} object, to collect
    152         * information about the chart dimensions/entities.  You will need this
    153         * info if you want to create an HTML image map.
    154         *
    155         * @param out  the output stream (<code>null</code> not permitted).
    156         * @param chart  the chart (<code>null</code> not permitted).
    157         * @param width  the image width.
    158         * @param height  the image height.
    159         * @param info  the chart rendering info (<code>null</code> permitted).
    160         *
    161         * @throws IOException if there are any I/O errors.
    162         */
    163        public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
    164                int width, int height,  ChartRenderingInfo info)
    165                throws IOException {
    166
    167            if (chart == null) {
    168                throw new IllegalArgumentException("Null 'chart' argument.");
    169            }
    170            BufferedImage bufferedImage
    171                    = chart.createBufferedImage(width, height, info);
    172            EncoderUtil.writeBufferedImage(bufferedImage, ImageFormat.PNG, out);
    173        }
    174
    175        /**
    176         * Writes a chart to an output stream in PNG format.  This method allows
    177         * you to pass in a {@link ChartRenderingInfo} object, to collect
    178         * information about the chart dimensions/entities.  You will need this
    179         * info if you want to create an HTML image map.
    180         *
    181         * @param out  the output stream (<code>null</code> not permitted).
    182         * @param chart  the chart (<code>null</code> not permitted).
    183         * @param width  the image width.
    184         * @param height  the image height.
    185         * @param info  carries back chart rendering info (<code>null</code>
    186         *              permitted).
    187         * @param encodeAlpha  encode alpha?
    188         * @param compression  the PNG compression level (0-9).
    189         *
    190         * @throws IOException if there are any I/O errors.
    191         */
    192        public static void writeChartAsPNG(OutputStream out, JFreeChart chart,
    193                int width, int height, ChartRenderingInfo info,
    194                boolean encodeAlpha, int compression) throws IOException {
    195
    196            if (out == null) {
    197                throw new IllegalArgumentException("Null 'out' argument.");
    198            }
    199            if (chart == null) {
    200                throw new IllegalArgumentException("Null 'chart' argument.");
    201            }
    202            BufferedImage chartImage = chart.createBufferedImage(width, height,
    203                    BufferedImage.TYPE_INT_ARGB, info);
    204            ChartUtilities.writeBufferedImageAsPNG(out, chartImage, encodeAlpha,
    205                    compression);
    206
    207        }
    208
    209        /**
    210         * Writes a scaled version of a chart to an output stream in PNG format.
    211         *
    212         * @param out  the output stream (<code>null</code> not permitted).
    213         * @param chart  the chart (<code>null</code> not permitted).
    214         * @param width  the unscaled chart width.
    215         * @param height  the unscaled chart height.
    216         * @param widthScaleFactor  the horizontal scale factor.
    217         * @param heightScaleFactor  the vertical scale factor.
    218         *
    219         * @throws IOException if there are any I/O problems.
    220         */
    221        public static void writeScaledChartAsPNG(OutputStream out,
    222                JFreeChart chart, int width, int height, int widthScaleFactor,
    223                int heightScaleFactor) throws IOException {
    224
    225            if (out == null) {
    226                throw new IllegalArgumentException("Null 'out' argument.");
    227            }
    228            if (chart == null) {
    229                throw new IllegalArgumentException("Null 'chart' argument.");
    230            }
    231
    232            double desiredWidth = width * widthScaleFactor;
    233            double desiredHeight = height * heightScaleFactor;
    234            double defaultWidth = width;
    235            double defaultHeight = height;
    236            boolean scale = false;
    237
    238            // get desired width and height from somewhere then...
    239            if ((widthScaleFactor != 1) || (heightScaleFactor != 1)) {
    240                scale = true;
    241            }
    242
    243            double scaleX = desiredWidth / defaultWidth;
    244            double scaleY = desiredHeight / defaultHeight;
    245
    246            BufferedImage image = new BufferedImage((int) desiredWidth,
    247                    (int) desiredHeight, BufferedImage.TYPE_INT_ARGB);
    248            Graphics2D g2 = image.createGraphics();
    249
    250            if (scale) {
    251                AffineTransform saved = g2.getTransform();
    252                g2.transform(AffineTransform.getScaleInstance(scaleX, scaleY));
    253                chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth,
    254                        defaultHeight), null, null);
    255                g2.setTransform(saved);
    256                g2.dispose();
    257            }
    258            else {
    259                chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth,
    260                        defaultHeight), null, null);
    261            }
    262            out.write(encodeAsPNG(image));
    263
    264        }
    265
    266        /**
    267         * Saves a chart to the specified file in PNG format.
    268         *
    269         * @param file  the file name (<code>null</code> not permitted).
    270         * @param chart  the chart (<code>null</code> not permitted).
    271         * @param width  the image width.
    272         * @param height  the image height.
    273         *
    274         * @throws IOException if there are any I/O errors.
    275         */
    276        public static void saveChartAsPNG(File file, JFreeChart chart,
    277                int width, int height) throws IOException {
    278
    279            // defer argument checking...
    280            saveChartAsPNG(file, chart, width, height, null);
    281
    282        }
    283
    284        /**
    285         * Saves a chart to a file in PNG format.  This method allows you to pass
    286         * in a {@link ChartRenderingInfo} object, to collect information about the
    287         * chart dimensions/entities.  You will need this info if you want to
    288         * create an HTML image map.
    289         *
    290         * @param file  the file (<code>null</code> not permitted).
    291         * @param chart  the chart (<code>null</code> not permitted).
    292         * @param width  the image width.
    293         * @param height  the image height.
    294         * @param info  the chart rendering info (<code>null</code> permitted).
    295         *
    296         * @throws IOException if there are any I/O errors.
    297         */
    298        public static void saveChartAsPNG(File file, JFreeChart chart,
    299                int width, int height, ChartRenderingInfo info)
    300            throws IOException {
    301
    302            if (file == null) {
    303                throw new IllegalArgumentException("Null 'file' argument.");
    304            }
    305            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
    306            try {
    307                ChartUtilities.writeChartAsPNG(out, chart, width, height, info);
    308            }
    309            finally {
    310                out.close();
    311            }
    312        }
    313
    314        /**
    315         * Saves a chart to a file in PNG format.  This method allows you to pass
    316         * in a {@link ChartRenderingInfo} object, to collect information about the
    317         * chart dimensions/entities.  You will need this info if you want to
    318         * create an HTML image map.
    319         *
    320         * @param file  the file (<code>null</code> not permitted).
    321         * @param chart  the chart (<code>null</code> not permitted).
    322         * @param width  the image width.
    323         * @param height  the image height.
    324         * @param info  the chart rendering info (<code>null</code> permitted).
    325         * @param encodeAlpha  encode alpha?
    326         * @param compression  the PNG compression level (0-9).
    327         *
    328         * @throws IOException if there are any I/O errors.
    329         */
    330        public static void saveChartAsPNG(File file, JFreeChart chart,
    331               int width, int height, ChartRenderingInfo info, boolean encodeAlpha,
    332               int compression) throws IOException {
    333
    334            if (file == null) {
    335                throw new IllegalArgumentException("Null 'file' argument.");
    336            }
    337            if (chart == null) {
    338                throw new IllegalArgumentException("Null 'chart' argument.");
    339            }
    340
    341            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
    342            try {
    343                writeChartAsPNG(out, chart, width, height, info, encodeAlpha,
    344                        compression);
    345            }
    346            finally {
    347                out.close();
    348            }
    349
    350        }
    351
    352        /**
    353         * Writes a chart to an output stream in JPEG format.  Please note that
    354         * JPEG is a poor format for chart images, use PNG if possible.
    355         *
    356         * @param out  the output stream (<code>null</code> not permitted).
    357         * @param chart  the chart (<code>null</code> not permitted).
    358         * @param width  the image width.
    359         * @param height  the image height.
    360         *
    361         * @throws IOException if there are any I/O errors.
    362         */
    363        public static void writeChartAsJPEG(OutputStream out,
    364                JFreeChart chart, int width, int height) throws IOException {
    365
    366            // defer argument checking...
    367            writeChartAsJPEG(out, chart, width, height, null);
    368
    369        }
    370
    371        /**
    372         * Writes a chart to an output stream in JPEG format.  Please note that
    373         * JPEG is a poor format for chart images, use PNG if possible.
    374         *
    375         * @param out  the output stream (<code>null</code> not permitted).
    376         * @param quality  the quality setting.
    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, float quality,
    384                JFreeChart chart, int width, int height) throws IOException {
    385
    386            // defer argument checking...
    387            ChartUtilities.writeChartAsJPEG(out, quality, chart, width, height,
    388                    null);
    389
    390        }
    391
    392        /**
    393         * Writes a chart to an output stream in JPEG format. This method allows
    394         * you to pass in a {@link ChartRenderingInfo} object, to collect
    395         * information about the chart dimensions/entities.  You will need this
    396         * info if you want to create an HTML image map.
    397         *
    398         * @param out  the output stream (<code>null</code> not permitted).
    399         * @param chart  the chart (<code>null</code> not permitted).
    400         * @param width  the image width.
    401         * @param height  the image height.
    402         * @param info  the chart rendering info (<code>null</code> permitted).
    403         *
    404         * @throws IOException if there are any I/O errors.
    405         */
    406        public static void writeChartAsJPEG(OutputStream out, JFreeChart chart,
    407                int width, int height, ChartRenderingInfo info)
    408                throws IOException {
    409
    410            if (chart == null) {
    411                throw new IllegalArgumentException("Null 'chart' argument.");
    412            }
    413            BufferedImage image = chart.createBufferedImage(width, height,
    414                    BufferedImage.TYPE_INT_RGB, info);
    415            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out);
    416
    417        }
    418
    419        /**
    420         * Writes a chart to an output stream in JPEG format.  This method allows
    421         * you to pass in a {@link ChartRenderingInfo} object, to collect
    422         * information about the chart dimensions/entities.  You will need this
    423         * info if you want to create an HTML image map.
    424         *
    425         * @param out  the output stream (<code>null</code> not permitted).
    426         * @param quality  the output quality (0.0f to 1.0f).
    427         * @param chart  the chart (<code>null</code> not permitted).
    428         * @param width  the image width.
    429         * @param height  the image height.
    430         * @param info  the chart rendering info (<code>null</code> permitted).
    431         *
    432         * @throws IOException if there are any I/O errors.
    433         */
    434        public static void writeChartAsJPEG(OutputStream out, float quality,
    435                JFreeChart chart, int width, int height, ChartRenderingInfo info)
    436                throws IOException {
    437
    438            if (chart == null) {
    439                throw new IllegalArgumentException("Null 'chart' argument.");
    440            }
    441            BufferedImage image = chart.createBufferedImage(width, height,
    442                    BufferedImage.TYPE_INT_RGB, info);
    443            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
    444
    445        }
    446
    447        /**
    448         * Saves a chart to a file in JPEG format.
    449         *
    450         * @param file  the file (<code>null</code> not permitted).
    451         * @param chart  the chart (<code>null</code> not permitted).
    452         * @param width  the image width.
    453         * @param height  the image height.
    454         *
    455         * @throws IOException if there are any I/O errors.
    456         */
    457        public static void saveChartAsJPEG(File file, JFreeChart chart,
    458                int width, int height) throws IOException {
    459
    460            // defer argument checking...
    461            saveChartAsJPEG(file, chart, width, height, null);
    462
    463        }
    464
    465        /**
    466         * Saves a chart to a file in JPEG format.
    467         *
    468         * @param file  the file (<code>null</code> not permitted).
    469         * @param quality  the JPEG quality setting.
    470         * @param chart  the chart (<code>null</code> not permitted).
    471         * @param width  the image width.
    472         * @param height  the image height.
    473         *
    474         * @throws IOException if there are any I/O errors.
    475         */
    476        public static void saveChartAsJPEG(File file, float quality,
    477                JFreeChart chart, int width, int height) throws IOException {
    478
    479            // defer argument checking...
    480            saveChartAsJPEG(file, quality, chart, width, height, null);
    481
    482        }
    483
    484        /**
    485         * Saves a chart to a file in JPEG format.  This method allows you to pass
    486         * in a {@link ChartRenderingInfo} object, to collect information about the
    487         * chart dimensions/entities.  You will need this info if you want to
    488         * create an HTML image map.
    489         *
    490         * @param file  the file name (<code>null</code> not permitted).
    491         * @param chart  the chart (<code>null</code> not permitted).
    492         * @param width  the image width.
    493         * @param height  the image height.
    494         * @param info  the chart rendering info (<code>null</code> permitted).
    495         *
    496         * @throws IOException if there are any I/O errors.
    497         */
    498        public static void saveChartAsJPEG(File file, JFreeChart chart,
    499                int width, int height, ChartRenderingInfo info) throws IOException {
    500
    501            if (file == null) {
    502                throw new IllegalArgumentException("Null 'file' argument.");
    503            }
    504            if (chart == null) {
    505                throw new IllegalArgumentException("Null 'chart' argument.");
    506            }
    507            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
    508            try {
    509                writeChartAsJPEG(out, chart, width, height, info);
    510            }
    511            finally {
    512                out.close();
    513            }
    514
    515        }
    516
    517        /**
    518         * Saves a chart to a file in JPEG format.  This method allows you to pass
    519         * in a {@link ChartRenderingInfo} object, to collect information about the
    520         * chart dimensions/entities.  You will need this info if you want to
    521         * create an HTML image map.
    522         *
    523         * @param file  the file name (<code>null</code> not permitted).
    524         * @param quality  the quality setting.
    525         * @param chart  the chart (<code>null</code> not permitted).
    526         * @param width  the image width.
    527         * @param height  the image height.
    528         * @param info  the chart rendering info (<code>null</code> permitted).
    529         *
    530         * @throws IOException if there are any I/O errors.
    531         */
    532        public static void saveChartAsJPEG(File file, float quality,
    533                JFreeChart chart, int width, int height,
    534                ChartRenderingInfo info) throws IOException {
    535
    536            if (file == null) {
    537                throw new IllegalArgumentException("Null 'file' argument.");
    538            }
    539            if (chart == null) {
    540                throw new IllegalArgumentException("Null 'chart' argument.");
    541            }
    542
    543            OutputStream out = new BufferedOutputStream(new FileOutputStream(
    544                    file));
    545            try {
    546                writeChartAsJPEG(out, quality, chart, width, height, info);
    547            }
    548            finally {
    549                out.close();
    550            }
    551
    552        }
    553
    554        /**
    555         * Writes a {@link BufferedImage} to an output stream in JPEG format.
    556         *
    557         * @param out  the output stream (<code>null</code> not permitted).
    558         * @param image  the image (<code>null</code> not permitted).
    559         *
    560         * @throws IOException if there are any I/O errors.
    561         */
    562        public static void writeBufferedImageAsJPEG(OutputStream out,
    563                BufferedImage image) throws IOException {
    564
    565            // defer argument checking...
    566            writeBufferedImageAsJPEG(out, 0.75f, image);
    567
    568        }
    569
    570        /**
    571         * Writes a {@link BufferedImage} to an output stream in JPEG format.
    572         *
    573         * @param out  the output stream (<code>null</code> not permitted).
    574         * @param quality  the image quality (0.0f to 1.0f).
    575         * @param image  the image (<code>null</code> not permitted).
    576         *
    577         * @throws IOException if there are any I/O errors.
    578         */
    579        public static void writeBufferedImageAsJPEG(OutputStream out, float quality,
    580                BufferedImage image) throws IOException {
    581
    582            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
    583
    584        }
    585
    586        /**
    587         * Writes a {@link BufferedImage} to an output stream in PNG format.
    588         *
    589         * @param out  the output stream (<code>null</code> not permitted).
    590         * @param image  the image (<code>null</code> not permitted).
    591         *
    592         * @throws IOException if there are any I/O errors.
    593         */
    594        public static void writeBufferedImageAsPNG(OutputStream out,
    595                BufferedImage image) throws IOException {
    596
    597            EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out);
    598
    599        }
    600
    601        /**
    602         * Writes a {@link BufferedImage} to an output stream in PNG format.
    603         *
    604         * @param out  the output stream (<code>null</code> not permitted).
    605         * @param image  the image (<code>null</code> not permitted).
    606         * @param encodeAlpha  encode alpha?
    607         * @param compression  the compression level (0-9).
    608         *
    609         * @throws IOException if there are any I/O errors.
    610         */
    611        public static void writeBufferedImageAsPNG(OutputStream out,
    612                BufferedImage image, boolean encodeAlpha, int compression)
    613                throws IOException {
    614
    615            EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out,
    616                    compression, encodeAlpha);
    617        }
    618
    619        /**
    620         * Encodes a {@link BufferedImage} to PNG format.
    621         *
    622         * @param image  the image (<code>null</code> not permitted).
    623         *
    624         * @return A byte array in PNG format.
    625         *
    626         * @throws IOException if there is an I/O problem.
    627         */
    628        public static byte[] encodeAsPNG(BufferedImage image) throws IOException {
    629            return EncoderUtil.encode(image, ImageFormat.PNG);
    630        }
    631
    632        /**
    633         * Encodes a {@link BufferedImage} to PNG format.
    634         *
    635         * @param image  the image (<code>null</code> not permitted).
    636         * @param encodeAlpha  encode alpha?
    637         * @param compression  the PNG compression level (0-9).
    638         *
    639         * @return The byte array in PNG format.
    640         *
    641         * @throws IOException if there is an I/O problem.
    642         */
    643        public static byte[] encodeAsPNG(BufferedImage image, boolean encodeAlpha,
    644                                         int compression)
    645                throws IOException {
    646            return EncoderUtil.encode(image, ImageFormat.PNG, compression,
    647                    encodeAlpha);
    648        }
    649
    650        /**
    651         * Writes an image map to an output stream.
    652         *
    653         * @param writer  the writer (<code>null</code> not permitted).
    654         * @param name  the map name (<code>null</code> not permitted).
    655         * @param info  the chart rendering info (<code>null</code> not permitted).
    656         * @param useOverLibForToolTips  whether to use OverLIB for tooltips
    657         *                               (http://www.bosrup.com/web/overlib/).
    658         *
    659         * @throws IOException if there are any I/O errors.
    660         */
    661        public static void writeImageMap(PrintWriter writer,
    662                                         String name,
    663                                         ChartRenderingInfo info,
    664                                         boolean useOverLibForToolTips)
    665            throws IOException {
    666
    667            ToolTipTagFragmentGenerator toolTipTagFragmentGenerator = null;
    668            if (useOverLibForToolTips) {
    669                toolTipTagFragmentGenerator
    670                        = new OverLIBToolTipTagFragmentGenerator();
    671            }
    672            else {
    673                toolTipTagFragmentGenerator
    674                        = new StandardToolTipTagFragmentGenerator();
    675            }
    676            ImageMapUtilities.writeImageMap(writer, name, info,
    677                    toolTipTagFragmentGenerator,
    678                    new StandardURLTagFragmentGenerator());
    679
    680        }
    681
    682        /**
    683         * Writes an image map to the specified writer.
    684         *
    685         * @param writer  the writer (<code>null</code> not permitted).
    686         * @param name  the map name (<code>null</code> not permitted).
    687         * @param info  the chart rendering info (<code>null</code> not permitted).
    688         * @param toolTipTagFragmentGenerator  a generator for the HTML fragment
    689         *     that will contain the tooltip text (<code>null</code> not permitted
    690         *     if <code>info</code> contains tooltip information).
    691         * @param urlTagFragmentGenerator  a generator for the HTML fragment that
    692         *     will contain the URL reference (<code>null</code> not permitted if
    693         *     <code>info</code> contains URLs).
    694         *
    695         * @throws IOException if there are any I/O errors.
    696         */
    697        public static void writeImageMap(PrintWriter writer, String name,
    698                ChartRenderingInfo info,
    699                ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
    700                URLTagFragmentGenerator urlTagFragmentGenerator)
    701                throws IOException {
    702
    703            writer.println(ImageMapUtilities.getImageMap(name, info,
    704                    toolTipTagFragmentGenerator, urlTagFragmentGenerator));
    705        }
    706
    707        /**
    708         * Creates an HTML image map.  This method maps to
    709         * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo,
    710         * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}, using default
    711         * generators.
    712         *
    713         * @param name  the map name (<code>null</code> not permitted).
    714         * @param info  the chart rendering info (<code>null</code> not permitted).
    715         *
    716         * @return The map tag.
    717         */
    718        public static String getImageMap(String name, ChartRenderingInfo info) {
    719            return ImageMapUtilities.getImageMap(name, info,
    720                    new StandardToolTipTagFragmentGenerator(),
    721                    new StandardURLTagFragmentGenerator());
    722        }
    723
    724        /**
    725         * Creates an HTML image map.  This method maps directly to
    726         * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo,
    727         * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}.
    728         *
    729         * @param name  the map name (<code>null</code> not permitted).
    730         * @param info  the chart rendering info (<code>null</code> not permitted).
    731         * @param toolTipTagFragmentGenerator  a generator for the HTML fragment
    732         *     that will contain the tooltip text (<code>null</code> not permitted
    733         *     if <code>info</code> contains tooltip information).
    734         * @param urlTagFragmentGenerator  a generator for the HTML fragment that
    735         *     will contain the URL reference (<code>null</code> not permitted if
    736         *     <code>info</code> contains URLs).
    737         *
    738         * @return The map tag.
    739         */
    740        public static String getImageMap(String name, ChartRenderingInfo info,
    741                ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
    742                URLTagFragmentGenerator urlTagFragmentGenerator) {
    743
    744            return ImageMapUtilities.getImageMap(name, info,
    745                    toolTipTagFragmentGenerator, urlTagFragmentGenerator);
    746
    747        }
    748
    749    }