Java Code Examples for java.awt.image.AffineTransformOp#TYPE_BILINEAR

@Documentation(
    value = "Resizes the Image by the given factor.",
    params = {
        @Param(name = "image", value = "The Image"),
        @Param(name = "factor", value = "The resize factor"),
    },
    result = "resize the image",
    examples = {
        @Example(expression = "myImage.resize(0.5)", result = "will resize the image by a factor 0.5"),
    }
)
// @formatter:on
public MImage resize(MImage image, Double factor) throws IOException {
    final BufferedImage bufferedImage = MImageAWTImpl.getBufferedImage(image);

    final BufferedImage resized = new BufferedImage((int) (bufferedImage.getWidth() * factor),
            (int) (bufferedImage.getHeight() * factor), bufferedImage.getType());

    final AffineTransform zoomTransfort = AffineTransform.getScaleInstance(factor, factor);
    final AffineTransformOp retaillerImage = new AffineTransformOp(zoomTransfort, AffineTransformOp.TYPE_BILINEAR);
    retaillerImage.filter(bufferedImage, resized);

    return new MImageAWTImpl(resized, image.getURI());
}
 

public void resizeImage(){
    BufferedImage before = SwingFXUtils.fromFXImage(gemIcon, null);
    int w = before.getWidth();
    int h = before.getHeight();
    // Create a new image of the proper size
    int w2 = (int) (w * 0.7);
    int h2 = (int) (h * 0.7);
    BufferedImage after = new BufferedImage(w2, h2, BufferedImage.TYPE_INT_ARGB);
    AffineTransform scaleInstance = AffineTransform.getScaleInstance(0.7, 0.7);
    AffineTransformOp scaleOp
        = new AffineTransformOp(scaleInstance, AffineTransformOp.TYPE_BILINEAR);

    after = scaleOp.filter(before, after);
    smallGemIcon = SwingFXUtils.toFXImage(after, null);
    //ImageIcon imageIcon = new ImageIcon(dimg);
}
 

static BufferedImage scaleDown( BufferedImage before ) {
    double xFactor = Math.min(1.0, MINIMAL_THUMBNAIL_SIZE / (double) before.getWidth());
    double yFactor = Math.min(1.0, MINIMAL_THUMBNAIL_SIZE / (double) before.getHeight());

    double factor = Math.max(xFactor, yFactor);

    int width = (int) Math.round(before.getWidth() * factor);
    int height = (int) Math.round(before.getHeight() * factor);
    BufferedImage after = new BufferedImage( width, height, BufferedImage.TYPE_INT_ARGB );

    AffineTransform at = new AffineTransform();
    at.scale( factor, factor );
    AffineTransformOp scaleOp = new AffineTransformOp( at, AffineTransformOp.TYPE_BILINEAR );

    return scaleOp.filter( before, after );
}
 

/**
 * Some quick and dirty image scaling - please note that for best performance
 * and quality you should use image rescaling libraries.
 */
@Override
public BufferedImage resample(BufferedImage bufferedImage, int width, int height) {

    Dimension imageDimension = new Dimension(bufferedImage.getWidth(), bufferedImage.getHeight());
    Dimension boundaryDimension = new Dimension(width, height);
    Dimension scaledDimension = BufferedImageUtils.getScaledDimension(imageDimension, boundaryDimension);

    double scaleX = scaledDimension.getWidth() / bufferedImage.getWidth();
    double scaleY = scaledDimension.getHeight() / bufferedImage.getHeight();

    AffineTransform scaleTransform = AffineTransform.getScaleInstance(scaleX, scaleY);
    AffineTransformOp biLinearScaleOp = new AffineTransformOp(scaleTransform, AffineTransformOp.TYPE_BILINEAR);

    return biLinearScaleOp.filter(
            bufferedImage,
            new BufferedImage(scaledDimension.width, scaledDimension.height, bufferedImage.getType()));
}
 

/**
 * Scale image buffered image.
 *
 * @param sourceImage the source image
 * @param newWidth    the new width
 * @param newHeight   the new height
 * @return the buffered image
 */
@Contract("null, _, _ -> null")
public static BufferedImage scaleImage(BufferedImage sourceImage, int newWidth, int newHeight) {
    if (sourceImage == null) {
        return null;
    }

    if (newWidth == 0 || newHeight == 0) {
        return null;
    }

    AffineTransform at = AffineTransform.getScaleInstance((double) newWidth / sourceImage.getWidth(null),
                                                          (double) newHeight / sourceImage.getHeight(null));

    //  http://nickyguides.digital-digest.com/bilinear-vs-bicubic.htm
    AffineTransformOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
    return op.filter(sourceImage, null);
}
 

/**
 * Some quick and dirty image scaling - please note that for best performance
 * and quality you should use image rescaling libraries.
 */
