java.awt.image.AffineTransformOp

Here are the examples of the java api class java.awt.image.AffineTransformOp taken from open source projects.

1. RotateOperation#apply()

Project: cocoon
File: RotateOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    int width = image.getWidth();
    int height = image.getHeight();
    int x = width / 2;
    int y = height / 2;
    WritableRaster newRaster1 = image.createCompatibleWritableRaster(-x, -y, width, height);
    AffineTransform translate = AffineTransform.getTranslateInstance(-x, -y);
    AffineTransformOp op = new AffineTransformOp(translate, AffineTransformOp.TYPE_BILINEAR);
    op.filter(image, newRaster1);
    AffineTransform rotate = AffineTransform.getRotateInstance(angle);
    op = new AffineTransformOp(rotate, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster newRaster2 = image.createCompatibleWritableRaster(-x, -y, width, height);
    op.filter(newRaster1, newRaster2);
    return newRaster2;
}

2. ImageTransformUtils#getTransformedImage()

Project: simpleimage
File: ImageTransformUtils.java
public static BufferedImage getTransformedImage(BufferedImage image, double scaleX, double scaleY, double shearX, double shearY) {
    AffineTransform transform = new AffineTransform();
    if (scaleX > 0 && scaleY > 0)
        transform.scale(scaleX, scaleY);
    if (shearX > 0 && shearY > 0)
        transform.shear(shearX, shearY);
    AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
    BufferedImage dest = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
    op.filter(image, dest);
    return dest;
}

3. GraphicsUtils#getResize()

Project: LGame
File: GraphicsUtils.java
/**
	 * ????BufferedImage??
	 * 
	 * @param image
	 * @param w
	 * @param h
	 * @return
	 */
public static BufferedImage getResize(BufferedImage image, int w, int h) {
    int width = image.getWidth(), height = image.getHeight();
    if (width == w && height == h) {
        return image;
    }
    BufferedImage img;
    AffineTransform tx = new AffineTransform();
    tx.scale((double) w / width, (double) h / height);
    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    img = op.filter(image, null);
    return img;
}

4. JavaSEGraphicsUtils#getResize()

Project: LGame
File: JavaSEGraphicsUtils.java
/**
	 * ????BufferedImage??
	 * 
	 * @param image
	 * @param w
	 * @param h
	 * @return
	 */
public static BufferedImage getResize(BufferedImage image, int w, int h) {
    int width = image.getWidth(), height = image.getHeight();
    if (width == w && height == h) {
        return image;
    }
    BufferedImage img;
    AffineTransform tx = new AffineTransform();
    tx.scale((double) w / width, (double) h / height);
    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    img = op.filter(image, null);
    return img;
}

5. GraphicsUtils#getResize()

Project: LGame
File: GraphicsUtils.java
/**
	 * ????BufferedImage??
	 * 
	 * @param image
	 * @param w
	 * @param h
	 * @return
	 */
public static BufferedImage getResize(BufferedImage image, int w, int h) {
    int width = image.getWidth(), height = image.getHeight();
    if (width == w && height == h) {
        return image;
    }
    BufferedImage img;
    AffineTransform tx = new AffineTransform();
    tx.scale((double) w / width, (double) h / height);
    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    img = op.filter(image, null);
    return img;
}

6. JmeDesktopSystem#verticalFlip()

Project: jmonkeyengine
File: JmeDesktopSystem.java
private static BufferedImage verticalFlip(BufferedImage original) {
    AffineTransform tx = AffineTransform.getScaleInstance(1, -1);
    tx.translate(0, -original.getHeight());
    AffineTransformOp transformOp = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    BufferedImage awtImage = new BufferedImage(original.getWidth(), original.getHeight(), BufferedImage.TYPE_INT_BGR);
    Graphics2D g2d = awtImage.createGraphics();
    g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
    g2d.drawImage(original, transformOp, 0, 0);
    g2d.dispose();
    return awtImage;
}

7. ImageSlicer#prepare()

Project: HiTune
File: ImageSlicer.java
/*
   * Prepare a large image for tiling.
   * 
   * Load an image from a file. Resize the image so that it is square,
   * with dimensions that are an even power of two in length (e.g. 512,
   * 1024, 2048, ...). Then, return it.
   * 
   */
