关于Java读取和编写BMP文件的总结

关于Java读取和编写BMP文件的总结

 

BMP到底是何方神圣？ 

    BMP文件格式，又称为Bitmap（位图）或是DIB(Device-Independent Device， 设备无关位图)，是Windows系统中广泛使用的图像文件格式。由于它可以不作任何变换  地保存图像像素域的数据，因此成为我们取得RAW数据的重要来源。Windows的图形用户界面（graphical user interfaces）也在它的内建图像子系统GDI中对BMP格式提供了支持。

 

那么BMP的格式到底什么？

BMP文件的数据按照从文件头开始的先后顺序分为四个部分：

Ø         bmp文件头(bmp file header)：提供文件的格式、大小等信息

Ø         位图信息头(bitmap information)：提供图像数据的尺寸、位平面数、压   缩方式、颜色索引等信息

Ø         调色板(color palette)：可选，如使用索引来表示图像，调色板就是索引 与其对应的颜色的映射表

Ø         位图数据(bitmap data)：就是图像数据啦^_^

 

 

 

下面结合Windows结构体的定义，通过一个表来分析这四个部分。
    

 

我们一般见到的图像以24位图像为主，即R、G、B三种颜色各用8个bit来表示，这样的图像我们称为真彩色，这种情况下是不需要调色板的，也就是所位图信息头后面紧跟的就是位图数据了。因此，我们常常见到有这样一种说法：位图文件从文件头开始偏移54个字节就是位图数据了，这其实说的是24或32位图的情况。这也就解释了我们按照这种程序写出来的程序为什么对某些位图文件没用了。

    下面针对一幅特定的图像进行分析，来看看在位图文件中这四个数据段的排布以及组成。

   我们使用的图像显示如下：

 

 

 

 

 

int biSize // 信息头所需的字节数（14-17字节）

 

int biWidth // 位图的宽（18-21字节）

 

int biHeight // 位图的高（22-25字节）

 

int biPlanes // 目标设备的级别，必须是1（26-27字节）

 

int  biBitcount // 每个像素所需的位数（28-29字节），必须是1位（双色）、4位（16色）、8位（256色）或者24位（真彩色）之一。

 

int biCompression // 位图压缩类型，必须是0（不压缩）（30-33字节）、1（BI_RLEB压缩类型）或2（BI_RLE4压缩类型）之一。

 

int biSizeImage // 实际位图图像的大小，即整个实际绘制的图像大小（34-37字节）

 

int biXPelsPerMeter // 位图水平分辨率，每米像素数（38-41字节）这个数是系统默认值

 

int biYPelsPerMeter // 位图垂直分辨率，每米像素数（42-45字节）这个数是系统默认值

 

int biClrUsed // 位图实际使用的颜色表中的颜色数（46-49字节），如果为0的话，说明全部使用了

 

int biClrImportant // 位图显示过程中重要的颜色数(50-53字节)，如果为0的话，说明全部重要

 

咱们再根据解析图来重点说明下biSize、biHeight、biBitCount。  

<!--EndFragment-->

<!--EndFragment-->

 

根据上面我列出的信息可知， 

在信息头的第一个信息就是biSize，即这个信息头所占的总共的字节空间为40个。

那么我们再结合上面所说的文件头的总字节空间为14个，那么我们相加一下是不是就是54呢！那么偏移量bfOffBits 就是54咯！不过你可能就会问了，为什么这样就是54了？怎么来的？是不是所有的bmp文件的偏移量bfOffBits 都是54呢？呵呵，不是的，不是所有的bmp文件的偏移量bfOffBits 都是54，对于24位的位图来说是的，对于其他的bmp文件就不一定了！这个偏移量很重要，大家在读取和编写的时候一定要注意它的准确性。

咱们再返回上面biSize，根据前面文件头是占14个字节，那么biSize的地址就是第14-17字节，那么对应上图，那么也就是28 00 00 00.而根据我们上面所说的机器的存储是小端存储，所以正确的读数是00 00 00 28。

而在读写后面的位图数据的时候，一定要注意，这个height到底是正数还是负数。如果是正数，那么位图数据读写的时候顺序就是从左到右，从下到上。否则就是从左到右，从上到下。因为我们这个图中height是正数，所以下面讨论位图数据的时候，就按照从左到右，从下到上的顺序来描述了。

