001/* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2011, 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 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates. 
025 * Other names may be trademarks of their respective owners.]
026 *
027 * ---------------------------
028 * DefaultShadowGenerator.java
029 * ---------------------------
030 * (C) Copyright 2009, 2011 by Object Refinery Limited and Contributors.
031 *
032 * Original Author:  David Gilbert (for Object Refinery Limited);
033 * Contributor(s):   -;
034 *
035 * Changes:
036 * --------
037 * 10-Jul-2009 : Version 1 (DG);
038 * 29-Oct-2011 : Fixed Eclipse warnings (DG);
039 *
040 */
041
042package org.jfree.chart.util;
043
044import java.awt.Color;
045import java.awt.Graphics2D;
046import java.awt.image.BufferedImage;
047import java.awt.image.DataBufferInt;
048import java.io.Serializable;
049import org.jfree.chart.HashUtilities;
050
051/**
052 * A default implementation of the {@link ShadowGenerator} interface, based on
053 * code in a 
054 * <a href="http://www.jroller.com/gfx/entry/fast_or_good_drop_shadows">blog
055 * post by Romain Guy</a>.
056 *
057 * @since 1.0.14
058 */
059public class DefaultShadowGenerator implements ShadowGenerator, Serializable {
060
061    private static final long serialVersionUID = 2732993885591386064L;
062
063    /** The shadow size. */
064    private int shadowSize;
065
066    /** The shadow color. */
067    private Color shadowColor;
068
069    /** The shadow opacity. */
070    private float shadowOpacity;
071
072    /** The shadow offset angle (in radians). */
073    private double angle;
074
075    /** The shadow offset distance (in Java2D units). */
076    private int distance;
077
078    /**
079     * Creates a new instance with default attributes.
080     */
081    public DefaultShadowGenerator() {
082        this(5, Color.black, 0.5f, 5, -Math.PI / 4);
083    }
084
085    /**
086     * Creates a new instance with the specified attributes.
087     *
088     * @param size  the shadow size.
089     * @param color  the shadow color.
090     * @param opacity  the shadow opacity.
091     * @param distance  the shadow offset distance.
092     * @param angle  the shadow offset angle (in radians).
093     */
094    public DefaultShadowGenerator(int size, Color color, float opacity,
095            int distance, double angle) {
096        if (color == null) {
097            throw new IllegalArgumentException("Null 'color' argument.");
098        }
099        this.shadowSize = size;
100        this.shadowColor = color;
101        this.shadowOpacity = opacity;
102        this.distance = distance;
103        this.angle = angle;
104    }
105
106    /**
107     * Returns the shadow size.
108     *
109     * @return The shadow size.
110     */
111    public int getShadowSize() {
112        return this.shadowSize;
113    }
114
115    /**
116     * Returns the shadow color.
117     *
118     * @return The shadow color (never <code>null</code>).
119     */
120    public Color getShadowColor() {
121        return this.shadowColor;
122    }
123
124    /**
125     * Returns the shadow opacity.
126     *
127     * @return The shadow opacity.
128     */
129    public float getShadowOpacity() {
130        return this.shadowOpacity;
131    }
132
133    /**
134     * Returns the shadow offset distance.
135     *
136     * @return The shadow offset distance (in Java2D units).
137     */
138    public int getDistance() {
139        return this.distance;
140    }
141
142    /**
143     * Returns the shadow offset angle (in radians).
144     *
145     * @return The angle (in radians).
146     */
147    public double getAngle() {
148        return this.angle;
149    }
150
151    /**
152     * Calculates the x-offset for drawing the shadow image relative to the
153     * source.
154     *
155     * @return The x-offset.
156     */
157    public int calculateOffsetX() {
158        return (int) (Math.cos(this.angle) * this.distance) - this.shadowSize;
159    }
160
161    /**
162     * Calculates the y-offset for drawing the shadow image relative to the
163     * source.
164     *
165     * @return The y-offset.
166     */
167    public int calculateOffsetY() {
168        return -(int) (Math.sin(this.angle) * this.distance) - this.shadowSize;
169    }
170
171    /**
172     * Creates and returns an image containing the drop shadow for the
173     * specified source image.
174     *
175     * @param source  the source image.
176     *
177     * @return A new image containing the shadow.
178     */
179    public BufferedImage createDropShadow(BufferedImage source) {
180        BufferedImage subject = new BufferedImage(
181                source.getWidth() + this.shadowSize * 2,
182                source.getHeight() + this.shadowSize * 2,
183                BufferedImage.TYPE_INT_ARGB);
184
185        Graphics2D g2 = subject.createGraphics();
186        g2.drawImage(source, null, this.shadowSize, this.shadowSize);
187        g2.dispose();
188        applyShadow(subject);
189        return subject;
190    }
191
192    /**
193     * Applies a shadow to the image.
194     *
195     * @param image  the image.
196     */
197    protected void applyShadow(BufferedImage image) {
198        int dstWidth = image.getWidth();
199        int dstHeight = image.getHeight();
200
201        int left = (this.shadowSize - 1) >> 1;
202        int right = this.shadowSize - left;
203        int xStart = left;
204        int xStop = dstWidth - right;
205        int yStart = left;
206        int yStop = dstHeight - right;
207
208        int shadowRgb = this.shadowColor.getRGB() & 0x00FFFFFF;
209
210        int[] aHistory = new int[this.shadowSize];
211        int historyIdx = 0;
212
213        int aSum;
214
215        int[] dataBuffer = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
216        int lastPixelOffset = right * dstWidth;
217        float sumDivider = this.shadowOpacity / this.shadowSize;
218
219        // horizontal pass
220
221        for (int y = 0, bufferOffset = 0; y < dstHeight; y++, bufferOffset = y * dstWidth) {
222            aSum = 0;
223            historyIdx = 0;
224            for (int x = 0; x < this.shadowSize; x++, bufferOffset++) {
225                int a = dataBuffer[bufferOffset] >>> 24;
226                aHistory[x] = a;
227                aSum += a;
228            }
229
230            bufferOffset -= right;
231
232            for (int x = xStart; x < xStop; x++, bufferOffset++) {
233                int a = (int) (aSum * sumDivider);
234                dataBuffer[bufferOffset] = a << 24 | shadowRgb;
235
236                // substract the oldest pixel from the sum
237                aSum -= aHistory[historyIdx];
238
239                // get the lastest pixel
240                a = dataBuffer[bufferOffset + right] >>> 24;
241                aHistory[historyIdx] = a;
242                aSum += a;
243
244                if (++historyIdx >= this.shadowSize) {
245                    historyIdx -= this.shadowSize;
246                }
247            }
248        }
249
250        // vertical pass
251        for (int x = 0, bufferOffset = 0; x < dstWidth; x++, bufferOffset = x) {
252            aSum = 0;
253            historyIdx = 0;
254            for (int y = 0; y < this.shadowSize; y++,
255                    bufferOffset += dstWidth) {
256                int a = dataBuffer[bufferOffset] >>> 24;
257                aHistory[y] = a;
258                aSum += a;
259            }
260
261            bufferOffset -= lastPixelOffset;
262
263            for (int y = yStart; y < yStop; y++, bufferOffset += dstWidth) {
264                int a = (int) (aSum * sumDivider);
265                dataBuffer[bufferOffset] = a << 24 | shadowRgb;
266
267                // substract the oldest pixel from the sum
268                aSum -= aHistory[historyIdx];
269
270                // get the lastest pixel
271                a = dataBuffer[bufferOffset + lastPixelOffset] >>> 24;
272                aHistory[historyIdx] = a;
273                aSum += a;
274
275                if (++historyIdx >= this.shadowSize) {
276                    historyIdx -= this.shadowSize;
277                }
278            }
279        }
280    }
281
282    /**
283     * Tests this object for equality with an arbitrary object.
284     * 
285     * @param obj  the object (<code>null</code> permitted).
286     * 
287     * @return The object.
288     */
289    public boolean equals(Object obj) {
290        if (obj == this) {
291            return true;
292        }
293        if (!(obj instanceof DefaultShadowGenerator)) {
294            return false;
295        }
296        DefaultShadowGenerator that = (DefaultShadowGenerator) obj;
297        if (this.shadowSize != that.shadowSize) {
298            return false;
299        }
300        if (!this.shadowColor.equals(that.shadowColor)) {
301            return false;
302        }
303        if (this.shadowOpacity != that.shadowOpacity) {
304            return false;
305        }
306        if (this.distance != that.distance) {
307            return false;
308        }
309        if (this.angle != that.angle) {
310            return false;
311        }
312        return true;
313    }
314
315    /**
316     * Returns a hash code for this instance.
317     * 
318     * @return The hash code.
319     */
320    public int hashCode() {
321        int hash = HashUtilities.hashCode(17, this.shadowSize);
322        hash = HashUtilities.hashCode(hash, this.shadowColor);
323        hash = HashUtilities.hashCode(hash, this.shadowOpacity);
324        hash = HashUtilities.hashCode(hash, this.distance);
325        hash = HashUtilities.hashCode(hash, this.angle);
326        return hash;
327    }
328
329}