java image 处理

package com.c.elmer.util.image;

import java.awt.Color;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/**
* EasyImage lets you do all the basic image operations - 
* converting, cropping, resizing, rotating, flipping?
* Plus it let抯 you do some really cool affects.
* All is done super easily.
* Combining operations can produce some very cool results.
*
* Operations:
    * Open image.
    * Save image
    * Convert image
    * Re-size image
    * Crop image
    * Convert to black and white image
    * Rotate image
    * Flip image
    * Add color to image
    * Create image with multiple instance of the original
    * Combining 2 images together
    * Emphasize parts of the image
    * Affine transform image
*
*
* @author Avi Yehuda
*
*/
public class Image {
    private BufferedImage bufferedImage;
    private String fileName;
   
    /**
     * Constructor - loads from an image file.
     * @param imageFile
     */
    public Image(File imageFile) {
        try {
            bufferedImage = ImageIO.read(imageFile);
            fileName = imageFile.getAbsolutePath();
        } catch (Exception e) {
            e.printStackTrace();
            bufferedImage = null;
            imageFile = null;
        }
    }
   
    /**
     * Constructor - loads from an image file.
     * @param imageFilePath
     */
    public Image(String imageFilePath) {
        this(new File(imageFilePath));
    }
   
    /**
     * Return image as java.awt.image.BufferedImage
     * @return image as java.awt.image.BufferedImage
     */
    public BufferedImage getAsBufferedImage(){
        return bufferedImage;
    }
   
    /**
     * Save the image as a new image file.
     * Can also convert the image according to file type.
     * @param fileName
     */
    public void saveAs(String fileName){
        saveImage(new File(fileName));
        this.fileName = fileName;
    }
   
   
    /**
     * Saves the image to the original file.
     */
    public void save(){
        saveImage(new File(fileName));
    }
   
   
  
    /**
     * Resizing the image by percentage of the original.
     * @param percentOfOriginal
     */
    public void resize( int percentOfOriginal){
        int newWidth = bufferedImage.getWidth()  * percentOfOriginal / 100;
        int newHeight = bufferedImage.getHeight() * percentOfOriginal / 100;
        resize(newWidth, newHeight);
    }
       
    /**
     * Resizing the image by width and height.
     * @param newWidth
     * @param newHeight
     */
    public void resize( int newWidth, int newHeight){
       
        int oldWidth = bufferedImage.getWidth();
        int oldHeight = bufferedImage.getHeight();
       
        if(newWidth == -1 || newHeight == -1){
            if(newWidth == -1){
                if(newHeight == -1){
                    return;
                }
               
                newWidth = newHeight * oldWidth/ oldHeight;
            }
            else {
                newHeight = newWidth * oldHeight / oldWidth;
            }
        }
       
        BufferedImage result =
            new BufferedImage(newWidth , newHeight, BufferedImage.TYPE_INT_BGR);
       
        int widthSkip =  oldWidth / newWidth;
        int heightSkip = oldHeight / newHeight;
       
        if(widthSkip == 0) widthSkip=1;
        if(heightSkip == 0) heightSkip=1;
       
        for (int x = 0; x < oldWidth; x += widthSkip) {
            for (int y = 0; y < oldHeight; y += heightSkip) {
                int rgb = bufferedImage.getRGB(x, y);
              
                if(x/widthSkip < newWidth && y/heightSkip < newHeight){
                    result.setRGB(x/widthSkip, y/heightSkip, rgb);
                }
            }
        }
       
       
        bufferedImage = result;
    }
   
