import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public void uploadThumbnail(String path, ByteArrayOutputStream buffer, int width, int height) throws IOException {
    ByteArrayOutputStream thumbBuffer = new ByteArrayOutputStream();
    BufferedImage thumb = ImageIO.read(new ByteArrayInputStream(buffer.toByteArray()));
    thumb = Scalr.resize(thumb, Method.ULTRA_QUALITY,
            thumb.getHeight() < thumb.getWidth() ? Mode.FIT_TO_HEIGHT : Mode.FIT_TO_WIDTH,
            Math.max(width, height), Math.max(width, height), Scalr.OP_ANTIALIAS);
    thumb = Scalr.crop(thumb, width, height);

    ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
    ImageWriteParam param = writer.getDefaultWriteParam();
    param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); // Needed see javadoc
    param.setCompressionQuality(1.0F); // Highest quality
    writer.setOutput(ImageIO.createImageOutputStream(thumbBuffer));
    writer.write(thumb);
    
    if (path.lastIndexOf('.') != -1) {
        path = path.substring(0, path.lastIndexOf('.'));
    }
    
    super.put(path + "." + width + "x" + height + ".jpg", new ByteArrayInputStream(thumbBuffer.toByteArray()),
            Long.valueOf(thumbBuffer.size()));
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
private BufferedImage getBestFit (BufferedImage bi, int maxWidth, int maxHeight)
  {
if (bi == null)
	return null ;

  	Mode mode = Mode.AUTOMATIC ;
  	int maxSize = Math.min(maxWidth, maxHeight) ;
  	double dh = (double)bi.getHeight() ;
  	if (dh > Double.MIN_VALUE)
  	{
  		double imageAspectRatio = (double)bi.getWidth() / dh ;
      	if (maxHeight * imageAspectRatio <=  maxWidth)
      	{
      		maxSize = maxHeight ;
      		mode = Mode.FIT_TO_HEIGHT ;
      	}
      	else
      	{
      		maxSize = maxWidth ;
      		mode = Mode.FIT_TO_WIDTH ;
      	}	
  	}
  	return Scalr.resize(bi, Method.QUALITY, mode, maxSize, Scalr.OP_ANTIALIAS) ; 
  }
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public byte[] getThumbnail(InputStream inputStream, String contentType, String rotation) throws IOException {
	try{
		String ext = contentType.replace("image/", "").equals("jpeg")? "jpg":contentType.replace("image/", "");

		BufferedImage bufferedImage = readImage(inputStream);	
		BufferedImage thumbImg = Scalr.resize(bufferedImage, Method.QUALITY,Mode.AUTOMATIC, 
				100,
				100, Scalr.OP_ANTIALIAS);
		//convert bufferedImage to outpurstream 
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ImageIO.write(thumbImg,ext,baos);
		baos.flush();

		return baos.toByteArray();
	}catch(Exception e){
		e.printStackTrace();
		return null;
	}
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * Scales the given image, preserving aspect ratio.
 */
public static BufferedImage scaleByWidth(BufferedImage inImage, int xSize)
{
	double aspectRatio = ((double) inImage.getHeight())
			/ inImage.getWidth();
	int ySize = (int) (xSize * aspectRatio);
	if (ySize == 0)
		ySize = 1;
	
	// This library is described at http://stackoverflow.com/questions/1087236/java-2d-image-resize-ignoring-bicubic-bilinear-interpolation-rendering-hints-os
	BufferedImage scaled = Scalr.resize(inImage, Method.QUALITY, xSize, ySize);

	if (inImage.getType() == BufferedImage.TYPE_BYTE_GRAY && scaled.getType() != BufferedImage.TYPE_BYTE_GRAY)
	{
		scaled = convertToGrayscale(scaled);
	}

	return scaled;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * Scales the given image, preserving aspect ratio.
 */
public static BufferedImage scaleByHeight(BufferedImage inImage, int ySize)
{
	double aspectRatioInverse = ((double) inImage.getWidth())
			/ inImage.getHeight();
	int xSize = (int) (aspectRatioInverse * ySize);
	if (xSize == 0)
		xSize = 1;
	
	// This library is described at http://stackoverflow.com/questions/1087236/java-2d-image-resize-ignoring-bicubic-bilinear-interpolation-rendering-hints-os
	BufferedImage scaled = Scalr.resize(inImage, Method.QUALITY, xSize, ySize);
	
	if (inImage.getType() == BufferedImage.TYPE_BYTE_GRAY && scaled.getType() != BufferedImage.TYPE_BYTE_GRAY)
	{
		scaled = convertToGrayscale(scaled);
	}
	
	return scaled;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public static BufferedImage getStyledImage(File img, float brightness, float transparency, int size) {
    BufferedImage outputImage = null;
    try {
        BufferedImage readBufferedImage = ImageIO.read(img);
        BufferedImage inputBufferedImage = convertToArgb(readBufferedImage);
        outputImage = inputBufferedImage;
        if (size > 0) {
            outputImage = Scalr.resize(inputBufferedImage
                    , Method.BALANCED
                    , size
                    , size);
        }

        float brightnessFactor = 1.0f + brightness/100.0f;
        float transparencyFactor = Math.abs(transparency/100.0f - 1.0f);
        RescaleOp rescale = new RescaleOp(
                new float[]{brightnessFactor, brightnessFactor, brightnessFactor, transparencyFactor},
                new float[]{0f, 0f, 0f, 0f}, null);
        rescale.filter(outputImage, outputImage);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return outputImage;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
private BufferedImage getStyledImage(float brightness, float transparency, int size) {
    BufferedImage outputImage = null;
    try {
        BufferedImage readBufferedImage = ImageIO.read(new File(imageFilePath));
        BufferedImage inputBufferedImage = convertToArgb(readBufferedImage);
        outputImage = inputBufferedImage;
        if (size > 0) {
            outputImage = Scalr.resize(inputBufferedImage
                    , Method.BALANCED
                    , size
                    , size);
        }

        float brightnessFactor = 1.0f + brightness/100.0f;
        float transparencyFactor = Math.abs(transparency/100.0f - 1.0f);
        RescaleOp rescale = new RescaleOp(
                new float[]{brightnessFactor, brightnessFactor, brightnessFactor, transparencyFactor},
                new float[]{0f, 0f, 0f, 0f}, null);
        rescale.filter(outputImage, outputImage);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return outputImage;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * Save screenshot thumb.
 * 
 * @param screenShotFile
 *            the screen shot file
 * @return the string
 */
private String saveScreenshotThumb(final String screenShotFile) {
    final int thumbWidth = 150;
    final int thumbHeight = 100;
    String screenShotThumb =
            "images" + File.separator + screenShotFile + "_Thumb.png";
    try {
        String screenShotOriginalFile =
                builder.getReportFolderLocation() + File.separator
                        + "images" + File.separator + screenShotFile;
        BufferedImage img = ImageIO.read(new File(screenShotOriginalFile));
        BufferedImage thumb =
                Scalr.resize(img, Method.SPEED, thumbWidth, thumbHeight,
                        Scalr.OP_ANTIALIAS, Scalr.OP_BRIGHTER);

        ImageIO.write(thumb, "png", new File(screenShotOriginalFile
                + "_Thumb.png"));

    } catch (IOException e) {
        e.printStackTrace();
    }
    return screenShotThumb;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * Checks the validity of the options values.
 * @return true if all options have valid values, false otherwise
 */
private boolean checkOptions() {
	String dName = m_nameText.getText();
	if ("".equals(dName)) {
		showError("The default picture start name cannot be empty !");
		return false;
	}
	Method gMethod = m_methodList.getSelectedValue();
	if (gMethod == null) {
		showError("You must select a scaling method to generate the thumbnails !");
		return false;		
	}
	int tSize = (Integer) m_sizeText.getValue();
	if ((tSize < m_minThumbnailSize) || (tSize > m_maxThumbnailSize)) {
		showError("The thumbnail size must be between "+m_minThumbnailSize+ " and "+m_maxThumbnailSize+ " !");
		return false;
	}
	return true;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
@Override
public Component getListCellRendererComponent(JList<? extends Thumb> list, Thumb value, int index, boolean isSelected, boolean cellHasFocus) {
	Thumb entry = (Thumb) value;
	ImageIcon currentIcon = entry.getPreviewImageIconThumbImage();
	//no preview image so let's just try to resize it
	if (currentIcon == null) {
		currentIcon = entry.getImageIconThumbImage();
		//Image scaledImg = currentIcon.getImage().getScaledInstance(250, 250, java.awt.Image.SCALE_SMOOTH);
		BufferedImage img = (BufferedImage) currentIcon.getImage();
		BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, 250, 250, Scalr.OP_ANTIALIAS);
		currentIcon = new ImageIcon(scaledImage);
	}
	setIcon(currentIcon);
	if (isSelected) {
		setBackground(HIGHLIGHT_COLOR);
		setForeground(Color.white);
	} else {
		setBackground(Color.white);
		setForeground(Color.black);
	}
	return this;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
@Override
public void imageLoaded(BufferedImage img) {
	//clean up old references, just to be safe
	this.resizedImage = null;
	this.img = null;

	this.img = img;
	if (img != null) {
		isPosterCandidate = (img.getHeight() >= img.getWidth());
		Dimension newImageSize = calculateDimensionFit(img.getWidth(), img.getHeight(), getSize().width, getSize().height);
		this.resizedImage = Scalr.resize(img, Method.QUALITY, Scalr.Mode.AUTOMATIC, newImageSize.width, newImageSize.height, Scalr.OP_ANTIALIAS);

	}
	doneLoading = true;
	repaint();
	handleAutoSelection();
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
private static ImageIcon initializeResourceIcon(String resourceName) {
	try {
		URL url = GUIMain.class.getResource(resourceName);
		if (url != null) {
			BufferedImage iconBufferedImage = ImageIO.read(url);
			if (iconBufferedImage != null) {
				iconBufferedImage = Scalr.resize(iconBufferedImage, Method.QUALITY, iconSizeX, iconSizeY, Scalr.OP_ANTIALIAS);
				return new ImageIcon(iconBufferedImage);
			} else
				return new ImageIcon();
		}
		return new ImageIcon();
	} catch (IOException e1) {
		e1.printStackTrace();
		return null;
	}
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
private ImageIcon initializeResourceIcon(String resourceName, int iconSizeX, int iconSizeY) {
	try {
		URL url = GUIMain.class.getResource(resourceName);
		if (url != null) {
			BufferedImage iconBufferedImage = ImageIO.read(url);
			if (iconBufferedImage != null) {
				iconBufferedImage = Scalr.resize(iconBufferedImage, Method.QUALITY, iconSizeX, iconSizeY, Scalr.OP_ANTIALIAS);
				return new ImageIcon(iconBufferedImage);
			} else
				return new ImageIcon();
		}
		return new ImageIcon();
	} catch (IOException e1) {
		e1.printStackTrace();
		return null;
	}
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * @param buffImage
 * @param scaleWidth
 * @param scaleHeight
 * @return
 */
public static BufferedImage scaleImage(BufferedImage buffImage, int scaleWidth, int scaleHeight) {
    int imgHeight = buffImage.getHeight();
    int imgWidth = buffImage.getWidth();

    float destHeight = scaleHeight;
    float destWidth = scaleWidth;

    if ((imgWidth >= imgHeight) && (imgWidth > scaleWidth)) {
        destHeight = imgHeight * ((float) scaleWidth / imgWidth);
    } else if ((imgWidth < imgHeight) && (imgHeight > scaleHeight)) {
        destWidth = imgWidth * ((float) scaleHeight / imgHeight);
    } else {
        return buffImage;
    }

    return Scalr.resize(buffImage, Method.BALANCED, Mode.AUTOMATIC, (int) destWidth, (int) destHeight);
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public static BufferedImage generateImageThumbnail(InputStream imageStream) throws IOException {
    try {
        int idealWidth = 256;
        BufferedImage source = ImageIO.read(imageStream);
        if (source == null) {
            return null;
        }
        int imgHeight = source.getHeight();
        int imgWidth = source.getWidth();

        float scale = (float) imgWidth / idealWidth;
        int height = (int) (imgHeight / scale);

        BufferedImage rescaledImage = Scalr.resize(source, Method.QUALITY,
                Mode.AUTOMATIC, idealWidth, height);
        if (height > 400) {
            rescaledImage = rescaledImage.getSubimage(0, 0,
                    Math.min(256, rescaledImage.getWidth()), 400);
        }
        return rescaledImage;
    } catch (Exception e) {
        LOG.error("Generate thumbnail for error", e);
        return null;
    }
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
private static byte[] processImage(BufferedImage image, int xRatio, int yRatio, int width, int height, PictureMode pictureMode) {
    final BufferedImage transformed, scaled;
    switch (pictureMode) {
    case FIT:
        transformed = Picture.transformFit(image, xRatio, yRatio);
        break;
    case ZOOM:
        transformed = Picture.transformZoom(image, xRatio, yRatio);
        break;
    default:
        transformed = Picture.transformFit(image, xRatio, yRatio);
        break;
    }
    scaled = Scalr.resize(transformed, Method.QUALITY, Mode.FIT_EXACT, width, height);
    return Picture.writeImage(scaled, ContentType.PNG);
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
/**
 * resize image
 * @param image image to resize
 * @param size result image size
 * @return result image
 */
protected BufferedImage resize(BufferedImage image, int size) {
	if (size == image.getWidth() && 
		size == image.getHeight()) {
		log.info("Resize Image, Image's Width And Height Equals [{}], Ignore.", size);
		return image;
	}
	log.info("Resize Image To Size [{}]x[{}].", size, size);
	return Scalr.resize(image, Method.QUALITY, size, size);
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public static File resize(File file, int width, int height) {
	File resized = null;
	BufferedImage source = readFile(file);
	BufferedImage scaledImg = Scalr.resize(source, Method.QUALITY, height, width, Scalr.OP_ANTIALIAS);
	resized = writeAsJpeg(scaledImg, 100);
	return resized;
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
public static void createThumbnail(File sourceImage, int width, int height, String extension) throws IOException {
	  BufferedImage img = ImageIO.read(sourceImage); // load image
	  BufferedImage thumbImg = Scalr.resize(img, Method.ULTRA_QUALITY,Mode.AUTOMATIC, 
			  width, height, Scalr.OP_ANTIALIAS);
	  
	   //convert bufferedImage to outpurstream 
	  ByteArrayOutputStream os = new ByteArrayOutputStream();
	  ImageIO.write(thumbImg,extension.toLowerCase(),os);
	  ImageIO.write(thumbImg, extension.toLowerCase(), sourceImage);
}
 

import org.imgscalr.Scalr.Method; //导入依赖的package包/类
@Override
public Sequence call(XPathContext context, Sequence[] arguments) throws XPathException {
  String source = ((StringValue) arguments[0].head()).getStringValue();
  String target = ((StringValue) arguments[1].head()).getStringValue();      
  String formatName = ((StringValue) arguments[2].head()).getStringValue();
  int targetSize = (int) ((Int64Value) arguments[3].head()).longValue();
  try {                             
    File targetFile = new File(target);                
    if (targetFile.isDirectory()) {          
      throw new IOException("Output file \"" + targetFile.getAbsolutePath() + "\" already exists as directory");          
    } else if (!targetFile.getParentFile().isDirectory() && !targetFile.getParentFile().mkdirs()) {
      throw new IOException("Could not create output directory \"" + targetFile.getParentFile().getAbsolutePath() + "\"");
    } else if (targetFile.isFile() && !targetFile.delete()) {
      throw new IOException("Error deleting existing target file \"" + targetFile.getAbsolutePath() + "\"");
    }               
    InputStream is;
    if (source.startsWith("http")) {
      is = new URL(source).openStream();
    } else {
      File file;
      if (source.startsWith("file:")) {
        file = new File(new URI(source));
      } else {
        file = new File(source);
      }                    
      if (!file.isFile()) {
        throw new IOException("File \"" + file.getAbsolutePath() + "\" not found or not a file");
      } 
      is = new BufferedInputStream(new FileInputStream(file));
    } 
    try {                
      BufferedImage img = ImageIO.read(is);          
      BufferedImage scaledImg = Scalr.resize(img, Method.AUTOMATIC, Mode.AUTOMATIC, targetSize, targetSize);
      BufferedImage imageToSave = new BufferedImage(scaledImg.getWidth(), scaledImg.getHeight(), BufferedImage.TYPE_INT_RGB);
      Graphics g = imageToSave.getGraphics();
      g.drawImage(scaledImg, 0, 0, null);          
      ImageIO.write(imageToSave, formatName, targetFile);
    } finally {
      is.close();
    }
    return EmptySequence.getInstance();
  } catch (Exception e) {
    throw new XPathException("Error scaling image \"" + source + "\" to \"" + target + "\"", e);
  }
}