bmpprocess.java

用java实现的对位图文件读取的源程序代码。

import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;


public class BMPProcess {
	final public static int GRAY = 256;
	
	final public static int RED 	= 0;
	final public static int GREEN 	= 1;
	final public static int BLUE 	= 2;
	final public static int ALPHA 	= 3;
	final public static int RGB 	= 4;
	
	final public static int SOBEL_X = 10;
	final public static int SOBEL_Y = 11;
	
	final public static int PREWITT_X = 20;
	final public static int PREWITT_Y = 21;
	
	final public static int D_X = 30;
	final public static int D_Y = 31;
	
	final public static int MY_0 = 40;
	final public static int MY_1 = 41;
	final public static int MY_2 = 42;
	final public static int MY_3 = 43;
	final public static int MY_4 = 44;
	
	

	final static int[][] SOBEL_PATTERN_X = new int[][] 	{	
											{1, 0, -1},
											{2, 0, -2},
											{1, 0, -1},										
										  				};
	
	final static int[][] SOBEL_PATTERN_Y = new int[][] {	
											{-1, -2, -1},
											{0, 0, 0},
											{1, 2, 1},										
										  };
										  
	final static int[][] PREWITT_PATTERN_X = new int[][] 	{	
											{1, 1, -1},
											{1, 0, -1},
											{1, 1, -1},										
										  				};
	
	final static int[][] PREWITT_PATTERN_Y = new int[][] {	
											{1, 1, 1},
											{0, 0, 0},
											{-1, -1, -1},										
										  };
	
	final static int[][] MY_PATTERN_0 = new int[][] {	
											{1, 1, -1},
											{1, 0, -1},
											{1, -1, -1},										
										  };
	
	final static int[][] MY_PATTERN_1 = new int[][] {	
											{1, -1, -1},
											{1, 0, -1},
											{1, 1, -1},										
										  };
	
	final static int[][] MY_PATTERN_2 = new int[][] {	
											{-1, -1, -1},
											{-1, 0, 1},
											{1, 1, 1},										
										  };
										  
	final static int[][] MY_PATTERN_3 = new int[][] {	
											{-1, 1, 1},
											{-1, 0, 1},
											{-1, -1, 1},										
										  };
	final static int[][] MY_PATTERN_4 = new int[][] {	
											{-1, 1, -1},
											{1, 0, 1},
											{-1, 1, -1},										
										  };
	
	
	final public static Map<Integer,int[][]> PATTERN_MAP = new HashMap<Integer,int[][]>(3);
	static {
		PATTERN_MAP.put(SOBEL_X,SOBEL_PATTERN_X);
		PATTERN_MAP.put(SOBEL_Y,SOBEL_PATTERN_Y);
		
		PATTERN_MAP.put(PREWITT_X,PREWITT_PATTERN_X);
		PATTERN_MAP.put(PREWITT_Y,PREWITT_PATTERN_Y);
		
	//	PATTERN_MAP.put(D_X,8);
	//	PATTERN_MAP.put(D_Y,0);
		
		PATTERN_MAP.put(MY_0,MY_PATTERN_0);
		PATTERN_MAP.put(MY_1,MY_PATTERN_1);
		PATTERN_MAP.put(MY_2,MY_PATTERN_2);
		PATTERN_MAP.put(MY_3,MY_PATTERN_3);
		PATTERN_MAP.put(MY_4,MY_PATTERN_4);
	}
										  
	final public static Map<Integer,Integer> SHIFT_MAP = new HashMap<Integer,Integer>(3);
	static {
		SHIFT_MAP.put(RED,16);
		SHIFT_MAP.put(GREEN,8);
		SHIFT_MAP.put(BLUE,0);
	}
	
	final public static Map<Integer,Integer> PART_MAP = new HashMap<Integer,Integer>(3);
	static {
		PART_MAP.put(RED,	0XFF0000);
		PART_MAP.put(GREEN,	0XFF00);
		PART_MAP.put(BLUE,	0XFF);
		PART_MAP.put(ALPHA,	0XFF000000);
		PART_MAP.put(RGB,	0XFFFFFF);
	}
	
	final public static Map<Integer,Integer> COLOR_PICKUP_MAP = new HashMap<Integer,Integer>(3);
	static {
		COLOR_PICKUP_MAP.put(RED,0XFF0000);
		COLOR_PICKUP_MAP.put(GREEN,0XFF00);
		COLOR_PICKUP_MAP.put(BLUE,0XFF);
	}
	
	
	//获取八位的直方图
	public static int[] getHistogram2(int[][] data) {
		int[] histogram = new int[GRAY];
		for (int i=0; i<histogram.length; i++) {
			histogram[i] = 0;
		}
		final int width = data.length / 4 * 4;
		for (int i=0; i<width; i++) {
			for (int j=0; j<data[i].length; j++) {
				histogram[data[i][j]]++;
			}
		}
		
		return histogram;
	}
	
	//获取任意的直方图
	public static int[] getHistogram(int[][] data,final int TYPE) {
		int[] histogram = new int[GRAY];

		int shift = SHIFT_MAP.get(TYPE);
		final int width = data.length / 4 * 4;
		for (int i=0; i<width; i++) {
			for (int j=0; j<data[i].length; j++) {
				histogram[(data[i][j] >>> shift) & 0xff]++;
			}
		}
		
		return histogram;
	}
	