public BufferedImage prepare(String filename) {
    try {
        src = ImageIO.read(new File(filename));
    } catch (IOException e) {
        log.error("Image file does not exist:" + filename + ", can not render image.");
    }
    XYData fullSize = new XYData(1, 1);
    while (fullSize.getX() < src.getWidth() || fullSize.getY() < src.getHeight()) {
        fullSize.set(fullSize.getX() * 2, fullSize.getY() * 2);
    }
    float scaleX = (float) fullSize.getX() / src.getWidth();
    float scaleY = (float) fullSize.getY() / src.getHeight();
    log.info("Image size: (" + src.getWidth() + "," + src.getHeight() + ")");
    log.info("Scale size: (" + scaleX + "," + scaleY + ")");
    AffineTransform at = AffineTransform.getScaleInstance(scaleX, scaleY);
    //       AffineTransform.getScaleInstance((fullSize.getX()-src.getWidth())/2,(fullSize.getY()-src.getHeight())/2);
    AffineTransformOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
    BufferedImage dest = op.filter(src, null);
    return dest;
}

8. MirrorOperation#apply()

Project: cocoon
File: MirrorOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    int xScale;
    int yScale;
    if (alongY) {
        xScale = -1;
        yScale = 1;
    } else {
        xScale = 1;
        yScale = -1;
    }
    AffineTransform transform = new AffineTransform(xScale, 0.0d, 0.0d, yScale, 0.0d, 0.0d);
    AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster scaledRaster = op.filter(image, null);
    return scaledRaster;
}

9. HeadlessAffineTransformOp#main()

