/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://www.alkacon.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* For further information about Alkacon Software, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://www.opencms.org
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.opencms.loader;
import com.alkacon.simapi.RenderSettings;
import com.alkacon.simapi.Simapi;
import com.alkacon.simapi.filter.GrayscaleFilter;
import com.alkacon.simapi.filter.ShadowFilter;
import org.opencms.file.CmsFile;
import org.opencms.file.CmsObject;
import org.opencms.file.CmsProperty;
import org.opencms.file.CmsPropertyDefinition;
import org.opencms.file.CmsResource;
import org.opencms.main.CmsLog;
import org.opencms.main.OpenCms;
import org.opencms.util.CmsStringUtil;
import java.awt.Color;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log;
/**
* Creates scaled images, acting as it's own parameter container.<p>
*
* @since 6.2.0
*/
public class CmsImageScaler {
/** The name of the transparent color (for the background image). */
public static final String COLOR_TRANSPARENT = "transparent";
/** The name of the grayscale image filter. */
public static final String FILTER_GRAYSCALE = "grayscale";
/** The name of the shadow image filter. */
public static final String FILTER_SHADOW = "shadow";
/** The supported image filter names. */
public static final List<String> FILTERS = Arrays.asList(new String[] {FILTER_GRAYSCALE, FILTER_SHADOW});
/** The (optional) parameter used for sending the scale information of an image in the http request. */
public static final String PARAM_SCALE = "__scale";
/** The default maximum image size (width * height) to apply image blurring when down scaling (setting this to high may case "out of memory" errors). */
public static final int SCALE_DEFAULT_MAX_BLUR_SIZE = 2500 * 2500;
/** The default maximum image size (width or height) to allow when up or down scaling an image using request parameters. */
public static final int SCALE_DEFAULT_MAX_SIZE = 1500;
/** The scaler parameter to indicate the requested image background color (if required). */
public static final String SCALE_PARAM_COLOR = "c";
/** The scaler parameter to indicate crop height. */
public static final String SCALE_PARAM_CROP_HEIGHT = "ch";
/** The scaler parameter to indicate crop width. */
public static final String SCALE_PARAM_CROP_WIDTH = "cw";
/** The scaler parameter to indicate crop X coordinate. */
public static final String SCALE_PARAM_CROP_X = "cx";
/** The scaler parameter to indicate crop Y coordinate. */
public static final String SCALE_PARAM_CROP_Y = "cy";
/** The scaler parameter to indicate the requested image filter. */
public static final String SCALE_PARAM_FILTER = "f";
/** The scaler parameter to indicate the requested image height. */
public static final String SCALE_PARAM_HEIGHT = "h";
/** The scaler parameter to indicate the requested image position (if required). */
public static final String SCALE_PARAM_POS = "p";
/** The scaler parameter to indicate to requested image save quality in percent (if applicable, for example used with JPEG images). */
public static final String SCALE_PARAM_QUALITY = "q";
/** The scaler parameter to indicate to requested <code>{@link java.awt.RenderingHints}</code> settings. */
public static final String SCALE_PARAM_RENDERMODE = "r";
/** The scaler parameter to indicate the requested scale type. */
public static final String SCALE_PARAM_TYPE = "t";
/** The scaler parameter to indicate the requested image width. */
public static final String SCALE_PARAM_WIDTH = "w";
/** The log object for this class. */
protected static final Log LOG = CmsLog.getLog(CmsImageScaler.class);
/** The target background color (optional). */
private Color m_color;
/** The height for image cropping. */
private int m_cropHeight;
/** The width for image cropping. */
private int m_cropWidth;
/** The x coordinate for image cropping. */
private int m_cropX;
/** The y coordinate for image cropping. */
private int m_cropY;
/** The list of image filter names (Strings) to apply. */
private List<String> m_filters;
/** The target height (required). */
private int m_height;
/** The maximum image size (width * height) to apply image blurring when down scaling (setting this to high may case "out of memory" errors). */
private int m_maxBlurSize;
/** The maximum target height (for scale type '5'). */
private int m_maxHeight;
/** The maximum target width (for scale type '5'). */
private int m_maxWidth;
/** The target position (optional). */
private int m_position;
/** The target image save quality (if applicable, for example used with JPEG images) (optional). */
private int m_quality;
/** The image processing renderings hints constant mode indicator (optional). */
private int m_renderMode;
/** The final (parsed and corrected) scale parameters. */
private String m_scaleParameters;
/** The target scale type (optional). */
private int m_type;
/** The target width (required). */
private int m_width;
/**
* Creates a new, empty image scaler object.<p>
*/
public CmsImageScaler() {
init();
}
/**
* Creates a new image scaler initialized with the height and width of
* the given image contained in the byte array.<p>
*
* <b>Please note:</b>The image itself is not stored in the scaler, only the width and
* height dimensions of the image. To actually scale an image, you need to use
* <code>{@link #scaleImage(CmsFile)}</code>. This constructor is commonly used only
* to extract the image dimensions, for example when creating a String value for
* the <code>{@link CmsPropertyDefinition#PROPERTY_IMAGE_SIZE}</code> property.<p>
*
* In case the byte array can not be decoded to an image, or in case of other errors,
* <code>{@link #isValid()}</code> will return <code>false</code>.<p>
*
* @param content the image to calculate the dimensions for
* @param rootPath the root path of the resource (for error logging)
*/
public CmsImageScaler(byte[] content, String rootPath) {
init();
try {
// read the scaled image
BufferedImage image = Simapi.read(content);
m_height = image.getHeight();
m_width = image.getWidth();
} catch (Exception e) {
// nothing we can do about this, keep the original properties
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.get().getBundle().key(Messages.ERR_UNABLE_TO_EXTRACT_IMAGE_SIZE_1, rootPath), e);
}
// set height / width to default of -1
init();
}
}
/**
* Creates a new image scaler by reading the property <code>{@link CmsPropertyDefinition#PROPERTY_IMAGE_SIZE}</code>
* from the given resource.<p>
*
* In case of any errors reading or parsing the property,
* <code>{@link #isValid()}</code> will return <code>false</code>.<p>
*
* @param cms the OpenCms user context to use when reading the property
* @param res the resource to read the property from
*/
public CmsImageScaler(CmsObject cms, CmsResource res) {
init();
String sizeValue = null;
if ((cms != null) && (res != null)) {
try {
CmsProperty sizeProp = cms.readPropertyObject(res, CmsPropertyDefinition.PROPERTY_IMAGE_SIZE, false);
if (!sizeProp.isNullProperty()) {
// parse property value using standard procedures
sizeValue = sizeProp.getValue();
}
} catch (Exception e) {
// ignore
}
}
if (CmsStringUtil.isNotEmpty(sizeValue)) {
parseParameters(sizeValue);
}
}
/**
* Creates a new image scaler based on the given HTTP request.<p>
*
* The maximum scale size is checked in order to prevent DOS attacks.
* Without this, it would be possible to request arbitrary huge images with a simple GET request,
* which would result in Out-Of-Memory errors if the image is just requested large enough.<p>
*
* The maximum blur size is checked since this operation is know to also cause memory issues
* with large images. If the original image is larger then this, no blur is applied before
* scaling down, which will result in a less optimal but still usable scale result.<p>
*
* @param request the HTTP request to read the parameters from
* @param maxScaleSize the maximum scale size (width or height) for the image
* @param maxBlurSize the maximum size of the image (width * height) to apply blur
*/
public CmsImageScaler(HttpServletRequest request, int maxScaleSize, int maxBlurSize) {
init();
m_maxBlurSize = maxBlurSize;
String parameters = request.getParameter(CmsImageScaler.PARAM_SCALE);
if (CmsStringUtil.isNotEmpty(parameters)) {
parseParameters(parameters);
if (isValid()) {
// valid parameters, check if scale size is not too big
if ((getWidth() > maxScaleSize) || (getHeight() > maxScaleSize)) {
// scale size is too big, reset scaler
init();
}
}
}
}
/**
* Creates a new image scaler based on the given parameter String.<p>
*
* @param parameters the scale parameters to use
*/
public CmsImageScaler(String parameters) {
init();
if (CmsStringUtil.isNotEmpty(parameters)) {
parseParameters(parameters);
}
}
/**
* Creates a new image scaler based on the given base scaler and the given width and height.<p>
*
* @param base the base scaler to initialize the values with
* @param width the width to set for this scaler
* @param height the height to set for this scaler
*/
protected CmsImageScaler(CmsImageScaler base, int width, int height) {
initValuesFrom(base);
setWidth(width);
setHeight(height);
}
/**
* Adds a filter name to the list of filters that should be applied to the image.<p>
*
* @param filter the filter name to add
*/
public void addFilter(String filter) {
if (CmsStringUtil.isNotEmpty(filter)) {
filter = filter.trim().toLowerCase();
if (FILTERS.contains(filter)) {
m_filters.add(filter);
}
}
}
/**
* @see java.lang.Object#clone()
*/
@Override
public Object clone() {
CmsImageScaler clone = new CmsImageScaler();
clone.initValuesFrom(this);
return clone;
}
/**
* Returns the color.<p>
*
* @return the color
*/
public Color getColor() {
return m_color;
}
/**
* Returns the color as a String.<p>
*
* @return the color as a String
*/
public String getColorString() {
StringBuffer result = new StringBuffer();
if (m_color == Simapi.COLOR_TRANSPARENT) {
result.append(COLOR_TRANSPARENT);
} else {
if (m_color.getRed() < 16) {
result.append('0');
}
result.append(Integer.toString(m_color.getRed(), 16));
if (m_color.getGreen() < 16) {
result.append('0');
}
result.append(Integer.toString(m_color.getGreen(), 16));
if (m_color.getBlue() < 16) {
result.append('0');
}
result.append(Integer.toString(m_color.getBlue(), 16));
}
return result.toString();
}
/**
* Returns the crop area height.<p>
*
* Use {@link #setCropArea(int, int, int, int)} to set this value.<p>
*
* @return the crop area height
*/
public int getCropHeight() {
return m_cropHeight;
}
/**
* Returns a new image scaler that is a cropped rescaler from <code>this</code> cropped scaler
* size to the given target scaler size.<p>
*
* @param target the image scaler that holds the target image dimensions
*
* @return a new image scaler that is a cropped rescaler from <code>this</code> cropped scaler
* size to the given target scaler size
*
* @see #getReScaler(CmsImageScaler)
* @see #setCropArea(int, int, int, int)
*/
public CmsImageScaler getCropScaler(CmsImageScaler target) {
// first re-scale the image (if required)
CmsImageScaler result = getReScaler(target);
// now use the crop area from the original
result.setCropArea(m_cropX, m_cropY, m_cropWidth, m_cropHeight);
return result;
}
/**
* Returns the crop area width.<p>
*
* Use {@link #setCropArea(int, int, int, int)} to set this value.<p>
*
* @return the crop area width
*/
public int getCropWidth() {
return m_cropWidth;
}
/**
* Returns the crop area X start coordinate.<p>
*
* Use {@link #setCropArea(int, int, int, int)} to set this value.<p>
*
* @return the crop area X start coordinate
*/
public int getCropX() {
return m_cropX;
}
/**
* Returns the crop area Y start coordinate.<p>
*
* Use {@link #setCropArea(int, int, int, int)} to set this value.<p>
*
* @return the crop area Y start coordinate
*/
public int getCropY() {
return m_cropY;
}
/**
* Returns a new image scaler that is a down scale from the size of <code>this</code> scaler
* to the given scaler size.<p>
*
* If no down scale from this to the given scaler is required according to
* {@link #isDownScaleRequired(CmsImageScaler)}, then <code>null</code> is returned.<p>
*
* @param downScaler the image scaler that holds the down scaled target image dimensions
*
* @return a new image scaler that is a down scale from the size of <code>this</code> scaler
* to the given target scaler size, or <code>null</code>
*/
public CmsImageScaler getDownScaler(CmsImageScaler downScaler) {
if (!isDownScaleRequired(downScaler)) {
// no down scaling is required
return null;
}
int downHeight = downScaler.getHeight();
int downWidth = downScaler.getWidth();
int height = getHeight();
int width = getWidth();
if (((height > width) && (downHeight < downWidth)) || ((width > height) && (downWidth < downHeight))) {
// adjust orientation
downHeight = downWidth;
downWidth = downScaler.getHeight();
}
if (width > downWidth) {
// width is too large, re-calculate height
float scale = (float)downWidth / (float)width;
downHeight = Math.round(height * scale);
} else if (height > downHeight) {
// height is too large, re-calculate width
float scale = (float)downHeight / (float)height;
downWidth = Math.round(width * scale);
} else {
// something is wrong, don't down scale
return null;
}
// now create and initialize the result scaler
return new CmsImageScaler(downScaler, downWidth, downHeight);
}
/**
* Returns the list of image filter names (Strings) to be applied to the image.<p>
*
* @return the list of image filter names (Strings) to be applied to the image
*/
public List<String> getFilters() {
return m_filters;
}
/**
* Returns the list of image filter names (Strings) to be applied to the image as a String.<p>
*
* @return the list of image filter names (Strings) to be applied to the image as a String
*/
public String getFiltersString() {
StringBuffer result = new StringBuffer();
Iterator<String> i = m_filters.iterator();
while (i.hasNext()) {
String filter = i.next();
result.append(filter);
if (i.hasNext()) {
result.append(':');
}
}
return result.toString();
}
/**
* Returns the height.<p>
*
* @return the height
*/
public int getHeight() {
return m_height;
}
/**
* Returns the image type from the given file name based on the file suffix (extension)
* and the available image writers.<p>
*
* For example, for the file name "opencms.gif" the type is GIF, for
* "opencms.jpg" is is "JPEG" etc.<p>
*
* In case the input filename has no suffix, or there is no known image writer for the format defined
* by the suffix, <code>null</code> is returned.<p>
*
* Any non-null result can be used if an image type input value is required.<p>
*
* @param filename the file name to get the type for
*
* @return the image type from the given file name based on the suffix and the available image writers,
* or null if no image writer is available for the format
*/
public String getImageType(String filename) {
return Simapi.getImageType(filename);
}
/**
* Returns the maximum image size (width * height) to apply image blurring when down scaling images.<p>
*
* Image blurring is required to achieve the best results for down scale operations when the target image size
* is 2 times or more smaller then the original image size.
* This parameter controls the maximum size (width * height) of an
* image that is blurred before it is down scaled. If the image is larger, no blurring is done.
* Image blurring is an expensive operation in both CPU usage and memory consumption.
* Setting the blur size to large may case "out of memory" errors.<p>
*
* @return the maximum image size (width * height) to apply image blurring when down scaling images
*/
public int getMaxBlurSize() {
return m_maxBlurSize;
}
/**
* Returns the maximum target height (for scale type '5').<p>
*
* @return the maximum target height (for scale type '5')
*/
public int getMaxHeight() {
return m_maxHeight;
}
/**
* Returns the maximum target width (for scale type '5').<p>
*
* @return the maximum target width (for scale type '5').
*/
public int getMaxWidth() {
return m_maxWidth;
}
/**
* Returns the image pixel count, that is the image with multiplied by the image height.<p>
*
* If this scaler is not valid (see {@link #isValid()}) the result is undefined.<p>
*
* @return the image pixel count, that is the image with multiplied by the image height
*/
public int getPixelCount() {
return m_width * m_height;
}
/**
* Returns the position.<p>
*
* @return the position
*/
public int getPosition() {
return m_position;
}
/**
* Returns the image saving quality in percent (0 - 100).<p>
*
* This is used only if applicable, for example when saving JPEG images.<p>
*
* @return the image saving quality in percent
*/
public int getQuality() {
return m_quality;
}
/**
* Returns the image rendering mode constant.<p>
*
* Possible values are:<dl>
* <dt>{@link Simapi#RENDER_QUALITY} (default)</dt>
* <dd>Use best possible image processing - this may be slow sometimes.</dd>
*
* <dt>{@link Simapi#RENDER_SPEED}</dt>
* <dd>Fastest image processing but worse results - use this for thumbnails or where speed is more important then quality.</dd>
*
* <dt>{@link Simapi#RENDER_MEDIUM}</dt>
* <dd>Use default rendering hints from JVM - not recommended since it's almost as slow as the {@link Simapi#RENDER_QUALITY} mode.</dd></dl>
*
* @return the image rendering mode constant
*/
public int getRenderMode() {
return m_renderMode;
}
/**
* Returns a new image scaler that is a rescaler from <code>this</code> scaler
* size to the given target scaler size.<p>
*
* The height of the target image is calculated in proportion
* to the original image width. If the width of the the original image is not known,
* the target image width is calculated in proportion to the original image height.<p>
*
* @param target the image scaler that holds the target image dimensions
*
* @return a new image scaler that is a rescaler from the <code>this</code> scaler
* size to the given target scaler size
*/
public CmsImageScaler getReScaler(CmsImageScaler target) {
int height = target.getHeight();
int width = target.getWidth();
int type = target.getType();
if (type == 5) {
// best fit option without upscale in the provided dimensions
if (target.isValid()) {
// ensure we have sensible values for maxWidth / minWidth even if one has not been set
float maxWidth = target.getMaxWidth() > 0 ? target.getMaxWidth() : height;
float maxHeight = target.getMaxHeight() > 0 ? target.getMaxHeight() : width;
// calculate the factor of the image and the 3 possible target dimensions
float scaleOfImage = (float)getWidth() / (float)getHeight();
float[] scales = new float[3];
scales[0] = (float)width / (float)height;
scales[1] = width / maxHeight;
scales[2] = maxWidth / height;
int useScale = calculateClosest(scaleOfImage, scales);
int[] dimensions;
switch (useScale) {
case 0:
default:
dimensions = calculateDimension(getWidth(), getHeight(), width, height);
break;
case 1:
dimensions = calculateDimension(getWidth(), getHeight(), width, (int)maxHeight);
break;
case 2:
dimensions = calculateDimension(getWidth(), getHeight(), (int)maxWidth, height);
break;
}
width = dimensions[0];
height = dimensions[1];
} else {
// target not valid, switch type to 1 (no upscale)
type = 1;
}
}
if (type != 5) {
if ((width > 0) && (getWidth() > 0)) {
// width is known, calculate height
float scale = (float)width / (float)getWidth();
height = Math.round(getHeight() * scale);
} else if ((height > 0) && (getHeight() > 0)) {
// height is known, calculate width
float scale = (float)height / (float)getHeight();
width = Math.round(getWidth() * scale);
} else if (isValid() && !target.isValid()) {
// scaler is not valid but original is, so use original size of image
width = getWidth();
height = getHeight();
}
}
if ((type == 1) && (!target.isValid())) {
// "no upscale" has been requested, only one target dimension was given
if ((target.getWidth() > 0) && (getWidth() < width)) {
// target width was given, target image should have this width
height = getHeight();
} else if ((target.getHeight() > 0) && (getHeight() < height)) {
// target height was given, target image should have this height
width = getWidth();
}
}
// now create and initialize the result scaler
CmsImageScaler result = new CmsImageScaler(target, width, height);
// type may have been switched
result.setType(type);
return result;
}
/**
* Returns the type.<p>
*
* Possible values are:<dl>
*
* <dt>0 (default): Scale to exact target size with background padding</dt><dd><ul>
* <li>enlarge image to fit in target size (if required)
* <li>reduce image to fit in target size (if required)
* <li>keep image aspect ratio / proportions intact
* <li>fill up with bgcolor to reach exact target size
* <li>fit full image inside target size (only applies if reduced)</ul></dd>
*
* <dt>1: Thumbnail generation mode (like 0 but no image enlargement)</dt><dd><ul>
* <li>dont't enlarge image
* <li>reduce image to fit in target size (if required)
* <li>keep image aspect ratio / proportions intact
* <li>fill up with bgcolor to reach exact target size
* <li>fit full image inside target size (only applies if reduced)</ul></dd>
*
* <dt>2: Scale to exact target size, crop what does not fit</dt><dd><ul>
* <li>enlarge image to fit in target size (if required)
* <li>reduce image to fit in target size (if required)
* <li>keep image aspect ratio / proportions intact
* <li>fit full image inside target size (crop what does not fit)</ul></dd>
*
* <dt>3: Scale and keep image proportions, target size variable</dt><dd><ul>
* <li>enlarge image to fit in target size (if required)
* <li>reduce image to fit in target size (if required)
* <li>keep image aspect ratio / proportions intact
* <li>scaled image will not be padded or cropped, so target size is likely not the exact requested size</ul></dd>
*
* <dt>4: Don't keep image proportions, use exact target size</dt><dd><ul>
* <li>enlarge image to fit in target size (if required)
* <li>reduce image to fit in target size (if required)
* <li>don't keep image aspect ratio / proportions intact
* <li>the image will be scaled exactly to the given target size and likely will be loose proportions</ul></dd>
* </dl>
*
* <dt>5: Scale and keep image proportions without enlargement, target size variable with optional max width and height</dt><dd><ul>
* <li>dont't enlarge image
* <li>reduce image to fit in target size (if required)
* <li>keep image aspect ratio / proportions intact
* <li>best fit into target width / height _OR_ width / maxHeight _OR_ maxWidth / height
* <li>scaled image will not be padded or cropped, so target size is likely not the exact requested size</ul></dd>
*
* @return the type
*/
public int getType() {
return m_type;
}
/**
* Returns the width.<p>
*
* @return the width
*/
public int getWidth() {
return m_width;
}
/**
* Returns a new image scaler that is a width based down scale from the size of <code>this</code> scaler
* to the given scaler size.<p>
*
* If no down scale from this to the given scaler is required because the width of <code>this</code>
* scaler is not larger than the target width, then the image dimensions of <code>this</code> scaler
* are unchanged in the result scaler. No up scaling is done!<p>
*
* @param downScaler the image scaler that holds the down scaled target image dimensions
*
* @return a new image scaler that is a down scale from the size of <code>this</code> scaler
* to the given target scaler size
*/
public CmsImageScaler getWidthScaler(CmsImageScaler downScaler) {
int width = downScaler.getWidth();
int height;
if (getWidth() > width) {
// width is too large, re-calculate height
float scale = (float)width / (float)getWidth();
height = Math.round(getHeight() * scale);
} else {
// width is ok
width = getWidth();
height = getHeight();
}
// now create and initialize the result scaler
return new CmsImageScaler(downScaler, width, height);
}
/**
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return toString().hashCode();
}
/**
* Returns <code>true</code> if all required parameters for image cropping are available.<p>
*
* Required parameters are <code>"cx","cy"</code> (x, y start coordinate),
* and <code>"ch","cw"</code> (crop height and width).<p>
*
* @return <code>true</code> if all required cropping parameters are available
*/
public boolean isCropping() {
return (m_cropX >= 0) && (m_cropY >= 0) && (m_cropHeight > 0) && (m_cropWidth > 0);
}
/**
* Returns <code>true</code> if this image scaler must be down scaled when compared to the
* given "down scale" image scaler.<p>
*
* If either <code>this</code> scaler or the given <code>downScaler</code> is invalid according to
* {@link #isValid()}, then <code>false</code> is returned.<p>
*
* The use case: <code>this</code> scaler represents an image (that is contains width and height of
* an image). The <code>downScaler</code> represents the maximum wanted image. The scalers
* are compared and if the image represented by <code>this</code> scaler is too large,
* <code>true</code> is returned. Image orientation is ignored, so for example an image with 600x800 pixel
* will NOT be down scaled if the target size is 800x600 but kept unchanged.<p>
*
* @param downScaler the down scaler to compare this image scaler with
*
* @return <code>true</code> if this image scaler must be down scaled when compared to the
* given "down scale" image scaler
*/
public boolean isDownScaleRequired(CmsImageScaler downScaler) {
if ((downScaler == null) || !isValid() || !downScaler.isValid()) {
// one of the scalers is invalid
return false;
}
if (getPixelCount() < (downScaler.getPixelCount() / 2)) {
// the image has much less pixels then the target, so don't downscale
return false;
}
int downWidth = downScaler.getWidth();
int downHeight = downScaler.getHeight();
if (downHeight > downWidth) {
// normalize image orientation - the width should always be the large side
downWidth = downHeight;
downHeight = downScaler.getWidth();
}
int height = getHeight();
int width = getWidth();
if (height > width) {
// normalize image orientation - the width should always be the large side
width = height;
height = getWidth();
}
return (width > downWidth) || (height > downHeight);
}
/**
* Returns <code>true</code> if all required parameters are available.<p>
*
* Required parameters are <code>"h"</code> (height), and <code>"w"</code> (width).<p>
*
* @return <code>true</code> if all required parameters are available
*/
public boolean isValid() {
return (m_width > 0) && (m_height > 0);
}
/**
* Parses the given parameters and sets the internal scaler variables accordingly.<p>
*
* The parameter String must have a format like <code>"h:100,w:200,t:1"</code>,
* that is a comma separated list of attributes followed by a colon ":", followed by a value.
* As possible attributes, use the constants from this class that start with <code>SCALE_PARAM</Code>
* for example {@link #SCALE_PARAM_HEIGHT} or {@link #SCALE_PARAM_WIDTH}.<p>
*
* @param parameters the parameters to parse
*/
public void parseParameters(String parameters) {
m_width = -1;
m_height = -1;
m_position = 0;
m_type = 0;
m_color = Color.WHITE;
m_cropX = -1;
m_cropY = -1;
m_cropWidth = -1;
m_cropHeight = -1;
List<String> tokens = CmsStringUtil.splitAsList(parameters, ',');
Iterator<String> it = tokens.iterator();
String k;
String v;
while (it.hasNext()) {
String t = it.next();
// extract key and value
k = null;
v = null;
int idx = t.indexOf(':');
if (idx >= 0) {
k = t.substring(0, idx).trim();
if (t.length() > idx) {
v = t.substring(idx + 1).trim();
}
}
if (CmsStringUtil.isNotEmpty(k) && CmsStringUtil.isNotEmpty(v)) {
// key and value are available
if (SCALE_PARAM_HEIGHT.equals(k)) {
// image height
m_height = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_WIDTH.equals(k)) {
// image width
m_width = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_CROP_X.equals(k)) {
// crop x coordinate
m_cropX = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_CROP_Y.equals(k)) {
// crop y coordinate
m_cropY = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_CROP_WIDTH.equals(k)) {
// crop width
m_cropWidth = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_CROP_HEIGHT.equals(k)) {
// crop height
m_cropHeight = CmsStringUtil.getIntValue(v, Integer.MIN_VALUE, k);
} else if (SCALE_PARAM_TYPE.equals(k)) {
// scaling type
setType(CmsStringUtil.getIntValue(v, -1, CmsImageScaler.SCALE_PARAM_TYPE));
} else if (SCALE_PARAM_COLOR.equals(k)) {
// image background color
setColor(v);
} else if (SCALE_PARAM_POS.equals(k)) {
// image position (depends on scale type)
setPosition(CmsStringUtil.getIntValue(v, -1, CmsImageScaler.SCALE_PARAM_POS));
} else if (SCALE_PARAM_QUALITY.equals(k)) {
// image position (depends on scale type)
setQuality(CmsStringUtil.getIntValue(v, 0, k));
} else if (SCALE_PARAM_RENDERMODE.equals(k)) {
// image position (depends on scale type)
setRenderMode(CmsStringUtil.getIntValue(v, 0, k));
} else if (SCALE_PARAM_FILTER.equals(k)) {
// image filters to apply
setFilters(v);
} else {
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.get().getBundle().key(Messages.ERR_INVALID_IMAGE_SCALE_PARAMS_2, k, v));
}
}
} else {
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.get().getBundle().key(Messages.ERR_INVALID_IMAGE_SCALE_PARAMS_2, k, v));
}
}
}
// initialize image crop area
initCropArea();
}
/**
* Returns a scaled version of the given image byte content according this image scalers parameters.<p>
*
* @param content the image byte content to scale
* @param rootPath the root path of the image file in the VFS
*
* @return a scaled version of the given image byte content according to the provided scaler parameters
*/
public byte[] scaleImage(byte[] content, String rootPath) {
byte[] result = content;
// flag for processed image
boolean imageProcessed = false;
// initialize image crop area
initCropArea();
RenderSettings renderSettings;
if ((m_renderMode == 0) && (m_quality == 0)) {
// use default render mode and quality
renderSettings = new RenderSettings(Simapi.RENDER_QUALITY);
} else {
// use special render mode and/or quality
renderSettings = new RenderSettings(m_renderMode);
if (m_quality != 0) {
renderSettings.setCompressionQuality(m_quality / 100f);
}
}
// set max blur size
renderSettings.setMaximumBlurSize(m_maxBlurSize);
// new create the scaler
Simapi scaler = new Simapi(renderSettings);
// calculate a valid image type supported by the imaging library (e.g. "JPEG", "GIF")
String imageType = Simapi.getImageType(rootPath);
if (imageType == null) {
// no type given, maybe the name got mixed up
String mimeType = OpenCms.getResourceManager().getMimeType(rootPath, null, null);
// check if this is another known MIME type, if so DONT use it (images should not be named *.pdf)
if (mimeType == null) {
// no MIME type found, use JPEG format to write images to the cache
imageType = Simapi.TYPE_JPEG;
}
}
if (imageType == null) {
// unknown type, unable to scale the image
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.get().getBundle().key(Messages.ERR_UNABLE_TO_SCALE_IMAGE_2, rootPath, toString()));
}
return result;
}
try {
BufferedImage image = Simapi.read(content);
if (isCropping()) {
// check if the crop width / height are not larger then the source image
if ((m_cropHeight > image.getHeight()) || (m_cropWidth > image.getWidth())) {
// crop height / width is outside of image - return image unchanged
return result;
}
}
Color color = getColor();
if (!m_filters.isEmpty()) {
Iterator<String> i = m_filters.iterator();
while (i.hasNext()) {
String filter = i.next();
if (FILTER_GRAYSCALE.equals(filter)) {
// add a gray scale filter
GrayscaleFilter grayscaleFilter = new GrayscaleFilter();
renderSettings.addImageFilter(grayscaleFilter);
} else if (FILTER_SHADOW.equals(filter)) {
// add a drop shadow filter
ShadowFilter shadowFilter = new ShadowFilter();
shadowFilter.setXOffset(5);
shadowFilter.setYOffset(5);
shadowFilter.setOpacity(192);
shadowFilter.setBackgroundColor(color.getRGB());
color = Simapi.COLOR_TRANSPARENT;
renderSettings.setTransparentReplaceColor(Simapi.COLOR_TRANSPARENT);
renderSettings.addImageFilter(shadowFilter);
}
}
}
if (isCropping()) {
// image crop operation
image = scaler.cropToSize(
image,
m_cropX,
m_cropY,
m_cropWidth,
m_cropHeight,
getWidth(),
getHeight(),
color);
imageProcessed = true;
} else {
// only rescale the image, if the width and hight are different to the target size
int imageWidth = image.getWidth();
int imageHeight = image.getHeight();
// image rescale operation
switch (getType()) {
// select the "right" method of scaling according to the "t" parameter
case 1:
// thumbnail generation mode (like 0 but no image enlargement)
image = scaler.resize(image, getWidth(), getHeight(), color, getPosition(), false);
imageProcessed = true;
break;
case 2:
// scale to exact target size, crop what does not fit
if (((imageWidth != getWidth()) || (imageHeight != getHeight()))) {
image = scaler.resize(image, getWidth(), getHeight(), getPosition());
imageProcessed = true;
}
break;
case 3:
// scale and keep image proportions, target size variable
if (((imageWidth != getWidth()) || (imageHeight != getHeight()))) {
image = scaler.resize(image, getWidth(), getHeight(), true);
imageProcessed = true;
}
break;
case 4:
// don't keep image proportions, use exact target size
if (((imageWidth != getWidth()) || (imageHeight != getHeight()))) {
image = scaler.resize(image, getWidth(), getHeight(), false);
imageProcessed = true;
}
break;
case 5:
// scale and keep image proportions, target size variable, include maxWidth / maxHeight option
// image proportions have already been calculated so should not be a problem, use
// 'false' to make sure image size exactly matches height and width attributes of generated tag
if (((imageWidth != getWidth()) || (imageHeight != getHeight()))) {
image = scaler.resize(image, getWidth(), getHeight(), false);
imageProcessed = true;
}
break;
default:
// scale to exact target size with background padding
image = scaler.resize(image, getWidth(), getHeight(), color, getPosition(), true);
imageProcessed = true;
}
}
if (!m_filters.isEmpty()) {
Rectangle targetSize = scaler.applyFilterDimensions(getWidth(), getHeight());
image = scaler.resize(
image,
(int)targetSize.getWidth(),
(int)targetSize.getHeight(),
Simapi.COLOR_TRANSPARENT,
Simapi.POS_CENTER);
image = scaler.applyFilters(image);
imageProcessed = true;
}
// get the byte result for the scaled image if some changes have been made.
// otherwiese use the original image
if (imageProcessed) {
result = scaler.getBytes(image, imageType);
}
} catch (Exception e) {
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.get().getBundle().key(Messages.ERR_UNABLE_TO_SCALE_IMAGE_2, rootPath, toString()), e);
}
}
return result;
}
/**
* Returns a scaled version of the given image file according this image scalers parameters.<p>
*
* @param file the image file to scale
*
* @return a scaled version of the given image file according to the provided scaler parameters
*/
public byte[] scaleImage(CmsFile file) {
return scaleImage(file.getContents(), file.getRootPath());
}
/**
* Sets the color.<p>
*
* @param color the color to set
*/
public void setColor(Color color) {
m_color = color;
}
/**
* Sets the color as a String.<p>
*
* @param value the color to set
*/
public void setColor(String value) {
if (COLOR_TRANSPARENT.indexOf(value) == 0) {
setColor(Simapi.COLOR_TRANSPARENT);
} else {
setColor(CmsStringUtil.getColorValue(value, Color.WHITE, SCALE_PARAM_COLOR));
}
}
/**
* Sets the image crop area.<p>
*
* @param x the x coordinate for the crop
* @param y the y coordinate for the crop
* @param width the crop width
* @param height the crop height
*/
public void setCropArea(int x, int y, int width, int height) {
m_cropX = x;
m_cropY = y;
m_cropWidth = width;
m_cropHeight = height;
}
/**
* Sets the list of filters as a String.<p>
*
* @param value the list of filters to set
*/
public void setFilters(String value) {
m_filters = new ArrayList<String>();
List<String> filters = CmsStringUtil.splitAsList(value, ':');
Iterator<String> i = filters.iterator();
while (i.hasNext()) {
String filter = i.next();
filter = filter.trim().toLowerCase();
Iterator<String> j = FILTERS.iterator();
while (j.hasNext()) {
String candidate = j.next();
if (candidate.startsWith(filter)) {
// found a matching filter
addFilter(candidate);
break;
}
}
}
}
/**
* Sets the height.<p>
*
* @param height the height to set
*/
public void setHeight(int height) {
m_height = height;
}
/**
* Sets the maximum image size (width * height) to apply image blurring when downscaling images.<p>
*
* @param maxBlurSize the maximum image blur size to set
*
* @see #getMaxBlurSize() for a more detailed description about this parameter
*/
public void setMaxBlurSize(int maxBlurSize) {
m_maxBlurSize = maxBlurSize;
}
/**
* Sets the maximum target height (for scale type '5').<p>
*
* @param maxHeight the maximum target height to set
*/
public void setMaxHeight(int maxHeight) {
m_maxHeight = maxHeight;
}
/**
* Sets the maximum target width (for scale type '5').<p>
*
* @param maxWidth the maximum target width to set
*/
public void setMaxWidth(int maxWidth) {
m_maxWidth = maxWidth;
}
/**
* Sets the scale position.<p>
*
* @param position the position to set
*/
public void setPosition(int position) {
switch (position) {
case Simapi.POS_DOWN_LEFT:
case Simapi.POS_DOWN_RIGHT:
case Simapi.POS_STRAIGHT_DOWN:
case Simapi.POS_STRAIGHT_LEFT:
case Simapi.POS_STRAIGHT_RIGHT:
case Simapi.POS_STRAIGHT_UP:
case Simapi.POS_UP_LEFT:
case Simapi.POS_UP_RIGHT:
// position is fine
m_position = position;
break;
default:
m_position = Simapi.POS_CENTER;
}
}
/**
* Sets the image saving quality in percent.<p>
*
* @param quality the image saving quality (in percent) to set
*/
public void setQuality(int quality) {
if (quality < 0) {
m_quality = 0;
} else if (quality > 100) {
m_quality = 100;
} else {
m_quality = quality;
}
}
/**
* Sets the image rendering mode constant.<p>
*
* @param renderMode the image rendering mode to set
*
* @see #getRenderMode() for a list of allowed values for the rendering mode
*/
public void setRenderMode(int renderMode) {
if ((renderMode < Simapi.RENDER_QUALITY) || (renderMode > Simapi.RENDER_SPEED)) {
renderMode = Simapi.RENDER_QUALITY;
}
m_renderMode = renderMode;
}
/**
* Sets the scale type.<p>
*
* @param type the scale type to set
*
* @see #getType() for a detailed description of the possible values for the type
*/
public void setType(int type) {
if ((type < 0) || (type > 5)) {
// invalid type, use 0
m_type = 0;
} else {
m_type = type;
}
}
/**
* Sets the width.<p>
*
* @param width the width to set
*/
public void setWidth(int width) {
m_width = width;
}
/**
* Creates a request parameter configured with the values from this image scaler, also
* appends a <code>'?'</code> char as a prefix so that this may be directly appended to an image URL.<p>
*
* This can be appended to an image request in order to apply image scaling parameters.<p>
*
* @return a request parameter configured with the values from this image scaler
*/
public String toRequestParam() {
StringBuffer result = new StringBuffer(128);
result.append('?');
result.append(PARAM_SCALE);
result.append('=');
result.append(toString());
return result.toString();
}
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
if (m_scaleParameters != null) {
return m_scaleParameters;
}
StringBuffer result = new StringBuffer(64);
if (isCropping()) {
result.append(CmsImageScaler.SCALE_PARAM_CROP_X);
result.append(':');
result.append(m_cropX);
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_CROP_Y);
result.append(':');
result.append(m_cropY);
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_CROP_WIDTH);
result.append(':');
result.append(m_cropWidth);
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_CROP_HEIGHT);
result.append(':');
result.append(m_cropHeight);
}
if (!isCropping() || ((m_width != m_cropWidth) || (m_height != m_cropHeight))) {
if (isCropping()) {
result.append(',');
}
result.append(CmsImageScaler.SCALE_PARAM_WIDTH);
result.append(':');
result.append(m_width);
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_HEIGHT);
result.append(':');
result.append(m_height);
}
if (m_type > 0) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_TYPE);
result.append(':');
result.append(m_type);
}
if (m_position > 0) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_POS);
result.append(':');
result.append(m_position);
}
if (m_color != Color.WHITE) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_COLOR);
result.append(':');
result.append(getColorString());
}
if (m_quality > 0) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_QUALITY);
result.append(':');
result.append(m_quality);
}
if (m_renderMode > 0) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_RENDERMODE);
result.append(':');
result.append(m_renderMode);
}
if (!m_filters.isEmpty()) {
result.append(',');
result.append(CmsImageScaler.SCALE_PARAM_FILTER);
result.append(':');
result.append(getFiltersString());
}
m_scaleParameters = result.toString();
return m_scaleParameters;
}
/**
* Calculate the closest match of the given base float with the list of others.<p>
*
* @param base the base float to compare the other with
* @param others the list of floats to compate to the base
*
* @return the array index of the closest match
*/
private int calculateClosest(float base, float[] others) {
int result = -1;
float bestMatch = Float.MAX_VALUE;
for (int count = 0; count < others.length; count++) {
float difference = Math.abs(base - others[count]);
if (difference < bestMatch) {
// new best match found
bestMatch = difference;
result = count;
}
if (bestMatch == 0f) {
// it does not get better then this
break;
}
}
return result;
}
/**
* Calculate the width and height of a source image if scaled inside the given box.<p>
*
* @param sourceWidth the width of the source image
* @param sourceHeight the height of the source image
* @param boxWidth the width of the target box
* @param boxHeight the height of the target box
*
* @return the width [0] and height [1] of the source image if scaled inside the given box
*/
private int[] calculateDimension(int sourceWidth, int sourceHeight, int boxWidth, int boxHeight) {
int result[] = new int[2];
if ((sourceWidth <= boxWidth) && (sourceHeight <= boxHeight)) {
result[0] = sourceWidth;
result[1] = sourceHeight;
} else {
float scaleWidth = (float)boxWidth / (float)sourceWidth;
float scaleHeight = (float)boxHeight / (float)sourceHeight;
float scale = Math.min(scaleHeight, scaleWidth);
result[0] = Math.round(sourceWidth * scale);
result[1] = Math.round(sourceHeight * scale);
}
return result;
}
/**
* Initializes the members with the default values.<p>
*/
private void init() {
m_height = -1;
m_width = -1;
m_maxHeight = -1;
m_maxWidth = -1;
m_type = 0;
m_position = 0;
m_renderMode = 0;
m_quality = 0;
m_cropX = -1;
m_cropY = -1;
m_cropHeight = -1;
m_cropWidth = -1;
m_color = Color.WHITE;
m_filters = new ArrayList<String>();
m_maxBlurSize = CmsImageLoader.getMaxBlurSize();
}
/**
* Initializes the crop area setting.<p>
*
* Only if all 4 required parameters have been set, the crop area is set accordingly.
* Moreover, it is not required to specify the target image width and height when using crop,
* because these parameters can be calculated from the crop area.<p>
*/
private void initCropArea() {
if (isCropping()) {
// crop area is set up correctly
// adjust target image height or width if required
if (m_width < 0) {
m_width = m_cropWidth;
}
if (m_height < 0) {
m_height = m_cropHeight;
}
// set type to 0 - scale type is ignored when using crop
setType(0);
}
}
/**
* Copies all values from the given scaler into this scaler.<p>
*
* @param source the source scaler
*/
private void initValuesFrom(CmsImageScaler source) {
m_width = source.m_width;
m_height = source.m_height;
m_type = source.m_type;
m_position = source.m_position;
m_renderMode = source.m_renderMode;
m_quality = source.m_quality;
m_color = source.m_color;
m_filters = new ArrayList<String>(source.m_filters);
m_maxBlurSize = source.m_maxBlurSize;
m_cropHeight = source.m_cropHeight;
m_cropWidth = source.m_cropWidth;
m_cropX = source.m_cropX;
m_cropY = source.m_cropY;
}
}