    /**
     * Add color to the RGB of the pixel
     * @param numToAdd
     */
    public void addPixelColor(int numToAdd){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                bufferedImage.setRGB(x, y, rgb+numToAdd);
            }
        }
    }
   
    /**
     * Covert image to black and white.
     */
    public void convertToBlackAndWhite() {
        ColorSpace gray_space = ColorSpace.getInstance(ColorSpace.CS_GRAY);
        ColorConvertOp convert_to_gray_op = new ColorConvertOp(gray_space, null);
        convert_to_gray_op.filter(bufferedImage, bufferedImage);
    }
   
   
    /**
     * Rotates image 90 degrees to the left.
     */
    public void rotateLeft(){
       
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(height,
                width, bufferedImage.TYPE_INT_BGR);
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(y, x, rgb);
            }
        }
       
        bufferedImage = result;
       
    }
   
    /**
     * Rotates image 90 degrees to the right.
     */
    public void rotateRight(){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(height,
                width, bufferedImage.TYPE_INT_BGR);
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(height-y-1, x, rgb);
            }
        }
       
        bufferedImage = result;
       
    }
   
   
    /**
     * Rotates image 180 degrees.
     */
    public void rotate180(){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(width,
                height, bufferedImage.TYPE_INT_BGR);
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(width-x-1, height-y-1, rgb);
            }
        }
       
        bufferedImage = result;
       
    }
   
    /**
     * Flips the image horizontally
     */
    public void flipHorizontally(){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(width,
                height, bufferedImage.TYPE_INT_BGR);
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(width-x-1, y, rgb);
            }
        }
       
        bufferedImage = result;
       
    }
   
    /**
     * Flips the image vertically.
     */
    public void flipVertically(){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(width,
                height, bufferedImage.TYPE_INT_BGR);
       
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(x, height-y-1, rgb);
            }
        }
       
        bufferedImage = result;
       
    }
   
    /**
     * Multiply the image.
     * @param timesToMultiplyVertically
     * @param timesToMultiplyHorizantelly
     */
    public void multiply(int timesToMultiplyVertically,
            int timesToMultiplyHorizantelly){
        multiply(timesToMultiplyVertically,timesToMultiplyHorizantelly,0);
    }
   
    /**
     * Multiply the image and also add color each of the multiplied images.
     * @param timesToMultiplyVertically
     * @param timesToMultiplyHorizantelly
     */
    public void multiply(int timesToMultiplyVertically,
            int timesToMultiplyHorizantelly, int colorToHenhancePerPixel){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        BufferedImage result = new BufferedImage(width*timesToMultiplyVertically,
                height*timesToMultiplyHorizantelly, bufferedImage.TYPE_INT_BGR);
       
        for (int xx = 0; xx < timesToMultiplyVertically; xx ++) {
            for (int yy = 0; yy < timesToMultiplyHorizantelly; yy ++) {
                for (int x = 0; x < width; x ++) {
                    for (int y = 0; y < height; y ++) {
                        int rgb = bufferedImage.getRGB(x, y);
                        result.setRGB(width*xx+x, height*yy+y, rgb+colorToHenhancePerPixel*(yy+xx));
                      
                    }
                }
            }
        }
       
        bufferedImage = result;
    }
   
    /**
     * Combines the image with another image in an equal presence to both;
     * @param newImagePath - image to combine with
     */
    public void combineWithPicture(String newImagePath){
        combineWithPicture(newImagePath, 2);
    }
   
   
   
    /**
     * Combines the image with another image.
     * jump = 2 means that every two pixels the new image is replaced.
     * This makes the 2 images equal in presence. If jump=3 than every 3rd
     * pixel is replaced by the new image.
     * As the jump is higher this is how much the new image has less presence.
     *
     * @param newImagePath
     * @param jump
     */
    public void combineWithPicture(String newImagePath, int jump){
        try {
            BufferedImage bufferedImage2 = ImageIO.read(new File(newImagePath));
            combineWithPicture(bufferedImage2, jump, null);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
   
   
    public void combineWithPicture(Image image2){
        combineWithPicture(image2.getAsBufferedImage(), 2, null);
    }
    public void combineWithPicture(Image image2, int jump){
            combineWithPicture(image2.getAsBufferedImage(), jump, null);
    }
   
    public void combineWithPicture(Image image2, Color ignoreColor){
        combineWithPicture(image2.getAsBufferedImage(), 2, ignoreColor);
    }
    public void combineWithPicture(Image image2, int jump, Color ignoreColor){
            combineWithPicture(image2.getAsBufferedImage(), jump, ignoreColor);
    }
   
    /**
     * Combines the image with another image.
     * jump = 2 means that every two pixels the new image is replaced.
     * This makes the 2 images equal in presence. If jump=3 than every 3rd
     * pixel is replaced by the new image.
     * As the jump is higher this is how much the new image has less presence.
     * 
     * ignoreColor is a color in the new image that will not be copied -
     * this is good where there is a background which you do not want to copy.
     * 
     * @param bufferedImage2
     * @param jump
     * @param ignoreColor
     */
    private void combineWithPicture(BufferedImage bufferedImage2,
            int jump, Color ignoreColor){
        checkJump(jump);
       
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        int width2 = bufferedImage2.getWidth();
        int height2 = bufferedImage2.getHeight();
       
        int ignoreColorRgb = -1;
       
        if(ignoreColor != null){
            ignoreColorRgb = ignoreColor.getRGB();
        }
       
        for (int y = 0; y < height; y ++) {
            for (int x = y%jump; x < width; x +=jump) {
                if(x >= width2 || y>= height2){
                    continue;
                }
               
                int rgb = bufferedImage2.getRGB(x, y);
               
                if( rgb != ignoreColorRgb ){
                    bufferedImage.setRGB(x, y, rgb);
                }
            }
        }
       
    }
   
   
    public void crop(int startX, int startY, int endX, int endY){
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        if(startX == -1){
            startX = 0;
        }
       
        if(startY == -1){
            startY = 0;
        }
       
        if(endX == -1){
            endX = width-1;
        }
       
        if(endY == -1){
            endY = height-1;
        }
       
        BufferedImage result = new BufferedImage(endX-startX+1,
                endY-startY+1, bufferedImage.TYPE_INT_BGR);
       
        for (int y = startY; y < endY; y ++) {
            for (int x = startX; x < endX; x ++) {
                int rgb = bufferedImage.getRGB(x, y);
                result.setRGB(x-startX, y-startY, rgb);
            }
        }
        bufferedImage = result;
    }
   
    private void saveImage(File file) {
        try {
            ImageIO.write(bufferedImage, getFileType(file), file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
   
    public void emphasize(int startX, int startY, int endX, int endY){
        emphasize(startX, startY, endX, endY, Color.BLACK, 3 );
    }
   
    public void emphasize(int startX, int startY, int endX, int endY, Color backgroundColor){
        emphasize(startX, startY, endX, endY, backgroundColor, 3 );
    }
   
    public void emphasize(int startX, int startY, int endX, int endY,int jump){
        emphasize(startX, startY, endX, endY, Color.BLACK, jump );
    }
    public void emphasize(int startX, int startY, int endX, int endY, Color backgroundColor,int jump){
       
        checkJump(jump);
       
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        if(startX == -1){
            startX = 0;
        }
       
        if(startY == -1){
            startY = 0;
        }
       
        if(endX == -1){
            endX = width-1;
        }
       
        if(endY == -1){
            endY = height-1;
        }
       
       
        for (int y = 0; y < height; y ++) {
            for (int x = y%jump; x < width; x +=jump) {
               
                if(y >= startY && y <= endY && x >= startX && x <= endX){
                    continue;
                }
               
                bufferedImage.setRGB(x, y, backgroundColor.getRGB());
            }
        }
      
    }
   
    private void checkJump(int jump) {
        if(jump<1){
            throw new RuntimeException("Error: jump can not be less than 1");
        }
       
    }

    public void addColorToImage(Color color, int jump){
        addColorToImage(color.getRGB(),jump);
    }
   
    public void addColorToImage(int rgb, int jump){
        checkJump(jump);
       
        int width = bufferedImage.getWidth();
        int height = bufferedImage.getHeight();
       
        for (int y = 0; y < height; y ++) {
            for (int x = y%jump; x < width; x +=jump) {
                bufferedImage.setRGB(x, y, rgb);
            }
        }
    }
   
   
   
    public void affineTransform (double fShxFactor, double fShyFactor) {

        try {
          AffineTransform shearer =
            AffineTransform.getShearInstance (fShxFactor, fShyFactor);
          AffineTransformOp shear_op =
            new AffineTransformOp (shearer, null);
          bufferedImage = shear_op.filter (bufferedImage, null);
        }
        catch (Exception e) {
          System.out.println("Shearing exception = " + e);
        }
      }
   
    private String getFileType(File file) {
        String fileName = file.getName();
        int idx =  fileName.lastIndexOf(".");
        if(idx == -1){
            throw new RuntimeException("Invalid file name");
        }
       
        return fileName.substring(idx+1);
    }
   
   
    public int getWidth(){
        return bufferedImage.getWidth();
    }
   
    public int getHeight(){
        return bufferedImage.getHeight();
    }
   
    public static void main(String[] args) {
       
        Image image1  = new Image("e:/123.jpg");
        image1.resize(10);
        image1.multiply(5, 5, 11111);
        image1.saveAs("e:/multiply+color.jpg");
       
       
        Image image22  = new Image("e:/123.jpg");
        Image image2  = new Image("e:/345.jpg");
        //image.resize(50);
        //image2.resize(50);
        //image.affineTransform(0, 0.3);
        //image2.affineTransform(0, -0.3);
        image22.combineWithPicture(image2);
        image22.saveAs("e:/affineTransformAndCombine2.jpg");
      
      
        Image image33 = new Image("e:/123.jpg");
        image33.resize(50);
        image33.affineTransform(0.0, 0.5);
        image33.saveAs("e:/affineTransform11.jpg");
       
     /*
        Image image  = new Image("c:/pics/heart.gif");
        image.multiply(20, 20);
        Image image2  = new Image("c:/pics/p6.jpg");
        image2.crop(800, 0, -1, -1);
        image2.resize(50);
        image2.combineWithPicture(image,3,Color.white);
        image2.saveAs("c:/pics/combineWithPictureWithoutBackground.jpg");
        /*
        image.resize(5);
        image.multiply(20, 20);
        image.combineWithPicture("c:/p2.jpg");
        //image.addColorToImage(Color.yellow, 3);
        //image.addColorToImage(Color.red, 5);
        //image.combineWithPicture("c:/p2.jpg",3);
     
      */
       
        Image image  = new Image("e:/123.jpg");
        int width = image.getWidth();
        int height = image.getHeight();
        for(int i=0,c=0;i<height;c++,i+=50){
            int x = width/2  - i;
            int y = height/2 - i;
           
            image.emphasize(x, y, width-1-x, height-1-y, Color.BLACK, 12 - c/4);
        }
        image.saveAs("e:/emphesizeTrick.jpg");
       
       


        Image image6  = new Image("e:/123.jpg");

        image6.emphasize(100, 20, 200, 200);

        image6.saveAs("e:/p1Emphesized6.jpg");

       
      //  */
       // image.saveAs("c:/xxx.jpg");
        /*
        Image image  = new Image("c:/pics/p1.jpg");
        image.addColorToImage(Color.red, 5);
        image.saveAs("c:/pics/addColorToImage.jpg");
        */
    }
}