Project: openjdk
File: HeadlessAffineTransformOp.java
public static void main(String args[]) {
    AffineTransformOp ato;
    ato = new AffineTransformOp(new AffineTransform(), AffineTransformOp.TYPE_BILINEAR);
    ato = new AffineTransformOp(new AffineTransform(), AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    ato = new AffineTransformOp(new AffineTransform(), AffineTransformOp.TYPE_BILINEAR);
    ato.getInterpolationType();
    ato.getTransform();
}

10. Images#rotate()

Project: nutz
File: Images.java
/**
     * ?????????
     * 
     * @param image
     *            ??
     * @param degree
     *            ????, 90 ???????? -90 ???????
     * @return ????????
     */
public static BufferedImage rotate(BufferedImage image, int degree) {
    // ???????
    int iw = image.getWidth();
    // ???????
    int ih = image.getHeight();
    int w = 0;
    int h = 0;
    int x = 0;
    int y = 0;
    degree = degree % 360;
    if (degree < 0)
        // ??????0-360???
        degree = 360 + degree;
    // ???????
    double ang = degree * 0.0174532925;
    if (degree == 180 || degree == 0 || degree == 360) {
        w = iw;
        h = ih;
    } else if (degree == 90 || degree == 270) {
        w = ih;
        h = iw;
    } else {
        int d = iw + ih;
        w = (int) (d * Math.abs(Math.cos(ang)));
        h = (int) (d * Math.abs(Math.sin(ang)));
    }
    // ??????
    x = (w / 2) - (iw / 2);
    y = (h / 2) - (ih / 2);
    BufferedImage rotatedImage = new BufferedImage(w, h, image.getType());
    Graphics2D gs = rotatedImage.createGraphics();
    // ???????????????
    gs.fillRect(0, 0, w, h);
    AffineTransform at = new AffineTransform();
    // ????
    at.rotate(ang, w / 2, h / 2);
    at.translate(x, y);
    AffineTransformOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    op.filter(image, rotatedImage);
    image = rotatedImage;
    return image;
}

11. AffineRed#genRect()

Project: batik
File: AffineRed.java
public void genRect(WritableRaster wr) {
    if (me2src == null)
        return;
    Rectangle srcR = me2src.createTransformedShape(wr.getBounds()).getBounds();
    // System.out.println("Affine wrR: " + wr.getBounds());
    // System.out.println("Affine srcR: " + srcR);
    // Outset by two pixels so we get context for interpolation...
    srcR.setBounds(srcR.x - 1, srcR.y - 1, srcR.width + 2, srcR.height + 2);
    // Don't try and get data from src that it doesn't have...
    CachableRed src = (CachableRed) getSources().get(0);
    if (!srcR.intersects(src.getBounds()))
        return;
    Raster srcRas = src.getData(srcR.intersection(src.getBounds()));
    if (srcRas == null)
        return;
    // This works around the problem that the buffered ops
    // completely ignore the coords of the Rasters passed in.
    AffineTransform aff = (AffineTransform) src2me.clone();
    // Translate what is at 0,0 (which will be what our current
    // minX/Y is) to our current minX,minY.
    aff.concatenate(AffineTransform.getTranslateInstance(srcRas.getMinX(), srcRas.getMinY()));
    Point2D srcPt = new Point2D.Float(wr.getMinX(), wr.getMinY());
    srcPt = me2src.transform(srcPt, null);
    Point2D destPt = new Point2D.Double(srcPt.getX() - srcRas.getMinX(), srcPt.getY() - srcRas.getMinY());
    destPt = aff.transform(destPt, null);
    // Translate what will be at minX,minY to zero, zero
    // which where java2d will think the real minX,minY is.
    aff.preConcatenate(AffineTransform.getTranslateInstance(-destPt.getX(), -destPt.getY()));
    AffineTransformOp op = new AffineTransformOp(aff, hints);
    BufferedImage srcBI, myBI;
    ColorModel srcCM = src.getColorModel();
    ColorModel myCM = getColorModel();
    WritableRaster srcWR = (WritableRaster) srcRas;
    // If the output buffer is not premultiplied in certain cases
    // it fails to properly divide out the Alpha (it always does
    // the affine on premultiplied data). We help it out by
    // premultiplying for it.
    srcCM = GraphicsUtil.coerceData(srcWR, srcCM, true);
    srcBI = new BufferedImage(srcCM, srcWR.createWritableTranslatedChild(0, 0), srcCM.isAlphaPremultiplied(), null);
    myBI = new BufferedImage(myCM, wr.createWritableTranslatedChild(0, 0), myCM.isAlphaPremultiplied(), null);
    op.filter(srcBI, myBI);
// if ((count % 40) == 0) {
//     org.apache.batik.ImageDisplay.showImage("Src: " , srcBI);
//     org.apache.batik.ImageDisplay.showImage("Dst: " , myBI);
// }
// count++;
}

12. AbstractBlackBoxTestCase#rotateImage()

Project: zxing
File: AbstractBlackBoxTestCase.java
protected static BufferedImage rotateImage(BufferedImage original, float degrees) {
    if (degrees == 0.0f) {
        return original;
    }
    switch(original.getType()) {
        case BufferedImage.TYPE_BYTE_INDEXED:
        case BufferedImage.TYPE_BYTE_BINARY:
            BufferedImage argb = new BufferedImage(original.getWidth(), original.getHeight(), BufferedImage.TYPE_INT_ARGB);
            Graphics g = argb.createGraphics();
            g.drawImage(original, 0, 0, null);
            g.dispose();
            original = argb;
            break;
    }
    double radians = Math.toRadians(degrees);
    // Transform simply to find out the new bounding box (don't actually run the image through it)
    AffineTransform at = new AffineTransform();
    at.rotate(radians, original.getWidth() / 2.0, original.getHeight() / 2.0);
    BufferedImageOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_BICUBIC);
    RectangularShape r = op.getBounds2D(original);
    int width = (int) Math.ceil(r.getWidth());
    int height = (int) Math.ceil(r.getHeight());
    // Real transform, now that we know the size of the new image and how to translate after we rotate
    // to keep it centered
    at = new AffineTransform();
    at.rotate(radians, width / 2.0, height / 2.0);
    at.translate((width - original.getWidth()) / 2.0, (height - original.getHeight()) / 2.0);
    op = new AffineTransformOp(at, AffineTransformOp.TYPE_BICUBIC);
    return op.filter(original, new BufferedImage(width, height, original.getType()));
}

13. ImageUtils#rotate()

Project: opensearchserver
File: ImageUtils.java
public static BufferedImage rotate(BufferedImage image, float degree) throws InterruptedException {
    Rotation rot = null;
    AffineTransformOp[] xform = null;
    switch((int) degree) {
        case 90:
            rot = Rotation.CW_90;
            break;
        case 180:
            rot = Rotation.CW_180;
            break;
        case 270:
            rot = Rotation.CW_270;
            break;
        default:
            xform = new AffineTransformOp[1];
            xform[0] = new AffineTransformOp(AffineTransform.getRotateInstance(Math.toRadians(degree)), AffineTransformOp.TYPE_BICUBIC);
            break;
    }
    if (rot != null)
        return Scalr.rotate(image, rot, xform);
    return Scalr.apply(image, xform);
}

