import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
private void writeResizedImage(CPRFile cprFile, String fileName,
                               int width, int height)
        throws IOException {
    File outputBMP = new File(imagesDirectory, fileName);
    if (outputBMP.exists()) {
        backUpFile(outputBMP);
    }
    logger.info("resizing {} to {}x{}", fileName, width, height);
    InputStream originalImageStream =
        cprFile.getInputStream("images\\" + fileName);
    BufferedImage original = ImageIO.read(originalImageStream);
    ResampleOp resampleOp = new ResampleOp(width, height);
    resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);
    BufferedImage resized = resampleOp.filter(original, null);
    ImageIO.write(resized, "bmp", outputBMP);
}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
private static BufferedImage resizeImageToDINA4WithDPI(BufferedImage origImage, int targetDpiX, int targetDpiY,
                                               int origDpiX, int origDpiY, float scaleDown) {

    float targetRatioX = (float)Consts.millisToPixels(Consts.A4_W_MM, targetDpiX)/origImage.getWidth();
    float targetRatioY = (float)Consts.millisToPixels(Consts.A4_H_MM, targetDpiY)/origImage.getHeight();
    float targetRatio = Math.min(1.0f, Math.min(targetRatioX, targetRatioY)/scaleDown);

    Logger.getLogger(ImageHelper.class.getName()).log(Level.INFO,
            "Resizing BufferedImage (px) --- "+
                    "Original dimensions: ("+Integer.toString(origImage.getWidth())+
                    ","+Integer.toString(origImage.getHeight())+")"+
                    " - Fraction: ("+Float.toString(targetRatioX)+","+Float.toString(targetRatioY)+")"+
                    " - Using ratio: "+Float.toString(targetRatio));

    ResampleOp resampleOp = new ResampleOp(DimensionConstrain.createRelativeDimension(targetRatio, targetRatio));
    resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);

    return resampleOp.filter(origImage, null);
}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
@Override
@SqlTransactional
public void storeCroppedProfilePictures(int x, int y, int size, String userId) {
    try {
        User user = getDao().getById(User.class, userId, true);
        String url = user.getProfilePictureURI();
        if (!url.startsWith("http")) {
            url = "http:" + url;
        }
        BufferedImage original = ImageIO.read(new URL(url));

        String format = FilenameUtils.getExtension(user.getProfilePictureURI());

        BufferedImage cropped = original.getSubimage(x, y, size, size);

        ResampleOp smallOp = new ResampleOp(48, 48);
        smallOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);
        BufferedImage small = smallOp.filter(cropped, null);

        ResampleOp largeOp = new ResampleOp(72, 72);
        largeOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);
        BufferedImage large = largeOp.filter(cropped, null);

        user.setSmallProfilePictureURI(pictureService.storedCroppedProfilePicture(small, "_small", user.getId(), format));
        user.setLargeProfilePictureURI(pictureService.storedCroppedProfilePicture(large, "_large", user.getId(), format));

        save(user);
    } catch (IOException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
public void testBug(){

		int srcWidth = 100;
		int srcHeight = 100;
		int dstWidth = 2;
		int dstHeight = 2;
		ResampleOp resampleOp = new ResampleOp(dstWidth, dstHeight);
		resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);
		BufferedImage rescaledImage = resampleOp.filter(new BufferedImage(srcWidth, srcHeight, BufferedImage.TYPE_INT_BGR), null);
	}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
public void testBug(){

		int srcWidth = 1920;
		int srcHeight = 1200;
		int dstWidth = (int) (srcWidth * 0.6);
		int dstHeight = (int) (srcHeight*0.6);
		ResampleOp resampleOp = new ResampleOp(dstWidth, dstHeight);
		resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Normal);
		BufferedImage rescaledImage = resampleOp.filter(new BufferedImage(srcWidth, srcHeight, BufferedImage.TYPE_INT_BGR), null);
		System.out.println("rescaledImage "+rescaledImage.getWidth()+"x"+rescaledImage.getHeight());
	}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
/**
 * Generate a new Picture object resized to a specific width, maintaining
 * the same aspect ratio of the original
 * @param width
 * @return Picture scaled to new width
 */
public Picture getResizedToWidth(int width) {
    if (width > getWidth())
        throw new IllegalArgumentException("Width "+ width +" exceeds width of image, which is "+ getWidth());
    int nHeight = width * img.getHeight() / img.getWidth();
    MultiStepRescaleOp rescale = new MultiStepRescaleOp(width, nHeight);
    rescale.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.Soft);
    BufferedImage resizedImage = rescale.filter(img, null);

    return new Picture(resizedImage, sourceType);
}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
public static BufferedImage createResizedCopy(BufferedImage originalImage, int scaledWidth, int scaledHeight) {
	ResampleOp  resampleOp = new ResampleOp (scaledWidth,scaledHeight);
	resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.VerySharp);
	BufferedImage rescaledTomato = resampleOp.filter(originalImage, null);
	return rescaledTomato;
}
 

import com.mortennobel.imagescaling.AdvancedResizeOp; //导入依赖的package包/类
private Object calculateResize(Object key) {
    FrontKey fk = (FrontKey) key;
    String message = "Unknown error";
    try {
        Element e = backCache.get(new BackKey(fk));
        byte[] res = null;
        if (e != null) {
            if (e.getObjectValue() instanceof String) {
                // Backend generated an error
                return e.getObjectValue();
            }
            byte[] img = (byte[]) e.getObjectValue();
            ByteArrayInputStream bais = new ByteArrayInputStream(img);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            switch (fk.resize_filter.toLowerCase()) {
                case "lanczos":
                    // Lanczos3 rescale algorithm from:
                    // Always non proportion preserving
                    // https://code.google.com/p/java-image-scaling/
                    BufferedImage src = ImageIO.read(bais);
                    ResampleOp resampleOp = new ResampleOp(fk.resize_x, fk.resize_y);
                    resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.None);
                    resampleOp.setNumberOfThreads(2);
                    createJPEG(fk.mod, baos, resampleOp.filter(src, null));
                    src.flush();
                    break;
                case "imgscalr" :
                    // imgscalr method (Always proportion preserving)
                    // http://www.thebuzzmedia.com/software/imgscalr-java-image-scaling-library/
                    // Lile slower than lanczos
                    BufferedImage src2 = ImageIO.read(bais);
                    createJPEG(fk.mod,baos,Scalr.resize(src2, Scalr.Method.QUALITY, fk.resize_x, fk.resize_y, Scalr.OP_ANTIALIAS));
                    src2.flush();
                    break;
                default:
                    // Thumbnailator library method
                    // https://code.google.com/p/thumbnailator/
                    Thumbnails.of(bais)
                            .forceSize(fk.resize_x, fk.resize_y)
                            .outputFormat("jpg").outputQuality((double) fk.mod / 100.0).toOutputStream(baos);
            }
            res = baos.toByteArray();
            return res;
        }
    } catch (IOException ex) {
        message = "Request: " + fk.source_url + " resize failed.";
        Logger.getLogger(FrontCacheUpdater.class.getName()).log(Level.WARNING, message, ex);
    } catch (IllegalStateException ex2) {
        message = "Unknown Error " + ex2.getLocalizedMessage();
        Logger.getLogger(FrontCacheUpdater.class.getName()).log(Level.WARNING, message, ex2);
    }
    return message;
}