HDR文件格式简介及其读写函数

转自：http://blog.csdn.net/lqhbupt/article/details/7828827

1、HDR简介
HDR的全称是High-DynamicRange（高动态范围）。在此，我们先解释一下什么是DynamicRange（动态范围），动态范围是指图像中所包含的从“最亮”至“最暗”的比值，也就是图像从“最亮”到“最暗”之间灰度划分的等级数；动态范围越大，所能表示的层次越丰富，所包含的色彩空间也越广。那高动态范围（HDR）顾名思义就是从“最亮”到“最暗”可以达到非常高的比值。
在日常生活中我们经常遇到这样的情况：突然从黑暗的房间中走到阳光下，眼睛会无法睁开；清晨阳光会穿透窗帘像光柱般照射入房间；反光度较高的物体在强光下会在周围产生光晕。以上这些生活中随处可见的现象在有HDR以前无法在3D世界中呈现！最大的原因就在于我们使用8~16bit的整数数据，使用8~16bit的整数数据是整个图象处理失真的关键点，所以我们对以往的运算方法做了以下二方面的重大改进：
1、使用16bit、32bit的数据来提高像素数据的精度。既然继续使用8bit的数据来记录像素的特征不能满足HDR数据所需要的高精度运算的要求，在这种情况下，我们考虑使用16bit、32bit的数据记录来提高像素数据的精度都是可以的。使用了更多的数据来保存像素特征之后，无论是像素的对比度还是像素可以体现的色彩数目都有了巨大的提高。
2、图象数据采用浮点数据。HDR真正的巨大变革来自于浮点数据的引入。我们可以采用浮点方式来处理和存放亮度数据，抛弃不准确的整数数据；同时计算机在引入浮点数据来存储象素的各个参数并且在运算的全过程都使用浮点数据，这样就可以有效的提高据的精确度。
那么采用HDR后动态范围最大可以有多大呢？我们看如下的公式，就可以知道我们到底使用了HDR后动态值可以有多大，而动态值的大小直接表现了动态范围的大小：DynamicRange=log10(Max Intensity / Min Intensity)。公式中intensity是指强度，我们对最大亮度除以最低亮度的结果取对数，得到的结果就是动态范围的相对数值。根据公式计算，当我们在亮度通道使用8bit的的情况下，最高亮度255，最低亮度1。那么计算得出的动态范围就是数值约为2.4，加上单位就是24dB。同理可以计算得出16bit的亮度通道的动态范围是数值约是4.8，是使用8bit亮度通道的一倍。理论上在HDR模式下，动态范围的数值最高可以到达76.8。在NVIDIA所使用的OpenEXR中表现出来的HDR动态范围的数值最大值约有12.0，远远高出单纯使用16bit亮度通道的所带来的亮度体验，这是采用了优秀算法的结果。OpenEXR所能实现的最大动态范围已经超过了人眼的9，带来了更加真实的视觉体验。

2、HDRI文件格式介绍(OpenEXR、RadianceRGBE、FloatTIFF)
HDRI（High-DynamicRange Image）就是记录采用了HDR技术的图象数据文件。常用的HDRI文件有OpenEXR、RadianceRGBE、FloatTIFF三种格式。 
2.1 OpenEXR文件格式
OpenEXR是由工业光魔（IndustrialLight & Magic）开发的一种HDR标准。OpenEXR文件的扩展名为.exr，常见的OpenEXR文件是FP16（16bitFloat Point，也被称为halfFloat Point）数据图像文件，每个通道的数据类型是FP16，一共四个通道64bpp，每个通道1个bit位用来标志“指数”，5个bit用来存放指数的值，10个bit存放色度坐标（u，v）的尾数，其动态范围从6.14× 10 ^ -5到6.41× 10 ^ 4。
在OpenEXR的算法里面共使用16bit来表示光照数据。虽然看起来和使用16bit亮度通道运算位数相同，但是OpenEXR巧妙的采用了1个bit位用来标志“指数”，5个bit用来存放指数的值，10个bit存放色度坐标的尾数。这样就轻易的解决了浮点数值由于位数少而精度不高的问题。大大的拓宽的在FP16下的动态范围。根据实际的计算结果：在正规化的情况下OpenEXR可以提供和人眼基本相同的动态范围，最暗到最亮是0.00006103515625（6.14 ×10 ^ -5）到65504（6.41 ×10 ^ 4），动态范围是9.03；非正规化条件下，OpenEXR可以提供从最暗到最亮的数值从0.000000059604644775390625（5.96 ×10 ^ -8 ）到65504（6.41 ×10 ^ 4），化为动态范围表示就是12。
下面是Still写的OpenEXR读写代码，保存的.exr文件采用Zips压缩编码。