	public static int getMaxRateColor(int[][] data,final int GRAY) {
		int[] histogram = getHistogram(data,GRAY);
		int maxRateColor = 0;
		for (int i=0; i<histogram.length; i++) {
			if (maxRateColor < histogram[i]) {
				maxRateColor = i;
			}
		}
		return maxRateColor;
	}
	
	public static double getEntropy(float[] percent) {
		double entropy = 0.0;
		
		for (int i=0; i<percent.length; i++) {
			if (percent[i] < 1E-6) {
				continue;
			}
			entropy +=  -percent[i] * Math.log(percent[i]) / Math.log(2);
		}
		return entropy;
	}
	
	public static float[] getPercent(int[] histogram,final long SUM) {
		float[] percent = new float[histogram.length];
		
		for (int i=0; i<percent.length; i++) {
			percent[i] = (float)(1.0 * histogram[i] / SUM);
		}
		return percent;
	}
	
	public static float[] getSumPercent(float[] percent) {
		float[] sumPercent = new float[percent.length];
		float sum = 0;
		for (int i=0; i<sumPercent.length; i++) {
			sum += percent[i];
			sumPercent[i] = sum;
		}
		return sumPercent;
	}
	
	
	public static int[][] getNewBMP(int[][] data,final int TYPE) {
		final int SUM = data.length * data[0].length;
		//int[][] newData = new int[data.length][data[0].length];
		int[] histogram = getHistogram(data,TYPE);
		float[] percent = getPercent(histogram,SUM);
		float[] sumPercent = getSumPercent(percent);
		final int SHIFT = SHIFT_MAP.get(TYPE);
		for (int i=0; i<data.length; i++) {
			for (int j = 0; j<data[i].length; j++) {
				
				data[i][j] = (int)(sumPercent[data[i][j]>>>SHIFT] * 255);
		    }
		}
		return data;
	}
	
	
	public static int[][] pickup(int[][] data, final int PART) {
		for (int i = 0; i<data.length; i++) {
			for (int j = 0; j<data[i].length; j++) {
				data[i][j] = data[i][j] & PART_MAP.get(PART);
		    }
	    }
	   	return data;
	}
	
	public static int[][] getAcuteImageData(int[][] data,final int TYPE) {
		pickup(data,RGB);
		int[][] pattern = PATTERN_MAP.get(TYPE);
		return patternProcess(data,pattern);
	}
	
	public static int[][] getSmoothImageDataByEqual(int[][] data) {
		int sumR = 0;
		int sumG = 0;
		int sumB = 0;
		
		for (int i = 1; i<data.length-1; i++) {
			for (int j = 1; j<data[i].length-1; j++) {
				
				sumR = 0;
				sumG = 0;
				sumB = 0;
		
				for (int p1 = -1; p1<2; p1++) {
					for (int p2 = -1; p2<2; p2++) {
						
						sumR += data[i+p1][j+p2] & PART_MAP.get(RED);
						sumG += data[i+p1][j+p2] & PART_MAP.get(GREEN);
						sumB += data[i+p1][j+p2] & PART_MAP.get(BLUE);
				    }
			    }
			    sumR = (sumR/9) & PART_MAP.get(RED);
			    sumG = (sumG/9) & PART_MAP.get(GREEN);
			    sumB = (sumB/9) & PART_MAP.get(BLUE);
			    
			    data[i][j] = sumR + sumG + sumB;
		    }
	    }
		return data;
	}
	
	public static int[][] getSmoothImageDataByMiddle(int[][] data) {
		int[] array = new int[9];
		int index = 0;
		for (int i = 1; i<data.length-1; i++) {
			for (int j = 1; j<data[i].length-1; j++) {
				index = 0;
				for (int p1 = -1; p1<2; p1++) {
					for (int p2 = -1; p2<2; p2++) {
						array[index++] = data[i+p1][j+p2];
				    }
			    }
			    Arrays.sort(array);
			    data[i][j] = array[4];
		    }
	    }
		return data;
	}
	
	public static int[][] patternProcess(int[][] data, int[][] pattern) {
		int[][] newData = new int[data.length][data[0].length];
		
		final int FLOW =  pattern.length;
		
		int sumR = 0;
		int sumG = 0;
		int sumB = 0;
		
		for (int i1 = 0; i1<data.length-FLOW; i1++) {
			for (int i2 = 0; i2<data[i1].length-FLOW; i2++) {
				sumR = 0;
				sumG = 0;
				sumB = 0;
				for (int i3 = 0; i3<pattern.length; i3++) {
					for (int i4 = 0; i4<pattern[i3].length; i4++) {
						sumR += (data[i1+i3][i2+i4] & PART_MAP.get(RED)) * pattern[i3][i4];
						sumG += (data[i1+i3][i2+i4] & PART_MAP.get(GREEN)) * pattern[i3][i4];
						sumB += (data[i1+i3][i2+i4] & PART_MAP.get(BLUE)) * pattern[i3][i4];
				   
						
				    }
			    }
			    
			    sumR = Math.abs(sumR) & PART_MAP.get(RED);
			    sumG = Math.abs(sumG) & PART_MAP.get(GREEN);
			    sumB = Math.abs(sumB) & PART_MAP.get(BLUE);
			    
				newData[i1+1][i2+1] = sumR + sumG + sumB;
		    }
	    }
	    
	    data = null;
	    data = newData;
	    return data;
	}
	
}