咱们看完了bmp文件的第二块信息头，接下来的第三块颜色表就要根据第二块信息头来了，什么意思？因为如果bmp文件是24位或者32位的图像，那么就没有颜色表这一块，只有当位数少于24位的时候，才需要考虑这一块。

  三.颜色表 
  颜色表其实是一张映射表，标识颜色索引号与其代表的颜色的对应关系。它在文件中的布局就像一个二维数组palette[N][4],其中N表示总的颜色索引数，每行的四个元素分别表示该索引对应的B、G、R和Alpha的值，每个分量占一个字节。如不设透明通道时，Alpha为0。具体的信息，大家可以google或者度娘一下。

 

   四.位图数据 

   好了，接下来就是我们最重要的一块了，写入或者读取bmp文件的实际数据了，也就是我们画的图像的每个像素。我们知道一个像素由三个int值来构成，即RGB，红色分量，绿色分量，蓝色分量。而一个像素在在内存中是占三个字节的，即每个分量占据一个字节。那么我们就需要得到每个像素的分量，然后按小端存储的方式按BGR顺序存入内存中。是否这样就可以了？No,No,No。不是的，因为我们必须还要注意Windows默认的扫描的最小单位是4字节，如果数据对齐满足这个值的话对于数据的获取速度等都是有很大的增益的。因此，BMP图像顺应了这个要求，要求每行的数据的长度必须是4的倍数，如果不够需要进行比特填充（以0填充），这样可以达到按行的快速存取。这时，位图数据区的大小就未必是 图片宽×每像素字节数×图片高能表示的了，因为每行可能还需要进行比特填充。具体的实现在我下面的代码中：

 BMP的读取：

 

 

 

Java代码  

