Mercurial > hg > orthanc-stone
annotate Framework/Toolbox/ImageGeometry.cpp @ 342:4297d6c5eef9 am-2
moving bitmap
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 22 Oct 2018 09:44:52 +0200 |
parents | f5d5814a41a0 |
children | c2e040ea8fbe |
rev | line source |
---|---|
182 | 1 /** |
2 * Stone of Orthanc | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
5 * Copyright (C) 2017-2018 Osimis S.A., Belgium | |
6 * | |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU Affero General Public License | |
9 * as published by the Free Software Foundation, either version 3 of | |
10 * the License, or (at your option) any later version. | |
11 * | |
12 * This program is distributed in the hope that it will be useful, but | |
13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Affero General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Affero General Public License | |
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 **/ | |
20 | |
21 | |
22 #include "ImageGeometry.h" | |
23 | |
24 #include "Extent2D.h" | |
25 #include "SubpixelReader.h" | |
26 | |
212
5412adf19980
resort to OrthancFramework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
201
diff
changeset
|
27 #include <Core/Images/ImageProcessing.h> |
5412adf19980
resort to OrthancFramework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
201
diff
changeset
|
28 #include <Core/Logging.h> |
335 | 29 #include <Core/OrthancException.h> |
182 | 30 |
31 | |
32 namespace OrthancStone | |
33 { | |
34 static void AddTransformedPoint(Extent2D& extent, | |
35 const Matrix& a, | |
36 double x, | |
37 double y) | |
38 { | |
39 assert(a.size1() == 3 && | |
40 a.size2() == 3); | |
41 | |
42 Vector p = LinearAlgebra::Product(a, LinearAlgebra::CreateVector(x, y, 1)); | |
43 | |
44 if (!LinearAlgebra::IsCloseToZero(p[2])) | |
45 { | |
46 extent.AddPoint(p[0] / p[2], p[1] / p[2]); | |
47 } | |
48 } | |
49 | |
50 | |
190 | 51 bool GetProjectiveTransformExtent(unsigned int& x1, |
182 | 52 unsigned int& y1, |
53 unsigned int& x2, | |
54 unsigned int& y2, | |
55 const Matrix& a, | |
56 unsigned int sourceWidth, | |
57 unsigned int sourceHeight, | |
58 unsigned int targetWidth, | |
59 unsigned int targetHeight) | |
60 { | |
61 if (targetWidth == 0 || | |
62 targetHeight == 0) | |
63 { | |
64 return false; | |
65 } | |
66 | |
67 Extent2D extent; | |
68 AddTransformedPoint(extent, a, 0, 0); | |
69 AddTransformedPoint(extent, a, sourceWidth, 0); | |
70 AddTransformedPoint(extent, a, 0, sourceHeight); | |
71 AddTransformedPoint(extent, a, sourceWidth, sourceHeight); | |
72 | |
73 if (extent.IsEmpty()) | |
74 { | |
75 return false; | |
76 } | |
77 else | |
78 { | |
79 int tmp; | |
80 | |
81 tmp = std::floor(extent.GetX1()); | |
82 if (tmp < 0) | |
83 { | |
84 x1 = 0; | |
85 } | |
86 else | |
87 { | |
88 x1 = static_cast<unsigned int>(tmp); | |
89 } | |
90 | |
91 tmp = std::floor(extent.GetY1()); | |
92 if (tmp < 0) | |
93 { | |
94 y1 = 0; | |
95 } | |
96 else | |
97 { | |
98 y1 = static_cast<unsigned int>(tmp); | |
99 } | |
100 | |
101 tmp = std::ceil(extent.GetX2()); | |
102 if (tmp < 0) | |
103 { | |
104 return false; | |
105 } | |
106 else if (static_cast<unsigned int>(tmp) >= targetWidth) | |
107 { | |
108 x2 = targetWidth - 1; | |
109 } | |
110 else | |
111 { | |
112 x2 = static_cast<unsigned int>(tmp); | |
113 } | |
114 | |
115 tmp = std::ceil(extent.GetY2()); | |
116 if (tmp < 0) | |
117 { | |
118 return false; | |
119 } | |
120 else if (static_cast<unsigned int>(tmp) >= targetHeight) | |
121 { | |
122 y2 = targetHeight - 1; | |
123 } | |
124 else | |
125 { | |
126 y2 = static_cast<unsigned int>(tmp); | |
127 } | |
128 | |
129 return (x1 <= x2 && | |
130 y1 <= y2); | |
131 } | |
132 } | |
133 | |
134 | |
135 template <typename Reader, | |
136 bool HasOffsetX, | |
137 bool HasOffsetY> | |
138 static void ApplyAffineTransformToRow(typename Reader::PixelType* p, | |
139 Reader& reader, | |
140 unsigned int x1, | |
141 unsigned int x2, | |
142 float positionX, | |
143 float positionY, | |
144 float offsetX, | |
145 float offsetY) | |
146 { | |
147 typename Reader::PixelType value; | |
148 | |
149 for (unsigned int x = x1; x <= x2; x++, p++) | |
150 { | |
151 if (reader.GetValue(value, positionX, positionY)) | |
152 { | |
153 *p = value; | |
154 } | |
155 else | |
156 { | |
157 Reader::Traits::SetZero(*p); | |
158 } | |
159 | |
160 if (HasOffsetX) | |
161 { | |
162 positionX += offsetX; | |
163 } | |
164 | |
165 if (HasOffsetY) | |
166 { | |
167 positionY += offsetY; | |
168 } | |
169 } | |
170 } | |
171 | |
172 | |
173 template <Orthanc::PixelFormat Format, | |
174 ImageInterpolation Interpolation> | |
175 static void ApplyAffineInternal(Orthanc::ImageAccessor& target, | |
176 const Orthanc::ImageAccessor& source, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
177 const Matrix& a, |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
178 bool clear) |
182 | 179 { |
180 assert(target.GetFormat() == Format && | |
181 source.GetFormat() == Format); | |
182 | |
183 typedef SubpixelReader<Format, Interpolation> Reader; | |
184 typedef typename Reader::PixelType PixelType; | |
185 | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
186 if (clear) |
182 | 187 { |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
188 if (Format == Orthanc::PixelFormat_RGB24) |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
189 { |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
190 Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
191 } |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
192 else |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
193 { |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
194 Orthanc::ImageProcessing::Set(target, 0); |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
195 } |
182 | 196 } |
197 | |
198 Matrix inva; | |
199 if (!LinearAlgebra::InvertMatrixUnsafe(inva, a)) | |
200 { | |
201 // Singular matrix | |
202 return; | |
203 } | |
204 | |
205 Reader reader(source); | |
206 | |
207 unsigned int x1, y1, x2, y2; | |
208 | |
190 | 209 if (GetProjectiveTransformExtent(x1, y1, x2, y2, a, |
182 | 210 source.GetWidth(), source.GetHeight(), |
211 target.GetWidth(), target.GetHeight())) | |
212 { | |
213 const size_t targetPitch = target.GetPitch(); | |
191
46cb2eedc2e0
ShearWarpProjectiveTransform
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
214 uint8_t *targetRow = reinterpret_cast<uint8_t*> |
46cb2eedc2e0
ShearWarpProjectiveTransform
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
215 (reinterpret_cast<PixelType*>(target.GetRow(y1)) + x1); |
182 | 216 |
217 for (unsigned int y = y1; y <= y2; y++) | |
218 { | |
219 Vector start; | |
220 LinearAlgebra::AssignVector(start, static_cast<double>(x1) + 0.5, | |
221 static_cast<double>(y) + 0.5, 1); | |
222 start = boost::numeric::ublas::prod(inva, start); | |
223 assert(LinearAlgebra::IsNear(1.0, start(2))); | |
224 | |
225 Vector offset; | |
226 LinearAlgebra::AssignVector(offset, static_cast<double>(x1) + 1.5, | |
227 static_cast<double>(y) + 0.5, 1); | |
228 offset = boost::numeric::ublas::prod(inva, offset) - start; | |
229 assert(LinearAlgebra::IsNear(0.0, offset(2))); | |
230 | |
231 float startX = static_cast<float>(start[0]); | |
232 float startY = static_cast<float>(start[1]); | |
233 float offsetX = static_cast<float>(offset[0]); | |
234 float offsetY = static_cast<float>(offset[1]); | |
235 | |
236 PixelType* pixel = reinterpret_cast<PixelType*>(targetRow); | |
237 if (LinearAlgebra::IsCloseToZero(offsetX)) | |
238 { | |
239 ApplyAffineTransformToRow<Reader, false, true> | |
240 (pixel, reader, x1, x2, startX, startY, offsetX, offsetY); | |
241 } | |
242 else if (LinearAlgebra::IsCloseToZero(offsetY)) | |
243 { | |
244 ApplyAffineTransformToRow<Reader, true, false> | |
245 (pixel, reader, x1, x2, startX, startY, offsetX, offsetY); | |
246 } | |
247 else | |
248 { | |
249 ApplyAffineTransformToRow<Reader, true, true> | |
250 (pixel, reader, x1, x2, startX, startY, offsetX, offsetY); | |
251 } | |
252 | |
253 targetRow += targetPitch; | |
254 } | |
255 } | |
256 } | |
257 | |
258 | |
259 void ApplyAffineTransform(Orthanc::ImageAccessor& target, | |
260 const Orthanc::ImageAccessor& source, | |
261 double a11, | |
262 double a12, | |
263 double b1, | |
264 double a21, | |
265 double a22, | |
266 double b2, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
267 ImageInterpolation interpolation, |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
268 bool clear) |
182 | 269 { |
270 if (source.GetFormat() != target.GetFormat()) | |
271 { | |
272 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat); | |
273 } | |
274 | |
275 if (interpolation != ImageInterpolation_Nearest && | |
276 interpolation != ImageInterpolation_Bilinear) | |
277 { | |
278 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
279 } | |
280 | |
281 Matrix a; | |
282 a.resize(3, 3); | |
283 a(0, 0) = a11; | |
284 a(0, 1) = a12; | |
285 a(0, 2) = b1; | |
286 a(1, 0) = a21; | |
287 a(1, 1) = a22; | |
288 a(1, 2) = b2; | |
289 a(2, 0) = 0; | |
290 a(2, 1) = 0; | |
291 a(2, 2) = 1; | |
292 | |
293 switch (source.GetFormat()) | |
294 { | |
295 case Orthanc::PixelFormat_Grayscale8: | |
296 switch (interpolation) | |
297 { | |
298 case ImageInterpolation_Nearest: | |
299 ApplyAffineInternal<Orthanc::PixelFormat_Grayscale8, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
300 ImageInterpolation_Nearest>(target, source, a, clear); |
182 | 301 break; |
302 | |
303 case ImageInterpolation_Bilinear: | |
304 ApplyAffineInternal<Orthanc::PixelFormat_Grayscale8, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
305 ImageInterpolation_Bilinear>(target, source, a, clear); |
182 | 306 break; |
307 | |
308 default: | |
309 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
310 } | |
311 break; | |
312 | |
313 case Orthanc::PixelFormat_Grayscale16: | |
314 switch (interpolation) | |
315 { | |
316 case ImageInterpolation_Nearest: | |
317 ApplyAffineInternal<Orthanc::PixelFormat_Grayscale16, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
318 ImageInterpolation_Nearest>(target, source, a, clear); |
182 | 319 break; |
320 | |
321 case ImageInterpolation_Bilinear: | |
322 ApplyAffineInternal<Orthanc::PixelFormat_Grayscale16, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
323 ImageInterpolation_Bilinear>(target, source, a, clear); |
182 | 324 break; |
325 | |
326 default: | |
327 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
328 } | |
329 break; | |
330 | |
331 case Orthanc::PixelFormat_SignedGrayscale16: | |
332 switch (interpolation) | |
333 { | |
334 case ImageInterpolation_Nearest: | |
335 ApplyAffineInternal<Orthanc::PixelFormat_SignedGrayscale16, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
336 ImageInterpolation_Nearest>(target, source, a, clear); |
182 | 337 break; |
338 | |
339 case ImageInterpolation_Bilinear: | |
340 ApplyAffineInternal<Orthanc::PixelFormat_SignedGrayscale16, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
341 ImageInterpolation_Bilinear>(target, source, a, clear); |
182 | 342 break; |
343 | |
344 default: | |
345 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
346 } | |
347 break; | |
348 | |
338 | 349 case Orthanc::PixelFormat_Float32: |
350 switch (interpolation) | |
351 { | |
352 case ImageInterpolation_Nearest: | |
353 ApplyAffineInternal<Orthanc::PixelFormat_Float32, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
354 ImageInterpolation_Nearest>(target, source, a, clear); |
338 | 355 break; |
356 | |
357 case ImageInterpolation_Bilinear: | |
358 ApplyAffineInternal<Orthanc::PixelFormat_Float32, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
359 ImageInterpolation_Bilinear>(target, source, a, clear); |
338 | 360 break; |
361 | |
362 default: | |
363 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
364 } | |
365 break; | |
366 | |
182 | 367 case Orthanc::PixelFormat_RGB24: |
368 switch (interpolation) | |
369 { | |
370 case ImageInterpolation_Nearest: | |
371 ApplyAffineInternal<Orthanc::PixelFormat_RGB24, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
372 ImageInterpolation_Nearest>(target, source, a, clear); |
182 | 373 break; |
374 | |
375 default: | |
376 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
377 } | |
378 break; | |
379 | |
380 default: | |
381 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
382 } | |
383 } | |
384 | |
385 | |
386 template <Orthanc::PixelFormat Format, | |
387 ImageInterpolation Interpolation> | |
190 | 388 static void ApplyProjectiveInternal(Orthanc::ImageAccessor& target, |
389 const Orthanc::ImageAccessor& source, | |
390 const Matrix& a, | |
391 const Matrix& inva) | |
182 | 392 { |
393 assert(target.GetFormat() == Format && | |
394 source.GetFormat() == Format); | |
395 | |
396 typedef SubpixelReader<Format, Interpolation> Reader; | |
397 typedef typename Reader::PixelType PixelType; | |
398 | |
399 Reader reader(source); | |
400 unsigned int x1, y1, x2, y2; | |
401 | |
402 const float floatWidth = source.GetWidth(); | |
403 const float floatHeight = source.GetHeight(); | |
404 | |
190 | 405 if (GetProjectiveTransformExtent(x1, y1, x2, y2, a, |
182 | 406 source.GetWidth(), source.GetHeight(), |
407 target.GetWidth(), target.GetHeight())) | |
408 { | |
409 const size_t targetPitch = target.GetPitch(); | |
191
46cb2eedc2e0
ShearWarpProjectiveTransform
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
410 uint8_t *targetRow = reinterpret_cast<uint8_t*> |
46cb2eedc2e0
ShearWarpProjectiveTransform
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
190
diff
changeset
|
411 (reinterpret_cast<PixelType*>(target.GetRow(y1)) + x1); |
182 | 412 |
413 for (unsigned int y = y1; y <= y2; y++) | |
414 { | |
415 PixelType *p = reinterpret_cast<PixelType*>(targetRow); | |
416 | |
417 for (unsigned int x = x1; x <= x2; x++) | |
418 { | |
419 Vector v; | |
420 LinearAlgebra::AssignVector(v, static_cast<double>(x) + 0.5, | |
421 static_cast<double>(y) + 0.5, 1); | |
422 | |
423 Vector vv = LinearAlgebra::Product(inva, v); | |
424 | |
425 assert(!LinearAlgebra::IsCloseToZero(vv[2])); | |
426 const double w = 1.0 / vv[2]; | |
427 const float sourceX = static_cast<float>(vv[0] * w); | |
428 const float sourceY = static_cast<float>(vv[1] * w); | |
429 | |
430 // Make sure no integer overflow will occur after truncation | |
431 // (the static_cast<unsigned int> could otherwise throw an | |
190 | 432 // exception in WebAssembly if strong projective effects) |
182 | 433 if (sourceX < floatWidth && |
434 sourceY < floatHeight) | |
435 { | |
436 reader.GetValue(*p, sourceX, sourceY); | |
437 } | |
438 else | |
439 { | |
440 Reader::Traits::SetZero(*p); | |
441 } | |
442 | |
443 p++; | |
444 } | |
445 | |
446 targetRow += targetPitch; | |
447 } | |
448 } | |
449 } | |
450 | |
451 | |
190 | 452 void ApplyProjectiveTransform(Orthanc::ImageAccessor& target, |
453 const Orthanc::ImageAccessor& source, | |
454 const Matrix& a, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
455 ImageInterpolation interpolation, |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
456 bool clear) |
182 | 457 { |
458 if (source.GetFormat() != target.GetFormat()) | |
459 { | |
460 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat); | |
461 } | |
462 | |
463 if (a.size1() != 3 || | |
464 a.size2() != 3) | |
465 { | |
466 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageSize); | |
467 } | |
468 | |
469 if (interpolation != ImageInterpolation_Nearest && | |
470 interpolation != ImageInterpolation_Bilinear) | |
471 { | |
472 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
473 } | |
474 | |
475 // Check whether we are dealing with an affine transform | |
476 if (LinearAlgebra::IsCloseToZero(a(2, 0)) && | |
477 LinearAlgebra::IsCloseToZero(a(2, 1))) | |
478 { | |
479 double w = a(2, 2); | |
480 if (LinearAlgebra::IsCloseToZero(w)) | |
481 { | |
190 | 482 LOG(ERROR) << "Singular projective matrix"; |
182 | 483 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); |
484 } | |
485 else | |
486 { | |
487 ApplyAffineTransform(target, source, | |
488 a(0, 0) / w, a(0, 1) / w, a(0, 2) / w, | |
489 a(1, 0) / w, a(1, 1) / w, a(1, 2) / w, | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
490 interpolation, clear); |
182 | 491 return; |
492 } | |
493 } | |
494 | |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
495 if (clear) |
182 | 496 { |
340
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
497 if (target.GetFormat() == Orthanc::PixelFormat_RGB24) |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
498 { |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
499 Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
500 } |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
501 else |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
502 { |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
503 Orthanc::ImageProcessing::Set(target, 0); |
f5d5814a41a0
rendering BitmapStack
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
338
diff
changeset
|
504 } |
182 | 505 } |
506 | |
507 Matrix inva; | |
508 if (!LinearAlgebra::InvertMatrixUnsafe(inva, a)) | |
509 { | |
510 return; | |
511 } | |
512 | |
513 switch (source.GetFormat()) | |
514 { | |
515 case Orthanc::PixelFormat_Grayscale8: | |
516 switch (interpolation) | |
517 { | |
518 case ImageInterpolation_Nearest: | |
190 | 519 ApplyProjectiveInternal<Orthanc::PixelFormat_Grayscale8, |
520 ImageInterpolation_Nearest>(target, source, a, inva); | |
182 | 521 break; |
522 | |
523 case ImageInterpolation_Bilinear: | |
190 | 524 ApplyProjectiveInternal<Orthanc::PixelFormat_Grayscale8, |
525 ImageInterpolation_Bilinear>(target, source, a, inva); | |
182 | 526 break; |
527 | |
528 default: | |
529 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
530 } | |
531 break; | |
532 | |
533 case Orthanc::PixelFormat_Grayscale16: | |
534 switch (interpolation) | |
535 { | |
536 case ImageInterpolation_Nearest: | |
190 | 537 ApplyProjectiveInternal<Orthanc::PixelFormat_Grayscale16, |
538 ImageInterpolation_Nearest>(target, source, a, inva); | |
182 | 539 break; |
540 | |
541 case ImageInterpolation_Bilinear: | |
190 | 542 ApplyProjectiveInternal<Orthanc::PixelFormat_Grayscale16, |
543 ImageInterpolation_Bilinear>(target, source, a, inva); | |
182 | 544 break; |
545 | |
546 default: | |
547 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
548 } | |
549 break; | |
550 | |
551 case Orthanc::PixelFormat_SignedGrayscale16: | |
552 switch (interpolation) | |
553 { | |
554 case ImageInterpolation_Nearest: | |
190 | 555 ApplyProjectiveInternal<Orthanc::PixelFormat_SignedGrayscale16, |
556 ImageInterpolation_Nearest>(target, source, a, inva); | |
182 | 557 break; |
558 | |
559 case ImageInterpolation_Bilinear: | |
190 | 560 ApplyProjectiveInternal<Orthanc::PixelFormat_SignedGrayscale16, |
561 ImageInterpolation_Bilinear>(target, source, a, inva); | |
182 | 562 break; |
563 | |
564 default: | |
565 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
566 } | |
567 break; | |
568 | |
338 | 569 case Orthanc::PixelFormat_Float32: |
570 switch (interpolation) | |
571 { | |
572 case ImageInterpolation_Nearest: | |
573 ApplyProjectiveInternal<Orthanc::PixelFormat_Float32, | |
574 ImageInterpolation_Nearest>(target, source, a, inva); | |
575 break; | |
576 | |
577 case ImageInterpolation_Bilinear: | |
578 ApplyProjectiveInternal<Orthanc::PixelFormat_Float32, | |
579 ImageInterpolation_Bilinear>(target, source, a, inva); | |
580 break; | |
581 | |
582 default: | |
583 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
584 } | |
585 break; | |
586 | |
182 | 587 case Orthanc::PixelFormat_RGB24: |
588 switch (interpolation) | |
589 { | |
590 case ImageInterpolation_Nearest: | |
190 | 591 ApplyProjectiveInternal<Orthanc::PixelFormat_RGB24, |
592 ImageInterpolation_Nearest>(target, source, a, inva); | |
182 | 593 break; |
594 | |
595 default: | |
596 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
597 } | |
598 break; | |
599 | |
600 default: | |
601 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
602 } | |
603 } | |
604 } |