Mercurial > hg > orthanc-stone

comparison Framework/Toolbox/GeometryToolbox.h @ 177:83200c4d07ca wasm

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix interpolation
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 09 Mar 2018 12:32:01 +0100
parents 15d92d93738b
children 964118e7e6de
comparison
equal deleted inserted replaced
176:ab9c799f5de1 177:83200c4d07ca
93 const Vector& normal, 93 const Vector& normal,
94 double d, 94 double d,
95 const Vector& origin, 95 const Vector& origin,
96 const Vector& direction); 96 const Vector& direction);
97 97
98 inline float ComputeBilinearInterpolationInternal(float x, 98 inline float ComputeBilinearInterpolationUnitSquare(float x,
99 float y, 99 float y,
100 float f00, // source(x, y) 100 float f00, // source(0, 0)
101 float f01, // source(x + 1, y) 101 float f01, // source(1, 0)
102 float f10, // source(x, y + 1) 102 float f10, // source(0, 1)
103 float f11); // source(x + 1, y + 1) 103 float f11); // source(1, 1)
104 104
105 inline float ComputeBilinearInterpolation(float x, 105 inline float ComputeTrilinearInterpolationUnitSquare(float x,
106 float y, 106 float y,
107 float f00, // source(x, y) 107 float z,
108 float f01, // source(x + 1, y) 108 float f000, // source(0, 0, 0)
109 float f10, // source(x, y + 1) 109 float f001, // source(1, 0, 0)
110 float f11); // source(x + 1, y + 1) 110 float f010, // source(0, 1, 0)
111 111 float f011, // source(1, 1, 0)
112 inline float ComputeTrilinearInterpolation(float x, 112 float f100, // source(0, 0, 1)
113 float y, 113 float f101, // source(1, 0, 1)
114 float z, 114 float f110, // source(0, 1, 1)
115 float f000, // source(x, y, z) 115 float f111); // source(1, 1, 1)
116 float f001, // source(x + 1, y, z)
117 float f010, // source(x, y + 1, z)
118 float f011, // source(x + 1, y + 1, z)
119 float f100, // source(x, y, z + 1)
120 float f101, // source(x + 1, y, z + 1)
121 float f110, // source(x, y + 1, z + 1)
122 float f111); // source(x + 1, y + 1, z + 1)
123 }; 116 };
124 } 117 }
125 118
126 119
127 float OrthancStone::GeometryToolbox::ComputeBilinearInterpolationInternal(float x, 120 float OrthancStone::GeometryToolbox::ComputeBilinearInterpolationUnitSquare(float x,
128 float y, 121 float y,
129 float f00, 122 float f00,
130 float f01, 123 float f01,
131 float f10, 124 float f10,
132 float f11) 125 float f11)
133 { 126 {
134 // This function only works on fractional parts 127 // This function only works within the unit square
135 assert(x >= 0 && y >= 0 && x < 1 && y < 1); 128 assert(x >= 0 && y >= 0 && x <= 1 && y <= 1);
136 129
137 // https://en.wikipedia.org/wiki/Bilinear_interpolation#Unit_square 130 // https://en.wikipedia.org/wiki/Bilinear_interpolation#Unit_square
138 return (f00 * (1.0f - x) * (1.0f - y) + 131 return (f00 * (1.0f - x) * (1.0f - y) +
139 f01 * x * (1.0f - y) + 132 f01 * x * (1.0f - y) +
140 f10 * (1.0f - x) * y + 133 f10 * (1.0f - x) * y +
141 f11 * x * y); 134 f11 * x * y);
142 } 135 }
143 136
144 137
145 float OrthancStone::GeometryToolbox::ComputeBilinearInterpolation(float x, 138 float OrthancStone::GeometryToolbox::ComputeTrilinearInterpolationUnitSquare(float x,
146 float y, 139 float y,
147 float f00, 140 float z,
148 float f01, 141 float f000,
149 float f10, 142 float f001,
150 float f11) 143 float f010,
144 float f011,
145 float f100,
146 float f101,
147 float f110,
148 float f111)
151 { 149 {
152 // Compute the fractional part of (x,y)
153 float xx = x - std::floor(x);
154 float yy = y - std::floor(y);
155
156 return ComputeBilinearInterpolationInternal(xx, yy, f00, f01, f10, f11);
157 }
158
159
160 float OrthancStone::GeometryToolbox::ComputeTrilinearInterpolation(float x,
161 float y,
162 float z,
163 float f000,
164 float f001,
165 float f010,
166 float f011,
167 float f100,
168 float f101,
169 float f110,
170 float f111)
171 {
172 float xx = x - std::floor(x);
173 float yy = y - std::floor(y);
174 float zz = z - std::floor(z);
175
176 // "In practice, a trilinear interpolation is identical to two 150 // "In practice, a trilinear interpolation is identical to two
177 // bilinear interpolation combined with a linear interpolation" 151 // bilinear interpolation combined with a linear interpolation"
178 // https://en.wikipedia.org/wiki/Trilinear_interpolation#Method 152 // https://en.wikipedia.org/wiki/Trilinear_interpolation#Method
179 float a = ComputeBilinearInterpolationInternal(xx, yy, f000, f001, f010, f011); 153 float a = ComputeBilinearInterpolationUnitSquare(x, y, f000, f001, f010, f011);
180 float b = ComputeBilinearInterpolationInternal(xx, yy, f100, f101, f110, f111); 154 float b = ComputeBilinearInterpolationUnitSquare(x, y, f100, f101, f110, f111);
181 155
182 return (1.0f - zz) * a + zz * b; 156 return (1.0f - z) * a + z * b;
183 } 157 }