/*
* Copyright (c) 2007, Romain Guy
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the TimingFramework project nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.Paint;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Transparency;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
* @author Romain Guy
*/
public class ImageReflectionDemoFilthy extends JFrame {
private ReflectionPanel reflectionPanel;
private JSlider opacitySlider;
private JSlider lengthSlider;
private JSlider radiusSlider;
public ImageReflectionDemoFilthy() {
super("Reflections");
setContentPane(new GradientPanel());
reflectionPanel = new ReflectionPanel();
add(reflectionPanel);
opacitySlider = new JSlider(0, 100, 35);
opacitySlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
reflectionPanel.setOpacity(opacitySlider.getValue() / 100.0f);
}
});
lengthSlider = new JSlider(0, 100, 40);
lengthSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
reflectionPanel.setLength(lengthSlider.getValue() / 100.0f);
}
});
radiusSlider = new JSlider(1, 20, 1);
radiusSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
reflectionPanel.setRadius(radiusSlider.getValue());
}
});
JPanel controls = new JPanel(new GridBagLayout());
JLabel label;
controls.setOpaque(false);
controls.add(label = new JLabel("Opacity: 0%"),
new GridBagConstraints(0, 0, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 6, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
controls.add(opacitySlider,
new GridBagConstraints(1, 0, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
controls.add(label = new JLabel("100%"),
new GridBagConstraints(2, 0, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
controls.add(label = new JLabel("Length: 0%"),
new GridBagConstraints(0, 1, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 6, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
controls.add(lengthSlider,
new GridBagConstraints(1, 1, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
controls.add(label = new JLabel("100%"),
new GridBagConstraints(2, 1, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
controls.add(label = new JLabel("Blur Radius: 1px"),
new GridBagConstraints(0, 2, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 6, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
controls.add(radiusSlider,
new GridBagConstraints(1, 2, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
controls.add(label = new JLabel("20px"),
new GridBagConstraints(2, 2, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0, 0));
label.setForeground(Color.WHITE);
JCheckBox blurCheckBox = new JCheckBox("Blur Enabled");
blurCheckBox.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
reflectionPanel.setBlurEnabled(
((JCheckBox) changeEvent.getSource()).isSelected());
}
});
blurCheckBox.setOpaque(false);
blurCheckBox.setForeground(Color.WHITE);
controls.add(blurCheckBox,
new GridBagConstraints(0, 3, 1, 1, 0.0, 1.0,
GridBagConstraints.LINE_START,
GridBagConstraints.NONE,
new Insets(0, 0, 6, 0),
0, 0));
//add(controls, BorderLayout.SOUTH);
reflectionPanel.setLayout(new BorderLayout());
reflectionPanel.add(controls, BorderLayout.SOUTH);
pack();
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private static class ReflectionPanel extends JPanel {
private BufferedImage image = null;
private BufferedImage imageA;
private ReflectionRenderer renderer = new ReflectionRenderer();
public ReflectionPanel() {
try {
imageA = GraphicsUtilities.loadCompatibleImage(getClass().getResource("A.jpg"));
} catch (IOException e) {
e.printStackTrace();
}
image = renderer.createReflection(imageA);
setOpaque(false);
}
@Override
public Dimension getPreferredSize() {
return new Dimension(640, 520);
}
@Override
protected void paintComponent(Graphics g) {
int x = (getWidth() - imageA.getWidth()) / 2;
int y = 24;
if (renderer.isBlurEnabled()) {
x -= renderer.getEffectiveBlurRadius();
y -= renderer.getEffectiveBlurRadius() + 1;
}
g.drawImage(image, x, y + imageA.getHeight(), null);
if (renderer.isBlurEnabled()) {
x += renderer.getEffectiveBlurRadius();
y += renderer.getEffectiveBlurRadius() + 1;
}
g.drawImage(imageA, x, y, null);
}
public void setOpacity(float opacity) {
renderer.setOpacity(opacity);
image = renderer.createReflection(imageA);
repaint();
}
public void setLength(float length) {
renderer.setLength(length);
image = renderer.createReflection(imageA);
repaint();
}
public void setBlurEnabled(boolean selected) {
renderer.setBlurEnabled(selected);
image = renderer.createReflection(imageA);
repaint();
}
public void setRadius(int radius) {
renderer.setBlurRadius(radius);
image = renderer.createReflection(imageA);
repaint();
}
}
private static class GradientPanel extends JPanel {
GradientPanel() {
super(new BorderLayout());
}
@Override
protected void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Rectangle clip = g2.getClipBounds();
Paint paint = g2.getPaint();
g2.setPaint(new GradientPaint(0.0f, getHeight() * 0.22f,
new Color(0x202737),
0.0f, getHeight() * 0.7f,
Color.BLACK));
g2.fillRect(clip.x, clip.y, clip.width, clip.height);
g2.setPaint(paint);
}
}
public static void main(String... args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new ImageReflectionDemoFilthy().setVisible(true);
}
});
}
}
/*
* Copyright (c) 2007, Romain Guy
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the TimingFramework project nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* GraphicsUtilities contains a set of tools to perform
* common graphics operations easily. These operations are divided into
* several themes, listed below.
* Compatible Images
* Compatible images can, and should, be used to increase drawing
* performance. This class provides a number of methods to load compatible
* images directly from files or to convert existing images to compatibles
* images.
* Creating Thumbnails
* This class provides a number of methods to easily scale down images.
* Some of these methods offer a trade-off between speed and result quality and
* shouuld be used all the time. They also offer the advantage of producing
* compatible images, thus automatically resulting into better runtime
* performance.
* All these methodes are both faster than
* {@link java.awt.Image#getScaledInstance(int, int, int)} and produce
* better-looking results than the various drawImage() methods
* in {@link java.awt.Graphics}, which can be used for image scaling.
* Image Manipulation
* This class provides two methods to get and set pixels in a buffered image.
* These methods try to avoid unmanaging the image in order to keep good
* performance.
*
* @author Romain Guy
*/
class GraphicsUtilities {
private GraphicsUtilities() {
}
// Returns the graphics configuration for the primary screen
private static GraphicsConfiguration getGraphicsConfiguration() {
return GraphicsEnvironment.getLocalGraphicsEnvironment().
getDefaultScreenDevice().getDefaultConfiguration();
}
/**
* Returns a new BufferedImage using the same color model
* as the image passed as a parameter. The returned image is only compatible
* with the image passed as a parameter. This does not mean the returned
* image is compatible with the hardware.
*
* @param image the reference image from which the color model of the new
* image is obtained
* @return a new BufferedImage, compatible with the color model
* of image
*/
public static BufferedImage createColorModelCompatibleImage(BufferedImage image) {
ColorModel cm = image.getColorModel();
return new BufferedImage(cm,
cm.createCompatibleWritableRaster(image.getWidth(),
image.getHeight()),
cm.isAlphaPremultiplied(), null);
}
/**
* Returns a new compatible image with the same width, height and
* transparency as the image specified as a parameter.
*
* @see java.awt.Transparency
* @see #createCompatibleImage(int, int)
* @see #createCompatibleImage(java.awt.image.BufferedImage, int, int)
* @see #createCompatibleTranslucentImage(int, int)
* @see #loadCompatibleImage(java.net.URL)
* @see #toCompatibleImage(java.awt.image.BufferedImage)
* @param image the reference image from which the dimension and the
* transparency of the new image are obtained
* @return a new compatible BufferedImage with the same
* dimension and transparency as image
*/
public static BufferedImage createCompatibleImage(BufferedImage image) {
return createCompatibleImage(image, image.getWidth(), image.getHeight());
}
/**
* Returns a new compatible image of the specified width and height, and
* the same transparency setting as the image specified as a parameter.
*
* @see java.awt.Transparency
* @see #createCompatibleImage(java.awt.image.BufferedImage)
* @see #createCompatibleImage(int, int)
* @see #createCompatibleTranslucentImage(int, int)
* @see #loadCompatibleImage(java.net.URL)
* @see #toCompatibleImage(java.awt.image.BufferedImage)
* @param width the width of the new image
* @param height the height of the new image
* @param image the reference image from which the transparency of the new
* image is obtained
* @return a new compatible BufferedImage with the same
* transparency as image and the specified dimension
*/
public static BufferedImage createCompatibleImage(BufferedImage image,
int width, int height) {
return getGraphicsConfiguration().createCompatibleImage(width, height,
image.getTransparency());
}
/**
* Returns a new opaque compatible image of the specified width and
* height.
*
* @see #createCompatibleImage(java.awt.image.BufferedImage)
* @see #createCompatibleImage(java.awt.image.BufferedImage, int, int)
* @see #createCompatibleTranslucentImage(int, int)
* @see #loadCompatibleImage(java.net.URL)
* @see #toCompatibleImage(java.awt.image.BufferedImage)
* @param width the width of the new image
* @param height the height of the new image
* @return a new opaque compatible BufferedImage of the
* specified width and height
*/
public static BufferedImage createCompatibleImage(int width, int height) {
return getGraphicsConfiguration().createCompatibleImage(width, height);
}
/**
* Returns a new translucent compatible image of the specified width
* and height.
*
* @see #createCompatibleImage(java.awt.image.BufferedImage)
* @see #createCompatibleImage(java.awt.image.BufferedImage, int, int)
* @see #createCompatibleImage(int, int)
* @see #loadCompatibleImage(java.net.URL)
* @see #toCompatibleImage(java.awt.image.BufferedImage)
* @param width the width of the new image
* @param height the height of the new image
* @return a new translucent compatible BufferedImage of the
* specified width and height
*/
public static BufferedImage createCompatibleTranslucentImage(int width,
int height) {
return getGraphicsConfiguration().createCompatibleImage(width, height,
Transparency.TRANSLUCENT);
}
/**
* Returns a new compatible image from a URL. The image is loaded from the
* specified location and then turned, if necessary into a compatible
* image.
*
* @see #createCompatibleImage(java.awt.image.BufferedImage)
* @see #createCompatibleImage(java.awt.image.BufferedImage, int, int)
* @see #createCompatibleImage(int, int)
* @see #createCompatibleTranslucentImage(int, int)
* @see #toCompatibleImage(java.awt.image.BufferedImage)
* @param resource the URL of the picture to load as a compatible image
* @return a new translucent compatible BufferedImage of the
* specified width and height
* @throws java.io.IOException if the image cannot be read or loaded
*/
public static BufferedImage loadCompatibleImage(URL resource)
throws IOException {
BufferedImage image = ImageIO.read(resource);
return toCompatibleImage(image);
}
/**
* Return a new compatible image that contains a copy of the specified
* image. This method ensures an image is compatible with the hardware,
* and therefore optimized for fast blitting operations.
*
* @see #createCompatibleImage(java.awt.image.BufferedImage)
* @see #createCompatibleImage(java.awt.image.BufferedImage, int, int)
* @see #createCompatibleImage(int, int)
* @see #createCompatibleTranslucentImage(int, int)
* @see #loadCompatibleImage(java.net.URL)
* @param image the image to copy into a new compatible image
* @return a new compatible copy, with the
* same width and height and transparency and content, of image
*/
public static BufferedImage toCompatibleImage(BufferedImage image) {
if (image.getColorModel().equals(
getGraphicsConfiguration().getColorModel())) {
return image;
}
BufferedImage compatibleImage =
getGraphicsConfiguration().createCompatibleImage(
image.getWidth(), image.getHeight(),
image.getTransparency());
Graphics g = compatibleImage.getGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
return compatibleImage;
}
/**
* Returns a thumbnail of a source image. newSize defines
* the length of the longest dimension of the thumbnail. The other
* dimension is then computed according to the dimensions ratio of the
* original picture.
* This method favors speed over quality. When the new size is less than
* half the longest dimension of the source image,
* {@link #createThumbnail(BufferedImage, int)} or
* {@link #createThumbnail(BufferedImage, int, int)} should be used instead
* to ensure the quality of the result without sacrificing too much
* performance.
*
* @see #createThumbnailFast(java.awt.image.BufferedImage, int, int)
* @see #createThumbnail(java.awt.image.BufferedImage, int)
* @see #createThumbnail(java.awt.image.BufferedImage, int, int)
* @param image the source image
* @param newSize the length of the largest dimension of the thumbnail
* @return a new compatible BufferedImage containing a
* thumbnail of image
* @throws IllegalArgumentException if newSize is larger than
* the largest dimension of image or <= 0
*/
public static BufferedImage createThumbnailFast(BufferedImage image,
int newSize) {
float ratio;
int width = image.getWidth();
int height = image.getHeight();
if (width > height) {
if (newSize >= width) {
throw new IllegalArgumentException("newSize must be lower than" +
" the image width");
} else if (newSize <= 0) {
throw new IllegalArgumentException("newSize must" +
" be greater than 0");
}
ratio = (float) width / (float) height;
width = newSize;
height = (int) (newSize / ratio);
} else {
if (newSize >= height) {
throw new IllegalArgumentException("newSize must be lower than" +
" the image height");
} else if (newSize <= 0) {
throw new IllegalArgumentException("newSize must" +
" be greater than 0");
}
ratio = (float) height / (float) width;
height = newSize;
width = (int) (newSize / ratio);
}
BufferedImage temp = createCompatibleImage(image, width, height);
Graphics2D g2 = temp.createGraphics();
g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2.drawImage(image, 0, 0, temp.getWidth(), temp.getHeight(), null);
g2.dispose();
return temp;
}
/**
* Returns a thumbnail of a source image.
* This method favors speed over quality. When the new size is less than
* half the longest dimension of the source image,
* {@link #createThumbnail(BufferedImage, int)} or
* {@link #createThumbnail(BufferedImage, int, int)} should be used instead
* to ensure the quality of the result without sacrificing too much
* performance.
*
* @see #createThumbnailFast(java.awt.image.BufferedImage, int)
* @see #createThumbnail(java.awt.image.BufferedImage, int)
* @see #createThumbnail(java.awt.image.BufferedImage, int, int)
* @param image the source image
* @param newWidth the width of the thumbnail
* @param newHeight the height of the thumbnail
* @return a new compatible BufferedImage containing a
* thumbnail of image
* @throws IllegalArgumentException if newWidth is larger than
* the width of image or if code>newHeight is largerimage or if one of the dimensionsReturns a thumbnail of a source image. newSize defines
* the length of the longest dimension of the thumbnail. The other
* dimension is then computed according to the dimensions ratio of the
* original picture.
This method offers a good trade-off between speed and quality.
* The result looks better than
* {@link #createThumbnailFast(java.awt.image.BufferedImage, int)} when
* the new size is less than half the longest dimension of the source
* image, yet the rendering speed is almost similar.
BufferedImage containing aimagenewSize is larger thanimage or <= 0Returns a thumbnail of a source image.
This method offers a good trade-off between speed and quality.
* The result looks better than
* {@link #createThumbnailFast(java.awt.image.BufferedImage, int)} when
* the new size is less than half the longest dimension of the source
* image, yet the rendering speed is almost similar.
BufferedImage containing aimagenewWidth is larger thanimage or if code>newHeight is largerimage or if one the dimensions is not > 0Returns an array of pixels, stored as integers, from a
* BufferedImage. The pixels are grabbed from a rectangular
* area defined by a location and two dimensions. Calling this method on
* an image of type different from BufferedImage.TYPE_INT_ARGB
* and BufferedImage.TYPE_INT_RGB will unmanage the image.
pixels if non-null, a new array of integerspixels is non-null andWrites a rectangular area of pixels in the destination
* BufferedImage. Calling this method on
* an image of type different from BufferedImage.TYPE_INT_ARGB
* and BufferedImage.TYPE_INT_RGB will unmanage the image.
pixels is non-null andA fast blur filter can be used to blur pictures quickly. This filter is an
* implementation of the box blur algorithm. The blurs generated by this
* algorithm might show square artifacts, especially on pictures containing
* straight lines (rectangles, text, etc.) On most pictures though, the
* result will look very good.
The force of the blur can be controlled with a radius and the
* default radius is 3. Since the blur clamps values on the edges of the
* source picture, you might need to provide a picture with empty borders
* to avoid artifacts at the edges. The performance of this filter are
* independant from the radius.
Creates a new blur filter with a default radius of 3.
Creates a new blur filter with the specified radius. If the radius
* is lower than 1, a radius of 1 will be used automatically.
Returns the radius used by this filter, in pixels.
Blurs the source pixels into the destination pixels. The force of
* the blur is specified by the radius which must be greater than 0.
The source and destination pixels arrays are expected to be in the
* INT_ARGB format.
After this method is executed, dstPixels contains a transposed and
* filtered copy of srcPixels.
Provides an abstract implementation of the BufferedImageOp
* interface. This class can be used to created new image filters based
* on BufferedImageOp.
A reflection renderer generates the reflection of a given picture. The
* result can be either the reflection itself, or an image containing both the
* source image and its reflection.
A reflection is defined by three properties:
*
* ReflectionRenderer renderer = new ReflectionRenderer(0.5f, 0.3f, true);
* // ..
* renderer = new ReflectionRenderer();
* renderer.setOpacity(0.5f);
* renderer.setLength(0.3f);
* renderer.setBlurEnabled(true);
*
A reflection is generated as a BufferedImage from another
* BufferedImage. Once the renderer is set up, you must call
* {@link #createReflection(java.awt.image.BufferedImage)} to actually generate
* the reflection:
*
* ReflectionRenderer renderer = new ReflectionRenderer();
* // renderer setup
* BufferedImage reflection = renderer.createReflection(bufferedImage);
*
The returned image contains only the reflection. You will have to append
* it to the source image at painting time to get a realistic results. You can
* also asks the rendered to return a picture composed of both the source image
* and its reflection:
*
* ReflectionRenderer renderer = new ReflectionRenderer();
* // renderer setup
* BufferedImage reflection = renderer.appendReflection(bufferedImage);
*
This renderer allows to register property change listeners with
* {@link #addPropertyChangeListener}. Listening to properties changes is very
* useful when you emebed the renderer in a graphical component and give the API
* user the ability to access the renderer. By listening to properties changes,
* you can easily repaint the component when needed.
ReflectionRenderer is not guaranteed to be thread-safe.
Identifies a change to the opacity used to render the reflection.
Identifies a change to the length of the rendered reflection.
Identifies a change to the blurring of the rendered reflection.
Creates a default good looking reflections generator.
* The default reflection renderer provides the following default values:
*
These properties provide a regular, good looking reflection.
Creates a default good looking reflections generator with the
* specified opacity. The default reflection renderer provides the following
* default values:
*
Creates a reflections generator with the specified properties. Both
* opacity and length are numbers between 0.0 (0%) and 1.0 (100%). If the
* provided numbers are outside this range, they are clamped.
Enabling the blur generates a different kind of reflections that might
* look more natural. The default blur radius is 1 pixel
Add a PropertyChangeListener to the listener list. The listener is
* registered for all properties. The same listener object may be added
* more than once, and will be called as many times as it is added. If
* listener is null, no exception is thrown and no action
* is taken.
Remove a PropertyChangeListener from the listener list. This removes
* a PropertyChangeListener that was registered for all properties. If
* listener was added more than once to the same event source,
* it will be notified one less time after being removed. If
* listener is null, or was never added, no exception is thrown
* and no action is taken.
Gets the opacity used by the factory to generate reflections.
The opacity is comprised between 0.0f and 1.0f; 0.0f being fully
* transparent and 1.0f fully opaque.
Sets the opacity used by the factory to generate reflections.
Consecutive calls to {@link #createReflection} will all use this
* opacity until it is set again.
The opacity is comprised between 0.0f and 1.0f; 0.0f being fully
* transparent and 1.0f fully opaque. If you provide a value out of these
* boundaries, it will be restrained to the closest boundary.
Returns the length of the reflection. The result is a number between
* 0.0 and 1.0. This number is the fraction of the height of the source
* image that is used to compute the size of the reflection.
Sets the length of the reflection, as a fraction of the height of the
* source image.
Consecutive calls to {@link #createReflection} will all use this
* opacity until it is set again.
The opacity is comprised between 0.0f and 1.0f; 0.0f being fully
* transparent and 1.0f fully opaque. If you provide a value out of these
* boundaries, it will be restrained to the closest boundary.
Returns true if the blurring of the reflection is enabled, false
* otherwise. When blurring is enabled, the reflection is blurred to look
* more natural.
Setting the blur to true will enable the blurring of the reflection
* when {@link #createReflection} is invoked.
Enabling the blurring of the reflection can yield to more natural
* results which may or may not be better looking, depending on the source
* picture.
Consecutive calls to {@link #createReflection} will all use this
* opacity until it is set again.
Returns the effective radius, in pixels, of the blur used by this
* renderer when {@link #isBlurEnabled()} is true.
isBlurEnabled is trueReturns the radius, in pixels, of the blur used by this renderer when
* {@link #isBlurEnabled()} is true.
isBlurEnabledSets the radius, in pixels, of the blur used by this renderer when
* {@link #isBlurEnabled()} is true. This radius changes the size of the
* generated image when blurring is applied.
Returns the source image and its reflection. The appearance of the
* reflection is defined by the opacity, the length and the blur
* properties.
The width of the generated image will be augmented when
* {@link #isBlurEnabled()} is true. The generated image will have the width
* of the source image plus twice the effective blur radius (see
* {@link #getEffectiveBlurRadius()}). The default blur radius is 1 so the
* width will be augmented by 6. You might need to take this into account
* at drawing time.
The returned image height depends on the value returned by
* {@link #getLength()} and {@link #getEffectiveBlurRadius()}. For instance,
* if the length is 0.5 (or 50%) and the source image is 480 pixels high,
* then the reflection will be 246 (480 * 0.5 + 3 * 2) pixels high.
You can create only the reflection by calling
* {@link #createReflection(java.awt.image.BufferedImage)}.
Returns the reflection of the source image. The appearance of the
* reflection is defined by the opacity, the length and the blur
* properties.
The width of the generated image will be augmented when
* {@link #isBlurEnabled()} is true. The generated image will have the width
* of the source image plus twice the effective blur radius (see
* {@link #getEffectiveBlurRadius()}). The default blur radius is 1 so the
* width will be augmented by 6. You might need to take this into account
* at drawing time.
The returned image height depends on the value returned by
* {@link #getLength()} and {@link #getEffectiveBlurRadius()}. For instance,
* if the length is 0.5 (or 50%) and the source image is 480 pixels high,
* then the reflection will be 246 (480 * 0.5 + 3 * 2) pixels high.
The returned image contains only
* the reflection. You will have to append it to the source image to produce
* the illusion of a reflective environement. The method
* {@link #appendReflection(java.awt.image.BufferedImage)} provides an easy
* way to create an image containing both the source and the reflection.
A stack blur filter can be used to create an approximation of a
* gaussian blur. The approximation is controlled by the number of times the
* {@link org.jdesktop.swingx.image.FastBlurFilter} is applied onto the source
* picture. The default number of iterations, 3, provides a decent compromise
* between speed and rendering quality.
The force of the blur can be controlled with a radius and the
* default radius is 3. Since the blur clamps values on the edges of the
* source picture, you might need to provide a picture with empty borders
* to avoid artifacts at the edges. The performance of this filter are
* independant from the radius.
Creates a new blur filter with a default radius of 3 and 3 iterations.
Creates a new blur filter with the specified radius and 3 iterations.
* If the radius is lower than 1, a radius of 1 will be used automatically.
Creates a new blur filter with the specified radius. If the radius
* is lower than 1, a radius of 1 will be used automatically. The number
* of iterations controls the approximation to a gaussian blur. If the
* number of iterations is lower than 1, one iteration will be used
* automatically.
Returns the effective radius of the stack blur. If the radius of the
* blur is 1 and the stack iterations count is 3, then the effective blur
* radius is 1 * 3 = 3.
Returns the radius used by this filter, in pixels.
Returns the number of iterations used to approximate a gaussian
* blur.