1. bool COpenExr::Load(const char fileName[], int& width, int& height, float** pixels)
2. {
3. std::vector<float> vecpixels;
4. if(!Load(fileName, width, height, vecpixels))
5. return false;
6. int num = width * height * 3;
7. *pixels = new float[num];
8. if(NULL == *pixels)
9. return false;
10. std::vector<float>::pointer ptr = &vecpixels[0];
11. memcpy(*pixels, ptr, num * 4);
12. return true;
13. }
14. bool COpenExr::Load(const char fileName[], int& width, int& height, std::vector<float> &pixels)
15. {
16. Imf::Array<Imf::Rgba> pixelsdata;
17. bool bLoad = loadImage(fileName, width, height, pixelsdata);
18. if(!bLoad) return false;
19. for(int y = 0; y < height; y++)
20. {
21. int i = y * width;
22. for(int x = 0; x < width; x++)
23. {
24. int j = i + x;
25. const Imf::Rgba &rp = pixelsdata[j];
26. pixels.push_back( float(rp.r));
27. pixels.push_back( float(rp.g));
28. pixels.push_back( float(rp.b));
29. }
30. }
31. return true;
32. }
33. bool COpenExr::loadImage (const char fileName[], int& width, int& height, Imf::Array<Imf::Rgba>& pixels)
34. {
35. Imf::RgbaInputFile in (fileName);
36. Imath::Box2i dataWindow = in.dataWindow();
37. int dw, dh, dx, dy;
38. width = dw = dataWindow.max.x - dataWindow.min.x + 1;
39. height = dh = dataWindow.max.y - dataWindow.min.y + 1;
40. dx = dataWindow.min.x;
41. dy = dataWindow.min.y;
42. pixels.resizeErase (dw * dh);
43. in.setFrameBuffer (pixels - dx - dy * dw, 1, dw);
44. try
45. {
46. in.readPixels (dataWindow.min.y, dataWindow.max.y);
47. }catch (const exception &e)
48. {
49. std::cerr << e.what() << std::endl;
50. return false;
51. }
52. return true;
53. }
54. bool COpenExr::Save(const char fileName[], int width, int height, const float* pixels)
55. {
56. std::vector<float> vecpixels(pixels, pixels + width * height * 3);
57. return Save(fileName, width, height, vecpixels);
58. }
59. bool COpenExr::Save(const char fileName[], int width, int height, const std::vector<float> pixels)
60. {
61. Imf::Array<Imf::Rgba> pixelsdata;
62. pixelsdata.resizeErase(width * height);
63. for(int y = 0; y < height; y++)
64. {
65. int i = y * width;
66. for(int x = 0; x < width; x++)
67. {
68. int j = i + x;
69. half r = pixels[j * 3 ];
70. half g = pixels[j * 3 + 1];
71. half b = pixels[j * 3 + 2];
72. pixelsdata[j] = Imf::Rgba(r, g, b);
73. }
74. }
75. return SaveImage(fileName, width, height, pixelsdata);
76. }
77. bool COpenExr::SaveImage(const char fileName[], int width, int height, const Imf::Array<Imf::Rgba> &pixels)
78. {
79. Imf::RgbaOutputFile file (fileName, width, height);
80. file.setFrameBuffer(pixels, 1, width);
81. try
82. {
83. file.writePixels(height);
84. }catch(const exception &e)
85. {
86. std::cerr<< e.what() <<std::endl;
87. return false;
88. }
89. return true;
90. }

官方库链接地址：http://www.openexr.com/

2.2 Radiance RGBE文件格式
RGBE文件的扩展名为.hdr，RGBE正式名称为RadianceRGBE格式。这个本来是BR、FR等作为radiance材质的一种格式，也叫做radiancemap，后来成为流行的一种HDR格式。所谓E，就是指数。RadianceRGBE文件每个通道为8bitBYTE数据类型，4个通道一共是32bit。RGBE可以使用RLE压缩编码压缩，也可以不压缩。由文件头、RGBE数据组成。
文件头如下：
类型输出格式
char programtype[16]; //#?Radiance/n#Generated by still/n
float gamma; //1.0
float exposure; //1.0
字符串常量//FORMAT=32-bit_rle_rgbe/n/n
int nWidth, int nHeight //-Y nHeight +X nWidth/n

