*/
#undef C99
-#if __STDC_VERSION__ >= 199901L
+#if __STDC_VERSION__ >= 199901L || __cplusplus__
#define C99
#endif
#define TWO_PI (4*atan2(1,1) * 2)
-void nmap_to_hmap(unsigned char *map, const unsigned char *refmap, int w, int h, double scale, double offset)
+int floatcmp(const void *a_, const void *b_)
+{
+ float a = *(float *)a_;
+ float b = *(float *)b_;
+ if(a < b)
+ return -1;
+ if(a > b)
+ return +1;
+ return 0;
+}
+
+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, int renormalize, double highpass, int use_median)
{
int x, y;
+ int i, j;
+ double fx, fy;
+ double ffx, ffy;
double nx, ny, nz;
- double v, vmin, vmax;
+ double v, vmin, vmed, vmax;
#ifndef C99
double save;
#endif
-
- fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
+ float *medianbuf = (float *) malloc(w*h * sizeof(*medianbuf));
+ fftw_complex *imgspace1 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *imgspace2 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *freqspace1 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *freqspace2 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
fftw_plan i12f1 = fftw_plan_dft_2d(h, w, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_plan i22f2 = fftw_plan_dft_2d(h, w, imgspace2, freqspace2, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_plan f12i1 = fftw_plan_dft_2d(h, w, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
imgspace1[(w*y+x)] = nx / nz * w; /* = dz/dx */
imgspace2[(w*y+x)] = -ny / nz * h; /* = dz/dy */
#else
- imgspace1[(w*y+x)][0] = nx / nz; /* = dz/dx */
+ imgspace1[(w*y+x)][0] = nx / nz * w; /* = dz/dx */
imgspace1[(w*y+x)][1] = 0;
- imgspace2[(w*y+x)][0] = -ny / nz; /* = dz/dy */
+ imgspace2[(w*y+x)][0] = -ny / nz * h; /* = dz/dy */
imgspace2[(w*y+x)][1] = 0;
#endif
+
+ if(renormalize)
+ {
+ double v = nx * nx + ny * ny + nz * nz;
+ if(v > 0)
+ {
+ v = 1/sqrt(v);
+ nx *= v;
+ ny *= v;
+ nz *= v;
+ map[(w*y+x)*4+2] = floor(nx * 127.5 + 128);
+ map[(w*y+x)*4+1] = floor(ny * 127.5 + 128);
+ map[(w*y+x)*4+0] = floor(nz * 127.5 + 128);
+ }
+ }
}
/* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
{
- int fx = x;
- int fy = y;
- if(fx > w/2)
- fx -= w;
- if(fy > h/2)
- fy -= h;
+ fx = x * 1.0 / w;
+ fy = y * 1.0 / h;
+ if(fx > 0.5)
+ fx -= 1;
+ if(fy > 0.5)
+ fy -= 1;
+ if(filter)
+ {
+ /* discontinous case; we must invert whatever "filter" would do on (x, y)! */
#ifdef C99
- if(fx||fy)
- freqspace1[(w*y+x)] = _Complex_I * (fx * freqspace1[(w*y+x)] + fy * freqspace2[(w*y+x)]) / (fx*fx + fy*fy) / TWO_PI;
- else
- freqspace1[(w*y+x)] = 0;
+ fftw_complex response_x = 0;
+ fftw_complex response_y = 0;
+ double sum;
+ for(i = -filterh / 2; i <= filterh / 2; ++i)
+ for(j = -filterw / 2; j <= filterw / 2; ++j)
+ {
+ response_x += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cexp(-_Complex_I * TWO_PI * (j * fx + i * fy));
+ response_y += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cexp(-_Complex_I * TWO_PI * (i * fx + j * fy));
+ }
+
+ /*
+ * we know:
+ * fourier(df/dx)_xy = fourier(f)_xy * response_x
+ * fourier(df/dy)_xy = fourier(f)_xy * response_y
+ * mult by conjugate of response_x, response_y:
+ * conj(response_x) * fourier(df/dx)_xy = fourier(f)_xy * |response_x^2|
+ * conj(response_y) * fourier(df/dy)_xy = fourier(f)_xy * |response_y^2|
+ * and
+ * fourier(f)_xy = (conj(response_x) * fourier(df/dx)_xy + conj(response_y) * fourier(df/dy)_xy) / (|response_x|^2 + |response_y|^2)
+ */
+
+ sum = cabs(response_x) * cabs(response_x) + cabs(response_y) * cabs(response_y);
+
+ if(sum > 0)
+ freqspace1[(w*y+x)] = (conj(response_x) * freqspace1[(w*y+x)] + conj(response_y) * freqspace2[(w*y+x)]) / sum;
+ else
+ freqspace1[(w*y+x)] = 0;
#else
- if(fx||fy)
- {
- save = freqspace1[(w*y+x)][0];
- freqspace1[(w*y+x)][0] = -(fx * freqspace1[(w*y+x)][1] + fy * freqspace2[(w*y+x)][1]) / (fx*fx + fy*fy) / TWO_PI;
- freqspace1[(w*y+x)][1] = (fx * save + fy * freqspace2[(w*y+x)][0]) / (fx*fx + fy*fy) / TWO_PI;
+ fftw_complex response_x = {0, 0};
+ fftw_complex response_y = {0, 0};
+ double sum;
+ for(i = -filterh / 2; i <= filterh / 2; ++i)
+ for(j = -filterw / 2; j <= filterw / 2; ++j)
+ {
+ response_x[0] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cos(-TWO_PI * (j * fx + i * fy));
+ response_x[1] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * sin(-TWO_PI * (j * fx + i * fy));
+ response_y[0] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * cos(-TWO_PI * (i * fx + j * fy));
+ response_y[1] += filter[(i + filterh / 2) * filterw + j + filterw / 2] * sin(-TWO_PI * (i * fx + j * fy));
+ }
+
+ sum = response_x[0] * response_x[0] + response_x[1] * response_x[1]
+ + response_y[0] * response_y[0] + response_y[1] * response_y[1];
+
+ if(sum > 0)
+ {
+ double s = freqspace1[(w*y+x)][0];
+ freqspace1[(w*y+x)][0] = (response_x[0] * s + 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;
+ freqspace1[(w*y+x)][1] = (response_x[0] * freqspace1[(w*y+x)][1] - response_x[1] * s + response_y[0] * freqspace2[(w*y+x)][1] - response_y[1] * freqspace2[(w*y+x)][0]) / sum;
+ }
+ else
+ {
+ freqspace1[(w*y+x)][0] = 0;
+ freqspace1[(w*y+x)][1] = 0;
+ }
+#endif
}
else
{
- freqspace1[(w*y+x)][0] = 0;
- freqspace1[(w*y+x)][1] = 0;
+ /* continuous integration case */
+ /* these must have the same sign as fx and fy (so ffx*fx + ffy*fy is nonzero), otherwise do not matter */
+ /* it basically decides how artifacts are distributed */
+ ffx = fx;
+ ffy = fy;
+#ifdef C99
+ if(fx||fy)
+ freqspace1[(w*y+x)] = _Complex_I * (ffx * freqspace1[(w*y+x)] + ffy * freqspace2[(w*y+x)]) / (ffx*fx + ffy*fy) / TWO_PI;
+ else
+ freqspace1[(w*y+x)] = 0;
+#else
+ if(fx||fy)
+ {
+ save = freqspace1[(w*y+x)][0];
+ freqspace1[(w*y+x)][0] = -(ffx * freqspace1[(w*y+x)][1] + ffy * freqspace2[(w*y+x)][1]) / (ffx*fx + ffy*fy) / TWO_PI;
+ freqspace1[(w*y+x)][1] = (ffx * save + ffy * freqspace2[(w*y+x)][0]) / (ffx*fx + ffy*fy) / TWO_PI;
+ }
+ else
+ {
+ freqspace1[(w*y+x)][0] = 0;
+ freqspace1[(w*y+x)][1] = 0;
+ }
+#endif
}
+ if(highpass > 0)
+ {
+ double f1 = (fabs(fx)*highpass);
+ double f2 = (fabs(fy)*highpass);
+ /* if either of them is < 1, phase out (min at 0.5) */
+ double f =
+ (f1 <= 0.5 ? 0 : (f1 >= 1 ? 1 : ((f1 - 0.5) * 2.0)))
+ *
+ (f2 <= 0.5 ? 0 : (f2 >= 1 ? 1 : ((f2 - 0.5) * 2.0)));
+#ifdef C99
+ freqspace1[(w*y+x)] *= f;
+#else
+ freqspace1[(w*y+x)][0] *= f;
+ freqspace1[(w*y+x)][1] *= f;
#endif
+ }
}
fftw_execute(f12i1);
/* renormalize, find min/max */
- vmin = vmax = 0;
+ vmin = vmed = vmax = 0;
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
{
#ifdef C99
- v = creal(imgspace1[(w*y+x)] /= (w*h));
+ v = creal(imgspace1[(w*y+x)] /= pow(w*h, 1.5));
#else
- v = (imgspace1[(w*y+x)][0] /= (w*h));
- imgspace1[(w*y+x)][1] /= (w*h);
+ v = (imgspace1[(w*y+x)][0] /= pow(w*h, 1.5));
+ /*
+ * imgspace1[(w*y+x)][1] /= pow(w*h, 1.5);
+ * this value is never used
+ */
#endif
if(v < vmin || (x == 0 && y == 0))
vmin = v;
if(v > vmax || (x == 0 && y == 0))
vmax = v;
+ medianbuf[w*y+x] = v;
}
+ qsort(medianbuf, w*h, sizeof(*medianbuf), floatcmp);
+ if(w*h % 2)
+ vmed = medianbuf[(w*h-1)/2];
+ else
+ vmed = (medianbuf[(w*h)/2] + medianbuf[(w*h-2)/2]) * 0.5;
if(refmap)
{
scale = 2 / (vmax - vmin);
offset = -(vmax + vmin) / (vmax - vmin);
}
+ else if(use_median)
+ {
+ /*
+ * negative scale = match median to offset
+ * we actually want (v - vmed) * scale + offset
+ */
+ offset -= vmed * scale;
+ }
- printf("Min: %f\nAvg: %f\nMax: %f\nScale: %f\nOffset: %f\nScaled-Min: %f\nScaled-Avg: %f\nScaled-Max: %f\n",
- vmin, 0.0, vmax, scale, offset, vmin * scale + offset, offset, vmax * scale + offset);
+ printf("Min: %f\nAvg: %f\nMed: %f\nMax: %f\nScale: %f\nOffset: %f\nScaled-Min: %f\nScaled-Avg: %f\nScaled-Med: %f\nScaled-Max: %f\n",
+ vmin, 0.0, vmed, vmax, scale, offset, vmin * scale + offset, offset, vmed * scale + offset, vmax * scale + offset);
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
v = -1;
if(v > 1)
v = 1;
- map[(w*y+x)*4+3] = floor(128.5 + 127 * v);
+ map[(w*y+x)*4+3] = floor(128.5 + 127 * v); /* in heightmaps, we avoid pixel value 0 as many imaging apps cannot handle it */
}
fftw_destroy_plan(i12f1);
fftw_free(freqspace1);
fftw_free(imgspace2);
fftw_free(imgspace1);
+ free(medianbuf);
}
void hmap_to_nmap(unsigned char *map, int w, int h, int src_chan, double scale)
{
int x, y;
+ double fx, fy;
double nx, ny, nz;
double v;
#ifndef C99
double save;
#endif
- fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
- fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *imgspace1 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *imgspace2 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *freqspace1 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
+ fftw_complex *freqspace2 = (fftw_complex *) fftw_malloc(w*h * sizeof(fftw_complex));
fftw_plan i12f1 = fftw_plan_dft_2d(h, w, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_plan f12i1 = fftw_plan_dft_2d(h, w, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_plan f22i2 = fftw_plan_dft_2d(h, w, freqspace2, imgspace2, FFTW_BACKWARD, FFTW_ESTIMATE);
imgspace1[(w*y+x)][0] = (v - 128.0) / 127.0;
imgspace1[(w*y+x)][1] = 0;
#endif
+ if(v < 1)
+ v = 1; /* do not write alpha zero */
map[(w*y+x)*4+3] = floor(v + 0.5);
}
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
{
- int fx = x;
- int fy = y;
+ fx = x;
+ fy = y;
if(fx > w/2)
fx -= w;
if(fy > h/2)
fy -= h;
+#ifdef DISCONTINUOUS
+ fx = sin(fx * TWO_PI / w);
+ fy = sin(fy * TWO_PI / h);
+#else
#ifdef C99
/* a lowpass to prevent the worst */
freqspace1[(w*y+x)] *= 1 - pow(abs(fx) / (double)(w/2), 1);
freqspace1[(w*y+x)] *= 1 - pow(abs(fy) / (double)(h/2), 1);
-
- freqspace2[(w*y+x)] = TWO_PI*_Complex_I * fy * freqspace1[(w*y+x)]; /* y derivative */
- freqspace1[(w*y+x)] = TWO_PI*_Complex_I * fx * freqspace1[(w*y+x)]; /* x derivative */
#else
/* a lowpass to prevent the worst */
freqspace1[(w*y+x)][0] *= 1 - pow(abs(fx) / (double)(w/2), 1);
freqspace1[(w*y+x)][1] *= 1 - pow(abs(fx) / (double)(w/2), 1);
freqspace1[(w*y+x)][0] *= 1 - pow(abs(fy) / (double)(h/2), 1);
freqspace1[(w*y+x)][1] *= 1 - pow(abs(fy) / (double)(h/2), 1);
-
+#endif
+#endif
+#ifdef C99
+ freqspace2[(w*y+x)] = TWO_PI*_Complex_I * fy * freqspace1[(w*y+x)]; /* y derivative */
+ freqspace1[(w*y+x)] = TWO_PI*_Complex_I * fx * freqspace1[(w*y+x)]; /* x derivative */
+#else
freqspace2[(w*y+x)][0] = -TWO_PI * fy * freqspace1[(w*y+x)][1]; /* y derivative */
freqspace2[(w*y+x)][1] = TWO_PI * fy * freqspace1[(w*y+x)][0];
save = freqspace1[(w*y+x)][0];
fftw_free(imgspace1);
}
-void hmap_to_nmap_local(unsigned char *map, int w, int h, int src_chan, double scale)
+void hmap_to_nmap_local(unsigned char *map, int w, int h, int src_chan, double scale, const double *filter, int filterw, int filterh)
{
int x, y;
double nx, ny, nz;
double v;
int i, j;
- double *img_reduced = malloc(w*h * sizeof(double));
- static const double filter[3][3] = { /* filter to derive one component */
- { -1, 0, 1 },
- { -2, 0, 2 },
- { -1, 0, 1 }
- };
- static const double filter_mult = 0.125;
+ double *img_reduced = (double *) malloc(w*h * sizeof(double));
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
break;
}
img_reduced[(w*y+x)] = (v - 128.0) / 127.0;
+ if(v < 1)
+ v = 1; /* do not write alpha zero */
map[(w*y+x)*4+3] = floor(v + 0.5);
}
for(y = 0; y < h; ++y)
for(x = 0; x < w; ++x)
{
- nz = -1 / (scale * filter_mult);
+ nz = -1 / scale;
nx = ny = 0;
- for(i = -(int)(sizeof(filter) / sizeof(*filter)) / 2; i <= (int)(sizeof(filter) / sizeof(*filter)) / 2; ++i)
- for(j = -(int)(sizeof(*filter) / sizeof(**filter)) / 2; j <= (int)(sizeof(*filter) / sizeof(**filter)) / 2; ++j)
+ for(i = -filterh / 2; i <= filterh / 2; ++i)
+ for(j = -filterw / 2; j <= filterw / 2; ++j)
{
- nx += img_reduced[w*((y+i+h)%h)+(x+j+w)%w] * filter[i+(sizeof(filter) / sizeof(*filter)) / 2][j+(sizeof(*filter) / sizeof(**filter)) / 2];
- ny += img_reduced[w*((y+j+h)%h)+(x+i+w)%w] * filter[i+(sizeof(filter) / sizeof(*filter)) / 2][j+(sizeof(*filter) / sizeof(**filter)) / 2];
+ nx += img_reduced[w*((y+i+h)%h)+(x+j+w)%w] * filter[(i + filterh / 2) * filterw + j + filterw / 2];
+ ny += img_reduced[w*((y+j+h)%h)+(x+i+w)%w] * filter[(i + filterh / 2) * filterw + j + filterw / 2];
}
v = -sqrt(nx*nx + ny*ny + nz*nz);
return NULL;
for(;;)
{
- buf = realloc(buf, *len + 65536);
+ buf = (unsigned char *) realloc(buf, *len + 65536);
if(!buf)
{
fclose(f);
int usage(const char *me)
{
- printf("Usage: %s <infile_norm.tga> <outfile_normandheight.tga> [<scale> [<offset> [<infile_ref.tga>]]] (get heightmap from normalmap)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -1 [<scale>] (read from B, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -2 [<scale>] (read from G, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -3 [<scale>] (read from R, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -4 [<scale>] (read from A, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -5 [<scale>] (read from (R+G+B)/3, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -6 [<scale>] (read from Y, Diff)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -7 [<scale>] (read from B, FFT)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -8 [<scale>] (read from G, FFT)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -9 [<scale>] (read from R, FFT)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -10 [<scale>] (read from A, FFT)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -11 [<scale>] (read from (R+G+B)/3, FFT)\n", me);
- printf("or: %s <infile_height.tga> <outfile_normandheight.tga> -12 [<scale>] (read from Y, FFT)\n", me);
+ printf("Usage: %s <infile_norm.tga> <outfile_normandheight.tga> filtertype [<scale> [<offset> [<infile_ref.tga>]]] (get heightmap from normalmap)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -1 [<scale>] (read from B)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -2 [<scale>] (read from G)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -3 [<scale>] (read from R)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -4 [<scale>] (read from A)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -5 [<scale>] (read from (R+G+B)/3)\n", me);
+ printf("or: %s <infile_height.tga> <outfile_normandheight.tga> filtertype -6 [<scale>] (read from Y)\n", me);
return 1;
}
+static const double filter_scharr3[3][3] = {
+ { -3/32.0, 0, 3/32.0 },
+ { -10/32.0, 0, 10/32.0 },
+ { -3/32.0, 0, 3/32.0 }
+};
+
+static const double filter_prewitt3[3][3] = {
+ { -1/6.0, 0, 1/6.0 },
+ { -1/6.0, 0, 1/6.0 },
+ { -1/6.0, 0, 1/6.0 }
+};
+
+/* pathologic for inverting */
+static const double filter_sobel3[3][3] = {
+ { -1/8.0, 0, 1/8.0 },
+ { -2/8.0, 0, 2/8.0 },
+ { -1/8.0, 0, 1/8.0 }
+};
+
+/* pathologic for inverting */
+static const double filter_sobel5[5][5] = {
+ { -1/128.0, -2/128.0, 0, 2/128.0, 1/128.0 },
+ { -4/128.0, -8/128.0, 0, 8/128.0, 4/128.0 },
+ { -6/128.0, -12/128.0, 0, 12/128.0, 6/128.0 },
+ { -4/128.0, -8/128.0, 0, 8/128.0, 4/128.0 },
+ { -1/128.0, -2/128.0, 0, 2/128.0, 1/128.0 }
+};
+
+/* pathologic for inverting */
+static const double filter_prewitt5[5][5] = {
+ { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
+ { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
+ { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
+ { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 },
+ { -1/40.0, -2/40.0, 0, 2/40.0, 1/40.0 }
+};
+
+static const double filter_trivial[1][3] = {
+ { -0.5, 0, 0.5 }
+};
+
int main(int argc, char **argv)
{
const char *infile, *outfile, *reffile;
double scale, offset;
int nmaplen, w, h;
+ int use_median = 0;
+ int renormalize = 0;
+ double highpass = 0;
unsigned char *nmapdata, *nmap, *refmap;
+ const char *filtertype;
+ const double *filter = NULL;
+ int filterw = 0, filterh = 0;
+#define USE_FILTER(f) \
+ do \
+ { \
+ filterw = sizeof(*(f)) / sizeof(**(f)); \
+ filterh = sizeof((f)) / sizeof(*(f)); \
+ filter = &(f)[0][0]; \
+ } \
+ while(0)
if(argc > 1)
infile = argv[1];
return usage(*argv);
if(argc > 3)
- scale = atof(argv[3]);
+ filtertype = argv[3];
+ else
+ return usage(*argv);
+
+ if(argc > 4)
+ scale = atof(argv[4]);
else
scale = 0;
- if(argc > 4)
- offset = atof(argv[4]);
+ if(argc > 5)
+ offset = atof(argv[5]);
else
offset = (scale<0) ? 1 : 0;
- if(argc > 5)
- reffile = argv[5];
+ if(argc > 6)
+ reffile = argv[6];
else
reffile = NULL;
+ /* experimental features */
+ if(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_RENORMALIZE"))
+ renormalize = atoi(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_RENORMALIZE"));
+ if(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_HIGHPASS"))
+ highpass = atof(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_HIGHPASS"));
+ if(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_USE_MEDIAN"))
+ use_median = atoi(getenv("FFT_NORMALMAP_TO_HEIGHTMAP_USE_MEDIAN"));
+
nmapdata = FS_LoadFile(infile, &nmaplen);
if(!nmapdata)
{
else
refmap = NULL;
- if(scale < -6)
- hmap_to_nmap(nmap, image_width, image_height, -scale-7, offset);
- else if(scale < 0)
- hmap_to_nmap_local(nmap, image_width, image_height, -scale-1, offset);
+ if(!strcmp(filtertype, "trivial"))
+ USE_FILTER(filter_trivial);
+ if(!strcmp(filtertype, "prewitt3"))
+ USE_FILTER(filter_prewitt3);
+ if(!strcmp(filtertype, "scharr3"))
+ USE_FILTER(filter_scharr3);
+ if(!strcmp(filtertype, "sobel3"))
+ USE_FILTER(filter_sobel3);
+ if(!strcmp(filtertype, "prewitt5"))
+ USE_FILTER(filter_prewitt5);
+ if(!strcmp(filtertype, "sobel5"))
+ USE_FILTER(filter_sobel5);
+
+ if(scale < 0)
+ {
+ if(filter)
+ hmap_to_nmap_local(nmap, image_width, image_height, -scale-1, offset, filter, filterw, filterh);
+ else
+ hmap_to_nmap(nmap, image_width, image_height, -scale-1, offset);
+ }
else
- nmap_to_hmap(nmap, refmap, image_width, image_height, scale, offset);
+ nmap_to_hmap(nmap, refmap, image_width, image_height, scale, offset, filter, filterw, filterh, renormalize, highpass, use_median);
+
if(!Image_WriteTGABGRA(outfile, image_width, image_height, nmap))
{
printf("Image_WriteTGABGRA failed\n");