Medical Imaging Interaction Toolkit  2018.4.99-b20efe7f
Medical Imaging Interaction Toolkit
mitkIpPicTypeMultiplex.h
Go to the documentation of this file.
1 /*============================================================================
2 
3  Copyright (c) German Cancer Research Center (DKFZ)
4  All rights reserved.
5 
6  Redistribution and use in source and binary forms, with or without
7  modification, are permitted provided that the following conditions are met:
8 
9  - Redistributions of source code must retain the above copyright notice, this
10  list of conditions and the following disclaimer.
11 
12  - Redistributions in binary form must reproduce the above copyright notice,
13  this list of conditions and the following disclaimer in the documentation
14  and/or other materials provided with the distribution.
15 
16  - All advertising materials mentioning features or use of this software must
17  display the following acknowledgement:
18 
19  "This product includes software developed by the German Cancer Research
20  Center (DKFZ)."
21 
22  - Neither the name of the German Cancer Research Center (DKFZ) nor the names
23  of its contributors may be used to endorse or promote products derived from
24  this software without specific prior written permission.
25 
26  THIS SOFTWARE IS PROVIDED BY THE GERMAN CANCER RESEARCH CENTER (DKFZ) AND
27  CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
28  BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
29  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GERMAN
30  CANCER RESEARCH CENTER (DKFZ) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
31  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
32  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
33  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
34  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
37  DAMAGE.
38 
39 ============================================================================*/
40 
78 #ifndef IP_PIC_TYPE_MULTIPLEX_H
79 #define IP_PIC_TYPE_MULTIPLEX_H
80 
81 #include "mitkIpPic.h"
82 //#include <complex>
83 
84 #define mitkIpPicTypeMultiplex0( function, pic ) \
85 { \
86 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
87 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
88 function<char>( pic ); \
89 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
90 function<unsigned char>( pic ); \
91 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
92 function<short>( pic ); \
93 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
94 function<unsigned short>( pic ); \
95 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
96 function<int>( pic ); \
97 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
98 function<unsigned int>( pic ); \
99 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
100 function<long>( pic ); \
101 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
102 function<unsigned long>( pic ); \
103 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
104 function<float>( pic ); \
105 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
106 function<double>( pic ); \
107 } \
108 }
109 
110 #define mitkIpPicTypeMultiplex1( function, pic, param1 ) \
111 { \
112 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
113 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
114 function<char>( pic, param1 ); \
115 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
116 function<unsigned char>( pic, param1 ); \
117 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
118 function<short>( pic, param1 ); \
119 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
120 function<unsigned short>( pic, param1 ); \
121 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
122 function<int>( pic, param1 ); \
123 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
124 function<unsigned int>( pic, param1 ); \
125 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
126 function<long>( pic, param1 ); \
127 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
128 function<unsigned long>( pic, param1 ); \
129 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
130 function<float>( pic, param1 ); \
131 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
132 function<double>( pic, param1 ); \
133 } \
134 }
135 /*
136 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
137 function<std::complex<float> >( pic, param1 );
138 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
139 function<std::complex<double> >( pic, param1 );
140 }
141 */
142 
143 #define mitkIpPicTypeMultiplex2( function, pic, param1, param2 ) \
144 { \
145 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
146  function<char>( pic, param1, param2 ); \
147 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
148 function<unsigned char>( pic, param1, param2 ); \
149 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
150 function<short>( pic, param1, param2 ); \
151 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
152 function<unsigned short>( pic, param1, param2 ); \
153 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
154 function<int>( pic, param1, param2 ); \
155 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
156 function<unsigned int>( pic, param1, param2 ); \
157 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
158 function<long>( pic, param1, param2 ); \
159 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
160 function<unsigned long>( pic, param1, param2 ); \
161 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
162 function<float>( pic, param1, param2 ); \
163 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
164 function<double>( pic, param1, param2 ); \
165 } \
166 }
167 /*
168 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
169 function<std::complex<float> >( pic, param1, param2 );
170 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
171 function<std::complex<double> >( pic, param1, param2 );
172 }
173 */
174 #define mitkIpPicTypeMultiplex3( function, pic, param1, param2, param3 ) \
175 { \
176 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
177  function<char>( pic, param1, param2, param3 ); \
178 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
179 function<unsigned char>( pic, param1, param2, param3 ); \
180 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
181 function<short>( pic, param1, param2, param3 ); \
182 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
183 function<unsigned short>( pic, param1, param2, param3 ); \
184 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
185 function<int>( pic, param1, param2, param3 ); \
186 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
187 function<unsigned int>( pic, param1, param2, param3 ); \
188 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
189 function<long>( pic, param1, param2, param3 ); \
190 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
191 function<unsigned long>( pic, param1, param2, param3 ); \
192 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
193 function<float>( pic, param1, param2, param3 ); \
194 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
195 function<double>( pic, param1, param2, param3 ); \
196 } \
197 }
198 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
199 function<std::complex<float> >( pic, param1, param2, param3 );
200 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
201 function<std::complex<double> >( pic, param1, param2, param3 );
202 }*/
203 
204 #define mitkIpPicTypeMultiplex4( function, pic, param1, param2, param3, param4 ) \
205 { \
206 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
207  function<char>( pic, param1, param2, param3, param4 ); \
208 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
209 function<unsigned char>( pic, param1, param2, param3, param4 ); \
210 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
211 function<short>( pic, param1, param2, param3, param4 ); \
212 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
213 function<unsigned short>( pic, param1, param2, param3, param4 ); \
214 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
215 function<int>( pic, param1, param2, param3, param4 ); \
216 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
217 function<unsigned int>( pic, param1, param2, param3, param4 ); \
218 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
219 function<long>( pic, param1, param2, param3, param4 ); \
220 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
221 function<unsigned long>( pic, param1, param2, param3, param4 ); \
222 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
223 function<float>( pic, param1, param2, param3, param4 ); \
224 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
225 function<double>( pic, param1, param2, param3, param4 ); \
226 } \
227 }
228 /*
229 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
230 function<std::complex<float> >( pic, param1, param2, param3, param4 );
231 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
232 function<std::complex<double> >( pic, param1, param2, param3, param4 );
233 }*/
234 
235 #define mitkIpPicTypeMultiplex5( function, pic, param1, param2, param3, param4, param5 ) \
236 { \
237 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
238  function<char>( pic, param1, param2, param3, param4, param5 ); \
239 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
240 function<unsigned char>( pic, param1, param2, param3, param4, param5 ); \
241 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
242 function<short>( pic, param1, param2, param3, param4, param5 ); \
243 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
244 function<unsigned short>( pic, param1, param2, param3, param4, param5 ); \
245 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
246 function<int>( pic, param1, param2, param3, param4, param5 ); \
247 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
248 function<unsigned int>( pic, param1, param2, param3, param4, param5 ); \
249 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
250 function<long>( pic, param1, param2, param3, param4, param5 ); \
251 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
252 function<unsigned long>( pic, param1, param2, param3, param4, param5 ); \
253 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
254 function<float>( pic, param1, param2, param3, param4, param5 ); \
255 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
256 function<double>( pic, param1, param2, param3, param4, param5 ); \
257 } \
258 }
259 /* else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
260 function<std::complex<float> >( pic, param1, param2, param3, param4, param5 );
261 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
262 function<std::complex<double> >( pic, param1, param2, param3, param4, param5 );
263 }
264 */
265 #define mitkIpPicTypeMultiplex6( function, pic, param1, param2, param3, param4, param5, param6 ) \
266 { \
267 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
268  function<char>( pic, param1, param2, param3, param4, param5, param6 ); \
269 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
270 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6 ); \
271 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
272 function<short>( pic, param1, param2, param3, param4, param5, param6 ); \
273 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
274 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6 ); \
275 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
276 function<int>( pic, param1, param2, param3, param4, param5, param6 ); \
277 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
278 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6 ); \
279 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
280 function<long>( pic, param1, param2, param3, param4, param5, param6 ); \
281 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
282 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6 ); \
283 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
284 function<float>( pic, param1, param2, param3, param4, param5, param6 ); \
285 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
286 function<double>( pic, param1, param2, param3, param4, param5, param6 ); \
287 } \
288 }
289 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
290 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
291 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
292 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
293 }*/
294 
295 #define mitkIpPicTypeMultiplex7( function, pic, param1, param2, param3, param4, param5, param6, param7 ) \
296 { \
297 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
298  function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
299 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
300 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
301 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
302 function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
303 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
304 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
305 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
306 function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
307 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
308 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
309 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
310 function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
311 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
312 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
313 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
314 function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
315 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
316 function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
317 } \
318 }
319 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
320 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
321 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
322 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
323 }*/
324 
325 #define mitkIpPicTypeMultiplex7( function, pic, param1, param2, param3, param4, param5, param6, param7 ) \
326 { \
327 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
328  function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
329 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
330 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
331 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
332 function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
333 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
334 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
335 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
336 function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
337 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
338 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
339 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
340 function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
341 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
342 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
343 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
344 function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
345 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
346 function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
347 } \
348 }
349 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
350 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
351 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
352 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
353 }*/
354 
355 #define mitkIpPicTypeMultiplex8( function, pic, param1, param2, param3, param4, param5, param6, param7, param8) \
356 { \
357 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
358  function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
359 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
360 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
361 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
362 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
363 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
364 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
365 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
366 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
367 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
368 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
369 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
370 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
371 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
372 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
373 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
374 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
375 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
376 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
377 } \
378 }
379 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
380 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
381 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
382 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
383 }*/
384 
385 #define mitkIpPicTypeMultiplex9( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9) \
386 { \
387 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
388  function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
389 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
390 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
391 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
392 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
393 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
394 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
395 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
396 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
397 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
398 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
399 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
400 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
401 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
402 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
403 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
404 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
405 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
406 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
407 } \
408 }
409 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
410 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
411 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
412 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
413 }*/
414 
415 #define mitkIpPicTypeMultiplex10( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10) \
416 { \
417 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
418  function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
419 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
420 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
421 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
422 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
423 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
424 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
425 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
426 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
427 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
428 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
429 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
430 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
431 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
432 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
433 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
434 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
435 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
436 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
437 } \
438 }
439 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
440 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
441 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
442 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
443 }*/
444 
445 #define mitkIpPicTypeMultiplex16( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ) \
446 { \
447 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
448  function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
449 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
450 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
451 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
452 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
453 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
454 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
455 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
456 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
457 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
458 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
459 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
460 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
461 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
462 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
463 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
464 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
465 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
466 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
467 } \
468 }
469 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
470 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
471 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
472 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
473 }*/
478 #define mitkIpPicTypeMultiplexR0( function, pic, returnValue ) \
479 { \
480 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
481 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
482 returnValue = function<char>( pic ); \
483 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
484 returnValue = function<unsigned char>( pic ); \
485 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
486 returnValue = function<short>( pic ); \
487 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
488 returnValue = function<unsigned short>( pic ); \
489 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
490 returnValue = function<int>( pic ); \
491 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
492 returnValue = function<unsigned int>( pic ); \
493 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
494 returnValue = function<long>( pic ); \
495 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
496 returnValue = function<unsigned long>( pic ); \
497 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
498 returnValue = function<float>( pic ); \
499 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
500 returnValue = function<double>( pic ); \
501 } \
502 }
503 
504 #define mitkIpPicTypeMultiplexR1( function, pic, returnValue, param1 ) \
505 { \
506 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
507 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
508 returnValue = function<char>( pic, param1 ); \
509 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
510 returnValue = function<unsigned char>( pic, param1 ); \
511 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
512 returnValue = function<short>( pic, param1 ); \
513 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
514 returnValue = function<unsigned short>( pic, param1 ); \
515 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
516 returnValue = function<int>( pic, param1 ); \
517 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
518 returnValue = function<unsigned int>( pic, param1 ); \
519 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
520 returnValue = function<long>( pic, param1 ); \
521 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
522 returnValue = function<unsigned long>( pic, param1 ); \
523 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
524 returnValue = function<float>( pic, param1 ); \
525 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
526 returnValue = function<double>( pic, param1 ); \
527 } \
528 }
529 
530 #define mitkIpPicTypeMultiplexR2( function, pic, returnValue, param1, param2 ) \
531 { \
532 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
533  returnValue = function<char>( pic, param1, param2 ); \
534 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
535 returnValue = function<unsigned char>( pic, param1, param2 ); \
536 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
537 returnValue = function<short>( pic, param1, param2 ); \
538 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
539 returnValue = function<unsigned short>( pic, param1, param2 ); \
540 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
541 returnValue = function<int>( pic, param1, param2 ); \
542 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
543 returnValue = function<unsigned int>( pic, param1, param2 ); \
544 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
545 returnValue = function<long>( pic, param1, param2 ); \
546 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
547 returnValue = function<unsigned long>( pic, param1, param2 ); \
548 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
549 returnValue = function<float>( pic, param1, param2 ); \
550 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
551 returnValue = function<double>( pic, param1, param2 ); \
552 } \
553 }
554 
555 #define mitkIpPicTypeMultiplexR3( function, pic, returnValue, param1, param2, param3 ) \
556 { \
557 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
558  returnValue = function<char>( pic, param1, param2, param3 ); \
559 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
560 returnValue = function<unsigned char>( pic, param1, param2, param3 ); \
561 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
562 returnValue = function<short>( pic, param1, param2, param3 ); \
563 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
564 returnValue = function<unsigned short>( pic, param1, param2, param3 ); \
565 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
566 returnValue = function<int>( pic, param1, param2, param3 ); \
567 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
568 returnValue = function<unsigned int>( pic, param1, param2, param3 ); \
569 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
570 returnValue = function<long>( pic, param1, param2, param3 ); \
571 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
572 returnValue = function<unsigned long>( pic, param1, param2, param3 ); \
573 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
574 returnValue = function<float>( pic, param1, param2, param3 ); \
575 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
576 returnValue = function<double>( pic, param1, param2, param3 ); \
577 } \
578 }
579 
580 #define mitkIpPicTypeMultiplexR4( function, pic, returnValue, param1, param2, param3, param4 ) \
581 { \
582 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
583  returnValue = function<char>( pic, param1, param2, param3, param4 ); \
584 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
585 returnValue = function<unsigned char>( pic, param1, param2, param3, param4 ); \
586 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
587 returnValue = function<short>( pic, param1, param2, param3, param4 ); \
588 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
589 returnValue = function<unsigned short>( pic, param1, param2, param3, param4 ); \
590 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
591 returnValue = function<int>( pic, param1, param2, param3, param4 ); \
592 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
593 returnValue = function<unsigned int>( pic, param1, param2, param3, param4 ); \
594 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
595 returnValue = function<long>( pic, param1, param2, param3, param4 ); \
596 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
597 returnValue = function<unsigned long>( pic, param1, param2, param3, param4 ); \
598 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
599 returnValue = function<float>( pic, param1, param2, param3, param4 ); \
600 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
601 returnValue = function<double>( pic, param1, param2, param3, param4 ); \
602 } \
603 }
604 
605 #define mitkIpPicTypeMultiplexR5( function, pic, returnValue, param1, param2, param3, param4, param5 ) \
606 { \
607 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
608  returnValue = function<char>( pic, param1, param2, param3, param4, param5 ); \
609 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
610 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5 ); \
611 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
612 returnValue = function<short>( pic, param1, param2, param3, param4, param5 ); \
613 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
614 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5 ); \
615 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
616 returnValue = function<int>( pic, param1, param2, param3, param4, param5 ); \
617 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
618 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5 ); \
619 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
620 returnValue = function<long>( pic, param1, param2, param3, param4, param5 ); \
621 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
622 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5 ); \
623 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
624 returnValue = function<float>( pic, param1, param2, param3, param4, param5 ); \
625 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
626 returnValue = function<double>( pic, param1, param2, param3, param4, param5 ); \
627 } \
628 }
629 
630 #define mitkIpPicTypeMultiplexR6( function, pic, returnValue, param1, param2, param3, param4, param5, param6 ) \
631 { \
632 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
633  returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6 ); \
634 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
635 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6 ); \
636 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
637 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6 ); \
638 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
639 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6 ); \
640 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
641 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6 ); \
642 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
643 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6 ); \
644 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
645 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6 ); \
646 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
647 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6 ); \
648 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
649 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6 ); \
650 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
651 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6 ); \
652 } \
653 }
654 
655 #define mitkIpPicTypeMultiplexR7( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7 ) \
656 { \
657 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
658  returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
659 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
660 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
661 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
662 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
663 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
664 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
665 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
666 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
667 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
668 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
669 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
670 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
671 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
672 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
673 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
674 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
675 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
676 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
677 } \
678 }
679 
680 #define mitkIpPicTypeMultiplexR8( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7, param8 ) \
681 { \
682 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
683  returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
684 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
685 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
686 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
687 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
688 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
689 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
690 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
691 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
692 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
693 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
694 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
695 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
696 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
697 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
698 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
699 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
700 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
701 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
702 } \
703 }
704 
705 #define mitkIpPicTypeMultiplexR9( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7, param8, param9 ) \
706 { \
707 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
708  returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
709 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
710 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
711 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
712 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
713 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
714 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
715 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
716 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
717 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
718 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
719 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
720 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
721 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
722 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
723 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
724 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
725 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
726 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
727 } \
728 }
729 
730 #endif // IP_PIC_TYPE_MULTIPLEX_H