RGBE数据与HDRFP32(RGB)相互转换公式如下：
1、rgbe->FP32(RGB)
如果e为0， R = G= B = 0.0，否则：
R = r * 2^(e – 128 - 8);
G = g * 2^(e – 128 - 8);
B = b * 2^(e – 128 - 8);

2、FP32(RGB)-> rgbe
v = max(R, G, B); 
如果v< 1e-32, r = g = b = e = 0, 否则：
将v用科学计算法表示成v = m * 2 ^ n ( 0 < m < 1)：
r = R * m * 256.0/v; 
g = G * m * 256.0/v;
b = B * m * 256.0/v;
e = n + 128;

Still注：
1、我们一般说HDR采用FP32，指的是HDR图象运算时候的内存数据类型，而RadianceRGBE文件采用8bitBYTE类型存储HDR数据。也就是说打开RadianceRGBE文件，要使用上面的公式1将RadianceRGBE文件的8bitBYTE文件数据转换为FP32的HDR内存数据进行运算；保存为RadianceRGBE文件时，要使用上面的公式2将HDR的FP32内存数据转换为RadianceRGBE的8bitBYTE文件数据进行保存。同理，OpenEXR文件的读写也存在将其FP16的文件数据到HDR的 FP32图象数据的转换；而下面将要讲的FloatTiff是不需要进行数据转换，直接将HDR的FP 32图象数据保存到TIFF文件中即可。
2、Radiance有多种文件格式，其官方库包含内容比较复杂，所以，实际的读写没有使用其官方库，而是使用了网络上一个简单的C语言读写类，Still并对其进行了部分修改（在文件头写入“Generatedby Still”）。

读写类链接地址：http://www.graphics.cornell.edu/~bjw/rgbe.html
官方库链接地址：http://radsite.lbl.gov/radiance/

****************************************************************************************

rgbe.txt - description of interface 
rgbe.h - header file 
rgbe.c - C code 
Where can I find more information?
See "Real Pixels" by Greg Ward in Graphics Gems II .

*****************************************************************************************

Here's the minimal code for using these files. sampleminimal writing code: 
f = fopen(image_filename,"wb"); 
RGBE_WriteHeader(f,image_width,image_height,NULL); 
RGBE_WritePixels(f,image,image_width*image_height); 
fclose(f); 
For run length encoding instead of RGBE_WritePixels, useRGBE_WritePixels_RLE(f,image,image_width,image_height). sample minimal readingcode: 
f = fopen(image_filename,"rb"); 
RGBE_ReadHeader(f,&image_width,&image_height,NULL); 
image = (float *)malloc(sizeof(float)*3*image_width*image_height); 
RGBE_ReadPixels_RLE(f,image,image_width,image_height); 
fclose(f); 
******************************************************************************************

1. //rgbe.h--header file
2. #ifndef _H_RGBE
3. #define _H_RGBE
4. /* THIS CODE CARRIES NO GUARANTEE OF USABILITY OR FITNESS FOR ANY PURPOSE.
5. * WHILE THE AUTHORS HAVE TRIED TO ENSURE THE PROGRAM WORKS CORRECTLY,
6. * IT IS STRICTLY USE AT YOUR OWN RISK. */
7. /* utility for reading and writing Ward's rgbe image format.
8. See rgbe.txt file for more details.
9. */
10. #include <stdio.h>
11. typedef struct {
12. int valid; /* indicate which fields are valid */
13. char programtype[16]; /* listed at beginning of file to identify it
14. * after "#?". defaults to "RGBE" */
15. float gamma; /* image has already been gamma corrected with
16. * given gamma. defaults to 1.0 (no correction) */
17. float exposure; /* a value of 1.0 in an image corresponds to
18. * <exposure> watts/steradian/m^2.
19. * defaults to 1.0 */
20. } rgbe_header_info;
21. /* flags indicating which fields in an rgbe_header_info are valid */
22. #define RGBE_VALID_PROGRAMTYPE 0x01
23. #define RGBE_VALID_GAMMA 0x02
24. #define RGBE_VALID_EXPOSURE 0x04
25. /* return codes for rgbe routines */
26. #define RGBE_RETURN_SUCCESS 0
27. #define RGBE_RETURN_FAILURE -1
28. /* read or write headers */
29. /* you may set rgbe_header_info to null if you want to */
30. int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info);
31. int RGBE_ReadHeader(FILE *fp, int *width, int *height, rgbe_header_info *info);
32. /* read or write pixels */
33. /* can read or write pixels in chunks of any size including single pixels*/
34. int RGBE_WritePixels(FILE *fp, float *data, int numpixels);
35. int RGBE_ReadPixels(FILE *fp, float *data, int numpixels);
36. /* read or write run length encoded files */
37. /* must be called to read or write whole scanlines */
38. int RGBE_WritePixels_RLE(FILE *fp, float *data, int scanline_width,
39. int num_scanlines);
40. int RGBE_ReadPixels_RLE(FILE *fp, float *data, int scanline_width,
41. int num_scanlines);
42. #endif /* _H_RGBE */

