Java图像处理类
Java图像高能处理，包含缩放，变色，改变尺寸，旋转，裁剪，仿射变换，打开，保存，转格式等诸多功能：
```java
package com.aviyehuda.easyimage;
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
*
*/
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 &##124;&##124; 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);
double widthSkip = new Double(oldWidth-newWidth) / new Double(newWidth);
double heightSkip = new Double(oldHeight-newHeight) / new Double(newHeight);
double widthCounter = 0;
double heightCounter = 0;
int newY = 0;
boolean isNewImageWidthSmaller = widthSkip >0;
boolean isNewImageHeightSmaller = heightSkip >0;
for (int y = 0; y < oldHeight && newY < newHeight; y++) {
if(isNewImageHeightSmaller && heightCounter > 1){ //new image suppose to be smaller - skip row
heightCounter -= 1;
}
else if (heightCounter < -1){ //new image suppose to be bigger - duplicate row
heightCounter += 1;
if(y > 1)
y = y - 2;
else
y = y - 1;
}
else{
heightCounter += heightSkip;
int newX = 0;
for (int x = 0; x < oldWidth && newX < newWidth; x++) {
if(isNewImageWidthSmaller && widthCounter > 1){ //new image suppose to be smaller - skip column
widthCounter -= 1;
}
else if (widthCounter < -1){ //new image suppose to be bigger - duplicate pixel
widthCounter += 1;
if(x >1)
x = x - 2;
else
x = x - 1;
}
else{
int rgb = bufferedImage.getRGB(x, y);
result.setRGB(newX, newY, rgb);
newX++;
widthCounter += widthSkip;
}
}
newY++;
}
}
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 &##124;&##124; 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 image = new Image("c:/pics/p1.jpg");
image.resize(10);
image.multiply(5, 5, 11111);
image.saveAs("c:/pics/multiply+color.jpg");
*/
/*
Image image = new Image("c:/pics/israel_flag.gif");
Image image2 = new Image("c:/pics/palestine_flag.gif");
//image.resize(50);
//image2.resize(50);
//image.affineTransform(0, 0.3);
//image2.affineTransform(0, -0.3);
image.combineWithPicture(image2);
image.saveAs("c:/pics/affineTransformAndCombine2.jpg");
*/
/*
Image image = new Image("c:/pics/p1.jpg");
image.resize(50);
image.affineTransform(0.0, 0.5);
image.saveAs("c:/pics/affineTransform.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("c:/pics/p1.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("c:/pics/emphesizeTrick.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");
*/
}
}
```