14. AwtPanel#reshapeInThread()

Project: jmonkeyengine
File: AwtPanel.java
private void reshapeInThread(int width, int height) {
    byteBuf = BufferUtils.ensureLargeEnough(byteBuf, width * height * 4);
    intBuf = byteBuf.asIntBuffer();
    if (fb != null) {
        fb.dispose();
        fb = null;
    }
    fb = new FrameBuffer(width, height, 1);
    fb.setDepthBuffer(Format.Depth);
    fb.setColorBuffer(Format.RGB8);
    fb.setSrgb(srgb);
    if (attachAsMain) {
        rm.getRenderer().setMainFrameBufferOverride(fb);
    }
    synchronized (lock) {
        img = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
    }
    //        synchronized (lock){
    //            img = (BufferedImage) getGraphicsConfiguration().createCompatibleImage(width, height);
    //        }
    AffineTransform tx = AffineTransform.getScaleInstance(1, -1);
    tx.translate(0, -img.getHeight());
    transformOp = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    for (ViewPort vp : viewPorts) {
        if (!attachAsMain) {
            vp.setOutputFrameBuffer(fb);
        }
        vp.getCamera().resize(width, height, true);
        // Main framebuffer should use RenderManager.notifyReshape().
        for (SceneProcessor sp : vp.getProcessors()) {
            sp.reshape(vp, width, height);
        }
    }
}

15. ImageUtils#resizeTo()

Project: jmonkeyengine
File: ImageUtils.java
/**
     * Resizes the image to the given width and height.
     * @param source
     *            the source image (this remains untouched, the new image instance is created)
     * @param width
     *            the target image width
     * @param height
     *            the target image height
     * @return the resized image
     */
public static Image resizeTo(Image source, int width, int height) {
    BufferedImage sourceImage = ImageToAwt.convert(source, false, false, 0);
    double scaleX = width / (double) sourceImage.getWidth();
    double scaleY = height / (double) sourceImage.getHeight();
    AffineTransform scaleTransform = AffineTransform.getScaleInstance(scaleX, scaleY);
    AffineTransformOp bilinearScaleOp = new AffineTransformOp(scaleTransform, AffineTransformOp.TYPE_BILINEAR);
    BufferedImage scaledImage = bilinearScaleOp.filter(sourceImage, new BufferedImage(width, height, sourceImage.getType()));
    return ImageUtils.toJmeImage(scaledImage, source.getFormat());
}

16. ShearOperation#apply()

Project: cocoon
File: ShearOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    AffineTransform shear = AffineTransform.getShearInstance(shearX, shearY);
    AffineTransformOp op = new AffineTransformOp(shear, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster scaledRaster = op.filter(image, null);
    return scaledRaster;
}

17. ScaleOperation#apply()

Project: cocoon
File: ScaleOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    AffineTransform scale = AffineTransform.getScaleInstance(this.scale, this.scale);
    AffineTransformOp op = new AffineTransformOp(scale, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster scaledRaster = op.filter(image, null);
    return scaledRaster;
}

18. OffsetOperation#apply()

Project: cocoon
File: OffsetOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    AffineTransform translate = AffineTransform.getTranslateInstance(left, up);
    AffineTransformOp op = new AffineTransformOp(translate, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster scaledRaster = op.filter(image, null);
    return scaledRaster;
}

19. AffineTransformOperation#apply()

Project: cocoon
File: AffineTransformOperation.java
public WritableRaster apply(WritableRaster image) {
    if (!enabled) {
        return image;
    }
    AffineTransform transform = new AffineTransform(matrix);
    AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
    WritableRaster scaledRaster = op.filter(image, null);
    return scaledRaster;
}

20. Utils#flipImage()

Project: ATLauncher
File: Utils.java
/**
     * Flips a given {@link BufferedImage}
     *
     * @param image The image to flip
     * @return The flipped image
     */
public static Image flipImage(BufferedImage image) {
    AffineTransform tx = AffineTransform.getScaleInstance(-1, 1);
    tx.translate(-image.getWidth(null), 0);
    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    image = op.filter(image, null);
    return image;
}