1. //rgbe.c -- C code
2. /* THIS CODE CARRIES NO GUARANTEE OF USABILITY OR FITNESS FOR ANY PURPOSE.
3. * WHILE THE AUTHORS HAVE TRIED TO ENSURE THE PROGRAM WORKS CORRECTLY,
4. * IT IS STRICTLY USE AT YOUR OWN RISK. */
5. #include "rgbe.h"
6. #include <math.h>
7. #include <malloc.h>
8. #include <string.h>
9. #include <ctype.h>
10. /* This file contains code to read and write four byte rgbe file format
11. developed by Greg Ward. It handles the conversions between rgbe and
12. pixels consisting of floats. The data is assumed to be an array of floats.
13. By default there are three floats per pixel in the order red, green, blue.
14. (RGBE_DATA_??? values control this.) Only the mimimal header reading and
15. writing is implemented. Each routine does error checking and will return
16. a status value as defined below. This code is intended as a skeleton so
17. feel free to modify it to suit your needs.
18. (Place notice here if you modified the code.)
19. posted to http://www.graphics.cornell.edu/~bjw/
20. written by Bruce Walter (bjw@graphics.cornell.edu) 5/26/95
21. based on code written by Greg Ward
22. */
23. #ifdef _CPLUSPLUS
24. /* define if your compiler understands inline commands */
25. #define INLINE inline
26. #else
27. #define INLINE
28. #endif
29. /* offsets to red, green, and blue components in a data (float) pixel */
30. #define RGBE_DATA_RED 0
31. #define RGBE_DATA_GREEN 1
32. #define RGBE_DATA_BLUE 2
33. /* number of floats per pixel */
34. #define RGBE_DATA_SIZE 3
35. enum rgbe_error_codes {
36. rgbe_read_error,
37. rgbe_write_error,
38. rgbe_format_error,
39. rgbe_memory_error,
40. };
41. /* default error routine. change this to change error handling */
42. static int rgbe_error(int rgbe_error_code, char *msg)
43. {
44. switch (rgbe_error_code) {
45. case rgbe_read_error:
46. perror("RGBE read error");
47. break;
48. case rgbe_write_error:
49. perror("RGBE write error");
50. break;
51. case rgbe_format_error:
52. fprintf(stderr,"RGBE bad file format: %s/n",msg);
53. break;
54. default:
55. case rgbe_memory_error:
56. fprintf(stderr,"RGBE error: %s/n",msg);
57. }
58. return RGBE_RETURN_FAILURE;
59. }
60. /* standard conversion from float pixels to rgbe pixels */
61. /* note: you can remove the "inline"s if your compiler complains about it */
62. static INLINE void
63. float2rgbe(unsigned char rgbe[4], float red, float green, float blue)
64. {
65. float v;
66. int e;
67. v = red;
68. if (green > v) v = green;
69. if (blue > v) v = blue;
70. if (v < 1e-32) {
71. rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
72. }
73. else {
74. v = frexp(v,&e) * 256.0/v;
75. rgbe[0] = (unsigned char) (red * v);
76. rgbe[1] = (unsigned char) (green * v);
77. rgbe[2] = (unsigned char) (blue * v);
78. rgbe[3] = (unsigned char) (e + 128);
79. }
80. }
81. /* standard conversion from rgbe to float pixels */
82. /* note: Ward uses ldexp(col+0.5,exp-(128+8)). However we wanted pixels */
83. /* in the range [0,1] to map back into the range [0,1]. */
84. static INLINE void
85. rgbe2float(float *red, float *green, float *blue, unsigned char rgbe[4])
86. {
87. float f;
88. if (rgbe[3]) { /*nonzero pixel*/
89. f = ldexp(1.0,rgbe[3]-(int)(128+8));
90. *red = rgbe[0] * f;
91. *green = rgbe[1] * f;
92. *blue = rgbe[2] * f;
93. }
94. else
95. *red = *green = *blue = 0.0;
96. }
97. /* default minimal header. modify if you want more information in header */
98. int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info)
99. {
100. char *programtype = "RGBE";
101. if (info && (info->valid & RGBE_VALID_PROGRAMTYPE))
102. programtype = info->programtype;
103. if (fprintf(fp,"#?%s/n",programtype) < 0)
104. return rgbe_error(rgbe_write_error,NULL);
105. /* The #? is to identify file type, the programtype is optional. */
106. if (info && (info->valid & RGBE_VALID_GAMMA)) {
107. if (fprintf(fp,"GAMMA=%g/n",info->gamma) < 0)
108. return rgbe_error(rgbe_write_error,NULL);
109. }
110. if (info && (info->valid & RGBE_VALID_EXPOSURE)) {
111. if (fprintf(fp,"EXPOSURE=%g/n",info->exposure) < 0)
112. return rgbe_error(rgbe_write_error,NULL);
113. }
114. if (fprintf(fp,"FORMAT=32-bit_rle_rgbe/n/n") < 0)
115. return rgbe_error(rgbe_write_error,NULL);
116. if (fprintf(fp, "-Y %d +X %d/n", height, width) < 0)
117. return rgbe_error(rgbe_write_error,NULL);
118. return RGBE_RETURN_SUCCESS;
119. }
120. /* minimal header reading. modify if you want to parse more information */
121. int RGBE_ReadHeader(FILE *fp, int *width, int *height, rgbe_header_info *info)
122. {
123. char buf[128];
124. int found_format;
125. float tempf;
126. int i;
127. found_format = 0;
128. if (info) {
129. info->valid = 0;
130. info->programtype[0] = 0;
131. info->gamma = info->exposure = 1.0;
132. }
133. if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == NULL)
134. return rgbe_error(rgbe_read_error,NULL);
135. if ((buf[0] != '#')||(buf[1] != '?')) {
136. /* if you want to require the magic token then uncomment the next line */
137. /*return rgbe_error(rgbe_format_error,"bad initial token"); */
138. }
139. else if (info) {
140. info->valid |= RGBE_VALID_PROGRAMTYPE;
141. for(i=0;i<sizeof(info->programtype)-1;i++) {
142. if ((buf[i+2] == 0) || isspace(buf[i+2]))
143. break;
144. info->programtype[i] = buf[i+2];
145. }
146. info->programtype[i] = 0;
147. if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
148. return rgbe_error(rgbe_read_error,NULL);
149. }
150. for(;;) {
151. if ((buf[0] == 0)||(buf[0] == '/n'))
152. return rgbe_error(rgbe_format_error,"no FORMAT specifier found");
153. else if (strcmp(buf,"FORMAT=32-bit_rle_rgbe/n") == 0)
154. break; /* format found so break out of loop */
155. else if (info && (sscanf(buf,"GAMMA=%g",&tempf) == 1)) {
156. info->gamma = tempf;
157. info->valid |= RGBE_VALID_GAMMA;
158. }
159. else if (info && (sscanf(buf,"EXPOSURE=%g",&tempf) == 1)) {
160. info->exposure = tempf;
161. info->valid |= RGBE_VALID_EXPOSURE;
162. }
163. if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
164. return rgbe_error(rgbe_read_error,NULL);
165. }
166. if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
167. return rgbe_error(rgbe_read_error,NULL);
168. if (strcmp(buf,"/n") != 0)
169. return rgbe_error(rgbe_format_error,
170. "missing blank line after FORMAT specifier");
171. if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
172. return rgbe_error(rgbe_read_error,NULL);
173. if (sscanf(buf,"-Y %d +X %d",height,width) < 2)
174. return rgbe_error(rgbe_format_error,"missing image size specifier");
175. return RGBE_RETURN_SUCCESS;
176. }
177. /* simple write routine that does not use run length encoding */
178. /* These routines can be made faster by allocating a larger buffer and
179. fread-ing and fwrite-ing the data in larger chunks */
180. int RGBE_WritePixels(FILE *fp, float *data, int numpixels)
181. {
182. unsigned char rgbe[4];
183. while (numpixels-- > 0) {
184. float2rgbe(rgbe,data[RGBE_DATA_RED],
185. data[RGBE_DATA_GREEN],data[RGBE_DATA_BLUE]);
186. data += RGBE_DATA_SIZE;
187. if (fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
188. return rgbe_error(rgbe_write_error,NULL);
189. }
190. return RGBE_RETURN_SUCCESS;
191. }
192. /* simple read routine. will not correctly handle run length encoding */
193. int RGBE_ReadPixels(FILE *fp, float *data, int numpixels)
194. {
195. unsigned char rgbe[4];
196. while(numpixels-- > 0) {
197. if (fread(rgbe, sizeof(rgbe), 1, fp) < 1)
198. return rgbe_error(rgbe_read_error,NULL);
199. rgbe2float(&data[RGBE_DATA_RED],&data[RGBE_DATA_GREEN],
200. &data[RGBE_DATA_BLUE],rgbe);
201. data += RGBE_DATA_SIZE;
202. }
203. return RGBE_RETURN_SUCCESS;
204. }
205. /* The code below is only needed for the run-length encoded files. */
206. /* Run length encoding adds considerable complexity but does */
207. /* save some space. For each scanline, each channel (r,g,b,e) is */
208. /* encoded separately for better compression. */
209. static int RGBE_WriteBytes_RLE(FILE *fp, unsigned char *data, int numbytes)
210. {
211. #define MINRUNLENGTH 4
212. int cur, beg_run, run_count, old_run_count, nonrun_count;
213. unsigned char buf[2];
214. cur = 0;
215. while(cur < numbytes) {
216. beg_run = cur;
217. /* find next run of length at least 4 if one exists */
218. run_count = old_run_count = 0;
219. while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
220. beg_run += run_count;
221. old_run_count = run_count;
222. run_count = 1;
223. while( (beg_run + run_count < numbytes) && (run_count < 127)
224. && (data[beg_run] == data[beg_run + run_count]))
225. run_count++;
226. }
227. /* if data before next big run is a short run then write it as such */
228. if ((old_run_count > 1)&&(old_run_count == beg_run - cur)) {
229. buf[0] = 128 + old_run_count; /*write short run*/
230. buf[1] = data[cur];
231. if (fwrite(buf,sizeof(buf[0])*2,1,fp) < 1)
232. return rgbe_error(rgbe_write_error,NULL);
233. cur = beg_run;
234. }
235. /* write out bytes until we reach the start of the next run */
236. while(cur < beg_run) {
237. nonrun_count = beg_run - cur;
238. if (nonrun_count > 128)
239. nonrun_count = 128;
240. buf[0] = nonrun_count;
241. if (fwrite(buf,sizeof(buf[0]),1,fp) < 1)
242. return rgbe_error(rgbe_write_error,NULL);
243. if (fwrite(&data[cur],sizeof(data[0])*nonrun_count,1,fp) < 1)
244. return rgbe_error(rgbe_write_error,NULL);
245. cur += nonrun_count;
246. }
247. /* write out next run if one was found */
248. if (run_count >= MINRUNLENGTH) {
249. buf[0] = 128 + run_count;
250. buf[1] = data[beg_run];
251. if (fwrite(buf,sizeof(buf[0])*2,1,fp) < 1)
252. return rgbe_error(rgbe_write_error,NULL);
253. cur += run_count;
254. }
255. }
256. return RGBE_RETURN_SUCCESS;
257. #undef MINRUNLENGTH
258. }
259. int RGBE_WritePixels_RLE(FILE *fp, float *data, int scanline_width,
260. int num_scanlines)
261. {
262. unsigned char rgbe[4];
263. unsigned char *buffer;
264. int i, err;
265. if ((scanline_width < 8)||(scanline_width > 0x7fff))
266. /* run length encoding is not allowed so write flat*/
267. return RGBE_WritePixels(fp,data,scanline_width*num_scanlines);
268. buffer = (unsigned char *)malloc(sizeof(unsigned char)*4*scanline_width);
269. if (buffer == NULL)
270. /* no buffer space so write flat */
271. return RGBE_WritePixels(fp,data,scanline_width*num_scanlines);
272. while(num_scanlines-- > 0) {
273. rgbe[0] = 2;
274. rgbe[1] = 2;
275. rgbe[2] = scanline_width >> 8;
276. rgbe[3] = scanline_width & 0xFF;
277. if (fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
278. free(buffer);
279. return rgbe_error(rgbe_write_error,NULL);
280. }
281. for(i=0;i<scanline_width;i++) {
282. float2rgbe(rgbe,data[RGBE_DATA_RED],
283. data[RGBE_DATA_GREEN],data[RGBE_DATA_BLUE]);
284. buffer[i] = rgbe[0];
285. buffer[i+scanline_width] = rgbe[1];
286. buffer[i+2*scanline_width] = rgbe[2];
287. buffer[i+3*scanline_width] = rgbe[3];
288. data += RGBE_DATA_SIZE;
289. }
290. /* write out each of the four channels separately run length encoded */
291. /* first red, then green, then blue, then exponent */
292. for(i=0;i<4;i++) {
293. if ((err = RGBE_WriteBytes_RLE(fp,&buffer[i*scanline_width],
294. scanline_width)) != RGBE_RETURN_SUCCESS) {
295. free(buffer);
296. return err;
297. }
298. }
299. }
300. free(buffer);
301. return RGBE_RETURN_SUCCESS;
302. }
303. int RGBE_ReadPixels_RLE(FILE *fp, float *data, int scanline_width,
304. int num_scanlines)
305. {
306. unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
307. int i, count;
308. unsigned char buf[2];
309. if ((scanline_width < 8)||(scanline_width > 0x7fff))
310. /* run length encoding is not allowed so read flat*/
311. return RGBE_ReadPixels(fp,data,scanline_width*num_scanlines);
312. scanline_buffer = NULL;
313. /* read in each successive scanline */
314. while(num_scanlines > 0) {
315. if (fread(rgbe,sizeof(rgbe),1,fp) < 1) {
316. free(scanline_buffer);
317. return rgbe_error(rgbe_read_error,NULL);
318. }
319. if ((rgbe[0] != 2)||(rgbe[1] != 2)||(rgbe[2] & 0x80)) {
320. /* this file is not run length encoded */
321. rgbe2float(&data[0],&data[1],&data[2],rgbe);
322. data += RGBE_DATA_SIZE;
323. free(scanline_buffer);
324. return RGBE_ReadPixels(fp,data,scanline_width*num_scanlines-1);
325. }
326. if ((((int)rgbe[2])<<8 | rgbe[3]) != scanline_width) {
327. free(scanline_buffer);
328. return rgbe_error(rgbe_format_error,"wrong scanline width");
329. }
330. if (scanline_buffer == NULL)
331. scanline_buffer = (unsigned char *)
332. malloc(sizeof(unsigned char)*4*scanline_width);
333. if (scanline_buffer == NULL)
334. return rgbe_error(rgbe_memory_error,"unable to allocate buffer space");
335. ptr = &scanline_buffer[0];
336. /* read each of the four channels for the scanline into the buffer */
337. for(i=0;i<4;i++) {
338. ptr_end = &scanline_buffer[(i+1)*scanline_width];
339. while(ptr < ptr_end) {
340. if (fread(buf,sizeof(buf[0])*2,1,fp) < 1) {
341. free(scanline_buffer);
342. return rgbe_error(rgbe_read_error,NULL);
343. }
344. if (buf[0] > 128) {
345. /* a run of the same value */
346. count = buf[0]-128;
347. if ((count == 0)||(count > ptr_end - ptr)) {
348. free(scanline_buffer);
349. return rgbe_error(rgbe_format_error,"bad scanline data");
350. }
351. while(count-- > 0)
352. *ptr++ = buf[1];
353. }
354. else {
355. /* a non-run */
356. count = buf[0];
357. if ((count == 0)||(count > ptr_end - ptr)) {
358. free(scanline_buffer);
359. return rgbe_error(rgbe_format_error,"bad scanline data");
360. }
361. *ptr++ = buf[1];
362. if (--count > 0) {
363. if (fread(ptr,sizeof(*ptr)*count,1,fp) < 1) {
364. free(scanline_buffer);
365. return rgbe_error(rgbe_read_error,NULL);
366. }
367. ptr += count;
368. }
369. }
370. }
371. }
372. /* now convert data from buffer into floats */
373. for(i=0;i<scanline_width;i++) {
374. rgbe[0] = scanline_buffer[i];
375. rgbe[1] = scanline_buffer[i+scanline_width];
376. rgbe[2] = scanline_buffer[i+2*scanline_width];
377. rgbe[3] = scanline_buffer[i+3*scanline_width];
378. rgbe2float(&data[RGBE_DATA_RED],&data[RGBE_DATA_GREEN],
379. &data[RGBE_DATA_BLUE],rgbe);
380. data += RGBE_DATA_SIZE;
381. }
382. num_scanlines--;
383. }
384. free(scanline_buffer);
385. return RGBE_RETURN_SUCCESS;
386. }

