ITK 6.0.0
Insight Toolkit
 
Loading...
Searching...
No Matches
itkFFTWCommonExtended.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 itkFFTWCommonExtended_h
19#define itkFFTWCommonExtended_h
20
21#if defined(ITK_USE_FFTWF) || defined(ITK_USE_FFTWD)
22# if defined(ITK_USE_CUFFTW)
23# include "cufftw.h"
24# else
25# include "itkFFTWGlobalConfiguration.h"
26# include "fftw3.h"
27# endif
28#endif
29
30#include <mutex>
31
32namespace itk
33{
34
35namespace fftw
36{
44template <typename TPixel>
45class ComplexToComplexProxy
46{
47 // empty -- only double and float specializations work
48protected:
49 ComplexToComplexProxy() = default;
50 ~ComplexToComplexProxy() = default;
51};
52
53#if defined(ITK_USE_FFTWF)
54
55template <>
56class ComplexToComplexProxy<float>
57{
58public:
59 using PixelType = float;
60 using ComplexType = fftwf_complex;
61 using PlanType = fftwf_plan;
62 using Self = ComplexToComplexProxy<float>;
63
64 static PlanType
65 Plan_dft_c2r_1d(int n, ComplexType * in, PixelType * out, unsigned int flags, [[maybe_unused]] int threads = 1)
66 {
67# ifndef ITK_USE_CUFFTW
68 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
69 fftwf_plan_with_nthreads(threads);
70# endif
71 PlanType plan = fftwf_plan_dft_c2r_1d(n, in, out, flags);
72 return plan;
73 }
74 static PlanType
75 Plan_dft_c2r_2d(int nx,
76 int ny,
77 ComplexType * in,
78 PixelType * out,
79 unsigned int flags,
80 [[maybe_unused]] int threads = 1)
81 {
82# ifndef ITK_USE_CUFFTW
83 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
84 fftwf_plan_with_nthreads(threads);
85# endif
86 PlanType plan = fftwf_plan_dft_c2r_2d(nx, ny, in, out, flags);
87 return plan;
88 }
89 static PlanType
90 Plan_dft_c2r_3d(int nx,
91 int ny,
92 int nz,
93 ComplexType * in,
94 PixelType * out,
95 unsigned int flags,
96 [[maybe_unused]] int threads = 1)
97 {
98# ifndef ITK_USE_CUFFTW
99 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
100 fftwf_plan_with_nthreads(threads);
101# endif
102 PlanType plan = fftwf_plan_dft_c2r_3d(nx, ny, nz, in, out, flags);
103 return plan;
104 }
105 static PlanType
106 Plan_dft_c2r(int rank,
107 const int * n,
108 ComplexType * in,
109 PixelType * out,
110 unsigned int flags,
111 [[maybe_unused]] int threads = 1)
112 {
113# ifndef ITK_USE_CUFFTW
114 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
115 fftwf_plan_with_nthreads(threads);
116# endif
117 PlanType plan = fftwf_plan_dft_c2r(rank, n, in, out, flags);
118 return plan;
119 }
120
121 static PlanType
122 Plan_dft_r2c_1d(int n, PixelType * in, ComplexType * out, unsigned int flags, [[maybe_unused]] int threads = 1)
123 {
124# ifndef ITK_USE_CUFFTW
125 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
126 fftwf_plan_with_nthreads(threads);
127# endif
128 PlanType plan = fftwf_plan_dft_r2c_1d(n, in, out, flags);
129 return plan;
130 }
131 static PlanType
132 Plan_dft_r2c_2d(int nx,
133 int ny,
134 PixelType * in,
135 ComplexType * out,
136 unsigned int flags,
137 [[maybe_unused]] int threads = 1)
138 {
139# ifndef ITK_USE_CUFFTW
140 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
141 fftwf_plan_with_nthreads(threads);
142# endif
143 PlanType plan = fftwf_plan_dft_r2c_2d(nx, ny, in, out, flags);
144 return plan;
145 }
146 static PlanType
147 Plan_dft_r2c_3d(int nx,
148 int ny,
149 int nz,
150 PixelType * in,
151 ComplexType * out,
152 unsigned int flags,
153 [[maybe_unused]] int threads = 1)
154 {
155# ifndef ITK_USE_CUFFTW
156 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
157 fftwf_plan_with_nthreads(threads);
158# endif
159 PlanType plan = fftwf_plan_dft_r2c_3d(nx, ny, nz, in, out, flags);
160 return plan;
161 }
162 static PlanType
163 Plan_dft_r2c(int rank,
164 const int * n,
165 PixelType * in,
166 ComplexType * out,
167 unsigned int flags,
168 [[maybe_unused]] int threads = 1)
169 {
170# ifndef ITK_USE_CUFFTW
171 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
172 fftwf_plan_with_nthreads(threads);
173# endif
174 PlanType plan = fftwf_plan_dft_r2c(rank, n, in, out, flags);
175 return plan;
176 }
177 static PlanType
178 Plan_dft_1d(const int n,
179 ComplexType * in,
180 ComplexType * out,
181 int sign,
182 unsigned int flags,
183 [[maybe_unused]] int threads = 1)
184 {
185# ifndef ITK_USE_CUFFTW
186 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
187 fftwf_plan_with_nthreads(threads);
188# endif
189 PlanType plan = fftwf_plan_dft_1d(n, in, out, sign, flags);
190 return plan;
191 }
192
193
194 static void
195 Execute(PlanType p)
196 {
197 fftwf_execute(p);
198 }
199 static void
200 DestroyPlan(PlanType p)
201 {
202 fftwf_destroy_plan(p);
203 }
204};
205
206#endif // USE_FFTWF
207
208
209#if defined(ITK_USE_FFTWD)
210template <>
211class ComplexToComplexProxy<double>
212{
213public:
214 using PixelType = double;
215 using ComplexType = fftw_complex;
216 using PlanType = fftw_plan;
217 using Self = ComplexToComplexProxy<double>;
218
219 static PlanType
220 Plan_dft_c2r_1d(int n, ComplexType * in, PixelType * out, unsigned int flags, [[maybe_unused]] int threads = 1)
221 {
222# ifndef ITK_USE_CUFFTW
223 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
224 fftw_plan_with_nthreads(threads);
225# endif
226 PlanType plan = fftw_plan_dft_c2r_1d(n, in, out, flags);
227 return plan;
228 }
229 static PlanType
230 Plan_dft_c2r_2d(int nx,
231 int ny,
232 ComplexType * in,
233 PixelType * out,
234 unsigned int flags,
235 [[maybe_unused]] int threads = 1)
236 {
237# ifndef ITK_USE_CUFFTW
238 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
239 fftw_plan_with_nthreads(threads);
240# endif
241 PlanType plan = fftw_plan_dft_c2r_2d(nx, ny, in, out, flags);
242 return plan;
243 }
244 static PlanType
245 Plan_dft_c2r_3d(int nx,
246 int ny,
247 int nz,
248 ComplexType * in,
249 PixelType * out,
250 unsigned int flags,
251 [[maybe_unused]] int threads = 1)
252 {
253# ifndef ITK_USE_CUFFTW
254 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
255 fftw_plan_with_nthreads(threads);
256# endif
257 PlanType plan = fftw_plan_dft_c2r_3d(nx, ny, nz, in, out, flags);
258 return plan;
259 }
260 static PlanType
261 Plan_dft_c2r(int rank,
262 const int * n,
263 ComplexType * in,
264 PixelType * out,
265 unsigned int flags,
266 [[maybe_unused]] int threads = 1)
267 {
268# ifndef ITK_USE_CUFFTW
269 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
270 fftw_plan_with_nthreads(threads);
271# endif
272 PlanType plan = fftw_plan_dft_c2r(rank, n, in, out, flags);
273 return plan;
274 }
275
276 static PlanType
277 Plan_dft_r2c_1d(int n, PixelType * in, ComplexType * out, unsigned int flags, [[maybe_unused]] int threads = 1)
278 {
279# ifndef ITK_USE_CUFFTW
280 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
281 fftw_plan_with_nthreads(threads);
282# endif
283 PlanType plan = fftw_plan_dft_r2c_1d(n, in, out, flags);
284 return plan;
285 }
286
287 static PlanType
288 Plan_dft_r2c_2d(int nx,
289 int ny,
290 PixelType * in,
291 ComplexType * out,
292 unsigned int flags,
293 [[maybe_unused]] int threads = 1)
294 {
295# ifndef ITK_USE_CUFFTW
296 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
297 fftw_plan_with_nthreads(threads);
298# endif
299 PlanType plan = fftw_plan_dft_r2c_2d(nx, ny, in, out, flags);
300 return plan;
301 }
302
303 static PlanType
304 Plan_dft_r2c_3d(int nx,
305 int ny,
306 int nz,
307 PixelType * in,
308 ComplexType * out,
309 unsigned int flags,
310 [[maybe_unused]] int threads = 1)
311 {
312# ifndef ITK_USE_CUFFTW
313 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
314 fftw_plan_with_nthreads(threads);
315# endif
316 PlanType plan = fftw_plan_dft_r2c_3d(nx, ny, nz, in, out, flags);
317 return plan;
318 }
319
320 static PlanType
321 Plan_dft_r2c(int rank,
322 const int * n,
323 PixelType * in,
324 ComplexType * out,
325 unsigned int flags,
326 [[maybe_unused]] int threads = 1)
327 {
328# ifndef ITK_USE_CUFFTW
329 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
330 fftw_plan_with_nthreads(threads);
331# endif
332 PlanType plan = fftw_plan_dft_r2c(rank, n, in, out, flags);
333 return plan;
334 }
335 static PlanType
336 Plan_dft_1d(const int n,
337 ComplexType * in,
338 ComplexType * out,
339 int sign,
340 unsigned int flags,
341 [[maybe_unused]] int threads = 1)
342 {
343# ifndef ITK_USE_CUFFTW
344 const std::lock_guard<FFTWGlobalConfiguration::MutexType> lockGuard(FFTWGlobalConfiguration::GetLockMutex());
345 fftw_plan_with_nthreads(threads);
346# endif
347 PlanType plan = fftw_plan_dft_1d(n, in, out, sign, flags);
348 return plan;
349 }
350
351 static void
352 Execute(PlanType p)
353 {
354 fftw_execute(p);
355 }
356 static void
357 DestroyPlan(PlanType p)
358 {
359 fftw_destroy_plan(p);
360 }
361};
362
363#endif
364} // namespace fftw
365} // namespace itk
366#endif
itk::FFTWGlobalConfiguration::GetLockMutex
static std::mutex & GetLockMutex()
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition itkAnatomicalOrientation.h:30