implement a missing C89 case
[xonotic/xonotic.git] / misc / tools / fft-normalmap-to-heightmap.c
1 /*
2  *  FFT based normalmap to heightmap converter
3  *  Copyright (C) 2010  Rudolf Polzer
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2 of the License, or
8  *  (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19
20 #undef C99
21 #if __STDC_VERSION__ >= 199901L
22 #define C99
23 #endif
24
25 #ifdef C99
26 #include <complex.h>
27 #endif
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <math.h>
33
34 #include <fftw3.h>
35
36 #define TWO_PI (4*atan2(1,1) * 2)
37
38 void nmap_to_hmap(unsigned char *map, const unsigned char *refmap, int w, int h, double scale, double offset, const double *filter, int filterw, int filterh)
39 {
40         int x, y;
41         int i, j;
42         double fx, fy;
43         double ffx, ffy;
44         double nx, ny, nz;
45         double v, vmin, vmax;
46 #ifndef C99
47         double save;
48 #endif
49
50         fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
51         fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
52         fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
53         fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
54         fftw_plan i12f1 = fftw_plan_dft_2d(h, w, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
55         fftw_plan i22f2 = fftw_plan_dft_2d(h, w, imgspace2, freqspace2, FFTW_FORWARD, FFTW_ESTIMATE);
56         fftw_plan f12i1 = fftw_plan_dft_2d(h, w, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
57
58         for(y = 0; y < h; ++y)
59         for(x = 0; x < w; ++x)
60         {
61                 /*
62                  * unnormalized normals:
63                  * n_x = -dh/dx
64                  * n_y = -dh/dy
65                  * n_z = -dh/dh = -1
66                  * BUT: darkplaces uses inverted normals, n_y actually is dh/dy by image pixel coordinates
67                  */
68                 nx = ((int)map[(w*y+x)*4+2] - 127.5) / 128;
69                 ny = ((int)map[(w*y+x)*4+1] - 127.5) / 128;
70                 nz = ((int)map[(w*y+x)*4+0] - 127.5) / 128;
71
72                 /* reconstruct the derivatives from here */
73 #ifdef C99
74                 imgspace1[(w*y+x)] =  nx / nz * w; /* = dz/dx */
75                 imgspace2[(w*y+x)] = -ny / nz * h; /* = dz/dy */
76 #else
77                 imgspace1[(w*y+x)][0] =  nx / nz; /* = dz/dx */
78                 imgspace1[(w*y+x)][1] = 0;
79                 imgspace2[(w*y+x)][0] = -ny / nz; /* = dz/dy */
80                 imgspace2[(w*y+x)][1] = 0;
81 #endif
82         }
83
84         /* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
85
86         fftw_execute(i12f1);
87         fftw_execute(i22f2);
88         
89         for(y = 0; y < h; ++y)
90         for(x = 0; x < w; ++x)
91         {
92                 fx = x * 1.0 / w;
93                 fy = y * 1.0 / h;
94                 if(filter)
95                 {
96                         // discontinous case
97                         // we must invert whatever "filter" would do on (x, y)!
98 #ifdef C99
99                         fftw_complex response_x = 0;
100                         fftw_complex response_y = 0;
101                         double sum;
102                         for(i = -filterh / 2; i <= filterh / 2; ++i)
103                                 for(j = -filterw / 2; j <= filterw / 2; ++j)
104                                 {
105                                         response_x += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cexp(-_Complex_I * TWO_PI * (j * fx + i * fy));
106                                         response_y += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cexp(-_Complex_I * TWO_PI * (i * fx + j * fy));
107                                 }
108
109                         // we know:
110                         //   fourier(df/dx)_xy = fourier(f)_xy * response_x
111                         //   fourier(df/dy)_xy = fourier(f)_xy * response_y
112                         // mult by conjugate of response_x, response_y:
113                         //   conj(response_x) * fourier(df/dx)_xy = fourier(f)_xy * |response_x^2|
114                         //   conj(response_y) * fourier(df/dy)_xy = fourier(f)_xy * |response_y^2|
115                         // and
116                         //   fourier(f)_xy = (conj(response_x) * fourier(df/dx)_xy + conj(response_y) * fourier(df/dy)_xy) / (|response_x|^2 + |response_y|^2)
117
118                         sum = cabs(response_x) * cabs(response_x) + cabs(response_y) * cabs(response_y);
119
120                         if(sum > 0)
121                                 freqspace1[(w*y+x)] = (conj(response_x) * freqspace1[(w*y+x)] + conj(response_y) * freqspace2[(w*y+x)]) / sum;
122                         else
123                                 freqspace1[(w*y+x)] = 0;
124 #else
125                         fftw_complex response_x = {0, 0};
126                         fftw_complex response_y = {0, 0};
127                         double sum;
128                         for(i = -filterh / 2; i <= filterh / 2; ++i)
129                                 for(j = -filterw / 2; j <= filterw / 2; ++j)
130                                 {
131                                         response_x[0] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cos(TWO_PI * (j * fx + i * fy));
132                                         response_x[1] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * sin(TWO_PI * (j * fx + i * fy));
133                                         response_y[0] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cos(TWO_PI * (i * fx + j * fy));
134                                         response_y[1] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * sin(TWO_PI * (i * fx + j * fy));
135                                 }
136
137                         sum = response_x[0] * response_x[0] + response_x[1] + response_x[1]
138                             + response_y[0] * response_y[0] + response_y[1] + response_y[1];
139
140                         if(sum > 0)
141                         {
142                                 freqspace1[(w*y+x)][0] = (response_x[0] * freqspace1[(w*y+x)][0] + response_x[1] * freqspace1[(w*y+x)][1] + response_y[0] * freqspace2[(w*y+x)][0] + response_y[1] * freqspace2[(w*y+x)][1]) / sum;
143                                 freqspace1[(w*y+x)][1] = (response_x[0] * freqspace1[(w*y+x)][1] - response_x[1] * freqspace1[(w*y+x)][0] + response_y[0] * freqspace2[(w*y+x)][1] - response_y[1] * freqspace2[(w*y+x)][0]) / sum;
144                         }
145                         else
146                         {
147                                 freqspace1[(w*y+x)][0] = 0;
148                                 freqspace1[(w*y+x)][1] = 0;
149                         }
150 #endif
151                 }
152                 else
153                 {
154                         // continuous integration case
155                         if(fx > 0.5)
156                                 fx -= 1;
157                         if(fy > 0.5)
158                                 fy -= 1;
159                         /* these must have the same sign as fx and fy (so ffx*fx + ffy*fy is nonzero), otherwise do not matter */
160                         /* it basically decides how artifacts are distributed */
161                         ffx = fx;
162                         ffy = fy;
163 #ifdef C99
164                         if(fx||fy)
165                                 freqspace1[(w*y+x)] = _Complex_I * (ffx * freqspace1[(w*y+x)] + ffy * freqspace2[(w*y+x)]) / (ffx*fx + ffy*fy) / TWO_PI;
166                         else
167                                 freqspace1[(w*y+x)] = 0;
168 #else
169                         if(fx||fy)
170                         {
171                                 save = freqspace1[(w*y+x)][0];
172                                 freqspace1[(w*y+x)][0] = -(ffx * freqspace1[(w*y+x)][1] + ffy * freqspace2[(w*y+x)][1]) / (ffx*fx + ffy*fy) / TWO_PI;
173                                 freqspace1[(w*y+x)][1] =  (ffx * save + ffy * freqspace2[(w*y+x)][0]) / (ffx*fx + ffy*fy) / TWO_PI;
174                         }
175                         else
176                         {
177                                 freqspace1[(w*y+x)][0] = 0;
178                                 freqspace1[(w*y+x)][1] = 0;
179                         }
180 #endif
181                 }
182         }
183
184         fftw_execute(f12i1);
185
186         /* renormalize, find min/max */
187         vmin = vmax = 0;
188         for(y = 0; y < h; ++y)
189         for(x = 0; x < w; ++x)
190         {
191 #ifdef C99
192                 v = creal(imgspace1[(w*y+x)] /= pow(w*h, 1.5));
193 #else
194                 v = (imgspace1[(w*y+x)][0] /= pow(w*h, 1.5));
195                 imgspace1[(w*y+x)][1] /= pow(w*h, 1.5);
196 #endif
197                 if(v < vmin || (x == 0 && y == 0))
198                         vmin = v;
199                 if(v > vmax || (x == 0 && y == 0))
200                         vmax = v;
201         }
202
203         if(refmap)
204         {
205                 double f, a;
206                 double o, s;
207                 double sa, sfa, sffa, sfva, sva;
208                 double mi, ma;
209                 sa = sfa = sffa = sfva = sva = 0;
210                 mi = 1;
211                 ma = -1;
212                 for(y = 0; y < h; ++y)
213                 for(x = 0; x < w; ++x)
214                 {
215                         a = (int)refmap[(w*y+x)*4+3];
216                         v = (refmap[(w*y+x)*4+0]*0.114 + refmap[(w*y+x)*4+1]*0.587 + refmap[(w*y+x)*4+2]*0.299);
217                         v = (v - 128.0) / 127.0;
218 #ifdef C99
219                         f = creal(imgspace1[(w*y+x)]);
220 #else
221                         f = imgspace1[(w*y+x)][0];
222 #endif
223                         if(a <= 0)
224                                 continue;
225                         if(v < mi)
226                                 mi = v;
227                         if(v > ma)
228                                 ma = v;
229                         sa += a;
230                         sfa += f*a;
231                         sffa += f*f*a;
232                         sfva += f*v*a;
233                         sva += v*a;
234                 }
235                 if(mi < ma)
236                 {
237                         /* linear regression ftw */
238                         o = (sfa*sfva - sffa*sva) / (sfa*sfa-sa*sffa);
239                         s = (sfa*sva - sa*sfva) / (sfa*sfa-sa*sffa);
240                 }
241                 else /* all values of v are equal, so we cannot get scale; we can still get offset */
242                 {
243                         o = ((sva - sfa) / sa);
244                         s = 1;
245                 }
246
247                 /*
248                  * now apply user-given offset and scale to these values
249                  * (x * s + o) * scale + offset
250                  * x * s * scale + o * scale + offset
251                  */
252                 offset += o * scale;
253                 scale *= s;
254         }
255         else if(scale == 0)
256         {
257                 /*
258                  * map vmin to -1
259                  * map vmax to +1
260                  */
261                 scale = 2 / (vmax - vmin);
262                 offset = -(vmax + vmin) / (vmax - vmin);
263         }
264
265         printf("Min: %f\nAvg: %f\nMax: %f\nScale: %f\nOffset: %f\nScaled-Min: %f\nScaled-Avg: %f\nScaled-Max: %f\n", 
266                 vmin, 0.0, vmax, scale, offset, vmin * scale + offset, offset, vmax * scale + offset);
267
268         for(y = 0; y < h; ++y)
269         for(x = 0; x < w; ++x)
270         {
271 #ifdef C99
272                 v = creal(imgspace1[(w*y+x)]);
273 #else
274                 v = imgspace1[(w*y+x)][0];
275 #endif
276                 v = v * scale + offset;
277                 if(v < -1)
278                         v = -1;
279                 if(v > 1)
280                         v = 1;
281                 map[(w*y+x)*4+3] = floor(128.5 + 127 * v);
282         }
283
284         fftw_destroy_plan(i12f1);
285         fftw_destroy_plan(i22f2);
286         fftw_destroy_plan(f12i1);
287
288         fftw_free(freqspace2);
289         fftw_free(freqspace1);
290         fftw_free(imgspace2);
291         fftw_free(imgspace1);
292 }
293
294 void hmap_to_nmap(unsigned char *map, int w, int h, int src_chan, double scale)
295 {
296         int x, y;
297         double fx, fy;
298         double nx, ny, nz;
299         double v;
300 #ifndef C99
301         double save;
302 #endif
303
304         fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
305         fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
306         fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
307         fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
308         fftw_plan i12f1 = fftw_plan_dft_2d(h, w, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
309         fftw_plan f12i1 = fftw_plan_dft_2d(h, w, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
310         fftw_plan f22i2 = fftw_plan_dft_2d(h, w, freqspace2, imgspace2, FFTW_BACKWARD, FFTW_ESTIMATE);
311
312         for(y = 0; y < h; ++y)
313         for(x = 0; x < w; ++x)
314         {
315                 switch(src_chan)
316                 {
317                         case 0:
318                         case 1:
319                         case 2:
320                         case 3:
321                                 v = map[(w*y+x)*4+src_chan];
322                                 break;
323                         case 4:
324                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
325                                 break;
326                         default:
327                         case 5:
328                                 v = (map[(w*y+x)*4+0]*0.114 + map[(w*y+x)*4+1]*0.587 + map[(w*y+x)*4+2]*0.299);
329                                 break;
330                 }
331 #ifdef C99
332                 imgspace1[(w*y+x)] = (v - 128.0) / 127.0;
333 #else
334                 imgspace1[(w*y+x)][0] = (v - 128.0) / 127.0;
335                 imgspace1[(w*y+x)][1] = 0;
336 #endif
337                 if(v < 1)
338                         v = 1; /* do not write alpha zero */
339                 map[(w*y+x)*4+3] = floor(v + 0.5);
340         }
341
342         /* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
343
344         fftw_execute(i12f1);
345         
346         for(y = 0; y < h; ++y)
347         for(x = 0; x < w; ++x)
348         {
349                 fx = x;
350                 fy = y;
351                 if(fx > w/2)
352                         fx -= w;
353                 if(fy > h/2)
354                         fy -= h;
355 #ifdef DISCONTINUOUS
356                 fx = sin(fx * TWO_PI / w);
357                 fy = sin(fy * TWO_PI / h);
358 #else
359 #ifdef C99
360                 /* a lowpass to prevent the worst */
361                 freqspace1[(w*y+x)] *= 1 - pow(abs(fx) / (double)(w/2), 1);
362                 freqspace1[(w*y+x)] *= 1 - pow(abs(fy) / (double)(h/2), 1);
363 #else
364                 /* a lowpass to prevent the worst */
365                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fx) / (double)(w/2), 1);
366                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fx) / (double)(w/2), 1);
367                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fy) / (double)(h/2), 1);
368                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fy) / (double)(h/2), 1);
369 #endif
370 #endif
371 #ifdef C99
372                 freqspace2[(w*y+x)] = TWO_PI*_Complex_I * fy * freqspace1[(w*y+x)]; /* y derivative */
373                 freqspace1[(w*y+x)] = TWO_PI*_Complex_I * fx * freqspace1[(w*y+x)]; /* x derivative */
374 #else
375                 freqspace2[(w*y+x)][0] = -TWO_PI * fy * freqspace1[(w*y+x)][1]; /* y derivative */
376                 freqspace2[(w*y+x)][1] =  TWO_PI * fy * freqspace1[(w*y+x)][0];
377                 save = freqspace1[(w*y+x)][0];
378                 freqspace1[(w*y+x)][0] = -TWO_PI * fx * freqspace1[(w*y+x)][1]; /* x derivative */
379                 freqspace1[(w*y+x)][1] =  TWO_PI * fx * save;
380 #endif
381         }
382
383         fftw_execute(f12i1);
384         fftw_execute(f22i2);
385
386         scale /= (w*h);
387
388         for(y = 0; y < h; ++y)
389         for(x = 0; x < w; ++x)
390         {
391 #ifdef C99
392                 nx = creal(imgspace1[(w*y+x)]);
393                 ny = creal(imgspace2[(w*y+x)]);
394 #else
395                 nx = imgspace1[(w*y+x)][0];
396                 ny = imgspace2[(w*y+x)][0];
397 #endif
398                 nx /= w;
399                 ny /= h;
400                 nz = -1 / scale;
401                 v = -sqrt(nx*nx + ny*ny + nz*nz);
402                 nx /= v;
403                 ny /= v;
404                 nz /= v;
405                 ny = -ny; /* DP inverted normals */
406                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
407                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
408                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
409         }
410
411         fftw_destroy_plan(i12f1);
412         fftw_destroy_plan(f12i1);
413         fftw_destroy_plan(f22i2);
414
415         fftw_free(freqspace2);
416         fftw_free(freqspace1);
417         fftw_free(imgspace2);
418         fftw_free(imgspace1);
419 }
420
421 void hmap_to_nmap_local(unsigned char *map, int w, int h, int src_chan, double scale, const double *filter, int filterw, int filterh)
422 {
423         int x, y;
424         double nx, ny, nz;
425         double v;
426         int i, j;
427         double *img_reduced = malloc(w*h * sizeof(double));
428
429         for(y = 0; y < h; ++y)
430         for(x = 0; x < w; ++x)
431         {
432                 switch(src_chan)
433                 {
434                         case 0:
435                         case 1:
436                         case 2:
437                         case 3:
438                                 v = map[(w*y+x)*4+src_chan];
439                                 break;
440                         case 4:
441                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
442                                 break;
443                         default:
444                         case 5:
445                                 v = (map[(w*y+x)*4+0]*0.114 + map[(w*y+x)*4+1]*0.587 + map[(w*y+x)*4+2]*0.299);
446                                 break;
447                 }
448                 img_reduced[(w*y+x)] = (v - 128.0) / 127.0;
449                 if(v < 1)
450                         v = 1; /* do not write alpha zero */
451                 map[(w*y+x)*4+3] = floor(v + 0.5);
452         }
453
454         for(y = 0; y < h; ++y)
455         for(x = 0; x < w; ++x)
456         {
457                 nz = -1 / scale;
458                 nx = ny = 0;
459
460                 for(i = -filterh / 2; i <= filterh / 2; ++i)
461                         for(j = -filterw / 2; j <= filterw / 2; ++j)
462                         {
463                                 nx += img_reduced[w*((y+i+h)%h)+(x+j+w)%w] * filter[(i + filterh / 2) * filterw + j + filterw / 2];
464                                 ny += img_reduced[w*((y+j+h)%h)+(x+i+w)%w] * filter[(i + filterh / 2) * filterw + j + filterw / 2];
465                         }
466
467                 v = -sqrt(nx*nx + ny*ny + nz*nz);
468                 nx /= v;
469                 ny /= v;
470                 nz /= v;
471                 ny = -ny; /* DP inverted normals */
472                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
473                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
474                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
475         }
476
477         free(img_reduced);
478 }
479
480 unsigned char *FS_LoadFile(const char *fn, int *len)
481 {
482         unsigned char *buf = NULL;
483         int n;
484         FILE *f = fopen(fn, "rb");
485         *len = 0;
486         if(!f)
487                 return NULL;
488         for(;;)
489         {
490                 buf = realloc(buf, *len + 65536);
491                 if(!buf)
492                 {
493                         fclose(f);
494                         free(buf);
495                         *len = 0;
496                         return NULL;
497                 }
498                 n = fread(buf + *len, 1, 65536, f);
499                 if(n < 0)
500                 {
501                         fclose(f);
502                         free(buf);
503                         *len = 0;
504                         return NULL;
505                 }
506                 *len += n;
507                 if(n < 65536)
508                         break;
509         }
510         return buf;
511 }
512
513 int FS_WriteFile(const char *fn, unsigned char *data, int len)
514 {
515         FILE *f = fopen(fn, "wb");
516         if(!f)
517                 return 0;
518         if(fwrite(data, len, 1, f) != 1)
519         {
520                 fclose(f);
521                 return 0;
522         }
523         if(fclose(f))
524                 return 0;
525         return 1;
526 }
527
528 /* START stuff that originates from image.c in DarkPlaces */
529 int image_width, image_height;
530
531 typedef struct _TargaHeader
532 {
533         unsigned char   id_length, colormap_type, image_type;
534         unsigned short  colormap_index, colormap_length;
535         unsigned char   colormap_size;
536         unsigned short  x_origin, y_origin, width, height;
537         unsigned char   pixel_size, attributes;
538 }
539 TargaHeader;
540
541 void PrintTargaHeader(TargaHeader *t)
542 {
543         printf("TargaHeader:\nuint8 id_length = %i;\nuint8 colormap_type = %i;\nuint8 image_type = %i;\nuint16 colormap_index = %i;\nuint16 colormap_length = %i;\nuint8 colormap_size = %i;\nuint16 x_origin = %i;\nuint16 y_origin = %i;\nuint16 width = %i;\nuint16 height = %i;\nuint8 pixel_size = %i;\nuint8 attributes = %i;\n", t->id_length, t->colormap_type, t->image_type, t->colormap_index, t->colormap_length, t->colormap_size, t->x_origin, t->y_origin, t->width, t->height, t->pixel_size, t->attributes);
544 }
545
546 unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
547 {
548         int x, y, pix_inc, row_inci, runlen, alphabits;
549         unsigned char *image_buffer;
550         unsigned int *pixbufi;
551         const unsigned char *fin, *enddata;
552         TargaHeader targa_header;
553         unsigned int palettei[256];
554         union
555         {
556                 unsigned int i;
557                 unsigned char b[4];
558         }
559         bgra;
560
561         if (filesize < 19)
562                 return NULL;
563
564         enddata = f + filesize;
565
566         targa_header.id_length = f[0];
567         targa_header.colormap_type = f[1];
568         targa_header.image_type = f[2];
569
570         targa_header.colormap_index = f[3] + f[4] * 256;
571         targa_header.colormap_length = f[5] + f[6] * 256;
572         targa_header.colormap_size = f[7];
573         targa_header.x_origin = f[8] + f[9] * 256;
574         targa_header.y_origin = f[10] + f[11] * 256;
575         targa_header.width = image_width = f[12] + f[13] * 256;
576         targa_header.height = image_height = f[14] + f[15] * 256;
577         targa_header.pixel_size = f[16];
578         targa_header.attributes = f[17];
579
580         if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
581         {
582                 printf("LoadTGA: invalid size\n");
583                 PrintTargaHeader(&targa_header);
584                 return NULL;
585         }
586
587         /* advance to end of header */
588         fin = f + 18;
589
590         /* skip TARGA image comment (usually 0 bytes) */
591         fin += targa_header.id_length;
592
593         /* read/skip the colormap if present (note: according to the TARGA spec it */
594         /* can be present even on 1color or greyscale images, just not used by */
595         /* the image data) */
596         if (targa_header.colormap_type)
597         {
598                 if (targa_header.colormap_length > 256)
599                 {
600                         printf("LoadTGA: only up to 256 colormap_length supported\n");
601                         PrintTargaHeader(&targa_header);
602                         return NULL;
603                 }
604                 if (targa_header.colormap_index)
605                 {
606                         printf("LoadTGA: colormap_index not supported\n");
607                         PrintTargaHeader(&targa_header);
608                         return NULL;
609                 }
610                 if (targa_header.colormap_size == 24)
611                 {
612                         for (x = 0;x < targa_header.colormap_length;x++)
613                         {
614                                 bgra.b[0] = *fin++;
615                                 bgra.b[1] = *fin++;
616                                 bgra.b[2] = *fin++;
617                                 bgra.b[3] = 255;
618                                 palettei[x] = bgra.i;
619                         }
620                 }
621                 else if (targa_header.colormap_size == 32)
622                 {
623                         memcpy(palettei, fin, targa_header.colormap_length*4);
624                         fin += targa_header.colormap_length * 4;
625                 }
626                 else
627                 {
628                         printf("LoadTGA: Only 32 and 24 bit colormap_size supported\n");
629                         PrintTargaHeader(&targa_header);
630                         return NULL;
631                 }
632         }
633
634         /* check our pixel_size restrictions according to image_type */
635         switch (targa_header.image_type & ~8)
636         {
637         case 2:
638                 if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
639                 {
640                         printf("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
641                         PrintTargaHeader(&targa_header);
642                         return NULL;
643                 }
644                 break;
645         case 3:
646                 /* set up a palette to make the loader easier */
647                 for (x = 0;x < 256;x++)
648                 {
649                         bgra.b[0] = bgra.b[1] = bgra.b[2] = x;
650                         bgra.b[3] = 255;
651                         palettei[x] = bgra.i;
652                 }
653                 /* fall through to colormap case */
654         case 1:
655                 if (targa_header.pixel_size != 8)
656                 {
657                         printf("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
658                         PrintTargaHeader(&targa_header);
659                         return NULL;
660                 }
661                 break;
662         default:
663                 printf("LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported, image_type = %i\n", targa_header.image_type);
664                 PrintTargaHeader(&targa_header);
665                 return NULL;
666         }
667
668         if (targa_header.attributes & 0x10)
669         {
670                 printf("LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n");
671                 return NULL;
672         }
673
674         /* number of attribute bits per pixel, we only support 0 or 8 */
675         alphabits = targa_header.attributes & 0x0F;
676         if (alphabits != 8 && alphabits != 0)
677         {
678                 printf("LoadTGA: only 0 or 8 attribute (alpha) bits supported\n");
679                 return NULL;
680         }
681
682         image_buffer = (unsigned char *)malloc(image_width * image_height * 4);
683         if (!image_buffer)
684         {
685                 printf("LoadTGA: not enough memory for %i by %i image\n", image_width, image_height);
686                 return NULL;
687         }
688
689         /* If bit 5 of attributes isn't set, the image has been stored from bottom to top */
690         if ((targa_header.attributes & 0x20) == 0)
691         {
692                 pixbufi = (unsigned int*)image_buffer + (image_height - 1)*image_width;
693                 row_inci = -image_width*2;
694         }
695         else
696         {
697                 pixbufi = (unsigned int*)image_buffer;
698                 row_inci = 0;
699         }
700
701         x = 0;
702         y = 0;
703         pix_inc = 1;
704         if ((targa_header.image_type & ~8) == 2)
705                 pix_inc = (targa_header.pixel_size + 7) / 8;
706         switch (targa_header.image_type)
707         {
708         case 1: /* colormapped, uncompressed */
709         case 3: /* greyscale, uncompressed */
710                 if (fin + image_width * image_height * pix_inc > enddata)
711                         break;
712                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
713                         for (x = 0;x < image_width;x++)
714                                 *pixbufi++ = palettei[*fin++];
715                 break;
716         case 2:
717                 /* BGR or BGRA, uncompressed */
718                 if (fin + image_width * image_height * pix_inc > enddata)
719                         break;
720                 if (targa_header.pixel_size == 32 && alphabits)
721                 {
722                         for (y = 0;y < image_height;y++)
723                                 memcpy(pixbufi + y * (image_width + row_inci), fin + y * image_width * pix_inc, image_width*4);
724                 }
725                 else
726                 {
727                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
728                         {
729                                 for (x = 0;x < image_width;x++, fin += pix_inc)
730                                 {
731                                         bgra.b[0] = fin[0];
732                                         bgra.b[1] = fin[1];
733                                         bgra.b[2] = fin[2];
734                                         bgra.b[3] = 255;
735                                         *pixbufi++ = bgra.i;
736                                 }
737                         }
738                 }
739                 break;
740         case 9: /* colormapped, RLE */
741         case 11: /* greyscale, RLE */
742                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
743                 {
744                         for (x = 0;x < image_width;)
745                         {
746                                 if (fin >= enddata)
747                                         break; /* error - truncated file */
748                                 runlen = *fin++;
749                                 if (runlen & 0x80)
750                                 {
751                                         /* RLE - all pixels the same color */
752                                         runlen += 1 - 0x80;
753                                         if (fin + pix_inc > enddata)
754                                                 break; /* error - truncated file */
755                                         if (x + runlen > image_width)
756                                                 break; /* error - line exceeds width */
757                                         bgra.i = palettei[*fin++];
758                                         for (;runlen--;x++)
759                                                 *pixbufi++ = bgra.i;
760                                 }
761                                 else
762                                 {
763                                         /* uncompressed - all pixels different color */
764                                         runlen++;
765                                         if (fin + pix_inc * runlen > enddata)
766                                                 break; /* error - truncated file */
767                                         if (x + runlen > image_width)
768                                                 break; /* error - line exceeds width */
769                                         for (;runlen--;x++)
770                                                 *pixbufi++ = palettei[*fin++];
771                                 }
772                         }
773
774                         if (x != image_width)
775                         {
776                                 /* pixbufi is useless now */
777                                 printf("LoadTGA: corrupt file\n");
778                                 break;
779                         }
780                 }
781                 break;
782         case 10:
783                 /* BGR or BGRA, RLE */
784                 if (targa_header.pixel_size == 32 && alphabits)
785                 {
786                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
787                         {
788                                 for (x = 0;x < image_width;)
789                                 {
790                                         if (fin >= enddata)
791                                                 break; /* error - truncated file */
792                                         runlen = *fin++;
793                                         if (runlen & 0x80)
794                                         {
795                                                 /* RLE - all pixels the same color */
796                                                 runlen += 1 - 0x80;
797                                                 if (fin + pix_inc > enddata)
798                                                         break; /* error - truncated file */
799                                                 if (x + runlen > image_width)
800                                                         break; /* error - line exceeds width */
801                                                 bgra.b[0] = fin[0];
802                                                 bgra.b[1] = fin[1];
803                                                 bgra.b[2] = fin[2];
804                                                 bgra.b[3] = fin[3];
805                                                 fin += pix_inc;
806                                                 for (;runlen--;x++)
807                                                         *pixbufi++ = bgra.i;
808                                         }
809                                         else
810                                         {
811                                                 /* uncompressed - all pixels different color */
812                                                 runlen++;
813                                                 if (fin + pix_inc * runlen > enddata)
814                                                         break; /* error - truncated file */
815                                                 if (x + runlen > image_width)
816                                                         break; /* error - line exceeds width */
817                                                 for (;runlen--;x++)
818                                                 {
819                                                         bgra.b[0] = fin[0];
820                                                         bgra.b[1] = fin[1];
821                                                         bgra.b[2] = fin[2];
822                                                         bgra.b[3] = fin[3];
823                                                         fin += pix_inc;
824                                                         *pixbufi++ = bgra.i;
825                                                 }
826                                         }
827                                 }
828
829                                 if (x != image_width)
830                                 {
831                                         /* pixbufi is useless now */
832                                         printf("LoadTGA: corrupt file\n");
833                                         break;
834                                 }
835                         }
836                 }
837                 else
838                 {
839                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
840                         {
841                                 for (x = 0;x < image_width;)
842                                 {
843                                         if (fin >= enddata)
844                                                 break; /* error - truncated file */
845                                         runlen = *fin++;
846                                         if (runlen & 0x80)
847                                         {
848                                                 /* RLE - all pixels the same color */
849                                                 runlen += 1 - 0x80;
850                                                 if (fin + pix_inc > enddata)
851                                                         break; /* error - truncated file */
852                                                 if (x + runlen > image_width)
853                                                         break; /* error - line exceeds width */
854                                                 bgra.b[0] = fin[0];
855                                                 bgra.b[1] = fin[1];
856                                                 bgra.b[2] = fin[2];
857                                                 bgra.b[3] = 255;
858                                                 fin += pix_inc;
859                                                 for (;runlen--;x++)
860                                                         *pixbufi++ = bgra.i;
861                                         }
862                                         else
863                                         {
864                                                 /* uncompressed - all pixels different color */
865                                                 runlen++;
866                                                 if (fin + pix_inc * runlen > enddata)
867                                                         break; /* error - truncated file */
868                                                 if (x + runlen > image_width)
869                                                         break; /* error - line exceeds width */
870                                                 for (;runlen--;x++)
871                                                 {
872                                                         bgra.b[0] = fin[0];
873                                                         bgra.b[1] = fin[1];
874                                                         bgra.b[2] = fin[2];
875                                                         bgra.b[3] = 255;
876                                                         fin += pix_inc;
877                                                         *pixbufi++ = bgra.i;
878                                                 }
879                                         }
880                                 }
881
882                                 if (x != image_width)
883                                 {
884                                         /* pixbufi is useless now */
885                                         printf("LoadTGA: corrupt file\n");
886                                         break;
887                                 }
888                         }
889                 }
890                 break;
891         default:
892                 /* unknown image_type */
893                 break;
894         }
895
896         return image_buffer;
897 }
898
899 int Image_WriteTGABGRA (const char *filename, int width, int height, const unsigned char *data)
900 {
901         int y;
902         unsigned char *buffer, *out;
903         const unsigned char *in, *end;
904         int ret;
905
906         buffer = (unsigned char *)malloc(width*height*4 + 18);
907
908         memset (buffer, 0, 18);
909         buffer[2] = 2;          /* uncompressed type */
910         buffer[12] = (width >> 0) & 0xFF;
911         buffer[13] = (width >> 8) & 0xFF;
912         buffer[14] = (height >> 0) & 0xFF;
913         buffer[15] = (height >> 8) & 0xFF;
914
915         for (y = 3;y < width*height*4;y += 4)
916                 if (data[y] < 255)
917                         break;
918
919         if (y < width*height*4)
920         {
921                 /* save the alpha channel */
922                 buffer[16] = 32;        /* pixel size */
923                 buffer[17] = 8; /* 8 bits of alpha */
924
925                 /* flip upside down */
926                 out = buffer + 18;
927                 for (y = height - 1;y >= 0;y--)
928                 {
929                         memcpy(out, data + y * width * 4, width * 4);
930                         out += width*4;
931                 }
932         }
933         else
934         {
935                 /* save only the color channels */
936                 buffer[16] = 24;        /* pixel size */
937                 buffer[17] = 0; /* 8 bits of alpha */
938
939                 /* truncate bgra to bgr and flip upside down */
940                 out = buffer + 18;
941                 for (y = height - 1;y >= 0;y--)
942                 {
943                         in = data + y * width * 4;
944                         end = in + width * 4;
945                         for (;in < end;in += 4)
946                         {
947                                 *out++ = in[0];
948                                 *out++ = in[1];
949                                 *out++ = in[2];
950                         }
951                 }
952         }
953         ret = FS_WriteFile (filename, buffer, out - buffer);
954
955         free(buffer);
956
957         return ret;
958 }
959 /* START stuff that originates from image.c in DarkPlaces */
960
961 int usage(const char *me)
962 {
963         printf("Usage: %s <infile_norm.tga> <outfile_normandheight.tga> filtertype [<scale> [<offset> [<infile_ref.tga>]]] (get heightmap from normalmap)\n", me);
964         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -1 [<scale>] (read from B)\n", me);
965         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -2 [<scale>] (read from G)\n", me);
966         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -3 [<scale>] (read from R)\n", me);
967         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -4 [<scale>] (read from A)\n", me);
968         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -5 [<scale>] (read from (R+G+B)/3)\n", me);
969         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> filtertype -6 [<scale>] (read from Y)\n", me);
970         return 1;
971 }
972
973 static const double filter_scharr3[3][3] = {
974         {  -3/32.0, 0,  3/32.0 },
975         { -10/32.0, 0, 10/32.0 },
976         {  -3/32.0, 0,  3/32.0 }
977 };
978
979 static const double filter_prewitt3[3][3] = {
980         { -1/6.0, 0, 1/6.0 },
981         { -1/6.0, 0, 1/6.0 },
982         { -1/6.0, 0, 1/6.0 }
983 };
984
985 // pathologic for inverting
986 static const double filter_sobel3[3][3] = {
987         { -1/8.0, 0, 1/8.0 },
988         { -2/8.0, 0, 2/8.0 },
989         { -1/8.0, 0, 1/8.0 }
990 };
991
992 // pathologic for inverting
993 static const double filter_sobel5[5][5] = {
994         { -1/128.0,  -2/128.0, 0,  2/128.0, 1/128.0 },
995         { -4/128.0,  -8/128.0, 0,  8/128.0, 4/128.0 },
996         { -6/128.0, -12/128.0, 0, 12/128.0, 6/128.0 },
997         { -4/128.0,  -8/128.0, 0,  8/128.0, 4/128.0 },
998         { -1/128.0,  -2/128.0, 0,  2/128.0, 1/128.0 }
999 };
1000
1001 // pathologic for inverting
1002 static const double filter_prewitt5[5][5] = {
1003         { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
1004         { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
1005         { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
1006         { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
1007         { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 }
1008 };
1009
1010 static const double filter_trivial[1][3] = {
1011         { -0.5, 0, 0.5 }
1012 };
1013
1014 int main(int argc, char **argv)
1015 {
1016         const char *infile, *outfile, *reffile;
1017         double scale, offset;
1018         int nmaplen, w, h;
1019         unsigned char *nmapdata, *nmap, *refmap;
1020         const char *filtertype;
1021         const double *filter = NULL;
1022         int filterw = 0, filterh = 0;
1023 #define USE_FILTER(f) \
1024         do \
1025         { \
1026                 filterw = sizeof(*(f)) / sizeof(**(f)); \
1027                 filterh = sizeof((f)) / sizeof(*(f)); \
1028                 filter = &(f)[0][0]; \
1029         } \
1030         while(0)
1031
1032         if(argc > 1)
1033                 infile = argv[1];
1034         else
1035                 return usage(*argv);
1036
1037         if(argc > 2)
1038                 outfile = argv[2];
1039         else
1040                 return usage(*argv);
1041         
1042         if(argc > 3)
1043                 filtertype = argv[3];
1044         else
1045                 return usage(*argv);
1046         
1047         if(argc > 4)
1048                 scale = atof(argv[4]);
1049         else
1050                 scale = 0;
1051
1052         if(argc > 5)
1053                 offset = atof(argv[5]);
1054         else
1055                 offset = (scale<0) ? 1 : 0;
1056
1057         if(argc > 6)
1058                 reffile = argv[6];
1059         else
1060                 reffile = NULL;
1061
1062         nmapdata = FS_LoadFile(infile, &nmaplen);
1063         if(!nmapdata)
1064         {
1065                 printf("FS_LoadFile failed\n");
1066                 return 2;
1067         }
1068         nmap = LoadTGA_BGRA(nmapdata, nmaplen);
1069         free(nmapdata);
1070         if(!nmap)
1071         {
1072                 printf("LoadTGA_BGRA failed\n");
1073                 return 2;
1074         }
1075         w = image_width;
1076         h = image_height;
1077
1078         if(reffile)
1079         {
1080                 nmapdata = FS_LoadFile(reffile, &nmaplen);
1081                 if(!nmapdata)
1082                 {
1083                         printf("FS_LoadFile failed\n");
1084                         return 2;
1085                 }
1086                 refmap = LoadTGA_BGRA(nmapdata, nmaplen);
1087                 free(nmapdata);
1088                 if(!refmap)
1089                 {
1090                         printf("LoadTGA_BGRA failed\n");
1091                         return 2;
1092                 }
1093                 if(image_width != w || image_height != h)
1094                 {
1095                         printf("reference map must have same size as input normalmap\n");
1096                         return 2;
1097                 }
1098         }
1099         else
1100                 refmap = NULL;
1101
1102         if(!strcmp(filtertype, "trivial"))
1103                 USE_FILTER(filter_trivial);
1104         if(!strcmp(filtertype, "prewitt3"))
1105                 USE_FILTER(filter_prewitt3);
1106         if(!strcmp(filtertype, "scharr3"))
1107                 USE_FILTER(filter_scharr3);
1108         if(!strcmp(filtertype, "sobel3"))
1109                 USE_FILTER(filter_sobel3);
1110         if(!strcmp(filtertype, "prewitt5"))
1111                 USE_FILTER(filter_prewitt5);
1112         if(!strcmp(filtertype, "sobel5"))
1113                 USE_FILTER(filter_sobel5);
1114
1115         if(scale < 0)
1116         {
1117                 if(filter)
1118                         hmap_to_nmap_local(nmap, image_width, image_height, -scale-1, offset, filter, filterw, filterh);
1119                 else
1120                         hmap_to_nmap(nmap, image_width, image_height, -scale-1, offset);
1121         }
1122         else
1123                 nmap_to_hmap(nmap, refmap, image_width, image_height, scale, offset, filter, filterw, filterh);
1124
1125         if(!Image_WriteTGABGRA(outfile, image_width, image_height, nmap))
1126         {
1127                 printf("Image_WriteTGABGRA failed\n");
1128                 free(nmap);
1129                 return 2;
1130         }
1131         free(nmap);
1132         return 0;
1133 }