1. package pcm24;  
2.   
3. import java.awt.Color;  
4. import java.awt.Graphics;  
5. import java.io.IOException;  
6.   
7. /** 
8.  *  
9.  * 类说明： 
10.  *  
11.  * @author 彭晨明 E-mail:[e-mail] 
12.  *  
13.  * @version 创建时间：2012-2-3下午8:48:27 
14.  *  
15.  */  
16. public class BmpRead24 extends javax.swing.JFrame {  
17.     /** 
18.      *  
19.      */  
20.     private static final long serialVersionUID = 1L;  
21.   
22.     /** 
23.      * 位图的宽 
24.      */  
25.     private static int width;  
26.   
27.     /** 
28.      * 位图的高 
29.      */  
30.     private static int height;  
31.   
32.     /** 
33.      * 位图数据数组,即一个像素的三个分量的数据数组 
34.      */  
35.     private static int[][] red, green, blue;  
36.   
37.     Graphics g;  
38.   
39.     public static void main(String args[]) {  
40.         BmpRead24 bmp = new BmpRead24();  
41.         bmp.init();  
42.     }  
43.   
44.     public void init() {  
45.         try {  
46.             // 通过bmp文件地址创建文件输入流对象  
47.             java.io.FileInputStream fin = new java.io.FileInputStream(  
48.                     "C:\\Documents and Settings\\专属于我\\桌面\\未命名1.bmp");  
49.   
50.             // 根据文件输入流对象创建原始数据输入对象  
51.             // 这里既可以用原始数据输入流来读取数据，也可以用缓冲输入流来读取，后者速度相比较快点。  
52. //          java.io.DataInputStream bis = new java.io.DataInputStream(fin);  
53.   
54.             java.io.BufferedInputStream bis = new java.io.BufferedInputStream(  
55.                     fin);  
56.   
57.             // 建立两个字节数组来得到文件头和信息头的数据  
58.             byte[] array1 = new byte[14];  
59.             bis.read(array1, 0, 14);  
60.   
61.             byte[] array2 = new byte[40];  
62.             bis.read(array2, 0, 40);  
63.   
64.             // 翻译bmp文件的数据，即将字节数据转化为int数据  
65.             // 通过翻译得到位图数据的宽和高  
66.             width = ChangeInt(array2, 7);  
67.             height = ChangeInt(array2, 11);  
68.   
69.             // 调用可以将整个位图数据读取成byte数组的方法  
70.             getInf(bis);  
71.   
72.             fin.close();  
73.             bis.close();  
74.   
75.             // 创建BMP对象来显示图画  
76.             showUI();  
77.         } catch (Exception e) {  
78.             e.printStackTrace();  
79.         }  
80.     }  
81.   
82.     /** 
83.      * 实现可将四个字节翻译int数据的方法 
84.      *  
85.      * @param array2 
86.      *            存储字节的字节数组 
87.      * @param start 
88.      *            起始字节 
89.      * @return 返回翻译后的int数据 
90.      */  
91.     public int ChangeInt(byte[] array2, int start) {  
92.         // 因为char,byte,short这些数据类型经过运算符后会自动转为成int数据类，  
93.         // 所以array2[start]&0xff的实际意思就是通过&0xff将字符数据转化为正int数据，然后在进行位运算。  
94.         // 这里需要注意的是<<的优先级别比&高，所以必须加上括号。  
95.   
96.         int i = (int) ((array2[start] & 0xff) << 24)  
97.                 | ((array2[start - 1] & 0xff) << 16)  
98.                 | ((array2[start - 2] & 0xff) << 8)  
99.                 | (array2[start - 3] & 0xff);  
100.         return i;  
101.     }  
102.   
103.     /** 
104.      * 得到位图数据的int数组 
105.      *  
106.      * @param dis 
107.      *            数据输入流对象 
108.      */  
109.     public void getInf(java.io.BufferedInputStream bis) {  
110.         // 给数组开辟空间  
111.         red = new int[height][width];  
112.         green = new int[height][width];  
113.         blue = new int[height][width];  
114.   
115.         // 通过计算得到每行计算机需要填充的字符数。  
116.         // 为什么要填充？这是因为windows系统在扫描数据的时候，每行都是按照4个字节的倍数来读取的。  
117.         // 因为图片是由每个像素点组成。而每个像素点都是由3个颜色分量来构成的，而每个分量占据1个字节。  
118.         // 因此在内存存储中实际图片数据每行的长度是width*3。  
119.         int skip_width = 0;  
120.         int m = width * 3 % 4;  
121.         if (m != 0) {  
122.             skip_width = 4 - m;  
123.         }  
124.   
125.         // 通过遍历给数组填值  
126.         // 这里需要注意，因为根据bmp的保存格式。  
127.         // 位图数据中height的值如果是正数的话:  
128.         // 那么数据就是按从下到上，从左到右的顺序来保存。这个称之为倒向位图。  
129.         // 反之就是按从上到下，从左到右的顺序来保存。这个则称之为正向位图。  
130.         for (int i = height - 1; i >= 0; i--) {  
131.             for (int j = 0; j < width; j++) {  
132.                 try {  
133.                     // 这里遍历的时候，一定要注意本来像素是有RGB来表示，  
134.                     // 但是在存储的时候由于windows是小段存储，所以在内存中是BGR顺序。  
135.                     blue[i][j] = bis.read();  
136.                     green[i][j] = bis.read();  
137.                     red[i][j] = bis.read();  
138.   
139.                     // 这里一定要知道，其实系统在给位图数据中添加填充0的时候，都是加在每行的最后。  
140.                     // 但是我们在使用dis.skipBytes（）这个方法的时候，却不一定要在最后一列。  
141.                     // 系统在填充数据的时候，在数据上加了标记。  
142.                     // 所以dis.skipBytes（）这个方法只要调用了，那么系统就会自动不读取填充数据。  
143.                     if (j == 0) {  
144.                         bis.skip(skip_width);  
145.                     }  
146.                 } catch (IOException e) {  
147.                     e.printStackTrace();  
148.                 }  
149.             }  
150.         }  
151.     }  
152.   
153.     public void showUI() {  
154.         // 对窗体的属性进行设置  
155.         this.setTitle("BMP解析");//设置标题  
156.         this.setSize(width, height);//设置窗体大小  
157.         this.setDefaultCloseOperation(3);//点击关闭，程序自动退出。  
158.         this.setResizable(false);//设置窗体大小不可以调节  
159.         this.setLocationRelativeTo(null);//设置窗体出现在屏幕中间  
160.   
161.         //创建自己的panel，用其来显示图形。  
162.         //因为如果将图片设置到窗体上显示时，因为jframe是一个复合组件，上面的组件有多个paint方法，所以在paint的时候会画两次，  
163.         //而panel是只需画一次。  
164.         MyPanel panel = new MyPanel();  
165.         java.awt.Dimension di = new java.awt.Dimension(width, height);//设置panel大小  
166.         panel.setPreferredSize(di);  
167.         this.add(panel);//窗体添加panel  
168.         this.setVisible(true);//使窗体可见。  
169.     }  
170.   
171.     public class MyPanel extends javax.swing.JPanel {  
172.         /** 
173.          *  
174.          */  
175.         private static final long serialVersionUID = 1L;  
176.   
177.         /** 
178.          * 重写paint方法 
179.          */  
180.         public void paint(Graphics g) {  
181.             // 这句话可写可不写，因为这句话是用来画jframe的contentPane的。   
182.             // 而这里我们已经在下面定义了contentPane的方法了  
183.             super.paint(g);  
184.             for (int i = 0; i < height; i++) {  
185.                 for (int j = 0; j < width; j++) {  
186.                     g.setColor(new Color(red[i][j], green[i][j], blue[i][j]));  
187.                     // 如果这里画点的话，是不能使用下面注释掉的方法的，不行的话，亲，自己试试吧  
188.                     // 因为系统在画椭圆的时候，是先画出椭圆的外切矩形。而矩形的边框刚好是占据一个像素点。  
189.                     // 因此也就出现了，jdk api中说g.drawOval的像素点是width+1,height+1。  
190.                     // 如果亲，你有更好的理解，请告诉我们。欢迎交流！！！  
191.                     // g.fillOval(j, i, 1, 1);  
192.                     g.fillRect(j, i, 1, 1);// 这里可以使用画点的任何方法，除了上面那种特例。  
193.                 }  
194.             }  
195.         }  
196.     }  
197. }  

 

