1 | #include "dxReaderCommon.h" |
---|
2 | #include "GradientFilter.h" |
---|
3 | |
---|
4 | #include "Vector3.h" |
---|
5 | #include "stdlib.h" |
---|
6 | |
---|
7 | float * |
---|
8 | merge(float* scalar, float* gradient, int size) |
---|
9 | { |
---|
10 | float* data = (float*) malloc(sizeof(float) * 4 * size); |
---|
11 | |
---|
12 | Vector3* g = (Vector3*) gradient; |
---|
13 | |
---|
14 | int ngen = 0, sindex = 0; |
---|
15 | for (sindex = 0; sindex <size; ++sindex) { |
---|
16 | data[ngen++] = scalar[sindex]; |
---|
17 | data[ngen++] = g[sindex].x; |
---|
18 | data[ngen++] = g[sindex].y; |
---|
19 | data[ngen++] = g[sindex].z; |
---|
20 | } |
---|
21 | return data; |
---|
22 | } |
---|
23 | |
---|
24 | void |
---|
25 | normalizeScalar(float* fdata, int count, float min, float max) |
---|
26 | { |
---|
27 | float v = max - min; |
---|
28 | if (v != 0.0f) { |
---|
29 | for (int i = 0; i < count; ++i) { |
---|
30 | fdata[i] = fdata[i] / v; |
---|
31 | } |
---|
32 | } |
---|
33 | } |
---|
34 | |
---|
35 | float* |
---|
36 | computeGradient(float* fdata, int width, int height, int depth, |
---|
37 | float min, float max) |
---|
38 | { |
---|
39 | float* gradients = (float *)malloc(width * height * depth * 3 * |
---|
40 | sizeof(float)); |
---|
41 | float* tempGradients = (float *)malloc(width * height * depth * 3 * |
---|
42 | sizeof(float)); |
---|
43 | int sizes[3] = { width, height, depth }; |
---|
44 | computeGradients(tempGradients, fdata, sizes, DATRAW_FLOAT); |
---|
45 | filterGradients(tempGradients, sizes); |
---|
46 | quantizeGradients(tempGradients, gradients, sizes, DATRAW_FLOAT); |
---|
47 | normalizeScalar(fdata, width * height * depth, min, max); |
---|
48 | float* data = merge(fdata, gradients, width * height * depth); |
---|
49 | return data; |
---|
50 | } |
---|
51 | |
---|
52 | void |
---|
53 | computeSimpleGradient(float* data, int nx, int ny, int nz) |
---|
54 | { |
---|
55 | // Compute the gradient of this data. BE CAREFUL: center |
---|
56 | // calculation on each node to avoid skew in either direction. |
---|
57 | int ngen = 0; |
---|
58 | for (int iz=0; iz < nz; iz++) { |
---|
59 | for (int iy=0; iy < ny; iy++) { |
---|
60 | for (int ix=0; ix < nx; ix++) { |
---|
61 | // gradient in x-direction |
---|
62 | |
---|
63 | // INSOO -teST |
---|
64 | double valm1 = (ix == 0) ? 0.0 : data[ngen - 4]; |
---|
65 | double valp1 = (ix == nx-1) ? 0.0 : data[ngen + 4]; |
---|
66 | if (valm1 < 0 || valp1 < 0) { |
---|
67 | data[ngen+1] = 0.0; |
---|
68 | } else { |
---|
69 | data[ngen+1] = valp1-valm1; // assume dx=1 // ISO |
---|
70 | //data[ngen+1] = ((valp1-valm1) + 1) * 0.5; // assume dx=1 |
---|
71 | } |
---|
72 | |
---|
73 | // gradient in y-direction |
---|
74 | valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx]; |
---|
75 | valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx]; |
---|
76 | if (valm1 < 0 || valp1 < 0) { |
---|
77 | data[ngen+2] = 0.0; |
---|
78 | } else { |
---|
79 | data[ngen+2] = valp1-valm1; // assume dx=1 |
---|
80 | //data[ngen+2] = ((valp1-valm1) + 1) * 0.5; // assume dy=1 // ISO |
---|
81 | } |
---|
82 | |
---|
83 | // gradient in z-direction |
---|
84 | valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny]; |
---|
85 | valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny]; |
---|
86 | if (valm1 < 0 || valp1 < 0) { |
---|
87 | data[ngen+3] = 0.0; |
---|
88 | } else { |
---|
89 | data[ngen+3] = valp1-valm1; // assume dx=1 |
---|
90 | //data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1 //ISO |
---|
91 | } |
---|
92 | |
---|
93 | ngen += 4; |
---|
94 | } |
---|
95 | } |
---|
96 | } |
---|
97 | } |
---|