bmp.java

来自「用java实现的对位图文件读取的源程序代码。」· Java 代码 · 共 398 行

import java.awt.Color;
import java.util.Arrays;
import static  java.lang.System.out;


public class BMP {
		
	BMPFileHeader bmpFileHeader;
	BMPInfoHeader bmpInfoHeader;
	BMPPalette bmpPalette;
	BMPData bmpData;
	
	
	public static final int[] BMP_TYPE = new int[]{1,2,4,8,16,24,32};
	
	int[][] data;
	
	int type = 8;
	
	public BMP() {
		bmpFileHeader 	= new BMPFileHeader();
		bmpInfoHeader 	= new BMPInfoHeader();
		bmpPalette 		= new BMPPalette();
		bmpData 		= new BMPData();
	}
	
	public BMP(int[][] aData) {
		this();
		this.setOriginData(aData);
		setOriginData();
	}
	
	public BMP(String fileName) throws Exception {
		this();
		fillBMP(fileName);
		
		setOriginData();
	}
	
	protected boolean isBMPFile(int bits) {
		boolean isBMP = false;
		for (int i=0; i<BMP_TYPE.length; i++) {
			if (bits == BMP_TYPE[i]) {
				isBMP = true;
				break;
			}
		}
		return isBMP;
	}
	
	public void fillBMP(String fileName) throws Exception {
		
		String mode = "r";
		BMPReader reader = null;
		reader = new BMPReader(fileName,mode);
		
		bmpFileHeader.fill(reader);
		bmpInfoHeader.fill(reader);
		
		int bits = bmpInfoHeader.getPixelBits();
		
		if (!isBMPFile(bits)) {
			throw new Exception("不是正确的BMP文件格式(可能是由于直接将其它格式的文件的扩展名改为BMP(bmp)造成");
		}
		
		if (bmpInfoHeader.getCompression() != 0) {
			throw new Exception("此文件经过压缩,程序不能处理");
		}
		
		System.out.println(bmpInfoHeader + "\n" + this.getProperty());
		
		int imageDataoffset = bmpFileHeader.getDataOffset();
		int width 			= bmpFileHeader.getWidth();
		int height 			= bmpFileHeader.getHeight();
		System.out.println("imageDataoffset = " + imageDataoffset);
		
		type = bmpInfoHeader.getPixelBits();
		if (type < 24) { //需要调色板
			bmpPalette.fill(reader,type);
			bmpData.fill(reader,imageDataoffset,width,height,type,bmpPalette.getPaletteColor());
		} else {		//不需要调色板
			bmpData.fill(reader,imageDataoffset,width,height,type);
		}		
	}

	final int GRAY_8_BIT = 256;
	public Color getMaxRateColor1() {
		//int maxRateColorInt = BMPProcess.getMaxRateColor(bmpData.getData8bit(),GRAY_8_BIT);
		//maxRateColorInt = bmpPalette.getPaletteColor()[maxRateColorInt];
		return null;//int2Color(maxRateColorInt);
	}
	
	public int[][] getData() {
		return data;
	}
	
	public void setData(int[][] data) {
		this.data = data;
	}
	
	public void setOriginData() {
		data = bmpData.copyData();
		this.setAlphas(data,ALPHA);
	}
	
	public void setOriginData(int[][] aData) {
		bmpData.setData(aData);
		setOriginData();
	}
	
	public int[][] getOriginData() {
		setOriginData();
		return data;
	}
	
	public void setAlphas(int[][] data,int alpha) {
		for (int i=0; i<data.length; i++) {
			for (int j = 0; j<data[i].length; j++) {
				data[i][j] = (data[i][j] & 0XFFFFFF) | (alpha << 24);
		    }
		}
	}
	
	public int[][] getReverseData() {
		for (int i=0; i<data.length; i++) {
			for (int j=0; j<data[i].length; j++) {
				data[i][j] = ~this.data[i][j];
			}
		}
		this.setAlphas(data,ALPHA);	
		return data;

	}
	