@Override
public BufferedImage resample(BufferedImage bufferedImage, int width, int height) {
    Dimension imageDimension = new Dimension(bufferedImage.getWidth(), bufferedImage.getHeight());
    Dimension boundaryDimension = new Dimension(width, height);
    Dimension scaledDimension = BufferedImageUtils.getScaledDimension(imageDimension, boundaryDimension);

    double scaleX = scaledDimension.getWidth() / bufferedImage.getWidth();
    double scaleY = scaledDimension.getHeight() / bufferedImage.getHeight();

    AffineTransform scaleTransform = AffineTransform.getScaleInstance(scaleX, scaleY);
    AffineTransformOp biLinearScaleOp = new AffineTransformOp(scaleTransform, AffineTransformOp.TYPE_BILINEAR);

    return biLinearScaleOp.filter(
            bufferedImage,
            new BufferedImage(scaledDimension.width, scaledDimension.height, bufferedImage.getType()));
}
 

@Override
public void apply()
{
	super.apply();

	if (face != null)
	{
		double scale_x = getWidth() / 154.0;
		double scale_y = getHeight() / 154.0;
		AffineTransform at = AffineTransform.getScaleInstance(scale_x,
				scale_y);
		AffineTransformOp op = new AffineTransformOp(at,
				AffineTransformOp.TYPE_BILINEAR);
		face_scale = new BufferedImage(getWidth(), getHeight(),
				BufferedImage.TYPE_4BYTE_ABGR);
		op.filter(face, face_scale);
		hour_scale = new BufferedImage((int) (hour.getWidth() * scale_x),
				(int) (hour.getHeight() * scale_y),
				BufferedImage.TYPE_4BYTE_ABGR);
		op.filter(hour, hour_scale);
		minute_scale = new BufferedImage(
				(int) (minute.getWidth() * scale_x), (int) (minute
						.getHeight() * scale_y),
				BufferedImage.TYPE_4BYTE_ABGR);
		op.filter(minute, minute_scale);

		offx = (int) (14 * scale_x);
	}
}
 

/** 平滑缩放 */
public BufferedImage scaling(double s) {
	AffineTransform tx = new AffineTransform();
	tx.scale(s, s);
	AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);
	return op.filter(image, null);
}
 

public static Raster testRasterTransform(Raster src, WritableRaster dst,
                                         AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    return op.filter(src, dst);
}
 

public static BufferedImage testImageTransform(BufferedImage image,
                                               AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    BufferedImage transformedImage = new BufferedImage(image.getWidth(),
                                                       image.getHeight(),
                                                       image.getType());

    return op.filter(image, transformedImage);
}
 

/**
 * Draw arrow curved.
 * @param g 
 */
protected final void paintArrowRotated(Graphics g)
{
    Graphics2D g2d = (Graphics2D)g;
    int size = (this.getWidth() > this.getHeight()) ? this.getHeight() : this.getWidth();
    
    // Arrow rotated.
    BufferedImage image = (this.getState().getRotation() == State.Rotation.COUNTER_CLOCKWISE) ? this.getImageArrowRotatedCounterClockwise() : this.getImageArrowRotatedClockwise();
    int imageWidth = image.getWidth();
    int imageHeight = image.getHeight();
    double imagePreferredSize = this.getConfiguration().getDouble("arrow-rotated.size") * size;
    double imageScaleFactor = (imageWidth > imageHeight) ? imagePreferredSize / imageWidth : imagePreferredSize / imageHeight;
    int imageNewWidth = (int)Math.floor(imageWidth * imageScaleFactor);
    int imageNewHeight = (int)Math.floor(imageHeight * imageScaleFactor);
    
    // Determine offset.
    double offset = this.getConfiguration().getDouble("arrow-rotated.offset");
    double imageOffset = (this.getState().getRotation() == State.Rotation.COUNTER_CLOCKWISE) ? -imageNewWidth - offset * size : offset * size;

    AffineTransform transform = new AffineTransform();
    transform.scale(imageScaleFactor, imageScaleFactor);
    
    AffineTransformOp operation = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
    image = operation.filter(image, null);

    g2d.drawImage(image,
                 (int)(this.getWidth() / 2  + imageOffset),
                 (int)((this.getHeight() - image.getHeight()) / 2),
                 null);
}
 

public static Raster testRasterTransform(Raster src, WritableRaster dst,
                                         AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    return op.filter(src, dst);
}
 

public static Raster testRasterTransform(Raster src, WritableRaster dst,
                                         AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    return op.filter(src, dst);
}
 

public static BufferedImage scaleImage(BufferedImage before, double newSize) {
	double w = before.getWidth();
	double h = before.getHeight();
	BufferedImage after = new BufferedImage((int) newSize, (int) newSize, BufferedImage.TYPE_INT_ARGB);
	AffineTransform at = new AffineTransform();
	at.scale(newSize / w, newSize / h);
	AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
	return scaleOp.filter(before, after);
}
 

public static Raster testRasterTransform(Raster src, WritableRaster dst,
                                         AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    return op.filter(src, dst);
}
 

