    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2007, 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-2007, 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     *
    074     */
    075
    076    package org.jfree.chart;
    077
    078    import java.awt.Graphics2D;
    079    import java.awt.geom.AffineTransform;
    080    import java.awt.geom.Rectangle2D;
    081    import java.awt.image.BufferedImage;
    082    import java.io.BufferedOutputStream;
    083    import java.io.File;
    084    import java.io.FileOutputStream;
    085    import java.io.IOException;
    086    import java.io.OutputStream;
    087    import java.io.PrintWriter;
    088
    089    import org.jfree.chart.encoders.EncoderUtil;
    090    import org.jfree.chart.encoders.ImageFormat;
    091    import org.jfree.chart.imagemap.ImageMapUtilities;
    092    import org.jfree.chart.imagemap.OverLIBToolTipTagFragmentGenerator;
    093    import org.jfree.chart.imagemap.StandardToolTipTagFragmentGenerator;
    094    import org.jfree.chart.imagemap.StandardURLTagFragmentGenerator;
    095    import org.jfree.chart.imagemap.ToolTipTagFragmentGenerator;
    096    import org.jfree.chart.imagemap.URLTagFragmentGenerator;
    097
    098    /**
    099     * 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    }