/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Eclipse Public License, Version 1.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.eclipse.org/org/documents/epl-v10.php
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.ide.eclipse.adt.internal.editors.layout.gle2;
import static com.android.SdkConstants.DOT_9PNG;
import static com.android.SdkConstants.DOT_BMP;
import static com.android.SdkConstants.DOT_GIF;
import static com.android.SdkConstants.DOT_JPG;
import static com.android.SdkConstants.DOT_PNG;
import static com.android.utils.SdkUtils.endsWithIgnoreCase;
import static java.awt.RenderingHints.KEY_ANTIALIASING;
import static java.awt.RenderingHints.KEY_INTERPOLATION;
import static java.awt.RenderingHints.KEY_RENDERING;
import static java.awt.RenderingHints.VALUE_ANTIALIAS_ON;
import static java.awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR;
import static java.awt.RenderingHints.VALUE_RENDER_QUALITY;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.api.Rect;
import com.android.ide.eclipse.adt.AdtPlugin;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;
import javax.imageio.ImageIO;
/**
* Utilities related to image processing.
*/
public class ImageUtils {
/**
* Returns true if the given image has no dark pixels
*
* @param image the image to be checked for dark pixels
* @return true if no dark pixels were found
*/
public static boolean containsDarkPixels(BufferedImage image) {
for (int y = 0, height = image.getHeight(); y < height; y++) {
for (int x = 0, width = image.getWidth(); x < width; x++) {
int pixel = image.getRGB(x, y);
if ((pixel & 0xFF000000) != 0) {
int r = (pixel & 0xFF0000) >> 16;
int g = (pixel & 0x00FF00) >> 8;
int b = (pixel & 0x0000FF);
// One perceived luminance formula is (0.299*red + 0.587*green + 0.114*blue)
// In order to keep this fast since we don't need a very accurate
// measure, I'll just estimate this with integer math:
long brightness = (299L*r + 587*g + 114*b) / 1000;
if (brightness < 128) {
return true;
}
}
}
}
return false;
}
/**
* Returns the perceived brightness of the given RGB integer on a scale from 0 to 255
*
* @param rgb the RGB triplet, 8 bits each
* @return the perceived brightness, with 0 maximally dark and 255 maximally bright
*/
public static int getBrightness(int rgb) {
if ((rgb & 0xFFFFFF) != 0) {
int r = (rgb & 0xFF0000) >> 16;
int g = (rgb & 0x00FF00) >> 8;
int b = (rgb & 0x0000FF);
// See the containsDarkPixels implementation for details
return (int) ((299L*r + 587*g + 114*b) / 1000);
}
return 0;
}
/**
* Converts an alpha-red-green-blue integer color into an {@link RGB} color.
* <p>
* <b>NOTE</b> - this will drop the alpha value since {@link RGB} objects do not
* contain transparency information.
*
* @param rgb the RGB integer to convert to a color description
* @return the color description corresponding to the integer
*/
public static RGB intToRgb(int rgb) {
return new RGB((rgb & 0xFF0000) >>> 16, (rgb & 0xFF00) >>> 8, rgb & 0xFF);
}
/**
* Converts an {@link RGB} color into a alpha-red-green-blue integer
*
* @param rgb the RGB color descriptor to convert
* @param alpha the amount of alpha to add into the color integer (since the
* {@link RGB} objects do not contain an alpha channel)
* @return an integer corresponding to the {@link RGB} color
*/
public static int rgbToInt(RGB rgb, int alpha) {
return alpha << 24 | (rgb.red << 16) | (rgb.green << 8) | rgb.blue;
}
/**
* Crops blank pixels from the edges of the image and returns the cropped result. We
* crop off pixels that are blank (meaning they have an alpha value = 0). Note that
* this is not the same as pixels that aren't opaque (an alpha value other than 255).
*
* @param image the image to be cropped
* @param initialCrop If not null, specifies a rectangle which contains an initial
* crop to continue. This can be used to crop an image where you already
* know about margins in the image
* @return a cropped version of the source image, or null if the whole image was blank
* and cropping completely removed everything
*/
@Nullable
public static BufferedImage cropBlank(
@NonNull BufferedImage image,
@Nullable Rect initialCrop) {
return cropBlank(image, initialCrop, image.getType());
}
/**
* Crops blank pixels from the edges of the image and returns the cropped result. We
* crop off pixels that are blank (meaning they have an alpha value = 0). Note that
* this is not the same as pixels that aren't opaque (an alpha value other than 255).
*
* @param image the image to be cropped
* @param initialCrop If not null, specifies a rectangle which contains an initial
* crop to continue. This can be used to crop an image where you already
* know about margins in the image
* @param imageType the type of {@link BufferedImage} to create
* @return a cropped version of the source image, or null if the whole image was blank
* and cropping completely removed everything
*/
public static BufferedImage cropBlank(BufferedImage image, Rect initialCrop, int imageType) {
CropFilter filter = new CropFilter() {
@Override
public boolean crop(BufferedImage bufferedImage, int x, int y) {
int rgb = bufferedImage.getRGB(x, y);
return (rgb & 0xFF000000) == 0x00000000;
// TODO: Do a threshold of 80 instead of just 0? Might give better
// visual results -- e.g. check <= 0x80000000
}
};
return crop(image, filter, initialCrop, imageType);
}
/**
* Crops pixels of a given color from the edges of the image and returns the cropped
* result.
*
* @param image the image to be cropped
* @param blankArgb the color considered to be blank, as a 32 pixel integer with 8
* bits of alpha, red, green and blue
* @param initialCrop If not null, specifies a rectangle which contains an initial
* crop to continue. This can be used to crop an image where you already
* know about margins in the image
* @return a cropped version of the source image, or null if the whole image was blank
* and cropping completely removed everything
*/
@Nullable
public static BufferedImage cropColor(
@NonNull BufferedImage image,
final int blankArgb,
@Nullable Rect initialCrop) {
return cropColor(image, blankArgb, initialCrop, image.getType());
}
/**
* Crops pixels of a given color from the edges of the image and returns the cropped
* result.
*
* @param image the image to be cropped
* @param blankArgb the color considered to be blank, as a 32 pixel integer with 8
* bits of alpha, red, green and blue
* @param initialCrop If not null, specifies a rectangle which contains an initial
* crop to continue. This can be used to crop an image where you already
* know about margins in the image
* @param imageType the type of {@link BufferedImage} to create
* @return a cropped version of the source image, or null if the whole image was blank
* and cropping completely removed everything
*/
public static BufferedImage cropColor(BufferedImage image,
final int blankArgb, Rect initialCrop, int imageType) {
CropFilter filter = new CropFilter() {
@Override
public boolean crop(BufferedImage bufferedImage, int x, int y) {
return blankArgb == bufferedImage.getRGB(x, y);
}
};
return crop(image, filter, initialCrop, imageType);
}
/**
* Interface implemented by cropping functions that determine whether
* a pixel should be cropped or not.
*/
private static interface CropFilter {
/**
* Returns true if the pixel is should be cropped.
*
* @param image the image containing the pixel in question
* @param x the x position of the pixel
* @param y the y position of the pixel
* @return true if the pixel should be cropped (for example, is blank)
*/
boolean crop(BufferedImage image, int x, int y);
}
private static BufferedImage crop(BufferedImage image, CropFilter filter, Rect initialCrop,
int imageType) {
if (image == null) {
return null;
}
// First, determine the dimensions of the real image within the image
int x1, y1, x2, y2;
if (initialCrop != null) {
x1 = initialCrop.x;
y1 = initialCrop.y;
x2 = initialCrop.x + initialCrop.w;
y2 = initialCrop.y + initialCrop.h;
} else {
x1 = 0;
y1 = 0;
x2 = image.getWidth();
y2 = image.getHeight();
}
// Nothing left to crop
if (x1 == x2 || y1 == y2) {
return null;
}
// This algorithm is a bit dumb -- it just scans along the edges looking for
// a pixel that shouldn't be cropped. I could maybe try to make it smarter by
// for example doing a binary search to quickly eliminate large empty areas to
// the right and bottom -- but this is slightly tricky with components like the
// AnalogClock where I could accidentally end up finding a blank horizontal or
// vertical line somewhere in the middle of the rendering of the clock, so for now
// we do the dumb thing -- not a big deal since we tend to crop reasonably
// small images.
// First determine top edge
topEdge: for (; y1 < y2; y1++) {
for (int x = x1; x < x2; x++) {
if (!filter.crop(image, x, y1)) {
break topEdge;
}
}
}
if (y1 == image.getHeight()) {
// The image is blank
return null;
}
// Next determine left edge
leftEdge: for (; x1 < x2; x1++) {
for (int y = y1; y < y2; y++) {
if (!filter.crop(image, x1, y)) {
break leftEdge;
}
}
}
// Next determine right edge
rightEdge: for (; x2 > x1; x2--) {
for (int y = y1; y < y2; y++) {
if (!filter.crop(image, x2 - 1, y)) {
break rightEdge;
}
}
}
// Finally determine bottom edge
bottomEdge: for (; y2 > y1; y2--) {
for (int x = x1; x < x2; x++) {
if (!filter.crop(image, x, y2 - 1)) {
break bottomEdge;
}
}
}
// No need to crop?
if (x1 == 0 && y1 == 0 && x2 == image.getWidth() && y2 == image.getHeight()) {
return image;
}
if (x1 == x2 || y1 == y2) {
// Nothing left after crop -- blank image
return null;
}
int width = x2 - x1;
int height = y2 - y1;
// Now extract the sub-image
if (imageType == -1) {
imageType = image.getType();
}
if (imageType == BufferedImage.TYPE_CUSTOM) {
imageType = BufferedImage.TYPE_INT_ARGB;
}
BufferedImage cropped = new BufferedImage(width, height, imageType);
Graphics g = cropped.getGraphics();
g.drawImage(image, 0, 0, width, height, x1, y1, x2, y2, null);
g.dispose();
return cropped;
}
/**
* Creates a drop shadow of a given image and returns a new image which shows the
* input image on top of its drop shadow.
* <p>
* <b>NOTE: If the shape is rectangular and opaque, consider using
* {@link #drawRectangleShadow(Graphics, int, int, int, int)} instead.</b>
*
* @param source the source image to be shadowed
* @param shadowSize the size of the shadow in pixels
* @param shadowOpacity the opacity of the shadow, with 0=transparent and 1=opaque
* @param shadowRgb the RGB int to use for the shadow color
* @return a new image with the source image on top of its shadow
*/
public static BufferedImage createDropShadow(BufferedImage source, int shadowSize,
float shadowOpacity, int shadowRgb) {
// This code is based on
// http://www.jroller.com/gfx/entry/non_rectangular_shadow
BufferedImage image = new BufferedImage(source.getWidth() + shadowSize * 2,
source.getHeight() + shadowSize * 2,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = image.createGraphics();
g2.drawImage(source, null, shadowSize, shadowSize);
int dstWidth = image.getWidth();
int dstHeight = image.getHeight();
int left = (shadowSize - 1) >> 1;
int right = shadowSize - left;
int xStart = left;
int xStop = dstWidth - right;
int yStart = left;
int yStop = dstHeight - right;
shadowRgb = shadowRgb & 0x00FFFFFF;
int[] aHistory = new int[shadowSize];
int historyIdx = 0;
int aSum;
int[] dataBuffer = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
int lastPixelOffset = right * dstWidth;
float sumDivider = shadowOpacity / shadowSize;
// horizontal pass
for (int y = 0, bufferOffset = 0; y < dstHeight; y++, bufferOffset = y * dstWidth) {
aSum = 0;
historyIdx = 0;
for (int x = 0; x < shadowSize; x++, bufferOffset++) {
int a = dataBuffer[bufferOffset] >>> 24;
aHistory[x] = a;
aSum += a;
}
bufferOffset -= right;
for (int x = xStart; x < xStop; x++, bufferOffset++) {
int a = (int) (aSum * sumDivider);
dataBuffer[bufferOffset] = a << 24 | shadowRgb;
// subtract the oldest pixel from the sum
aSum -= aHistory[historyIdx];
// get the latest pixel
a = dataBuffer[bufferOffset + right] >>> 24;
aHistory[historyIdx] = a;
aSum += a;
if (++historyIdx >= shadowSize) {
historyIdx -= shadowSize;
}
}
}
// vertical pass
for (int x = 0, bufferOffset = 0; x < dstWidth; x++, bufferOffset = x) {
aSum = 0;
historyIdx = 0;
for (int y = 0; y < shadowSize; y++, bufferOffset += dstWidth) {
int a = dataBuffer[bufferOffset] >>> 24;
aHistory[y] = a;
aSum += a;
}
bufferOffset -= lastPixelOffset;
for (int y = yStart; y < yStop; y++, bufferOffset += dstWidth) {
int a = (int) (aSum * sumDivider);
dataBuffer[bufferOffset] = a << 24 | shadowRgb;
// subtract the oldest pixel from the sum
aSum -= aHistory[historyIdx];
// get the latest pixel
a = dataBuffer[bufferOffset + lastPixelOffset] >>> 24;
aHistory[historyIdx] = a;
aSum += a;
if (++historyIdx >= shadowSize) {
historyIdx -= shadowSize;
}
}
}
g2.drawImage(source, null, 0, 0);
g2.dispose();
return image;
}
/**
* Draws a rectangular drop shadow (of size {@link #SHADOW_SIZE} by
* {@link #SHADOW_SIZE} around the given source and returns a new image with
* both combined
*
* @param source the source image
* @return the source image with a drop shadow on the bottom and right
*/
public static BufferedImage createRectangularDropShadow(BufferedImage source) {
int type = source.getType();
if (type == BufferedImage.TYPE_CUSTOM) {
type = BufferedImage.TYPE_INT_ARGB;
}
int width = source.getWidth();
int height = source.getHeight();
BufferedImage image = new BufferedImage(width + SHADOW_SIZE, height + SHADOW_SIZE, type);
Graphics g = image.getGraphics();
g.drawImage(source, 0, 0, width, height, null);
ImageUtils.drawRectangleShadow(image, 0, 0, width, height);
g.dispose();
return image;
}
/**
* Draws a drop shadow for the given rectangle into the given context. It
* will not draw anything if the rectangle is smaller than a minimum
* determined by the assets used to draw the shadow graphics.
* The size of the shadow is {@link #SHADOW_SIZE}.
*
* @param image the image to draw the shadow into
* @param x the left coordinate of the left hand side of the rectangle
* @param y the top coordinate of the top of the rectangle
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public static final void drawRectangleShadow(BufferedImage image,
int x, int y, int width, int height) {
Graphics gc = image.getGraphics();
try {
drawRectangleShadow(gc, x, y, width, height);
} finally {
gc.dispose();
}
}
/**
* Draws a small drop shadow for the given rectangle into the given context. It
* will not draw anything if the rectangle is smaller than a minimum
* determined by the assets used to draw the shadow graphics.
* The size of the shadow is {@link #SMALL_SHADOW_SIZE}.
*
* @param image the image to draw the shadow into
* @param x the left coordinate of the left hand side of the rectangle
* @param y the top coordinate of the top of the rectangle
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public static final void drawSmallRectangleShadow(BufferedImage image,
int x, int y, int width, int height) {
Graphics gc = image.getGraphics();
try {
drawSmallRectangleShadow(gc, x, y, width, height);
} finally {
gc.dispose();
}
}
/**
* The width and height of the drop shadow painted by
* {@link #drawRectangleShadow(Graphics, int, int, int, int)}
*/
public static final int SHADOW_SIZE = 20; // DO NOT EDIT. This corresponds to bitmap graphics
/**
* The width and height of the drop shadow painted by
* {@link #drawSmallRectangleShadow(Graphics, int, int, int, int)}
*/
public static final int SMALL_SHADOW_SIZE = 10; // DO NOT EDIT. Corresponds to bitmap graphics
/**
* Draws a drop shadow for the given rectangle into the given context. It
* will not draw anything if the rectangle is smaller than a minimum
* determined by the assets used to draw the shadow graphics.
* <p>
* This corresponds to
* {@link SwtUtils#drawRectangleShadow(org.eclipse.swt.graphics.GC, int, int, int, int)},
* but applied to an AWT graphics object instead, such that no image
* conversion has to be performed.
* <p>
* Make sure to keep changes in the visual appearance here in sync with the
* AWT version in
* {@link SwtUtils#drawRectangleShadow(org.eclipse.swt.graphics.GC, int, int, int, int)}.
*
* @param gc the graphics context to draw into
* @param x the left coordinate of the left hand side of the rectangle
* @param y the top coordinate of the top of the rectangle
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public static final void drawRectangleShadow(Graphics gc,
int x, int y, int width, int height) {
if (sShadowBottomLeft == null) {
// Shadow graphics. This was generated by creating a drop shadow in
// Gimp, using the parameters x offset=10, y offset=10, blur radius=10,
// color=black, and opacity=51. These values attempt to make a shadow
// that is legible both for dark and light themes, on top of the
// canvas background (rgb(150,150,150). Darker shadows would tend to
// blend into the foreground for a dark holo screen, and lighter shadows
// would be hard to spot on the canvas background. If you make adjustments,
// make sure to check the shadow with both dark and light themes.
//
// After making the graphics, I cut out the top right, bottom left
// and bottom right corners as 20x20 images, and these are reproduced by
// painting them in the corresponding places in the target graphics context.
// I then grabbed a single horizontal gradient line from the middle of the
// right edge,and a single vertical gradient line from the bottom. These
// are then painted scaled/stretched in the target to fill the gaps between
// the three corner images.
//
// Filenames: bl=bottom left, b=bottom, br=bottom right, r=right, tr=top right
sShadowBottomLeft = readImage("shadow-bl.png"); //$NON-NLS-1$
sShadowBottom = readImage("shadow-b.png"); //$NON-NLS-1$
sShadowBottomRight = readImage("shadow-br.png"); //$NON-NLS-1$
sShadowRight = readImage("shadow-r.png"); //$NON-NLS-1$
sShadowTopRight = readImage("shadow-tr.png"); //$NON-NLS-1$
assert sShadowBottomLeft != null;
assert sShadowBottomRight.getWidth() == SHADOW_SIZE;
assert sShadowBottomRight.getHeight() == SHADOW_SIZE;
}
int blWidth = sShadowBottomLeft.getWidth();
int trHeight = sShadowTopRight.getHeight();
if (width < blWidth) {
return;
}
if (height < trHeight) {
return;
}
gc.drawImage(sShadowBottomLeft, x, y + height, null);
gc.drawImage(sShadowBottomRight, x + width, y + height, null);
gc.drawImage(sShadowTopRight, x + width, y, null);
gc.drawImage(sShadowBottom,
x + sShadowBottomLeft.getWidth(), y + height,
x + width, y + height + sShadowBottom.getHeight(),
0, 0, sShadowBottom.getWidth(), sShadowBottom.getHeight(),
null);
gc.drawImage(sShadowRight,
x + width, y + sShadowTopRight.getHeight(),
x + width + sShadowRight.getWidth(), y + height,
0, 0, sShadowRight.getWidth(), sShadowRight.getHeight(),
null);
}
/**
* Draws a small drop shadow for the given rectangle into the given context. It
* will not draw anything if the rectangle is smaller than a minimum
* determined by the assets used to draw the shadow graphics.
* <p>
*
* @param gc the graphics context to draw into
* @param x the left coordinate of the left hand side of the rectangle
* @param y the top coordinate of the top of the rectangle
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public static final void drawSmallRectangleShadow(Graphics gc,
int x, int y, int width, int height) {
if (sShadow2BottomLeft == null) {
// Shadow graphics. This was generated by creating a drop shadow in
// Gimp, using the parameters x offset=5, y offset=%, blur radius=5,
// color=black, and opacity=51. These values attempt to make a shadow
// that is legible both for dark and light themes, on top of the
// canvas background (rgb(150,150,150). Darker shadows would tend to
// blend into the foreground for a dark holo screen, and lighter shadows
// would be hard to spot on the canvas background. If you make adjustments,
// make sure to check the shadow with both dark and light themes.
//
// After making the graphics, I cut out the top right, bottom left
// and bottom right corners as 20x20 images, and these are reproduced by
// painting them in the corresponding places in the target graphics context.
// I then grabbed a single horizontal gradient line from the middle of the
// right edge,and a single vertical gradient line from the bottom. These
// are then painted scaled/stretched in the target to fill the gaps between
// the three corner images.
//
// Filenames: bl=bottom left, b=bottom, br=bottom right, r=right, tr=top right
sShadow2BottomLeft = readImage("shadow2-bl.png"); //$NON-NLS-1$
sShadow2Bottom = readImage("shadow2-b.png"); //$NON-NLS-1$
sShadow2BottomRight = readImage("shadow2-br.png"); //$NON-NLS-1$
sShadow2Right = readImage("shadow2-r.png"); //$NON-NLS-1$
sShadow2TopRight = readImage("shadow2-tr.png"); //$NON-NLS-1$
assert sShadow2BottomLeft != null;
assert sShadow2TopRight != null;
assert sShadow2BottomRight.getWidth() == SMALL_SHADOW_SIZE;
assert sShadow2BottomRight.getHeight() == SMALL_SHADOW_SIZE;
}
int blWidth = sShadow2BottomLeft.getWidth();
int trHeight = sShadow2TopRight.getHeight();
if (width < blWidth) {
return;
}
if (height < trHeight) {
return;
}
gc.drawImage(sShadow2BottomLeft, x, y + height, null);
gc.drawImage(sShadow2BottomRight, x + width, y + height, null);
gc.drawImage(sShadow2TopRight, x + width, y, null);
gc.drawImage(sShadow2Bottom,
x + sShadow2BottomLeft.getWidth(), y + height,
x + width, y + height + sShadow2Bottom.getHeight(),
0, 0, sShadow2Bottom.getWidth(), sShadow2Bottom.getHeight(),
null);
gc.drawImage(sShadow2Right,
x + width, y + sShadow2TopRight.getHeight(),
x + width + sShadow2Right.getWidth(), y + height,
0, 0, sShadow2Right.getWidth(), sShadow2Right.getHeight(),
null);
}
/**
* Reads the given image from the plugin folder
*
* @param name the name of the image (including file extension)
* @return the corresponding image, or null if something goes wrong
*/
@Nullable
public static BufferedImage readImage(@NonNull String name) {
InputStream stream = ImageUtils.class.getResourceAsStream("/icons/" + name); //$NON-NLS-1$
if (stream != null) {
try {
return ImageIO.read(stream);
} catch (IOException e) {
AdtPlugin.log(e, "Could not read %1$s", name);
} finally {
try {
stream.close();
} catch (IOException e) {
// Dumb API
}
}
}
return null;
}
// Normal drop shadow
private static BufferedImage sShadowBottomLeft;
private static BufferedImage sShadowBottom;
private static BufferedImage sShadowBottomRight;
private static BufferedImage sShadowRight;
private static BufferedImage sShadowTopRight;
// Small drop shadow
private static BufferedImage sShadow2BottomLeft;
private static BufferedImage sShadow2Bottom;
private static BufferedImage sShadow2BottomRight;
private static BufferedImage sShadow2Right;
private static BufferedImage sShadow2TopRight;
/**
* Returns a bounding rectangle for the given list of rectangles. If the list is
* empty, the bounding rectangle is null.
*
* @param items the list of rectangles to compute a bounding rectangle for (may not be
* null)
* @return a bounding rectangle of the passed in rectangles, or null if the list is
* empty
*/
public static Rectangle getBoundingRectangle(List<Rectangle> items) {
Iterator<Rectangle> iterator = items.iterator();
if (!iterator.hasNext()) {
return null;
}
Rectangle bounds = iterator.next();
Rectangle union = new Rectangle(bounds.x, bounds.y, bounds.width, bounds.height);
while (iterator.hasNext()) {
union.add(iterator.next());
}
return union;
}
/**
* Returns a new image which contains of the sub image given by the rectangle (x1,y1)
* to (x2,y2)
*
* @param source the source image
* @param x1 top left X coordinate
* @param y1 top left Y coordinate
* @param x2 bottom right X coordinate
* @param y2 bottom right Y coordinate
* @return a new image containing the pixels in the given range
*/
public static BufferedImage subImage(BufferedImage source, int x1, int y1, int x2, int y2) {
int width = x2 - x1;
int height = y2 - y1;
int imageType = source.getType();
if (imageType == BufferedImage.TYPE_CUSTOM) {
imageType = BufferedImage.TYPE_INT_ARGB;
}
BufferedImage sub = new BufferedImage(width, height, imageType);
Graphics g = sub.getGraphics();
g.drawImage(source, 0, 0, width, height, x1, y1, x2, y2, null);
g.dispose();
return sub;
}
/**
* Returns the color value represented by the given string value
* @param value the color value
* @return the color as an int
* @throw NumberFormatException if the conversion failed.
*/
public static int getColor(String value) {
// Copied from ResourceHelper in layoutlib
if (value != null) {
if (value.startsWith("#") == false) { //$NON-NLS-1$
throw new NumberFormatException(
String.format("Color value '%s' must start with #", value));
}
value = value.substring(1);
// make sure it's not longer than 32bit
if (value.length() > 8) {
throw new NumberFormatException(String.format(
"Color value '%s' is too long. Format is either" +
"#AARRGGBB, #RRGGBB, #RGB, or #ARGB",
value));
}
if (value.length() == 3) { // RGB format
char[] color = new char[8];
color[0] = color[1] = 'F';
color[2] = color[3] = value.charAt(0);
color[4] = color[5] = value.charAt(1);
color[6] = color[7] = value.charAt(2);
value = new String(color);
} else if (value.length() == 4) { // ARGB format
char[] color = new char[8];
color[0] = color[1] = value.charAt(0);
color[2] = color[3] = value.charAt(1);
color[4] = color[5] = value.charAt(2);
color[6] = color[7] = value.charAt(3);
value = new String(color);
} else if (value.length() == 6) {
value = "FF" + value; //$NON-NLS-1$
}
// this is a RRGGBB or AARRGGBB value
// Integer.parseInt will fail to parse strings like "ff191919", so we use
// a Long, but cast the result back into an int, since we know that we're only
// dealing with 32 bit values.
return (int)Long.parseLong(value, 16);
}
throw new NumberFormatException();
}
/**
* Resize the given image
*
* @param source the image to be scaled
* @param xScale x scale
* @param yScale y scale
* @return the scaled image
*/
public static BufferedImage scale(BufferedImage source, double xScale, double yScale) {
return scale(source, xScale, yScale, 0, 0);
}
/**
* Resize the given image
*
* @param source the image to be scaled
* @param xScale x scale
* @param yScale y scale
* @param rightMargin extra margin to add on the right
* @param bottomMargin extra margin to add on the bottom
* @return the scaled image
*/
public static BufferedImage scale(BufferedImage source, double xScale, double yScale,
int rightMargin, int bottomMargin) {
int sourceWidth = source.getWidth();
int sourceHeight = source.getHeight();
int destWidth = Math.max(1, (int) (xScale * sourceWidth));
int destHeight = Math.max(1, (int) (yScale * sourceHeight));
int imageType = source.getType();
if (imageType == BufferedImage.TYPE_CUSTOM) {
imageType = BufferedImage.TYPE_INT_ARGB;
}
if (xScale > 0.5 && yScale > 0.5) {
BufferedImage scaled =
new BufferedImage(destWidth + rightMargin, destHeight + bottomMargin, imageType);
Graphics2D g2 = scaled.createGraphics();
g2.setComposite(AlphaComposite.Src);
g2.setColor(new Color(0, true));
g2.fillRect(0, 0, destWidth + rightMargin, destHeight + bottomMargin);
g2.setRenderingHint(KEY_INTERPOLATION, VALUE_INTERPOLATION_BILINEAR);
g2.setRenderingHint(KEY_RENDERING, VALUE_RENDER_QUALITY);
g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
g2.drawImage(source, 0, 0, destWidth, destHeight, 0, 0, sourceWidth, sourceHeight,
null);
g2.dispose();
return scaled;
} else {
// When creating a thumbnail, using the above code doesn't work very well;
// you get some visible artifacts, especially for text. Instead use the
// technique of repeatedly scaling the image into half; this will cause
// proper averaging of neighboring pixels, and will typically (for the kinds
// of screen sizes used by this utility method in the layout editor) take
// about 3-4 iterations to get the result since we are logarithmically reducing
// the size. Besides, each successive pass in operating on much fewer pixels
// (a reduction of 4 in each pass).
//
// However, we may not be resizing to a size that can be reached exactly by
// successively diving in half. Therefore, once we're within a factor of 2 of
// the final size, we can do a resize to the exact target size.
// However, we can get even better results if we perform this final resize
// up front. Let's say we're going from width 1000 to a destination width of 85.
// The first approach would cause a resize from 1000 to 500 to 250 to 125, and
// then a resize from 125 to 85. That last resize can distort/blur a lot.
// Instead, we can start with the destination width, 85, and double it
// successfully until we're close to the initial size: 85, then 170,
// then 340, and finally 680. (The next one, 1360, is larger than 1000).
// So, now we *start* the thumbnail operation by resizing from width 1000 to
// width 680, which will preserve a lot of visual details such as text.
// Then we can successively resize the image in half, 680 to 340 to 170 to 85.
// We end up with the expected final size, but we've been doing an exact
// divide-in-half resizing operation at the end so there is less distortion.
int iterations = 0; // Number of halving operations to perform after the initial resize
int nearestWidth = destWidth; // Width closest to source width that = 2^x, x is integer
int nearestHeight = destHeight;
while (nearestWidth < sourceWidth / 2) {
nearestWidth *= 2;
nearestHeight *= 2;
iterations++;
}
// If we're supposed to add in margins, we need to do it in the initial resizing
// operation if we don't have any subsequent resizing operations.
if (iterations == 0) {
nearestWidth += rightMargin;
nearestHeight += bottomMargin;
}
BufferedImage scaled = new BufferedImage(nearestWidth, nearestHeight, imageType);
Graphics2D g2 = scaled.createGraphics();
g2.setRenderingHint(KEY_INTERPOLATION, VALUE_INTERPOLATION_BILINEAR);
g2.setRenderingHint(KEY_RENDERING, VALUE_RENDER_QUALITY);
g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
g2.drawImage(source, 0, 0, nearestWidth, nearestHeight,
0, 0, sourceWidth, sourceHeight, null);
g2.dispose();
sourceWidth = nearestWidth;
sourceHeight = nearestHeight;
source = scaled;
for (int iteration = iterations - 1; iteration >= 0; iteration--) {
int halfWidth = sourceWidth / 2;
int halfHeight = sourceHeight / 2;
if (iteration == 0) { // Last iteration: Add margins in final image
scaled = new BufferedImage(halfWidth + rightMargin, halfHeight + bottomMargin,
imageType);
} else {
scaled = new BufferedImage(halfWidth, halfHeight, imageType);
}
g2 = scaled.createGraphics();
g2.setRenderingHint(KEY_INTERPOLATION,VALUE_INTERPOLATION_BILINEAR);
g2.setRenderingHint(KEY_RENDERING, VALUE_RENDER_QUALITY);
g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
g2.drawImage(source, 0, 0,
halfWidth, halfHeight, 0, 0,
sourceWidth, sourceHeight,
null);
g2.dispose();
sourceWidth = halfWidth;
sourceHeight = halfHeight;
source = scaled;
iterations--;
}
return scaled;
}
}
/**
* Returns true if the given file path points to an image file recognized by
* Android. See http://developer.android.com/guide/appendix/media-formats.html
* for details.
*
* @param path the filename to be tested
* @return true if the file represents an image file
*/
public static boolean hasImageExtension(String path) {
return endsWithIgnoreCase(path, DOT_PNG)
|| endsWithIgnoreCase(path, DOT_9PNG)
|| endsWithIgnoreCase(path, DOT_GIF)
|| endsWithIgnoreCase(path, DOT_JPG)
|| endsWithIgnoreCase(path, DOT_BMP);
}
/**
* Creates a new image of the given size filled with the given color
*
* @param width the width of the image
* @param height the height of the image
* @param color the color of the image
* @return a new image of the given size filled with the given color
*/
public static BufferedImage createColoredImage(int width, int height, RGB color) {
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics g = image.getGraphics();
g.setColor(new Color(color.red, color.green, color.blue));
g.fillRect(0, 0, image.getWidth(), image.getHeight());
g.dispose();
return image;
}
}