Java image manipulation class

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import javax.imageio.ImageIO;

/**
 * This class facilitates the image manipulation.
 * Use factoryImageObject to create a instance loading from a string with the path.
 * An example that doubles the image size: <br>
 * 
 * ImageObject variableNameHere = ImageObject.factoryImageObject("imagename.png");
 * variableNameHere.multiplySize(2);
 * variableNameHere.writeFile("newimagename.png");
 * 
 * @author FL
**/
public class ImageObject implements Cloneable{
	private int width;
	private int height;
	private int[][][] rgbaArray;
	
	private ImageObject(int width, int height){
		this.width = width;
		this.height = height;
		rgbaArray = new int[width][height][4];
	}
	
	/** 
	 * Factory method that reads the file from a path
	**/
	public static ImageObject factoryImageObject(String filename) throws IOException {
		BufferedImage bufferedImage = ImageIO.read(new File(filename));
		ImageObject ret = new ImageObject(bufferedImage.getWidth(),bufferedImage.getHeight());
		for (int line = 0; line < ret.height; line++) {
			for (int column = 0; column < ret.width; column++) {
				Color pixel = new Color(bufferedImage.getRGB(column, line),true);
				ret.rgbaArray[column][line][0] = pixel.getRed();
				ret.rgbaArray[column][line][1] = pixel.getGreen();
				ret.rgbaArray[column][line][2] = pixel.getBlue();
				ret.rgbaArray[column][line][3] = pixel.getAlpha();
			}
		}
		return ret;
	}

	/**
	 * Saves the image at a filename location. 
	**/
	public void writeFile(String filename) throws IOException {
		File file = new File(filename);
		BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
		for (int line = 0; line < height; line++) {
			for (int column = 0; column < width; column++) {
				int r = rgbaArray[column][line][0];
				int g = rgbaArray[column][line][1];
				int b = rgbaArray[column][line][2];
				int a = rgbaArray[column][line][3];
				Color pixel = new Color(r, g, b,a);
				bufferedImage.setRGB(column, line, pixel.getRGB());
			}
		}
		String[] splited = filename.split(Pattern.quote(".")); // Split at "." to get the extension
		String extension = splited[splited.length-1].toUpperCase();
		ImageIO.write(bufferedImage, extension, file);
	}
	
	
	/**
	 * Concatenates imageObjects horizontally or vertically to create a new instance.
	**/
	public ImageObject(ImageObject[] imageObjectArray, boolean horizontally){
		int number = imageObjectArray.length;
		// Define size 
		width = imageObjectArray[0].width;
		height = imageObjectArray[0].height;
		for (int i = 1; i < number; i++) {
			if(horizontally){
				width+=imageObjectArray[i].width;
			}else{
				height+=imageObjectArray[i].height;
			}
		}
		rgbaArray = new int[width][height][4];
		// Combine
		for (int i = 0; i < number; i++) {
			for (int line = 0; line < height; line++) {
				for (int column = 0; column < width; column++) {
					int x = column;
					int y = line;
					if(horizontally){
						x += i*width;
					}else{
						y += i*height;
					}
					for (int color = 0; color < 4; color++) {
						rgbaArray[x][y][color] = imageObjectArray[i].rgbaArray[column][line][color];
					}
				}
			}
		}
	}	
	
	/**
	 *  Divides the image in equals proportions
	**/
	public ImageObject[] divide(int number, boolean horizontally){ 
		ImageObject[] ret = new ImageObject[number];
		for (int i = 0; i < number; i++) {
			ret[i] = new ImageObject(horizontally ? width/number : width, horizontally ? height : height/number);
			for (int line = 0; line < ret[i].height; line++) {
				for (int column = 0; column < ret[i].width; column++) {
					int x = column;
					int y = line;
					if(horizontally){
						x += i*width/number;
					}else{
						y += i*height/number;
					}
					for (int color = 0; color < 4; color++) {
						ret[i].rgbaArray[column][line][color] = rgbaArray[x][y][color];
					}
				}
			}
		}
		return ret;
	}	
	
