Smoke: fixing some compile warning reported by Ton and one compile erro for gcc 4...
[blender.git] / intern / smoke / intern / IMAGE.h
1 //////////////////////////////////////////////////////////////////////
2 // This file is part of Wavelet Turbulence.
3 //
4 // Wavelet Turbulence is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Wavelet Turbulence is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Wavelet Turbulence.  If not, see <http://www.gnu.org/licenses/>.
16 //
17 // Copyright 2008 Theodore Kim and Nils Thuerey
18 //
19 //////////////////////////////////////////////////////////////////////
20 //
21 #ifndef IMAGE_H
22 #define IMAGE_H
23
24 #include <stdlib.h>
25 #include <string>
26 #include <fstream>
27 #include <sstream>
28 #include <zlib.h>
29
30 //////////////////////////////////////////////////////////////////////
31 // NT helper functions
32 //////////////////////////////////////////////////////////////////////
33 template < class T > inline T ABS( T a ) {
34         return (0 < a) ? a : -a ;
35 }
36
37 template < class T > inline void SWAP_POINTERS( T &a, T &b ) {
38         T temp = a;
39         a = b;
40         b = temp;
41 }
42
43 template < class T > inline void CLAMP( T &a, T b=0., T c=1.) {
44         if(a<b) { a=b; return; }
45         if(a>c) { a=c; return; }
46 }
47
48 template < class T > inline T MIN( T a, T b) {
49         return (a < b) ? a : b;
50 }
51
52 template < class T > inline T MAX( T a, T b) {
53         return (a > b) ? a : b;
54 }
55
56 template < class T > inline T MAX3( T a, T b, T c) {
57         T max = (a > b) ? a : b;
58         max = (max > c) ? max : c;
59         return max;
60 }
61
62 template < class T > inline float MAX3V( T vec) {
63         float max = (vec[0] > vec[1]) ? vec[0] : vec[1];
64         max = (max > vec[2]) ? max : vec[2];
65         return max;
66 }
67
68 template < class T > inline float MIN3V( T vec) {
69         float min = (vec[0] < vec[1]) ? vec[0] : vec[1];
70         min = (min < vec[2]) ? min : vec[2];
71         return min;
72 }
73
74 //////////////////////////////////////////////////////////////////////
75 // PNG, POV-Ray, and PBRT output functions
76 //////////////////////////////////////////////////////////////////////
77 #include <png.h>
78
79 namespace IMAGE {
80         /*
81   static int writePng(const char *fileName, unsigned char **rowsp, int w, int h)
82   {
83     // defaults
84     const int colortype = PNG_COLOR_TYPE_RGBA;
85     const int bitdepth = 8;
86     png_structp png_ptr = NULL;
87     png_infop info_ptr = NULL;
88     png_bytep *rows = rowsp;
89
90     FILE *fp = NULL;
91     std::string doing = "open for writing";
92     if (!(fp = fopen(fileName, "wb"))) goto fail;
93
94     if(!png_ptr) {
95       doing = "create png write struct";
96       if (!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) goto fail;
97     }
98     if(!info_ptr) {
99       doing = "create png info struct";
100       if (!(info_ptr = png_create_info_struct(png_ptr))) goto fail;
101     }
102
103     if (setjmp(png_jmpbuf(png_ptr))) goto fail;
104     doing = "init IO";
105     png_init_io(png_ptr, fp);
106     doing = "write header";
107     png_set_IHDR(png_ptr, info_ptr, w, h, bitdepth, colortype, PNG_INTERLACE_NONE,
108         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
109     doing = "write info";
110     png_write_info(png_ptr, info_ptr);
111     doing = "write image";
112     png_write_image(png_ptr, rows);
113     doing = "write end";
114     png_write_end(png_ptr, NULL);
115     doing = "write destroy structs";
116     png_destroy_write_struct(&png_ptr, &info_ptr);
117
118     fclose( fp );
119     return 0;
120
121   fail:
122     std::cerr << "writePng: could not "<<doing<<" !\n";
123     if(fp) fclose( fp );
124     if(png_ptr || info_ptr) png_destroy_write_struct(&png_ptr, &info_ptr);
125     return -1;
126   }
127   */
128
129   /////////////////////////////////////////////////////////////////////////////////
130   // write a numbered PNG file out, padded with zeros up to three zeros
131   /////////////////////////////////////////////////////////////////////////////////
132   /*
133   static void dumpNumberedPNG(int counter, std::string prefix, float* field, int xRes, int yRes)
134   {
135         char buffer[256];
136     sprintf(buffer,"%04i", counter);
137     std::string number = std::string(buffer);
138
139     unsigned char pngbuf[xRes*yRes*4];
140     unsigned char *rows[yRes];
141     float *pfield = field;
142     for (int j=0; j<yRes; j++) {
143       for (int i=0; i<xRes; i++) {
144         float val = *pfield;
145         if(val>1.) val=1.;
146         if(val<0.) val=0.;
147         pngbuf[(j*xRes+i)*4+0] = (unsigned char)(val*255.);
148         pngbuf[(j*xRes+i)*4+1] = (unsigned char)(val*255.);
149         pngbuf[(j*xRes+i)*4+2] = (unsigned char)(val*255.);
150         pfield++;
151         pngbuf[(j*xRes+i)*4+3] = 255;
152       }
153       rows[j] = &pngbuf[(yRes-j-1)*xRes*4];
154     }
155     std::string filenamePNG = prefix + number + std::string(".png");
156     writePng(filenamePNG.c_str(), rows, xRes, yRes, false);
157     printf("Writing %s\n", filenamePNG.c_str());
158    
159   }
160 */
161   /////////////////////////////////////////////////////////////////////////////////
162   // export pbrt volumegrid geometry object
163   /////////////////////////////////////////////////////////////////////////////////
164         /*
165   static void dumpPBRT(int counter, std::string prefix, float* fieldOrg, int xRes, int yRes, int zRes)
166   {
167     char buffer[256];
168     sprintf(buffer,"%04i", counter);
169     std::string number = std::string(buffer);
170
171     std::string filenamePbrt = prefix + number + std::string(".pbrt.gz");
172     printf("Writing PBRT %s\n", filenamePbrt.c_str());
173
174     float *field = new float[xRes*yRes*zRes];
175     // normalize values
176     float maxDensVal = ABS(fieldOrg[0]);
177     float targetNorm = 0.5;
178     for (int i = 0; i < xRes * yRes * zRes; i++) {
179       if(ABS(fieldOrg[i])>maxDensVal) maxDensVal = ABS(fieldOrg[i]);
180       field[i] = 0.;
181     }
182     if(maxDensVal>0.) {
183       for (int i = 0; i < xRes * yRes * zRes; i++) {
184         field[i] = ABS(fieldOrg[i]) / maxDensVal * targetNorm;
185       }
186     }
187
188     std::fstream fout;
189     fout.open(filenamePbrt.c_str(), std::ios::out);
190
191     int maxRes = (xRes > yRes) ? xRes : yRes;
192     maxRes = (maxRes > zRes) ? maxRes : zRes;
193
194     const float xSize = 1.0 / (float)maxRes * (float)xRes;
195     const float ySize = 1.0 / (float)maxRes * (float)yRes;
196     const float zSize = 1.0 / (float)maxRes * (float)zRes;
197
198     gzFile file;
199     file = gzopen(filenamePbrt.c_str(), "wb1");
200     if (file == NULL) {
201       std::cerr << " Couldn't write file " << filenamePbrt << "!!!" << std::endl;
202       return;
203     }
204
205     // dimensions
206     gzprintf(file, "Volume \"volumegrid\" \n");
207     gzprintf(file, " \"integer nx\" %i\n", xRes);
208     gzprintf(file, " \"integer ny\" %i\n", yRes);
209     gzprintf(file, " \"integer nz\" %i\n", zRes);
210     gzprintf(file, " \"point p0\" [ 0.0 0.0 0.0 ] \"point p1\" [%f %f %f ] \n", xSize, ySize, zSize);
211     gzprintf(file, " \"float density\" [ \n");
212     for (int i = 0; i < xRes * yRes * zRes; i++)
213       gzprintf(file, "%f ", field[i]);
214     gzprintf(file, "] \n \n");
215
216     gzclose(file);
217     delete[] field;
218   }
219   */
220
221   /////////////////////////////////////////////////////////////////////////////////
222   // 3D df3 export
223   /////////////////////////////////////////////////////////////////////////////////
224 /*
225   static void dumpDF3(int counter, std::string prefix, float* fieldOrg, int xRes, int yRes, int zRes)
226   {
227     char buffer[256];
228
229     // do deferred copying to final directory, better for network directories
230     sprintf(buffer,"%04i", counter);
231     std::string number = std::string(buffer);
232     std::string filenameDf3 = prefix + number + std::string(".df3.gz");
233     printf("Writing DF3 %s\n", filenameDf3.c_str());
234
235     gzFile file;
236     file = gzopen(filenameDf3.c_str(), "wb1");
237     if (file == NULL) {
238       std::cerr << " Couldn't write file " << filenameDf3 << "!!!" << std::endl;
239       return;
240     }
241
242     // dimensions
243     const int byteSize = 2;
244     const unsigned short int onx=xRes,ony=yRes,onz=zRes;
245     unsigned short int nx,ny,nz;
246     nx = onx >> 8;
247     ny = ony >> 8;
248     nz = onz >> 8;
249     nx += (onx << 8);
250     ny += (ony << 8);
251     nz += (onz << 8);
252     gzwrite(file, (void*)&nx, sizeof(short));
253     gzwrite(file, (void*)&ny, sizeof(short));
254     gzwrite(file, (void*)&nz, sizeof(short));
255     const int nitems = onx*ony*onz;
256     const float mul = (float)( (1<<(8*byteSize))-1);
257
258     unsigned short int *buf = new unsigned short int[nitems];
259     for (int k = 0; k < onz; k++)
260       for (int j = 0; j < ony; j++)
261         for (int i = 0; i < onx; i++) {
262           float val = fieldOrg[k*(onx*ony)+j*onx+i] ;
263           CLAMP(val);
264           buf[k*(onx*ony)+j*onx+i] = (short int)(val*mul);
265         }
266     gzwrite(file, (void*)buf, sizeof(unsigned short int)* nitems);
267
268     gzclose(file);
269     delete[] buf;
270   }
271   */
272
273 };
274
275
276 #endif
277