public static BufferedImage testImageTransform(BufferedImage image,
                                               AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    BufferedImage transformedImage = new BufferedImage(image.getWidth(),
                                                       image.getHeight(),
                                                       image.getType());

    return op.filter(image, transformedImage);
}
 

public static Raster testRasterTransform(Raster src, WritableRaster dst,
                                         AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    return op.filter(src, dst);
}
 

public static BufferedImage testImageTransform(BufferedImage image,
                                               AffineTransform transform) {
    AffineTransformOp op =
            new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

    BufferedImage transformedImage = new BufferedImage(image.getWidth(),
                                                       image.getHeight(),
                                                       image.getType());

    return op.filter(image, transformedImage);
}
 

CursorImageData(BufferedImage[] bi, int delay, int hsX, int hsY, int curType) {
    // cursor type
    // 0 - Undefined (an array of images inside an ICO)
    // 1 - ICO
    // 2 - CUR
    IntBuffer singleCursor = null;
    ArrayList<IntBuffer> cursors = new ArrayList<IntBuffer>();
    int bwidth = 0;
    int bheight = 0;
    boolean multIcons = false;

    // make the cursor image
    for (int i = 0; i < bi.length; i++) {
        BufferedImage img = bi[i];
        bwidth = img.getWidth();
        bheight = img.getHeight();
        if (curType == 1) {
            hsX = 0;
            hsY = bheight - 1;
        } else if (curType == 2) {
            if (hsY == 0) {
                // make sure we flip if 0
                hsY = bheight - 1;
            }
        } else {
            // We force to choose 32x32 icon from
            // the array of icons in that ICO file.
            if (bwidth != 32 && bheight != 32) {
                multIcons = true;
                continue;
            } else {
                if (img.getType() != 2) {
                    continue;
                } else {
                    // force hotspot
                    hsY = bheight - 1;
                }
            }
        }

        // We flip our image because .ICO and .CUR will always be reversed.
        AffineTransform trans = AffineTransform.getScaleInstance(1, -1);
        trans.translate(0, -img.getHeight(null));
        AffineTransformOp op = new AffineTransformOp(trans, AffineTransformOp.TYPE_BILINEAR);
        img = op.filter(img, null);

        singleCursor = BufferUtils.createIntBuffer(img.getWidth() * img.getHeight());
        DataBufferInt dataIntBuf = (DataBufferInt) img.getData().getDataBuffer();
        singleCursor = IntBuffer.wrap(dataIntBuf.getData());
        cursors.add(singleCursor);
    }

    int count;
    if (multIcons) {
        bwidth = 32;
        bheight = 32;
        count = 1;
    } else {
        count = cursors.size();
    }
    // put the image in the IntBuffer
    data = BufferUtils.createIntBuffer(bwidth * bheight);
    imgDelay = BufferUtils.createIntBuffer(bi.length);
    for (int i = 0; i < count; i++) {
        data.put(cursors.get(i));
        if (delay > 0) {
            imgDelay.put(delay);
        }
    }
    width = bwidth;
    height = bheight;
    xHotSpot = hsX;
    yHotSpot = hsY;
    numImages = count;
    data.rewind();
    if (imgDelay != null) {
        imgDelay.rewind();
    }
}
 

private void drawImage() {
    // check first
    if (iconBytes == null || iconBytes.length == 0) {
        return;
    }

    // load bufered image
    BufferedImage bi;
    try {
        bi = ImageIO.read(new ByteArrayInputStream(iconBytes));
    } catch (IOException ex) {
        return;
    }

    // rotate
    if (rotationAngle != 0) {
        AffineTransform tx = new AffineTransform();
        tx.rotate(Math.PI * rotationAngle / 2.0, bi.getWidth() / 2.0, bi.getHeight() / 2.0);
        if (rotationAngle == 1 || rotationAngle == 3) {
            double offset;
            if (rotationAngle == 1) {
                offset = (bi.getWidth() - bi.getHeight()) / 2.0;
            } else {
                offset = (bi.getHeight() - bi.getWidth()) / 2.0;
            }
            tx.translate(offset, offset);
        }
        AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);
        bi = op.filter(bi, null);
    }

    // get width and height
    int width = bi.getWidth();
    int height = bi.getHeight();

    // first check if we need to scale width
    if (bi.getWidth() > jLabel_ScreenShot.getWidth()) {
        //scale width to fit
        width = jLabel_ScreenShot.getWidth();
        //scale height to maintain aspect ratio
        height = (width * bi.getHeight()) / bi.getWidth();
    }
    // then check if we need to scale even with the new height
    if (height > jLabel_ScreenShot.getHeight()) {
        //scale height to fit instead
        height = jLabel_ScreenShot.getHeight();
        //scale width to maintain aspect ratio
        width = (height * bi.getWidth()) / bi.getHeight();
    }

    // set image
    jLabel_ScreenShot.setIcon(new ImageIcon(bi.getScaledInstance(width, height, Image.SCALE_DEFAULT)));
}