BMP格式解析与保存 画图板的重绘

实现画图板重绘的两种方法
1.抽象Shape类 每次画的时候 都保存在ArrayList中 当窗体改变 自动调用paint方法时 取出ArrayList中保存的Shape对象

	public void paint(Graphics g) {
	    super.paint(g);// 将面板本身绘制在屏幕上
                      // 当面板发生改变的时候，
		//将ArrayList中保存的形状对象取出来，重新绘制
            for(int i=0;i<DrawListener.list.size();i++){
	    Shape shape = DrawListener.list.get(i);
		shape.draw(g);
		}
    }

2.截屏 每次释放的时候 用二维数组保存屏幕上的点

 // 释放一次，就重新保存一次
 	// 截屏
    Point point= drawJPanel.getLocationOnScreen();
   Dimension dim=drawJPanel.getPreferredSize();
   Rectangle screenrect=new Rectangle(point,dim);
   BufferedImage bufferedImg=robot.createScreenCapture(screenrect);
   // 根据面板大小调整数组大小
   array=new int[dim.height][dim.width];
    for(int i=0;i<array.length;i++){
 	for(int j=0;j<array[i].length;j++){
 	array[i][j]=bufferedImg.getRGB(j, i);
 	}
 }

先介绍一下有关BMP的基础知识：

BMP 是一种与硬件设备无关的图像文件格式，使用非常广。它采用位映射存储格式，除了图 像深度可选以外，不采用其他任何压缩，因此， BMP 文件所占用的空间很大。 BMP 文件的图 像深度可选 lbit 、 4bit 、 8bit 及 24bit 。 BMP 文件存储数据时，图像的扫描方式是按从左 到右、从下到上的顺序。由于 BMP 文件格式是 Windows 环境中交换与图有关的数据的一种标 准，因此在 Windows 环境中运行的图形图像软件都支持 BMP 图像格式。

要解析文件，就必须知道他的文件结构：

BMP 文件结构
典型的 BMP 图像文件由四部分组成：
1 . 位图文件 头数据结构 ，它包含 BMP 图像文件的类型、显示内容等信息；
2 .位图信息数据结构 ，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信息；
3. 调色板 ，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24 位 的 BMP ）就不需要调色板；
4. 位图数据 ，这部分的内容根据 BMP 位图使用的位数不同而不同，在 24 位图中直 接使用 RGB ，而其他的小于 24 位的使用调色板中颜色索引值。

对应的数据结构
① BMP 文件头 (14 字节 )
BMP 文件头数据结构含有 BMP 文件的类型、文件大小和位图起始位置等信息。其结构定 义如下:
int bfType; // 位图文件的类型，必须为 ' B '' M '两个字母 (0-1字节 )
int bfSize; // 位图文件的大小，以字节为单位 (2-5 字节 )
int usignedshort bfReserved1; // 位图文件保留字，必须为 0(6-7 字节 )
int usignedshort bfReserved2; // 位图文件保留字，必须为 0(8-9 字节 )
int bfOffBits; // 位图数据的起始位置，以相对于位图 (10-13 字节 )
int bfOffBits;// 文件头的偏移量表示，以字节为单位

② 位图信息头(40 字节 )
BMP 位图信息头数据用于说明位图的尺寸等信息。
int Size; // 本结构所占用字节数 (14-17 字节 )
int image_width; // 位图的宽度，以像素为单位 (18-21 字节 )
int image_heigh; // 位图的高度，以像素为单位 (22-25 字节 )