	/**
	 * Resize the image size. 
	 * Only accept multipler divisors like 2, 4, 0.5, 0.25
	**/
	public void multiplySize(double factor){ 
		width *= factor;
		height *= factor;
		int multipler = factor > 1 ? (int)Math.round(factor) : 1;
		int divider = factor < 1 ? (int)Math.round(1/factor) : 1;
		int[][][] rgbaArrayNew = new int[width][height][4];
		for (int line = 0; line < height; line++) {
			for (int column = 0; column < width; column++) {
				for (int color = 0; color < 4; color++) {
					rgbaArrayNew[column/divider][line/divider][color] = rgbaArray[column/multipler][line/multipler][color];
				}
			}
		}
		rgbaArray = rgbaArrayNew;
	}	
	
	/**
	 * Remove the background.
	 * Detects the background as the color that the most appears at the first line.
	 * 
	 * @return Number of pixel affected.
	**/
	public int removeBackground(){
		return makeBackgroundTransparent(pickBackgroundRGB(0,0,width-1,0));
	}
	
	/**
	 * Picks the pixel that most appears at the param coordinates at image 
	**/
	protected int[] pickBackgroundRGB(int xstart, int ystart, int xend, int yend){
		List <int[]> firstLine = new ArrayList<int[]>();
		for(int y=ystart;y<=yend;y++){
			for(int x=xstart;x<=xend;x++){
				firstLine.add(new int[]{rgbaArray[x][y][0],rgbaArray[x][y][1],rgbaArray[x][y][2]});
			}
		}
		int rgbBackground[] = new int[3];
		int backgroundOccurrences = 0;
		while(!firstLine.isEmpty()){
			int rgbBackgroundNew[] = firstLine.get(0);
			int backgroundOccurrencesNew = 0;
			for(int i=0;i<firstLine.size();i++){
				int array[] = firstLine.get(i);
				if(rgbBackgroundNew[0]==array[0] && rgbBackgroundNew[1]==array[1] && rgbBackgroundNew[2]==array[2]){
					backgroundOccurrencesNew++;
					firstLine.remove(i--);
				}
			}
			if(backgroundOccurrencesNew>backgroundOccurrences){
				rgbBackground = rgbBackgroundNew;
				backgroundOccurrences = backgroundOccurrencesNew;
			}
		}
		return rgbBackground;
	}
	
	/**
	 * Search for every rgb equals to rgbTransparent at set the alpha to minimum, making it transparent.
	 * 
	 * @return Number of pixel affected.
	**/
	public int makeBackgroundTransparent(int[] rgbTransparent){
		int ret = 0;
		for (int line = 0; line < height; line++) {
			for (int column = 0; column < width; column++) {
				boolean equals = true;
				for(int color=0;color<rgbTransparent.length;color++){
					if(rgbaArray[column][line][color]!=rgbTransparent[color])
						equals = false;
				}
				if(equals){
					rgbaArray[column][line][3]=0;
					ret++;
				}	
			}
		}
		return ret;
	}
	
	public int makeBackgroundTransparent(int r, int g, int b){
		return makeBackgroundTransparent(new int[]{r,g,b});
	}
	

	/**
	 * Increase or decrease the image size.
	 * Don't mix positive and negative numbers! 
	**/
	public void addSize(int left, int up, int right, int down){ 
		int widthNew = width+left+right;
		int heightNew = height+up+down;
		int[][][] rgbaArrayNew = new int[widthNew][heightNew][4];
		if(left>0 || up>0 || right>0 || down>0){ // If increase the size, make the background transparent
			int[] backgroundRGB = pickBackgroundRGB(0,0,width-1,height-1);
			for (int line = 0; line < heightNew; line++) {
				for (int column = 0; column < widthNew; column++) {
					rgbaArrayNew[column][line][0] = backgroundRGB[0];
					rgbaArrayNew[column][line][1] = backgroundRGB[1];
					rgbaArrayNew[column][line][2] = backgroundRGB[2];
					rgbaArrayNew[column][line][3] = 0;
				}
			}
		}
		for (int line = 0; line < (heightNew>height ? height : heightNew); line++) {
			for (int column = 0; column < (widthNew>width ? width : widthNew); column++) {
				for (int color = 0; color < 4; color++) {
					int x = widthNew>width ? column : column-left;
					int y = heightNew>height ? line : line-up;
					int xNew = widthNew>width ? column+left : column;
					int yNew = heightNew>height ? line+up : line;
					rgbaArrayNew[xNew][yNew][color] = rgbaArray[x][y][color];
				}
			}
		}
		width = widthNew;
		height = heightNew;
		rgbaArray = rgbaArrayNew;
	}
	