	public int[][] getAcuteData(final int TYPE) {
		//data = this.getSingleColorData(data,BMPProcess.RED);
		data = BMPProcess.getAcuteImageData(data,TYPE);
		//data = this.getSingleColorData(data,BMPProcess.RED);
		this.setAlphas(data,ALPHA);
		return data;
	}

	private int[][] getSingleColorData(final int TYPE) {
		data = getData();
		
		return getSingleColorData(data,TYPE);
	}
	
	private int[][] getSingleColorData(int[][] data,final int TYPE) {
		int[][] xxxData = new int[data.length][data[0].length];
		final int PICKUP = BMPProcess.COLOR_PICKUP_MAP.get(TYPE);
		for (int i=0; i<xxxData.length;i++) {
			for (int j=0; j<xxxData[i].length; j++) {
				xxxData[i][j] = data[i][j] & PICKUP;
		    }
		}
		return xxxData;
	}
		
	public int[][] getRedData() {
		int[][] data = getSingleColorData(BMPProcess.RED);
		this.setAlphas(data,this.ALPHA);
		return data;
	}
	
	public int[][] getGreenData() {
		int[][] data = getSingleColorData(BMPProcess.GREEN);
		this.setAlphas(data,this.ALPHA);
		return data;
	}
	
	public int[][] getBlueData() {
		int[][] data = getSingleColorData(BMPProcess.BLUE);
		this.setAlphas(data,this.ALPHA);
		return data;
	}

//修复
	final int GRAY = 256;
	
	public int[][] getNewData() {
		int[][] newData = null;
		int[][] data = getNewDataByColor(BMPProcess.RED);
		newData = data;
		data = getNewDataByColor(BMPProcess.GREEN);
		add(data,newData,newData);
		data = getNewDataByColor(BMPProcess.BLUE);
		add(data,newData,newData);
		this.setAlphas(newData,ALPHA);
		return newData;
	}
	
	public void add(int[][] a,int [][] b,int[][] c) {
		for (int i=0; i<a.length; i++) {
			for (int j = 0; j<a[i].length; j++) {
				c[i][j] = a[i][j] + b[i][j];
		    }
		}
	}
	
	public int[][] getNewRedData() {
		data = getNewDataByColor(BMPProcess.RED);
		this.setAlphas(data,ALPHA);
		return data;
	}
	
	public int[][] getNewGreenData() {
		data = getNewDataByColor(BMPProcess.GREEN);
		this.setAlphas(data,ALPHA);
		return data;
	}
	
	
	public int[][] getNewBlueData() {
		data = getNewDataByColor(BMPProcess.BLUE);
		this.setAlphas(data,ALPHA);
		return data;
	}
	
	final int ALPHA =  0XFF;
	public int[][] getNewDataByColor(final int TYPE) {
		int[][] newData = getSingleColorData(TYPE);
		newData = BMPProcess.getNewBMP(newData,TYPE);
		
		leftShift(newData,BMPProcess.SHIFT_MAP.get(TYPE));

		return newData;
	}
	
	public void leftShift(int[][] data, final int SHIFT) {
		for (int i=0; i<data.length; i++) {
			for (int j = 0; j<data[i].length; j++) {
				data[i][j] = (data[i][j] << SHIFT);
		    }
		}
	}

	
	
	public int[][] getShieldData(int shieldColor, int error) {
		int[][] data = getData();
		int[][] shieldData = new int[data.length][data[0].length];
			
		int replaceColor = getReplaceColor(shieldColor);
		
		for (int i=0; i<shieldData.length;i++) {
			for (int j=0; j<shieldData[i].length; j++) {
				shieldData[i][j] = isPickupedColor(data[i][j],shieldColor,error) ? replaceColor : data[i][j];
		    }
		}
		return shieldData;
	}
	
	public int getReplaceColor(int color) {
		int replaceColor = 0;
		replaceColor  = (color & 0XFF) +  
						((color & 0XFF00) >>> 8) +
						((color & 0XFF0000) >>> 16);
		replaceColor = replaceColor > 128 * 3 ? 0 : 0XFFFFFF;
		return replaceColor | 0XFF000000;
	}
	