int Planes; // 目标设备的级别，必须为 1(26-27 字节 )
int biBitCount;// 每个像素所需的位数，必须是 1(双色),(28-29 字节) 4(16
色 ) ， 8(256 色 ) 或 24(// 真彩色 ) 之一
int biCompression; // 位图压缩类型，必须是 0( 不压缩 ),(30-33 字节 ) 1(BI_RLE8 压缩类型 ) 或// 2(BI_RLE4 压缩类型 ) 之一
int SizeImage; // 位图的大小，以字节为单位 (34-37 字节 )
int biXPelsPerMeter; // 位图水平分辨率，每米像素数 (38-41 字节 ) int biYPelsPerMeter; // 位图垂直分辨率，每米像素数 (42-45 字节 ) int biClrUsed;// 位图实际使用的颜色表中的颜色数 (46-49 字节 )
int biClrImportant;// 位图显示过程中重要的颜色数 (50-53 字节 )


③ 颜色表
颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个 RGBQUAD 类型的结 构，定义一种颜色。
class RGBQUAD {
byte rgbBlue;// 蓝色的亮度 ( 值范围为 0-255)
byte rgbGreen; // 绿色的亮度 ( 值范围为 0-255)
byte rgbRed; // 红色的亮度 ( 值范围为 0-255)
byte rgbReserved;// 保留，必须为 0
}
颜色表中 RGBQUAD 结构数据的个数有 biBitCount 来确定。当 biBitCount=1,4,8 时，分别有 2,16,256 个表项 ; 当 biBitCount=24 时，没有颜色表项。 位图信息头和颜色表组成位图信息，BITMAPINFO 结构定义如下 :
class BITMAPINFO {
BITMAPINFOHEADER bmiHeader; // 位图信息头
RGBQUAD bmiColors[1]; // 颜色表
}

④ 位图数据
位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右,扫描行之间是从 下到上。位图的一个像素值所占的字节数:
当 biBitCount=1 时， 8 个像素占 1 个字节 ; 当 biBitCount=4 时， 2 个像素占 1 个字节 ; 当 biBitCount=8 时， 1 个像素占 1 个字节 ; 当 biBitCount=24 时 ,1 个像素占 3 个字节 ;
Windows 规定一个扫描行所占的字节数必须是 4 的倍数 ( 即以 long 为单位 ), 不足的以 0填充


简单来说 文件格式保存 就是 怎么写进去 就怎么读出来 但是其中转换格式还是很麻烦的
通过网上查资料 BMP解析可以有两种方式实现 其实方法差不多 原理都一样

方法一：

package BMP_Color;

import java.awt.Color;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class BMPWrite24 {


	Color [][] color;
	int width,height;
	String path;
	public BMPWrite24(Color [][] color,String path){
		this.color=color;
		this.height=color.length;
		this.width=color[0].length;
		this.path=path;
		this.write();
	}
	public void write(){
		try {
	FileOutputStream fos=new FileOutputStream(path);
	DataOutputStream dos=new DataOutputStream(fos);


         int bfSize=54+width*height*3+(4 - width * 3 % 4) * height;
         int bfReserved1=0;
	int bfReserved2=0;
	int bfOffBits=54;

	dos.write('B');
	dos.write('M');
	dos.write(ChangeByte(bfSize),0,4);
	dos.write(ChangeByte(bfReserved1),0,2);
	dos.write(ChangeByte(bfReserved2),0,2);
	dos.write(ChangeByte(bfOffBits),0,4);


	int size=40;
	int image_width=width;
	int image_height=height;
	int Planes=1;
	int biBitCount=24;
	int biCompression=0;
	int SizeImage=width*height;
	int biXPelsPerMeter=0;
	int biYPelsPerMeter=0;
	int biClrUsed=0;
	int biClrImportant=0;

	// 因为java是大端存储，那么也就是说同样会大端输出。
	// 但计算机是按小端读取，如果我们不改变多字节数据的顺序的话，那么机器就不能正常读取。
	// 所以首先调用方法将int数据转变为多个byte数据，并且按小端存储的顺序。

	dos.write(ChangeByte(size),0,4);
	dos.write(ChangeByte(image_width),0,4);
	dos.write(ChangeByte(image_height),0,4);
	dos.write(ChangeByte(Planes),0,2);
         dos.write(ChangeByte(biBitCount),0,2);
         dos.write(ChangeByte(biCompression),0,4);
         dos.write(ChangeByte(SizeImage),0,4);
         dos.write(ChangeByte(biXPelsPerMeter),0,4);
         dos.write(ChangeByte(biYPelsPerMeter),0,4); 
         dos.write(ChangeByte(biClrUsed),0,4);
         dos.write(ChangeByte(biClrImportant),0,4);

          int skip=0;
            if(!(width*3%4==0)){
            	skip=4-width*3%4;
            }

           // 因为是24位图，所以没有颜色表
	  // 通过遍历输入位图数据
	  // 这里遍历的时候注意，在计算机内存中位图数据是从左到右，从下到上来保存的，
	 // 也就是说实际图像的第一行的点在内存是最后一行
            for(int i=height-1;i>=0;i--){
            	for(int j=0;j<width;j++){

            	int red=color[i][j].getRed();
            	int green=color[i][j].getGreen();
            	int blue=color[i][j].getBlue();

            	byte[] r=ChangeByte(red);
            	byte[] g=ChangeByte(green);
            	byte[] b=ChangeByte(blue);
            	dos.write(b,0,1);
            	dos.write(g,0,1);
                  dos.write(r,0,1);  

        		for (int k = 0; k < skip; k++) {
    		   dos.write(0);
    			}
            	}

            }
            dos.flush();
			dos.close();
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public byte[]  ChangeByte(int data){
		byte b4=(byte)((data)>>24);
		byte b3=(byte)(((data)<<8)>>24);
		byte b2=(byte)(((data)<<16)>>24);
		byte b1=(byte)(((data)<<24)>>24);
		byte [] b={b1,b2,b3,b4};
		return b;
	}

}

package BMP_Color;

import java.awt.Color;
import java.io.DataInputStream;
import java.io.FileInputStream;

import javax.swing.JOptionPane;

public class  BMPReader24{
    MyPanel panel;
    String path;
    int [][] red,green,blue;
   public BMPReader24(MyPanel panel,String  path){
	this.panel=panel;
	this.path=path;
	this.reader();
    }
	public void reader(){
     try {
	FileInputStream fis=new FileInputStream(path);
	DataInputStream dis=new DataInputStream(fis);

	int biLen=14;
	byte[] bi=new byte[biLen];
	dis.read(bi, 0, biLen);

	int bfLen=40;
	byte[] bf=new byte[bfLen];
	dis.read(bf, 0, bfLen);

	int width=ChangeInt(bf, 7);
	int height=ChangeInt(bf, 11);

	red=new int [height][width];
	green=new int[height][width];
	blue=new int[height][width];


	// 通过计算得到每行计算机需要填充的字符数。
	// 为什么要填充？这是因为windows系统在扫描数据的时候，每行都是按照4个字节的倍数来读取的。
	// 因为图片是由每个像素点组成。而每个像素点都是由3个颜色分量来构成的，而每个分量占据1个字节。
	// 因此在内存存储中实际图片数据每行的长度是width*3。
	int skip=0;
	if(!(width*3%4==0)){
	           skip=4-width*3%4;
	      }
	for(int i=height-1;i>=0;i--){
	   for(int j=0;j<width;j++){

	     blue[i][j]=dis.read();
	     green[i][j]=dis.read();
	     red[i][j]=dis.read();

        DrawListener.color[i][j]=new Color(red[i][j],green[i][j],blue[i][j]);
	 if(j==0){
	           dis.skipBytes(skip);
	        }
           }
         }
	 panel.repaint();
	} catch (Exception e) {
	JOptionPane.showMessageDialog(null, "文件打开失败！！");
	e.printStackTrace();
	}
   }
	public int ChangeInt(byte[] array2, int start) {
// 因为char,byte,short这些数据类型经过运算符后会自动转为成int数据类，
// 所以array2[start]&0xff的实际意思就是通过&0xff将字符数据转化为正int数据，然后在进行位运算。
// 这里需要注意的是<<的优先级别比&高，所以必须加上括号。

        int i = (int) ((array2[start] & 0xff) << 24)
		| ((array2[start - 1] & 0xff) << 16)
		| ((array2[start - 2] & 0xff) << 8)
		| (array2[start - 3] & 0xff);
		return i;
	}

}

方法二：

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.swing.JFileChooser;
import javax.swing.JOptionPane;

/**
 * 菜单处理监听器
 * 
 * @author kowloon
 * 
 */
public class MenuListener implements ActionListener {

	private MyPanel panel;

	public MenuListener(MyPanel panel) {
		this.panel = panel;
	}
	// bmp文件头
	public void savebmpTop(OutputStream ops) throws Exception {
		ops.write('B');
		ops.write('M');
	    int height = DrawListener.array.length;
	    int width = DrawListener.array[0].length;
             int size = 14 + 40 + height * width * 3 + (4 - width * 3 % 4) * height;
		// 位图文件的大小
		size = 14 + 40 + height * width * 3 + (4 - width * 3 % 4) * 255;
		writeInt(ops, size);
		// 保留字节，必须为零
		writeShort(ops, (short) 0);
		writeShort(ops, (short) 0);
		// 位图偏移量
		writeInt(ops, 54);
	}

	// 位图信息头
	public void savebmpInfo(OutputStream ops) throws Exception {
		int height = DrawListener.array.length;
		int width = DrawListener.array[0].length;

		// 位图信息头长度
		writeInt(ops, 40);
		// 位图宽
		writeInt(ops, width);
		// 位图高
		writeInt(ops, height);
		// 位图位面数总是为1
		writeShort(ops, (short) 1);
		// 位图24位像素
		writeShort(ops, (short) 24);
		// 位图是否被压缩，0为不压缩
		writeInt(ops, 0);
		// 字节数代表位图大小
		writeInt(ops, height * width * 3 + (4 - width * 3 % 4) * height);
		// 水平分辨率
		writeInt(ops, 0);
		// 垂直分辨率
		writeInt(ops, 0);
		// 颜色索引，0为所有调色板
		writeInt(ops, 0);
		// 对图象显示有重要影响的颜色索引的数目。如果是0，表示都重要
		writeInt(ops, 0);
	}

	// 图像数据阵列
	public void savebmpDate(OutputStream ops) throws Exception {
		int height = DrawListener.array.length;
		int width = DrawListener.array[0].length;

		int m = 0;
		// 进行补0
		if (width * 3 % 4 > 0) {
			m = 4 - width * 3 % 4;
		}
		for (int i = height - 1; i >= 0; i--) {
			for (int j = 0; j < width; j++) {
				int t = DrawListener.array[i][j];
				writeColor(ops, t);
			}
			for (int k = 0; k < m; k++) {
				ops.write(0);
			}
		}
	}

	public void writeInt(OutputStream ops, int t) throws Exception {
		int a = (t >> 24) & 0xff;
		int b = (t >> 16) & 0xff;
		int c = (t >> 8) & 0xff;
		int d = t & 0xff;
		ops.write(d);
		ops.write(c);
		ops.write(b);
		ops.write(a);
		//System.out.println(d+" <>"+c+"<>"+b+"<>"+a);
	}

	public void writeColor(OutputStream ops, int t) throws Exception {
		int b = (t >> 16) & 0xff;
		int c = (t >> 8) & 0xff;
		int d = t & 0xff;
		ops.write(d);
		ops.write(c);
		ops.write(b);
	}

	public void writeShort(OutputStream ops, short t) throws Exception {
		int c = (t >> 8) & 0xff;
		int d = t & 0xff;
		ops.write(d);
		ops.write(c);
	}

	// 由于读取的是字节，把读取到的4个byte转化成1个int
	public int changeInt(InputStream ips) throws IOException {
		int t1 = ips.read() & 0xff;
		int t2 = ips.read() & 0xff;
		int t3 = ips.read() & 0xff;
		int t4 = ips.read() & 0xff;
		int num = (t4 << 24) + (t3 << 16) + (t2 << 8) + t1;
		System.out.println(num);
		return num;
	}

	// 24位的图片是1个像素3个字节。
	public int readColor(InputStream ips) throws IOException {
		int b = ips.read() & 0xff;
		int g = ips.read() & 0xff;
		int r = ips.read() & 0xff;
		int c = (r << 16) + (g << 8) + b;
		return c;
	}

	public void actionPerformed(ActionEvent e) {
		// 获得被点击的组件的动作命令
		String command = e.getActionCommand();
		JFileChooser chooser = new JFileChooser();
	if (command.equals("保存")) {
		int t = chooser.showSaveDialog(null);
	         if (t == JFileChooser.APPROVE_OPTION) {
		String path = chooser.getSelectedFile().getAbsolutePath();
		try {
	  FileOutputStream fos = new FileOutputStream(path);
	  DataOutputStream dos = new DataOutputStream(fos);

		savebmpTop(dos);
		savebmpInfo(dos);
		savebmpDate(dos);
		fos.flush();
		fos.close();

     } catch (Exception ef) {
					JOptionPane.showMessageDialog(null, "文件保存失败！！");
	ef.printStackTrace();
	}
      }
} else if (command.equals("打开")) {

		int t = chooser.showOpenDialog(null);
		if (t == JFileChooser.APPROVE_OPTION) {
		String path = chooser.getSelectedFile().getAbsolutePath();
	try {
		FileInputStream fis = new FileInputStream(path);
		DataInputStream dis = new DataInputStream(fis);

	dis.skip(18);
	int width = changeInt(dis);// 跳过不需要的，读取宽度和高度
	int height = changeInt(dis);
	dis.skip(28);
	// 跳过，直接读取位图数据。
	DrawListener.array = new int[height][width];
	int w = 0;
	 if (width * 3 % 4 > 0) {
	   t = 4 - width * 3 % 4;
		}
		for (int i = height - 1; i >= 0; i--) {
			for (int j = 0; j < width; j++) {
		 // 调用自定义方法，得到图片的像素点并保存到int数组中
	int c = readColor(dis);
							DrawListener.array[i][j] = c;
		}
	dis.skip(w);
	}
	fis.close();
	// 刷新界面
	panel.repaint();
	} catch (Exception ef) {
					JOptionPane.showMessageDialog(null, "文件打开失败！！");
	ef.printStackTrace();
	}
    }
  }
 }
}

比较两个方法 ：
方法一比较麻烦 再定义一个Color[][]数组 保存屏幕上的点的颜色 BMP格式保存时
color[i][j].getRed()getGreen()getBlue()方法获取屏幕点的颜色分量
方法二 直接利用重绘时定义int[][]数组 32位 后24位是红绿蓝颜色分量

public void writeColor(OutputStream ops, int t) throws Exception {
		int b = (t >> 16) & 0xff;
		int c = (t >> 8) & 0xff;
		int d = t & 0xff;
		ops.write(d);
		ops.write(c);
		ops.write(b);
	}

1.byte转成int为何要&0xff?
第一，oxff默认为整形，二进制位最低8位是1111 1111，前面24位都是0；

第二，&运算: 如果2个bit都是1，则得1，否则得0；

第三，byte的8位和0xff进行&运算后，最低8位中，原来为1的还是1，原来为0的还是0，而0xff其他位都是0，所以&后仍然得0

2.writeInt 方法中传入int值 写出4个int值 依旧是4个字节
因为 write(int a) 是把a转换为byte 而不是byte[] a的高24位将被忽略 只有低8位转成byte写入流