ITK  5.4.0
Insight Toolkit
itkFFTWCommon.h
Go to the documentation of this file.
1/*=========================================================================
2 *
3 * Copyright NumFOCUS
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0.txt
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *=========================================================================*/
18#ifndef itkFFTWCommon_h
19#define itkFFTWCommon_h
20
21#if defined(ITK_USE_FFTWF) || defined(ITK_USE_FFTWD)
22# if defined(ITK_USE_CUFFTW)
23# include "cufftw.h"
24# else
26# include "fftw3.h"
27# endif
28# if !defined(FFTW_WISDOM_ONLY)
29// FFTW_WISDOM_ONLY is a "beyond guru" option that is only available in fftw 3.2.2
30// to be compatible with all the fftw 3.x API, we need to define this away here:
31# error "FFTW 3.3.2 or later is required so that FFTW_WISDOM_ONLY is defined."
32# endif
33
34#endif
35
36#include <mutex>
37
38namespace itk
39{
40namespace fftw
41{
53template <typename TPixel>
54class Proxy
55{
56 // empty -- only double and float specializations work
57
58protected:
59 Proxy() = default;
60 ~Proxy() = default;
61};
62
63#if defined(ITK_USE_FFTWF)
64
65template <>
66class Proxy<float>
67{
68public:
69 using PixelType = float;
70 using ComplexType = fftwf_complex;
71 using PlanType = fftwf_plan;
73
74 // FFTW works with any data size, but is optimized for size decomposition with prime factors up to 13.
75# ifdef ITK_USE_CUFFTW
76 static constexpr SizeValueType GREATEST_PRIME_FACTOR = 7;
77# else
78 static constexpr SizeValueType GREATEST_PRIME_FACTOR = 13;
79# endif
80
81 static PlanType
83 ComplexType * in,
84 PixelType * out,
85 unsigned int flags,
86 int threads = 1,
87 bool canDestroyInput = false)
88 {
89 return Plan_dft_c2r(1, &n, in, out, flags, threads, canDestroyInput);
90 }
91
92 static PlanType
94 int ny,
95 ComplexType * in,
96 PixelType * out,
97 unsigned int flags,
98 int threads = 1,
99 bool canDestroyInput = false)
100 {
101 int sizes[2];
102 sizes[0] = nx;
103 sizes[1] = ny;
104 PlanType plan = Plan_dft_c2r(2, sizes, in, out, flags, threads, canDestroyInput);
105 return plan;
106 }
107
108 static PlanType
110 int ny,
111 int nz,
112 ComplexType * in,
113 PixelType * out,
114 unsigned int flags,
115 int threads = 1,
116 bool canDestroyInput = false)
117 {
118 int sizes[3];
119 sizes[0] = nx;
120 sizes[1] = ny;
121 sizes[2] = nz;
122 PlanType plan = Plan_dft_c2r(3, sizes, in, out, flags, threads, canDestroyInput);
123 return plan;
124 }
125
126 static PlanType
127 Plan_dft_c2r(int rank,
128 const int * n,
129 ComplexType * in,
130 PixelType * out,
131 unsigned int flags,
132 int threads = 1,
133 bool canDestroyInput = false)
134 {
135# ifndef ITK_USE_CUFFTW
136 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
137 fftwf_plan_with_nthreads(threads);
138# else
139 (void)threads;
140# endif
141 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
142 // because FFTW_ESTIMATE guarantee to not destroy the input
143 unsigned int roflags = flags;
144 if (!(flags & FFTW_ESTIMATE))
145 {
146 roflags = flags | FFTW_WISDOM_ONLY;
147 }
148 PlanType plan = fftwf_plan_dft_c2r(rank, n, in, out, roflags);
149 if (plan == nullptr)
150 {
151 // no wisdom available for that plan
152 if (canDestroyInput)
153 {
154 // just create the plan
155 plan = fftwf_plan_dft_c2r(rank, n, in, out, flags);
156 }
157 else
158 {
159 // lets create a plan with a fake input to generate the wisdom
160 int total = 1;
161 for (int i = 0; i < rank; ++i)
162 {
163 total *= n[i];
164 }
165 auto * din = new ComplexType[total];
166 fftwf_plan_dft_c2r(rank, n, din, out, flags);
167 delete[] din;
168 // and then create the final plan - this time it shouldn't fail
169 plan = fftwf_plan_dft_c2r(rank, n, in, out, roflags);
170 }
171# ifndef ITK_USE_CUFFTW
173# endif
174 }
175 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
176 return plan;
177 }
178
179
180 static PlanType
182 PixelType * in,
183 ComplexType * out,
184 unsigned int flags,
185 int threads = 1,
186 bool canDestroyInput = false)
187 {
188 return Plan_dft_r2c(1, &n, in, out, flags, threads, canDestroyInput);
189 }
190
191 static PlanType
193 int ny,
194 PixelType * in,
195 ComplexType * out,
196 unsigned int flags,
197 int threads = 1,
198 bool canDestroyInput = false)
199 {
200 int sizes[2];
201 sizes[0] = nx;
202 sizes[1] = ny;
203 PlanType plan = Plan_dft_r2c(2, sizes, in, out, flags, threads, canDestroyInput);
204 return plan;
205 }
206
207 static PlanType
209 int ny,
210 int nz,
211 PixelType * in,
212 ComplexType * out,
213 unsigned int flags,
214 int threads = 1,
215 bool canDestroyInput = false)
216 {
217 int sizes[3];
218 sizes[0] = nx;
219 sizes[1] = ny;
220 sizes[2] = nz;
221 PlanType plan = Plan_dft_r2c(3, sizes, in, out, flags, threads, canDestroyInput);
222 return plan;
223 }
224
225 static PlanType
226 Plan_dft_r2c(int rank,
227 const int * n,
228 PixelType * in,
229 ComplexType * out,
230 unsigned int flags,
231 int threads = 1,
232 bool canDestroyInput = false)
233 {
234 //
235# ifndef ITK_USE_CUFFTW
236 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
237 fftwf_plan_with_nthreads(threads);
238# else
239 (void)threads;
240# endif
241 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
242 // because FFTW_ESTIMATE guarantee to not destroy the input
243 unsigned int roflags = flags;
244 if (!(flags & FFTW_ESTIMATE))
245 {
246 roflags = flags | FFTW_WISDOM_ONLY;
247 }
248 PlanType plan = fftwf_plan_dft_r2c(rank, n, in, out, roflags);
249 if (plan == nullptr)
250 {
251 // no wisdom available for that plan
252 if (canDestroyInput)
253 {
254 // just create the plan
255 plan = fftwf_plan_dft_r2c(rank, n, in, out, flags);
256 }
257 else
258 {
259 // lets create a plan with a fake input to generate the wisdom
260 int total = 1;
261 for (int i = 0; i < rank; ++i)
262 {
263 total *= n[i];
264 }
265 auto * din = new PixelType[total];
266 fftwf_plan_dft_r2c(rank, n, din, out, flags);
267 delete[] din;
268 // and then create the final plan - this time it shouldn't fail
269 plan = fftwf_plan_dft_r2c(rank, n, in, out, roflags);
270 }
271# ifndef ITK_USE_CUFFTW
273# endif
274 }
275 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
276 return plan;
277 }
278
279 static PlanType
281 ComplexType * in,
282 ComplexType * out,
283 int sign,
284 unsigned int flags,
285 int threads = 1,
286 bool canDestroyInput = false)
287 {
288 return Plan_dft(1, &n, in, out, sign, flags, threads, canDestroyInput);
289 }
290
291 static PlanType
293 int ny,
294 ComplexType * in,
295 ComplexType * out,
296 int sign,
297 unsigned int flags,
298 int threads = 1,
299 bool canDestroyInput = false)
300 {
301 int sizes[2];
302 sizes[0] = nx;
303 sizes[1] = ny;
304 PlanType plan = Plan_dft(2, sizes, in, out, sign, flags, threads, canDestroyInput);
305 return plan;
306 }
307
308 static PlanType
310 int ny,
311 int nz,
312 ComplexType * in,
313 ComplexType * out,
314 int sign,
315 unsigned int flags,
316 int threads = 1,
317 bool canDestroyInput = false)
318 {
319 int sizes[3];
320 sizes[0] = nx;
321 sizes[1] = ny;
322 sizes[2] = nz;
323 PlanType plan = Plan_dft(3, sizes, in, out, sign, flags, threads, canDestroyInput);
324 return plan;
325 }
326
327 static PlanType
328 Plan_dft(int rank,
329 const int * n,
330 ComplexType * in,
331 ComplexType * out,
332 int sign,
333 unsigned int flags,
334 int threads = 1,
335 bool canDestroyInput = false)
336 {
337# ifndef ITK_USE_CUFFTW
338 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
339 fftwf_plan_with_nthreads(threads);
340# else
341 (void)threads;
342# endif
343 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
344 // because FFTW_ESTIMATE guarantee to not destroy the input
345 unsigned int roflags = flags;
346 if (!(flags & FFTW_ESTIMATE))
347 {
348 roflags = flags | FFTW_WISDOM_ONLY;
349 }
350 PlanType plan = fftwf_plan_dft(rank, n, in, out, sign, roflags);
351 if (plan == nullptr)
352 {
353 // no wisdom available for that plan
354 if (canDestroyInput)
355 {
356 // just create the plan
357 plan = fftwf_plan_dft(rank, n, in, out, sign, flags);
358 }
359 else
360 {
361 // lets create a plan with a fake input to generate the wisdom
362 int total = 1;
363 for (int i = 0; i < rank; ++i)
364 {
365 total *= n[i];
366 }
367 auto * din = new ComplexType[total];
368 fftwf_plan_dft(rank, n, din, out, sign, flags);
369 delete[] din;
370 // and then create the final plan - this time it shouldn't fail
371 plan = fftwf_plan_dft(rank, n, in, out, sign, roflags);
372 }
373# ifndef ITK_USE_CUFFTW
375# endif
376 }
377 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
378 return plan;
379 }
380
381
382 static void
384 {
385 fftwf_execute(p);
386 }
387 static void
389 {
390# ifndef ITK_USE_CUFFTW
391 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
392# endif
393 fftwf_destroy_plan(p);
394 }
395};
396
397#endif // ITK_USE_FFTWF
398
399
400#if defined(ITK_USE_FFTWD)
401template <>
402class Proxy<double>
403{
404public:
405 using PixelType = double;
406 using ComplexType = fftw_complex;
407 using PlanType = fftw_plan;
409
410 // FFTW works with any data size, but is optimized for size decomposition with prime factors up to 13.
411# ifdef ITK_USE_CUFFTW
412 static constexpr SizeValueType GREATEST_PRIME_FACTOR = 7;
413# else
414 static constexpr SizeValueType GREATEST_PRIME_FACTOR = 13;
415# endif
416
417 static PlanType
419 ComplexType * in,
420 PixelType * out,
421 unsigned int flags,
422 int threads = 1,
423 bool canDestroyInput = false)
424 {
425 return Plan_dft_c2r(1, &n, in, out, flags, threads, canDestroyInput);
426 }
427
428 static PlanType
430 int ny,
431 ComplexType * in,
432 PixelType * out,
433 unsigned int flags,
434 int threads = 1,
435 bool canDestroyInput = false)
436 {
437 int sizes[2];
438 sizes[0] = nx;
439 sizes[1] = ny;
440 PlanType plan = Plan_dft_c2r(2, sizes, in, out, flags, threads, canDestroyInput);
441 return plan;
442 }
443
444 static PlanType
446 int ny,
447 int nz,
448 ComplexType * in,
449 PixelType * out,
450 unsigned int flags,
451 int threads = 1,
452 bool canDestroyInput = false)
453 {
454 int sizes[3];
455 sizes[0] = nx;
456 sizes[1] = ny;
457 sizes[2] = nz;
458 PlanType plan = Plan_dft_c2r(3, sizes, in, out, flags, threads, canDestroyInput);
459 return plan;
460 }
461
462 static PlanType
463 Plan_dft_c2r(int rank,
464 const int * n,
465 ComplexType * in,
466 PixelType * out,
467 unsigned int flags,
468 int threads = 1,
469 bool canDestroyInput = false)
470 {
471# ifndef ITK_USE_CUFFTW
472 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
473 fftw_plan_with_nthreads(threads);
474# else
475 (void)threads;
476# endif
477 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
478 // because FFTW_ESTIMATE guarantee to not destroy the input
479 unsigned int roflags = flags;
480 if (!(flags & FFTW_ESTIMATE))
481 {
482 roflags = flags | FFTW_WISDOM_ONLY;
483 }
484 PlanType plan = fftw_plan_dft_c2r(rank, n, in, out, roflags);
485 if (plan == nullptr)
486 {
487 // no wisdom available for that plan
488 if (canDestroyInput)
489 {
490 // just create the plan
491 plan = fftw_plan_dft_c2r(rank, n, in, out, flags);
492 }
493 else
494 {
495 // lets create a plan with a fake input to generate the wisdom
496 int total = 1;
497 for (int i = 0; i < rank; ++i)
498 {
499 total *= n[i];
500 }
501 auto * din = new ComplexType[total];
502 fftw_plan_dft_c2r(rank, n, din, out, flags);
503 delete[] din;
504 // and then create the final plan - this time it shouldn't fail
505 plan = fftw_plan_dft_c2r(rank, n, in, out, roflags);
506 }
507# ifndef ITK_USE_CUFFTW
509# endif
510 }
511 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
512 return plan;
513 }
514
515
516 static PlanType
518 PixelType * in,
519 ComplexType * out,
520 unsigned int flags,
521 int threads = 1,
522 bool canDestroyInput = false)
523 {
524 return Plan_dft_r2c(1, &n, in, out, flags, threads, canDestroyInput);
525 }
526
527 static PlanType
529 int ny,
530 PixelType * in,
531 ComplexType * out,
532 unsigned int flags,
533 int threads = 1,
534 bool canDestroyInput = false)
535 {
536 int sizes[2];
537 sizes[0] = nx;
538 sizes[1] = ny;
539 PlanType plan = Plan_dft_r2c(2, sizes, in, out, flags, threads, canDestroyInput);
540 return plan;
541 }
542
543 static PlanType
545 int ny,
546 int nz,
547 PixelType * in,
548 ComplexType * out,
549 unsigned int flags,
550 int threads = 1,
551 bool canDestroyInput = false)
552 {
553 int sizes[3];
554 sizes[0] = nx;
555 sizes[1] = ny;
556 sizes[2] = nz;
557 PlanType plan = Plan_dft_r2c(3, sizes, in, out, flags, threads, canDestroyInput);
558 return plan;
559 }
560
561 static PlanType
562 Plan_dft_r2c(int rank,
563 const int * n,
564 PixelType * in,
565 ComplexType * out,
566 unsigned int flags,
567 int threads = 1,
568 bool canDestroyInput = false)
569 {
570# ifndef ITK_USE_CUFFTW
571 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
572 fftw_plan_with_nthreads(threads);
573# else
574 (void)threads;
575# endif
576 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
577 // because FFTW_ESTIMATE guarantee to not destroy the input
578 unsigned int roflags = flags;
579 if (!(flags & FFTW_ESTIMATE))
580 {
581 roflags = flags | FFTW_WISDOM_ONLY;
582 }
583 PlanType plan = fftw_plan_dft_r2c(rank, n, in, out, roflags);
584 if (plan == nullptr)
585 {
586 // no wisdom available for that plan
587 if (canDestroyInput)
588 {
589 // just create the plan
590 plan = fftw_plan_dft_r2c(rank, n, in, out, flags);
591 }
592 else
593 {
594 // lets create a plan with a fake input to generate the wisdom
595 int total = 1;
596 for (int i = 0; i < rank; ++i)
597 {
598 total *= n[i];
599 }
600 auto * din = new PixelType[total];
601 fftw_plan_dft_r2c(rank, n, din, out, flags);
602 delete[] din;
603 // and then create the final plan - this time it shouldn't fail
604 plan = fftw_plan_dft_r2c(rank, n, in, out, roflags);
605 }
606# ifndef ITK_USE_CUFFTW
608# endif
609 }
610 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
611 return plan;
612 }
613
614 static PlanType
616 ComplexType * in,
617 ComplexType * out,
618 int sign,
619 unsigned int flags,
620 int threads = 1,
621 bool canDestroyInput = false)
622 {
623 return Plan_dft(1, &n, in, out, sign, flags, threads, canDestroyInput);
624 }
625
626 static PlanType
628 int ny,
629 ComplexType * in,
630 ComplexType * out,
631 int sign,
632 unsigned int flags,
633 int threads = 1,
634 bool canDestroyInput = false)
635 {
636 int sizes[2];
637 sizes[0] = nx;
638 sizes[1] = ny;
639 PlanType plan = Plan_dft(2, sizes, in, out, sign, flags, threads, canDestroyInput);
640 return plan;
641 }
642
643 static PlanType
645 int ny,
646 int nz,
647 ComplexType * in,
648 ComplexType * out,
649 int sign,
650 unsigned int flags,
651 int threads = 1,
652 bool canDestroyInput = false)
653 {
654 int sizes[3];
655 sizes[0] = nx;
656 sizes[1] = ny;
657 sizes[2] = nz;
658 PlanType plan = Plan_dft(3, sizes, in, out, sign, flags, threads, canDestroyInput);
659 return plan;
660 }
661
662 static PlanType
663 Plan_dft(int rank,
664 const int * n,
665 ComplexType * in,
666 ComplexType * out,
667 int sign,
668 unsigned int flags,
669 int threads = 1,
670 bool canDestroyInput = false)
671 {
672# ifndef ITK_USE_CUFFTW
673 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
674 fftw_plan_with_nthreads(threads);
675# else
676 (void)threads;
677# endif
678 // don't add FFTW_WISDOM_ONLY if the plan rigor is FFTW_ESTIMATE
679 // because FFTW_ESTIMATE guarantee to not destroy the input
680 unsigned int roflags = flags;
681 if (!(flags & FFTW_ESTIMATE))
682 {
683 roflags = flags | FFTW_WISDOM_ONLY;
684 }
685 PlanType plan = fftw_plan_dft(rank, n, in, out, sign, roflags);
686 if (plan == nullptr)
687 {
688 // no wisdom available for that plan
689 if (canDestroyInput)
690 {
691 // just create the plan
692 plan = fftw_plan_dft(rank, n, in, out, sign, flags);
693 }
694 else
695 {
696 // lets create a plan with a fake input to generate the wisdom
697 int total = 1;
698 for (int i = 0; i < rank; ++i)
699 {
700 total *= n[i];
701 }
702 auto * din = new ComplexType[total];
703 fftw_plan_dft(rank, n, din, out, sign, flags);
704 delete[] din;
705 // and then create the final plan - this time it shouldn't fail
706 plan = fftw_plan_dft(rank, n, in, out, sign, roflags);
707 }
708# ifndef ITK_USE_CUFFTW
710# endif
711 }
712 itkAssertOrThrowMacro(plan != nullptr, "PLAN_CREATION_FAILED ");
713 return plan;
714 }
715
716
717 static void
719 {
720 fftw_execute(p);
721 }
722 static void
724 {
725# ifndef ITK_USE_CUFFTW
726 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
727# endif
728 fftw_destroy_plan(p);
729 }
730};
731
732#endif
733} // end namespace fftw
734} // end namespace itk
735#endif
static std::mutex & GetLockMutex()
static void SetNewWisdomAvailable(const bool v)
static PlanType Plan_dft_c2r(int rank, const int *n, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static void Execute(PlanType p)
static PlanType Plan_dft_2d(int nx, int ny, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_3d(int nx, int ny, int nz, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c_2d(int nx, int ny, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_1d(int n, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r_1d(int n, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c_3d(int nx, int ny, int nz, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static void DestroyPlan(PlanType p)
static PlanType Plan_dft_c2r_2d(int nx, int ny, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft(int rank, const int *n, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c_1d(int n, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c(int rank, const int *n, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r_3d(int nx, int ny, int nz, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c_2d(int nx, int ny, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r_2d(int nx, int ny, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
Definition: itkFFTWCommon.h:93
static PlanType Plan_dft_1d(int n, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft(int rank, const int *n, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_2d(int nx, int ny, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r(int rank, const int *n, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r_3d(int nx, int ny, int nz, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c_3d(int nx, int ny, int nz, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_c2r_1d(int n, ComplexType *in, PixelType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
Definition: itkFFTWCommon.h:82
static PlanType Plan_dft_3d(int nx, int ny, int nz, ComplexType *in, ComplexType *out, int sign, unsigned int flags, int threads=1, bool canDestroyInput=false)
static void DestroyPlan(PlanType p)
static void Execute(PlanType p)
static PlanType Plan_dft_r2c_1d(int n, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
static PlanType Plan_dft_r2c(int rank, const int *n, PixelType *in, ComplexType *out, unsigned int flags, int threads=1, bool canDestroyInput=false)
~Proxy()=default
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
unsigned long SizeValueType
Definition: itkIntTypes.h:83