BMP文件的编写：

Java代码  

1. package pcm24;  
2.   
3. import java.awt.Color;  
4.   
5. /** 
6.  *  
7.  * 类说明：实现BMP文件格式的保存 
8.  *  
9.  * @author 彭晨明 E-mail:[e-mail] 
10.  *  
11.  * @version 创建时间：2012-2-5下午9:06:28 
12.  *  
13.  */  
14. public class BmpWrite24 {  
15.     /** 
16.      * 图形数据数组 
17.      */  
18.     private Color[][] pointArray;  
19.   
20.     /** 
21.      * 图形的宽 
22.      */  
23.     int width;  
24.   
25.     /** 
26.      * 图形的高 
27.      */  
28.     int height;  
29.   
30.     /** 
31.      * BMPWrite构造器的重载，传入图形数据数组 
32.      *  
33.      * @param pointArray 
34.      */  
35.     public BmpWrite24(Color[][] pointArray) {  
36.         this.pointArray = pointArray;  
37.         this.width = pointArray.length;  
38.         this.height = pointArray[0].length;  
39.         this.write();  
40.     }  
41.   
42.     /** 
43.      * 将数据传入内存 
44.      */  
45.     public void write() {  
46.         try {  
47.             // 创建输出流文件对象  
48.             java.io.FileOutputStream fos = new java.io.FileOutputStream(  
49.                     "C:\\Documents and Settings\\专属于我\\桌面\\未命名1.bmp");  
50.             // 创建原始数据输出流对象  
51.             java.io.DataOutputStream dos = new java.io.DataOutputStream(fos);  
52.   
53.             // 给文件头的变量赋值  
54.             int bfType = 0x424d; // 位图文件类型（0—1字节）  
55.             int bfSize = 54 + width * height * 3;// bmp文件的大小（2—5字节）  
56.             int bfReserved1 = 0;// 位图文件保留字，必须为0（6-7字节）  
57.             int bfReserved2 = 0;// 位图文件保留字，必须为0（8-9字节）  
58.             int bfOffBits = 54;// 文件头开始到位图实际数据之间的字节的偏移量（10-13字节）  
59.   
60.             // 输入数据的时候要注意输入的数据在内存中要占几个字节，  
61.             // 然后再选择相应的写入方法，而不是它自己本身的数据类型  
62.             // 输入文件头数据  
63.             dos.writeShort(bfType); // 输入位图文件类型'BM'  
64.             dos.write(changeByte(bfSize),0,4); // 输入位图文件大小  
65.             dos.write(changeByte(bfReserved1),0,2);// 输入位图文件保留字  
66.             dos.write(changeByte(bfReserved2),0,2);// 输入位图文件保留字  
67.             dos.write(changeByte(bfOffBits),0,4);// 输入位图文件偏移量  
68.   
69.             // 给信息头的变量赋值  
70.             int biSize = 40;// 信息头所需的字节数（14-17字节）  
71.             int biWidth = width;// 位图的宽（18-21字节）  
72.             int biHeight = height;// 位图的高（22-25字节）  
73.             int biPlanes = 1; // 目标设备的级别，必须是1（26-27字节）  
74.             int biBitcount = 24;// 每个像素所需的位数（28-29字节），必须是1位（双色）、4位（16色）、8位（256色）或者24位（真彩色）之一。  
75.             int biCompression = 0;// 位图压缩类型，必须是0（不压缩）（30-33字节）、1（BI_RLEB压缩类型）或2（BI_RLE4压缩类型）之一。  
76.             int biSizeImage = width * height;// 实际位图图像的大小，即整个实际绘制的图像大小（34-37字节）  
77.             int biXPelsPerMeter = 0;// 位图水平分辨率，每米像素数（38-41字节）这个数是系统默认值  
78.             int biYPelsPerMeter = 0;// 位图垂直分辨率，每米像素数（42-45字节）这个数是系统默认值  
79.             int biClrUsed = 0;// 位图实际使用的颜色表中的颜色数（46-49字节），如果为0的话，说明全部使用了  
80.             int biClrImportant = 0;// 位图显示过程中重要的颜色数(50-53字节)，如果为0的话，说明全部重要  
81.               
82.             // 因为java是大端存储，那么也就是说同样会大端输出。  
83.             // 但计算机是按小端读取，如果我们不改变多字节数据的顺序的话，那么机器就不能正常读取。  
84.             // 所以首先调用方法将int数据转变为多个byte数据，并且按小端存储的顺序。  
85.               
86.             // 输入信息头数据  
87.             dos.write(changeByte(biSize),0,4);// 输入信息头数据的总字节数  
88.             dos.write(changeByte(biWidth),0,4);// 输入位图的宽  
89.             dos.write(changeByte(biHeight),0,4);// 输入位图的高  
90.             dos.write(changeByte(biPlanes),0,2);// 输入位图的目标设备级别  
91.             dos.write(changeByte(biBitcount),0,2);// 输入每个像素占据的字节数  
92.             dos.write(changeByte(biCompression),0,4);// 输入位图的压缩类型  
93.             dos.write(changeByte(biSizeImage),0,4);// 输入位图的实际大小  
94.             dos.write(changeByte(biXPelsPerMeter),0,4);// 输入位图的水平分辨率  
95.             dos.write(changeByte(biYPelsPerMeter),0,4);// 输入位图的垂直分辨率  
96.             dos.write(changeByte(biClrUsed),0,4);// 输入位图使用的总颜色数  
97.             dos.write(changeByte(biClrImportant),0,4);// 输入位图使用过程中重要的颜色数  
98.   
99.             // 因为是24位图，所以没有颜色表  
100.             // 通过遍历输入位图数据  
101.             // 这里遍历的时候注意，在计算机内存中位图数据是从左到右，从下到上来保存的，  
102.             // 也就是说实际图像的第一行的点在内存是最后一行  
103.             for (int i = height - 1; i >= 0; i--) {  
104.                 for (int j = 0; j < width; j++) {  
105.                     // 这里还需要注意的是，每个像素是有三个RGB颜色分量组成的，  
106.                     // 而数据在windows操作系统下是小端存储，对多字节数据有用。  
107.                     int red = pointArray[i][j].getRed();// 得到位图点的红色分量  
108.                     int green = pointArray[i][j].getGreen();// 得到位图点的绿色分量  
109.                     int blue = pointArray[i][j].getBlue();// 得到位图点的蓝色分量  
110.                     byte[] red1 = changeByte(red);  
111.                     byte[] green1 = changeByte(green);  
112.                     byte[] blue1 = changeByte(blue);  
113.                     dos.write(blue1,0,1);  
114.                     dos.write(green1,0,1);  
115.                     dos.write(red1,0,1);  
116.                 }  
117.             }  
118.             //关闭数据的传输  
119.             dos.flush();  
120.             dos.close();  
121.             fos.close();  
122.             System.out.println("success!!!");  
123.         } catch (Exception e) {  
124.             e.printStackTrace();  
125.         }  
126.     }  
127.       
128.     /** 
129.      * 将一个int数据转为按小端顺序排列的字节数组 
130.      * @param data int数据 
131.      * @return  按小端顺序排列的字节数组 
132.      */  
133.     public byte[] changeByte(int data){  
134.         byte b4 = (byte)((data)>>24);  
135.         byte b3 = (byte)(((data)<<8)>>24);  
136.         byte b2= (byte)(((data)<<16)>>24);  
137.         byte b1 = (byte)(((data)<<24)>>24);  
138.         byte[] bytes = {b1,b2,b3,b4};  
139.         return bytes;  
140.     }  
141. }  

 

部分参考：http://www.cnblogs.com/Jason_Yao/archive/2009/12/02/1615295.html