	public void addSize(int fourDirections){ 
		addSize(fourDirections,fourDirections,fourDirections,fourDirections);
	}
}

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author FL
**/
public class FormatImage {
	public static void main(String[] args) {
		copyImagesNumered(547,757,53);
	}
	
	/**
	 * Returns a list with names of all file at dir. 
	**/
	public static ArrayList<String> fileNames(String dir){
		ArrayList<String> ret = new ArrayList<String>();
		File folder = new File(dir);
		File[] listOfFiles = folder.listFiles();

	    for (int i = 0; i < listOfFiles.length; i++) {
	    	if (listOfFiles[i].isFile()) {
	    		ret.add(listOfFiles[i].getName());
//	    		System.out.println("File " + listOfFiles[i].getName());
//	    	} else if (listOfFiles[i].isDirectory()) {
//	    		System.out.println("Directory " + listOfFiles[i].getName());
	    	}
	    }
	    return ret;
	}
	
	/**
	 * Copy the numered image at Chaos Rush pack.
	 * 
	 * @param firstIndex : Count as image index
	 * @param lastIndex : Count as image index
	 * @param correction : Difference between the pokémon index and the image number.
	**/
	public static void copyImagesNumered(int firstIndex, int lastIndex, int correction){
		String dirOriginal="original";
		String[] dir = new String[]{"front","frontshiny","back","backshiny"};
		String[] name = new String[]{"","s","b","sb"};
		
		String separatorDir = "/";
		String separatorFile = ".";
		String extension = "png";
		
		List <Integer> femaleSpriteNames = Arrays.asList(new Integer[]{521,592,593}); 
		Map <Integer,Integer> exceptions = new HashMap<Integer,Integer>();
		int[] exceptioNames = null;
		int exceptionFirstIndex = 736;
		exceptioNames = new int[]{
				550,555,585,585,585,586,586,586,646,646,648,649,649,649,649,641,642,645,647
		};
		for(Integer exception : exceptioNames){
			exceptions.put(exceptionFirstIndex++,exception);
			if(exceptionFirstIndex==750+1) // Small numeration fix
				exceptionFirstIndex += 3;
		}
		//exceptions.put(exceptionFirstIndex++,550);
		//exceptions.put(exceptionFirstIndex++,555);
		int index = 0;
		int formIndex = 0;
		int lastForm = 0;
		
		try {
			index = firstIndex-correction;
			while(index+correction<=lastIndex){
				int originIndex = index+correction;
				String originalLocation = dirOriginal+separatorDir+(originIndex)+separatorFile+extension;
				ImageObject imageObject = ImageObject.factoryImageObject(originalLocation);
//				imageObject.removeBackground();
				imageObject.multiplySize(2);
				String filename = index+"";
				if(exceptions.containsKey(originIndex)){
					int formName = exceptions.get(originIndex);
					filename = formName+"";
					formIndex = (formName == lastForm) ? formIndex+1 : 1;
					lastForm = formName;
				}else{
					formIndex = 0;
				}
				boolean hadFemaleSprite = femaleSpriteNames.contains(index);
				// Divides vertically the sprite if there two sprites for gender and add the "f" at the second sprite
				ImageObject[] imageArrayGender = hadFemaleSprite ? imageObject.divide(2, false) : new ImageObject[]{imageObject};
				boolean femaleSprite = false;
				for(ImageObject imageObjectGender : imageArrayGender){
					ImageObject[] imageObjectArray = imageObjectGender.divide(4, true);
					for(int i=0;i<dir.length;i++){
						String saveLocation = dir[i]+separatorDir+filename+(femaleSprite ? "f" : "")+name[i];
						if(formIndex>0)
							saveLocation+="_"+formIndex;
						saveLocation+=separatorFile+extension;
						imageObjectArray[i].removeBackground();
						imageObjectArray[i].writeFile(saveLocation);
					}
					femaleSprite = true;
				}
				if(originIndex==750) // Small numeration fix
					correction+=3;
				if(originIndex==702) // Again
					correction+=33;
				
				if(formIndex==0){ // Doesn't has the exception number
					index++;
				}else{
					correction++;
				}
			}
			System.out.println("Success!");
		} catch (IOException e) {
			System.out.println("Failed at "+(index+correction)+"!");
			e.printStackTrace();
		}
	}
}