2.3 FloatTiff文件格式
Tiff文件的扩展名为.tif(.tiff)，FloatTiff每个通道为FP32(32bit Float Point)类型，一共3个通道96bpp。用Tiff文件存储HDR数据，直接将HDR的FP32保存到TIFF文件中，有官方库可以利用。下面是Still写的代码样例，HDR数据我采用的是LZW压缩编码：

1. bool CFloatTiff::Load(const char fileName[], int& width, int& height, float** pixels)
2. {
3. TIFF* fp = NULL;
4. if((fp = TIFFOpen(fileName, "r")) == NULL)
5. return false;
6. //获取信息
7. uint16 bps, spp, datatype, photometric, compression, planarconfig, fillorder;
8. //每个通道占据的数据位数
9. if( (TIFFGetField(fp, TIFFTAG_BITSPERSAMPLE, &bps) == 0) || (bps != 32))
10. return false;
11. //每个象素的通道数目
12. if((TIFFGetField(fp, TIFFTAG_SAMPLESPERPIXEL, &spp) == 0) || (spp != 3))
13. return false;
14. //每个通道的数据类型
15. if((TIFFGetField(fp, TIFFTAG_SAMPLEFORMAT, &datatype) == 0) || (datatype != AMPLEFORMAT_IEEEFP))
16. return false;
17. //图像的数据采用的颜色模型
18. if((TIFFGetField(fp, TIFFTAG_PHOTOMETRIC, &photometric) == 0) || (photometric != PHOTOMETRIC_RGB))
19. return false;
20. TIFFGetField(fp, TIFFTAG_IMAGEWIDTH, &width);
21. TIFFGetField(fp, TIFFTAG_IMAGELENGTH, &height);
22. int num = width * height * 3;
23. *pixels = new float[num];
24. if(NULL == *pixels)
25. return false;
26. if( TIFFReadEncodedStrip(fp, 0, *pixels, width * height * 3 * 4) == -1)
27. return false;
28. TIFFClose(fp);
29. return true;
30. }
31. bool CFloatTiff::Save(const char fileName[], int width, int height, const float* pixels)
32. {
33. if(NULL == pixels)
34. return false;
35. TIFF *fp = NULL;
36. if((fp = TIFFOpen(fileName, "w")) == NULL)
37. return false;
38. TIFFSetField(fp, TIFFTAG_IMAGEWIDTH, width);
39. TIFFSetField(fp, TIFFTAG_IMAGELENGTH, height);
40. TIFFSetField(fp, TIFFTAG_COMPRESSION, COMPRESSION_LZW);//COMPRESSION_DEFLATE;
41. TIFFSetField(fp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
42. TIFFSetField(fp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
43. TIFFSetField(fp, TIFFTAG_BITSPERSAMPLE, 32);
44. TIFFSetField(fp, TIFFTAG_SAMPLESPERPIXEL, 3);
45. TIFFSetField(fp, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
46. if(TIFFWriteEncodedStrip(fp, 0, const_cast<float*>(pixels), width * height * 3 * 4) == -1)
47. return false;
48. TIFFClose(fp);
49. return true;
50. }

官方库链接地址：http://www.remotesensing.org/libtiff/

Still注：
1、这篇文章的基础知识大部分来自：《光与影的魔术棒——HDR技术解析》http://www.cqumzh.cn/topic_show.php?tid=200271。
2、这段时间工作比较忙，关于OpenEXR文件格式的详细介绍需要翻译相关文档，而且这部分内容是05年接触的，重新总结需要一些时间；还有HDR合成、ToneMapping方面的技术下次再奉上。