	public int[][] getPickupData(int pickupColor, int error) {
		int[][] data = getData();
		int[][] pickupData = new int[data.length][data[0].length];
			
		int replaceColor = getReplaceColor(pickupColor);
		
		for (int i=0; i<pickupData.length;i++) {
			for (int j=0; j<pickupData[i].length; j++) {
				pickupData[i][j] = isPickupedColor(data[i][j],pickupColor,error) ? data[i][j] : replaceColor;
		    }
		}
		return pickupData;
	}
	
	public boolean isPickupedColor(int color,int pickupColor,int error) {
		boolean result = true;
		result 	= result && isInErea(color,pickupColor,error,0XFF0000); //判断红色
		result 	= result && isInErea(color,pickupColor,error,0XFF00); //判断绿色
		result 	= result && isInErea(color,pickupColor,error,0XFF);//判断蓝色
		
		return result;
	}
	
	public boolean isInErea(int x, int x0,int error,int cut) {
		
		return ((x0&cut) - (error&cut) <= (x&cut))  &&  ((x&cut) <= (x0&cut) + (error&cut));
	}
	
	public void print(int color, int pickupColor, int error) {
		print(color);
		System.out.print("IN");
		print(pickupColor);
		System.out.print("±");
		print(error);
		System.out.print(isPickupedColor(color,pickupColor,pickupColor) + " ");
	}
	
	public void print(int x) {
		System.out.print(Integer.toHexString(x));		
	}
	
	public long getFileSize() {
		return bmpFileHeader.getFileSize();
	}
	
	public long getImageSize(boolean isBMP) {
		
		if(isBMP) {
			return getImageSize();
		}
		
		return data.length * data[0].length;
		
	}
	public long getImageSize() {
		int width = bmpFileHeader.getWidth();
		int height = bmpFileHeader.getHeight();
		
		width = width / 4 * 4;
		return width * height;
	}
	
	public String getProperty() {
		int colorBit = bmpInfoHeader.getPixelBits();
		long fileLength = bmpFileHeader.getFileSize();
		
		int width = bmpFileHeader.getWidth();
		int height = bmpFileHeader.getHeight();
		
		String type = "文件类型 : " + colorBit + "位";
		String length = "文件大小" + (fileLength>>10) + "K";
		String imageSize = "图像大小[" + width + "×" + height + "]";
		
		return type + "\n" + length + "\n" + imageSize;
	}
	
	
	
	public int[][] getSmoothByEqual() {
		data = BMPProcess.getSmoothImageDataByEqual(this.data);
		this.setAlphas(data,ALPHA);
		return data;
	}
	
	public int[][] getSmoothByMiddle() {
		data = BMPProcess.getSmoothImageDataByMiddle(this.data);
		this.setAlphas(data,ALPHA);
		return data;
	}
	
	
	
	
	public static void main(String[] args) throws Exception {
	/*	String[] fileNames = {"8.bmp","24.bmp","32.bmp"};
		BMP bmp = new BMP(fileNames[0]);
		out.println(bmp.getProperty());
		final int SUM = 256;
		final long imageSize = bmp.getImageSize();
		int[][] data8bit = bmp.bmpData.getData8bit();
		int[]   histogram = BMPProcess.getHistogram(data8bit,SUM);
		float[] percent = BMPProcess.getPercent(histogram,imageSize);
		double entropy = BMPProcess.getEntropy(percent);
		

		
		Toolbox.println("data:");
		Toolbox.println(data8bit);
		Toolbox.println("percent:");
		Toolbox.println(percent);
		Toolbox.println("entropy = " + entropy);
		Toolbox.println("imageSize = " + imageSize);	
		*/
		
		
		BMP bmp = new BMP();
		int color 		= 0X80808000;
		int pickupColor = 0;
		int error 		= 0Xffffff00;
		Toolbox.println("" + color);
		Toolbox.println("" + pickupColor);
		Toolbox.println("" + error);
		Toolbox.println(""+bmp.isPickupedColor(color,pickupColor,error));
	}
	
	public static int[][] getEqu() {
		int[][] data = new int[16][16];
		for (int i=0; i<data.length; i++) {
			for (int j=0; j<data[i].length; j++) {
				data[i][j] = i * data[i].length + j;
			}
		}
		
		return data;
	}
}