ML Reference
mlTypedHandlers.h
Go to the documentation of this file.
1 /*************************************************************************************
2 **
3 ** Copyright 2009, MeVis Medical Solutions AG
4 **
5 ** The user may use this file in accordance with the license agreement provided with
6 ** the Software or, alternatively, in accordance with the terms contained in a
7 ** written agreement between the user and MeVis Medical Solutions AG.
8 **
9 ** For further information use the contact form at https://www.mevislab.de/contact
10 **
11 **************************************************************************************/
12 
13 #ifndef ML_TYPED_HANDLERS_H
14 #define ML_TYPED_HANDLERS_H
15 
16 #include "mlInitSystemML.h"
17 
18 #include "mlTSubImage.h"
19 #include "mlModuleInterfaces.h"
20 #include "mlTypeTraits.h"
21 #include "mlProcessAllPagesHandler.h"
22 #include "mlPagedImage.h"
23 
24 // Deprecated macros that do nothing, should be removed in a future version:
25 #define MLCarrierForType(TYPE) TYPE
26 #define MLCarrierInForType(TYPE) TYPE
27 
28 // Warn users about the above macros:
29 #if defined(WIN32)
30 #pragma deprecated("MLCarrierForType")
31 #pragma deprecated("MLCarrierInForType")
32 #endif
33 
34 ML_START_NAMESPACE
35 
36 //---------------------------------------------------------------------------
39 //---------------------------------------------------------------------------
40 
44 #define ML_N_INPUTS 0x4000
45 
47 #define _ML_SWITCH_SELECT_OFFSET 32768
48 
50 #define _ML_OUTPUTINDEX -1
51 
53 const int MLVariableType0 = _ML_SWITCH_SELECT_OFFSET;
55 const int MLVariableType1 = _ML_SWITCH_SELECT_OFFSET+1;
57 const int MLVariableType2 = _ML_SWITCH_SELECT_OFFSET+2;
59 const int MLVariableType3 = _ML_SWITCH_SELECT_OFFSET+3;
61 const int MLGenericType = _ML_SWITCH_SELECT_OFFSET+10;
62 
64 
91 class VariableType {
92 };
93 
94 namespace internal {
95 
96 #ifndef DOXYGEN_SHOULD_SKIP_THIS
97 
98 //-------------------------------------------------------------------------------------------------
99 
101 template <int select, typename Types>
102 struct SwitchOrFixedTypeSelector {
103  typedef typename DataTypeSelector<select>::Type Type;
104  typedef TSubImage<Type> SubImageType;
105 };
106 
107 // Specializations for SwitchOrFixedTypeSelector
108 template <typename Types>
109 struct SwitchOrFixedTypeSelector<_ML_SWITCH_SELECT_OFFSET+0, Types> {
110  typedef typename Types::T0 Type;
111  typedef TSubImage<Type> SubImageType;
112 };
113 template <typename Types>
114 struct SwitchOrFixedTypeSelector<_ML_SWITCH_SELECT_OFFSET+1, Types> {
115  typedef typename Types::T1 Type;
116  typedef TSubImage<Type> SubImageType;
117 };
118 template <typename Types>
119 struct SwitchOrFixedTypeSelector<_ML_SWITCH_SELECT_OFFSET+2, Types> {
120  typedef typename Types::T2 Type;
121  typedef TSubImage<Type> SubImageType;
122 };
123 template <typename Types>
124 struct SwitchOrFixedTypeSelector<_ML_SWITCH_SELECT_OFFSET+3, Types> {
125  typedef typename Types::T3 Type;
126  typedef TSubImage<Type> SubImageType;
127 };
128 template <typename Types>
129 struct SwitchOrFixedTypeSelector<_ML_SWITCH_SELECT_OFFSET+10, Types> {
130  typedef void Type;
131  typedef SubImage SubImageType;
132 };
133 
134 //-------------------------------------------------------------------------------------------------
135 
137 template <int shouldBeConst, typename InType>
138 struct ConstTypeSelector {};
139 
140 // Specializations for ConstTypeSelector,
141 template <typename InType>
142 struct ConstTypeSelector<0, InType> { typedef InType Type; };
143 template <typename InType>
144 struct ConstTypeSelector<1, InType> { typedef const InType Type; };
145 
146 //-------------------------------------------------------------------------------------------------
147 
149 template <int v>
150 class InputImagesCount {
151 public:
152  enum {
153  count = v
154  };
155 };
156 
157 //------------------------------------------------------------------------------------------
158 
160 struct CalculateOutputSubImageArguments {
162  CalculateOutputSubImageArguments() {
163  outImg = nullptr;
164  inImgs = nullptr;
165  userThreadData = nullptr;
166  }
167 
169  CalculateOutputSubImageArguments(SubImage* outImage, SubImage* inImages, UserThreadData* threadData) {
170  outImg = outImage;
171  inImgs = inImages;
172  userThreadData = threadData;
173  }
174 
175  // Members are intentionally public, since this is used as replacement for individual arguments.
176  SubImage* outImg;
177  SubImage* inImgs;
178  UserThreadData* userThreadData;
179  int variableDataType[4];
180 };
181 
182 //------------------------------------------------------------------------------------------
183 
185 template<typename InT0, typename InT1, typename InT2, typename InT3>
186 struct TypeTuple4 {
187  typedef InT0 T0;
188  typedef InT1 T1;
189  typedef InT2 T2;
190  typedef InT3 T3;
191 };
192 
194 struct EmptyType {};
195 
197 typedef TypeTuple4<EmptyType, EmptyType, EmptyType, EmptyType> EmptyTypeTuple4;
198 
201 template <int position, typename T, typename Tuple>
202 struct TypeTuple4Insert {};
203 
204 // Specializations of TypeTuple4Insert for four positions.
205 template <typename T, typename Tuple>
206 struct TypeTuple4Insert<0, T, Tuple> {
207  typedef TypeTuple4<T, T, T, T> Type;
208 };
209 template <typename T, typename Tuple>
210 struct TypeTuple4Insert<1, T, Tuple> {
211  typedef TypeTuple4<typename Tuple::T0, T, T, T> Type;
212 };
213 template <typename T, typename Tuple>
214 struct TypeTuple4Insert<2, T, Tuple> {
215  typedef TypeTuple4<typename Tuple::T0, typename Tuple::T1, T, T> Type;
216 };
217 template <typename T, typename Tuple>
218 struct TypeTuple4Insert<3, T, Tuple> {
219  typedef TypeTuple4<typename Tuple::T0, typename Tuple::T1, typename Tuple::T2, T> Type;
220 };
221 
222 #endif // of DOXYGEN_SHOULD_SKIP_THIS
223 
224 #ifndef DOXYGEN_SHOULD_SKIP_THIS
225 
228 MLEXPORT void setupKnownPagedImgProperties(PagedImage* outImg, int templateNumImages, int outputType, const int inputTypes[10], const int inputReadOnly[10], int numVariableTypes, const int variableTypes[4]);
229 
232 MLEXPORT void verifyPagedImgProperties(PagedImage* outImg, int templateNumImages, int outputType, const int inputTypes[10], const int inputReadOnly[10], int numVariableTypes, const int variableTypes[4], int resultDataTypes[4]);
233 
234 #endif // of DOXYGEN_SHOULD_SKIP_THIS
235 
236 //-----------------------------------------------------------------------------------------------------
237 
239 
243 template<class BaseClass, class Derived, int NumberOfInputImages>
244 class TypedHandlerBase : public BaseClass {
245 
246 public:
247  // Defines the preconfigured static selection of types and their properties.
248  enum {
249  // Enums to be overwritten by user
250  OutputSubImage_Type = MLVariableType0,
251  InputSubImage0_Type = MLVariableType1,
252  InputSubImage1_Type = MLVariableType2,
253  InputSubImage2_Type = MLVariableType3,
254  InputSubImage3_Type = MLVariableType3,
255  InputSubImage4_Type = MLVariableType3,
256  InputSubImage5_Type = MLVariableType3,
257  InputSubImage6_Type = MLVariableType3,
258  InputSubImage7_Type = MLVariableType3,
259  InputSubImage8_Type = MLVariableType3,
260  InputSubImage9_Type = MLVariableType3,
261 
262  InputSubImage0_ReadOnly = true,
263  InputSubImage1_ReadOnly = true,
264  InputSubImage2_ReadOnly = true,
265  InputSubImage3_ReadOnly = true,
266  InputSubImage4_ReadOnly = true,
267  InputSubImage5_ReadOnly = true,
268  InputSubImage6_ReadOnly = true,
269  InputSubImage7_ReadOnly = true,
270  InputSubImage8_ReadOnly = true,
271  InputSubImage9_ReadOnly = true,
272  };
273 
274  TypedHandlerBase() {
275  setupVariableTypes(_variableTypeIndex);
276  }
277 
278 private:
280  int _variableTypeIndex[4];
281 
283  static void setupVariableTypes(int variableTypeIndex[4]) {
284  const int inputTypes[10] = {
285  Derived::InputSubImage0_Type, Derived::InputSubImage1_Type, Derived::InputSubImage2_Type, Derived::InputSubImage3_Type, Derived::InputSubImage4_Type,
286  Derived::InputSubImage5_Type, Derived::InputSubImage6_Type, Derived::InputSubImage7_Type, Derived::InputSubImage8_Type, Derived::InputSubImage9_Type };
287  for (int i=0;i<Derived::getNumVariableTypes();i++) {
288  // use output image as default
289  variableTypeIndex[i] = _ML_OUTPUTINDEX;
290  // find the first image that uses variable type i, either the output or one of the inputs
291  if (Derived::OutputSubImage_Type == MLVariableType0 + i) {
292  variableTypeIndex[i] = _ML_OUTPUTINDEX;
293  } else {
294  // for the purpose of the below loop, treat ML_N_INPUTS as 1
295  const int numInputs = (NumberOfInputImages==ML_N_INPUTS)?1:NumberOfInputImages;
296  for (int j=0;j<numInputs;j++) {
297  if (inputTypes[j] == MLVariableType0 + i) {
298  variableTypeIndex[i] = j;
299  break;
300  }
301  }
302  }
303  }
304  }
305 
306 public:
307 
309  void calculateOutputSubImage(SubImage* outImg, SubImage* inImgs, UserThreadData* userThreadData) override {
310  // Put arguments in struct to facilitate passing them through.
311  CalculateOutputSubImageArguments args(outImg, inImgs, userThreadData);
312 
313  // Detect the correct data type for up to 4 variable types (loop length is compile time!)
314  for (int i=0; i<Derived::getNumVariableTypes(); i++) {
315  args.variableDataType[i] = (_variableTypeIndex[i] == _ML_OUTPUTINDEX) ?
316  args.outImg->getDataType() : args.inImgs[_variableTypeIndex[i]].getDataType();
317  }
318 
319  // Start the switching, which will call back to helperCalculateOutputSubImage below when all types are switched.
320  static_cast<Derived*>(this)->doSwitching(args);
321  }
322 
323 #ifndef DOXYGEN_SHOULD_SKIP_THIS
324 
325  template<typename Types>
326  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args) {
327  // we collected up to 4 types in Types, now delegate to specific method for NumberOfInputImages
328  helperCalculateOutputSubImage<Types>(args, static_cast<InputImagesCount<NumberOfInputImages>*>(nullptr));
329  }
330 
331  template<typename Types>
332  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<ML_N_INPUTS>*) {
333  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::Type OUTTYPE;
334  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::Type INTYPE0;
335  TSubImage<OUTTYPE> outTSubImg(*args.outImg);
336  typedef typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, TSubImage<INTYPE0> >::Type INTSUBIMG0;
337  // Cast inImgs to TSubImage!
338  INTSUBIMG0* inTSubImgs = tsubimage_cast<INTYPE0>(args.inImgs);
339  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImgs, args.userThreadData);
340  }
341 
342  template<typename Types>
343  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<0>*) {
344  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
345  OUTIMAGETYPE outTSubImg(*args.outImg);
346  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, args.userThreadData);
347  }
348 
349  template<typename Types>
350  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<1>*) {
351  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
352  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
353  OUTIMAGETYPE outTSubImg(*args.outImg);
354  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
355  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, args.userThreadData);
356  }
357 
358  template<typename Types>
359  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<2>*) {
360  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
361  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
362  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
363  OUTIMAGETYPE outTSubImg(*args.outImg);
364  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
365  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
366  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, args.userThreadData);
367  }
368 
369  template<typename Types>
370  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<3>*) {
371  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
372  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
373  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
374  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
375  OUTIMAGETYPE outTSubImg(*args.outImg);
376  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
377  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
378  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
379  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, args.userThreadData);
380  }
381 
382  template<typename Types>
383  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<4>*) {
384  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
385  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
386  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
387  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
388  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
389  OUTIMAGETYPE outTSubImg(*args.outImg);
390  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
391  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
392  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
393  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
394  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, args.userThreadData);
395  }
396 
397  template<typename Types>
398  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<5>*) {
399  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
400  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
401  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
402  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
403  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
404  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
405  OUTIMAGETYPE outTSubImg(*args.outImg);
406  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
407  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
408  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
409  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
410  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
411  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, args.userThreadData);
412  }
413 
414  template<typename Types>
415  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<6>*) {
416  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
417  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
418  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
419  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
420  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
421  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
422  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage5_Type, Types>::SubImageType INIMAGETYPE5;
423  OUTIMAGETYPE outTSubImg(*args.outImg);
424  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
425  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
426  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
427  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
428  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
429  typename ConstTypeSelector<Derived::InputSubImage5_ReadOnly, INIMAGETYPE5>::Type inTSubImg5(args.inImgs[5]);
430  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, inTSubImg5, args.userThreadData);
431  }
432 
433  template<typename Types>
434  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<7>*) {
435  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
436  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
437  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
438  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
439  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
440  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
441  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage5_Type, Types>::SubImageType INIMAGETYPE5;
442  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage6_Type, Types>::SubImageType INIMAGETYPE6;
443  OUTIMAGETYPE outTSubImg(*args.outImg);
444  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
445  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
446  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
447  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
448  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
449  typename ConstTypeSelector<Derived::InputSubImage5_ReadOnly, INIMAGETYPE5>::Type inTSubImg5(args.inImgs[5]);
450  typename ConstTypeSelector<Derived::InputSubImage6_ReadOnly, INIMAGETYPE6>::Type inTSubImg6(args.inImgs[6]);
451  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, inTSubImg5, inTSubImg6, args.userThreadData);
452  }
453 
454  template<typename Types>
455  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<8>*) {
456  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
457  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
458  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
459  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
460  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
461  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
462  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage5_Type, Types>::SubImageType INIMAGETYPE5;
463  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage6_Type, Types>::SubImageType INIMAGETYPE6;
464  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage7_Type, Types>::SubImageType INIMAGETYPE7;
465  OUTIMAGETYPE outTSubImg(*args.outImg);
466  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
467  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
468  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
469  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
470  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
471  typename ConstTypeSelector<Derived::InputSubImage5_ReadOnly, INIMAGETYPE5>::Type inTSubImg5(args.inImgs[5]);
472  typename ConstTypeSelector<Derived::InputSubImage6_ReadOnly, INIMAGETYPE6>::Type inTSubImg6(args.inImgs[6]);
473  typename ConstTypeSelector<Derived::InputSubImage7_ReadOnly, INIMAGETYPE7>::Type inTSubImg7(args.inImgs[7]);
474  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, inTSubImg5, inTSubImg6, inTSubImg7, args.userThreadData);
475  }
476 
477  template<typename Types>
478  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<9>*) {
479  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
480  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
481  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
482  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
483  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
484  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
485  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage5_Type, Types>::SubImageType INIMAGETYPE5;
486  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage6_Type, Types>::SubImageType INIMAGETYPE6;
487  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage7_Type, Types>::SubImageType INIMAGETYPE7;
488  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage8_Type, Types>::SubImageType INIMAGETYPE8;
489  OUTIMAGETYPE outTSubImg(*args.outImg);
490  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
491  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
492  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
493  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
494  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
495  typename ConstTypeSelector<Derived::InputSubImage5_ReadOnly, INIMAGETYPE5>::Type inTSubImg5(args.inImgs[5]);
496  typename ConstTypeSelector<Derived::InputSubImage6_ReadOnly, INIMAGETYPE6>::Type inTSubImg6(args.inImgs[6]);
497  typename ConstTypeSelector<Derived::InputSubImage7_ReadOnly, INIMAGETYPE7>::Type inTSubImg7(args.inImgs[7]);
498  typename ConstTypeSelector<Derived::InputSubImage8_ReadOnly, INIMAGETYPE8>::Type inTSubImg8(args.inImgs[8]);
499  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, inTSubImg5, inTSubImg6, inTSubImg7, inTSubImg8, args.userThreadData);
500  }
501 
502  template<typename Types>
503  void helperCalculateOutputSubImage(const CalculateOutputSubImageArguments& args, InputImagesCount<10>*) {
504  typedef typename SwitchOrFixedTypeSelector<Derived::OutputSubImage_Type, Types>::SubImageType OUTIMAGETYPE;
505  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage0_Type, Types>::SubImageType INIMAGETYPE0;
506  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage1_Type, Types>::SubImageType INIMAGETYPE1;
507  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage2_Type, Types>::SubImageType INIMAGETYPE2;
508  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage3_Type, Types>::SubImageType INIMAGETYPE3;
509  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage4_Type, Types>::SubImageType INIMAGETYPE4;
510  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage5_Type, Types>::SubImageType INIMAGETYPE5;
511  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage6_Type, Types>::SubImageType INIMAGETYPE6;
512  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage7_Type, Types>::SubImageType INIMAGETYPE7;
513  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage8_Type, Types>::SubImageType INIMAGETYPE8;
514  typedef typename SwitchOrFixedTypeSelector<Derived::InputSubImage9_Type, Types>::SubImageType INIMAGETYPE9;
515  OUTIMAGETYPE outTSubImg(*args.outImg);
516  typename ConstTypeSelector<Derived::InputSubImage0_ReadOnly, INIMAGETYPE0>::Type inTSubImg0(args.inImgs[0]);
517  typename ConstTypeSelector<Derived::InputSubImage1_ReadOnly, INIMAGETYPE1>::Type inTSubImg1(args.inImgs[1]);
518  typename ConstTypeSelector<Derived::InputSubImage2_ReadOnly, INIMAGETYPE2>::Type inTSubImg2(args.inImgs[2]);
519  typename ConstTypeSelector<Derived::InputSubImage3_ReadOnly, INIMAGETYPE3>::Type inTSubImg3(args.inImgs[3]);
520  typename ConstTypeSelector<Derived::InputSubImage4_ReadOnly, INIMAGETYPE4>::Type inTSubImg4(args.inImgs[4]);
521  typename ConstTypeSelector<Derived::InputSubImage5_ReadOnly, INIMAGETYPE5>::Type inTSubImg5(args.inImgs[5]);
522  typename ConstTypeSelector<Derived::InputSubImage6_ReadOnly, INIMAGETYPE6>::Type inTSubImg6(args.inImgs[6]);
523  typename ConstTypeSelector<Derived::InputSubImage7_ReadOnly, INIMAGETYPE7>::Type inTSubImg7(args.inImgs[7]);
524  typename ConstTypeSelector<Derived::InputSubImage8_ReadOnly, INIMAGETYPE8>::Type inTSubImg8(args.inImgs[8]);
525  typename ConstTypeSelector<Derived::InputSubImage9_ReadOnly, INIMAGETYPE9>::Type inTSubImg9(args.inImgs[9]);
526  static_cast<Derived*>(this)->typedCalculateOutputSubImage(outTSubImg, inTSubImg0, inTSubImg1, inTSubImg2, inTSubImg3, inTSubImg4, inTSubImg5, inTSubImg6, inTSubImg7, inTSubImg8, inTSubImg9, args.userThreadData);
527  }
528 
529 #endif // of DOXYGEN_SHOULD_SKIP_THIS
530 
531  // Helper macro that collects compile time enum information of 'Derived' class.
532  #define _ML_COLLECT_ENUMS \
533  const int inputTypes[10] = { \
534  Derived::InputSubImage0_Type, Derived::InputSubImage1_Type, Derived::InputSubImage2_Type, Derived::InputSubImage3_Type, Derived::InputSubImage4_Type, \
535  Derived::InputSubImage5_Type, Derived::InputSubImage6_Type, Derived::InputSubImage7_Type, Derived::InputSubImage8_Type, Derived::InputSubImage9_Type }; \
536  const int inputReadOnly[10] = { \
537  Derived::InputSubImage0_ReadOnly, Derived::InputSubImage1_ReadOnly, Derived::InputSubImage2_ReadOnly, Derived::InputSubImage3_ReadOnly, Derived::InputSubImage4_ReadOnly, \
538  Derived::InputSubImage5_ReadOnly, Derived::InputSubImage6_ReadOnly, Derived::InputSubImage7_ReadOnly, Derived::InputSubImage8_ReadOnly, Derived::InputSubImage9_ReadOnly }; \
539  int variableTypes[4] {}; \
540  setupVariableTypes(variableTypes);
541 
544  static void setupKnownProperties(PagedImage* outImg) {
545  // collect static information
546  _ML_COLLECT_ENUMS
547  setupKnownPagedImgProperties(outImg, NumberOfInputImages, Derived::OutputSubImage_Type, inputTypes, inputReadOnly, Derived::getNumVariableTypes(), variableTypes);
548  }
549 
553  static bool verifyProperties(PagedImage* outImg) {
554  // collect static information
555  _ML_COLLECT_ENUMS
556  int resultDataTypes[4];
557  verifyPagedImgProperties(outImg, NumberOfInputImages, Derived::OutputSubImage_Type, inputTypes, inputReadOnly, Derived::getNumVariableTypes(), variableTypes, resultDataTypes);
558  if (outImg->isValid()) {
559  std::ostringstream errorMessages;
560  for (int i = 0; i < Derived::getNumVariableTypes(); i++) {
561  if (!Derived::doesVariableTypeSupportDataType(i, resultDataTypes[i])) {
562  if (variableTypes[i]!=_ML_OUTPUTINDEX) {
563  errorMessages << "Unsupported data type '" << MLNameFromDataType(resultDataTypes[i]) << "' at input" << variableTypes[i] << " using variable type " << Derived::variableTypeName(i) << std::endl;
564  } else {
565  errorMessages << "Unsupported data type '" << MLNameFromDataType(resultDataTypes[i]) << "' at output using variable type " << Derived::variableTypeName(i) << std::endl;
566  }
567  }
568  }
569  if (errorMessages.str().size()) {
570  outImg->setInvalid();
571  outImg->setStateInfo(errorMessages.str(), ML_BAD_DATA_TYPE);
572  }
573  }
574  return outImg->isValid();
575  }
576 
577  #undef _ML_COLLECT_ENUMS
578 };
579 
580 #ifndef DOXYGEN_SHOULD_SKIP_THIS
581 
584 template<class Derived, int Step, class Args >
585 class NoTypes : public VariableType {
586 public:
587  enum {
588  IsEmpty = true
589  };
590 
591  static const char* name() { return "NoTypes"; }
592 
593  // Empty switching code that returns \c true.
594  template<typename PrevTypes, typename TargetLabelType>
595  bool doSwitchingCode(int /*switchCode*/, const Args& /*args*/, bool /*printError*/ = true) { return true; }
596 };
597 
598 //------------------------------------------------------------------------------------------
601 struct DispatchVariableType1Label {};
602 struct DispatchVariableType2Label {};
603 struct DispatchVariableType3Label {};
604 struct DispatchDoneLabel {};
605 struct DispatchDoNothingLabel {};
606 
609 typedef TypeTuple4<DispatchDoneLabel, DispatchDoneLabel, DispatchDoneLabel, DispatchDoneLabel> JumpTable1;
612 typedef TypeTuple4<DispatchVariableType1Label, DispatchDoneLabel, DispatchDoneLabel, DispatchDoneLabel> JumpTable2;
615 typedef TypeTuple4<DispatchVariableType1Label, DispatchVariableType2Label, DispatchDoneLabel, DispatchDoneLabel> JumpTable3;
618 typedef TypeTuple4<DispatchVariableType1Label, DispatchVariableType2Label, DispatchVariableType3Label, DispatchDoneLabel> JumpTable4;
619 
620 
622 template<class Derived>
623 class EmptyVariableTypeDispatcher
624 {
625 public:
626  static int getNumVariableTypes() { return 0; }
627  static bool doesVariableTypeSupportDataType(int /*variableType*/, int /*switchCode*/) { return false; }
628  static const char* variableTypeName(int /*variableType*/) { return "NoTypes"; }
629 
630  void doSwitching(const CalculateOutputSubImageArguments& args) {
631  // call back directly to caller, we have no variable types
632  static_cast<Derived*>(this)->template helperCalculateOutputSubImage<EmptyTypeTuple4>(args);
633  }
634 
635 };
636 
639 template<class Derived, class JumpTable, class VariableType0, class VariableType1, class VariableType2, class VariableType3>
640 class VariableTypeDispatcher : public VariableType0, public VariableType1, public VariableType2, public VariableType3 {
641 public:
642 
644  static int getNumVariableTypes() {
645  return (VariableType0::IsEmpty?0:1) + (VariableType1::IsEmpty?0:1) +
646  (VariableType2::IsEmpty?0:1) + (VariableType3::IsEmpty?0:1);
647  }
648 
649  static bool doesVariableTypeSupportDataType(int variableType, int switchCode) {
650  VariableTypeDispatcher<Derived, JumpTable, VariableType0, VariableType1, VariableType2, VariableType3> self;
651  CalculateOutputSubImageArguments args;
652  if (variableType == 0) {
653  return static_cast<VariableType0*>(&self)->template doSwitchingCode<EmptyTypeTuple4, DispatchDoNothingLabel>(switchCode, args, false /* no error printing*/ );
654  } else if (variableType == 1) {
655  return static_cast<VariableType1*>(&self)->template doSwitchingCode<EmptyTypeTuple4, DispatchDoNothingLabel>(switchCode, args, false /* no error printing*/ );
656  } else if (variableType == 2) {
657  return static_cast<VariableType2*>(&self)->template doSwitchingCode<EmptyTypeTuple4, DispatchDoNothingLabel>(switchCode, args, false /* no error printing*/ );
658  } else if (variableType == 3) {
659  return static_cast<VariableType3*>(&self)->template doSwitchingCode<EmptyTypeTuple4, DispatchDoNothingLabel>(switchCode, args, false /* no error printing*/ );
660  }
661  return false;
662  }
663 
664  static const char* variableTypeName(int variableType) {
665  if (variableType == 0) {
666  return VariableType0::name();
667  } else if (variableType == 1) {
668  return VariableType1::name();
669  } else if (variableType == 2) {
670  return VariableType2::name();
671  } else if (variableType == 3) {
672  return VariableType3::name();
673  }
674  return "";
675  }
676 
677  void doSwitching(const CalculateOutputSubImageArguments& args) {
678  MLDataType dt = args.variableDataType[0];
679  static_cast<VariableType0*>(this)->template doSwitchingCode<EmptyTypeTuple4, typename JumpTable::T0>(dt, args);
680  }
681 
682  template<typename Types>
683  void doSwitchingWithLabel(const CalculateOutputSubImageArguments& args, DispatchVariableType1Label*) {
684  MLDataType dt = args.variableDataType[1];
685  static_cast<VariableType1*>(this)->template doSwitchingCode<Types, typename JumpTable::T1>(dt, args);
686  }
687 
688  template<typename Types>
689  void doSwitchingWithLabel(const CalculateOutputSubImageArguments& args, DispatchVariableType2Label*) {
690  MLDataType dt = args.variableDataType[2];
691  static_cast<VariableType2*>(this)->template doSwitchingCode<Types, typename JumpTable::T2>(dt, args);
692  }
693 
694  template<typename Types>
695  void doSwitchingWithLabel(const CalculateOutputSubImageArguments& args, DispatchVariableType3Label*) {
696  MLDataType dt = args.variableDataType[3];
697  static_cast<VariableType3*>(this)->template doSwitchingCode<Types, typename JumpTable::T3>(dt, args);
698  }
699 
700  template<typename Types>
701  void doSwitchingWithLabel(const CalculateOutputSubImageArguments& args, DispatchDoneLabel*) {
702  static_cast<Derived*>(this)->template helperCalculateOutputSubImage<Types>(args);
703  }
704 
705  template<typename Types>
706  void doSwitchingWithLabel(const CalculateOutputSubImageArguments&, DispatchDoNothingLabel*) {
707  }
708 };
709 
710 #endif // of DOXYGEN_SHOULD_SKIP_THIS
711 
712 } // end namespace internal
713 
714 
715 //----------------------------------------------------------------------------------------------------
716 
721 template <typename Derived, int NumberOfInputImages,
722  template <typename, int, typename>class VariableType0 = internal::NoTypes,
723  template <typename, int, typename>class VariableType1 = internal::NoTypes,
724  template <typename, int, typename>class VariableType2 = internal::NoTypes,
725  template <typename, int, typename>class VariableType3 = internal::NoTypes >
726 class TypedProcessAllPagesHandler : public internal::TypedHandlerBase<ProcessAllPagesHandler, Derived, NumberOfInputImages>,
727  public internal::VariableTypeDispatcher<Derived, internal::JumpTable4, VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
728  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
729  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
730  VariableType3<Derived, 3, internal::CalculateOutputSubImageArguments > >
731 {
732 };
733 
734 
735 #ifndef DOXYGEN_SHOULD_SKIP_THIS
736 
737 // Specialization with three variable types.
738 template <typename Derived, int NumberOfInputImages,
739 template <typename, int, typename>class VariableType0,
740 template <typename, int, typename>class VariableType1,
741 template <typename, int, typename>class VariableType2>
742 class TypedProcessAllPagesHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, VariableType2, internal::NoTypes> :
743  public internal::TypedHandlerBase<ProcessAllPagesHandler, Derived, NumberOfInputImages>,
744  public internal::VariableTypeDispatcher<Derived, internal::JumpTable3,
745  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
746  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
747  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
748  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
749 {
750 };
751 
752 // Specialization with two variable types.
753 template <typename Derived, int NumberOfInputImages,
754 template <typename, int, typename>class VariableType0,
755 template <typename, int, typename>class VariableType1>
756 class TypedProcessAllPagesHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, internal::NoTypes, internal::NoTypes> :
757  public internal::TypedHandlerBase<ProcessAllPagesHandler, Derived, NumberOfInputImages>,
758  public internal::VariableTypeDispatcher<Derived, internal::JumpTable2,
759  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
760  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
761  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
762  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
763 {
764 };
765 
766 // Specialization with one variable type.
767 template <typename Derived, int NumberOfInputImages,
768 template <typename, int, typename>class VariableType0>
769 class TypedProcessAllPagesHandler<Derived, NumberOfInputImages, VariableType0, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
770  public internal::TypedHandlerBase<ProcessAllPagesHandler, Derived, NumberOfInputImages>,
771  public internal::VariableTypeDispatcher<Derived, internal::JumpTable1,
772  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
773  internal::NoTypes<Derived, 1, internal::CalculateOutputSubImageArguments >,
774  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
775  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
776 {
777 };
778 
779 // Specialization with zero variable types.
780 template <typename Derived, int NumberOfInputImages>
781 class TypedProcessAllPagesHandler<Derived, NumberOfInputImages, internal::NoTypes, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
782  public internal::TypedHandlerBase<ProcessAllPagesHandler, Derived, NumberOfInputImages>,
783  public internal::EmptyVariableTypeDispatcher<Derived>
784 {
785 };
786 
787 #endif // of DOXYGEN_SHOULD_SKIP_THIS
788 
789 //----------------------------------------------------------------------------------------------------
790 
796 
822 
834 
855 
862 
887 
895 
914 
925 
937 template <typename Derived, int NumberOfInputImages,
938 template <typename, int, typename>class VariableType0 = internal::NoTypes,
939 template <typename, int, typename>class VariableType1 = internal::NoTypes,
940 template <typename, int, typename>class VariableType2 = internal::NoTypes,
941 template <typename, int, typename>class VariableType3 = internal::NoTypes >
942 class TypedCalculateOutputImageHandler : public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
943  public internal::VariableTypeDispatcher<Derived, internal::JumpTable4,
944  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
945  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
946  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
947  VariableType3<Derived, 3, internal::CalculateOutputSubImageArguments > >
948 {
949 };
950 
951 #ifndef DOXYGEN_SHOULD_SKIP_THIS
952 
953 // Specialization with three variable types
954 template <typename Derived, int NumberOfInputImages,
955 template <typename, int, typename>class VariableType0,
956 template <typename, int, typename>class VariableType1,
957 template <typename, int, typename>class VariableType2>
958 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, VariableType2, internal::NoTypes> :
959  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
960  public internal::VariableTypeDispatcher<Derived, internal::JumpTable3,
961  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
962  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
963  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
964  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
965 {
966 };
967 
968 // Specialization with two variable types
969 template <typename Derived, int NumberOfInputImages,
970 template <typename, int, typename>class VariableType0,
971 template <typename, int, typename>class VariableType1>
972 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, internal::NoTypes, internal::NoTypes> :
973  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
974  public internal::VariableTypeDispatcher<Derived, internal::JumpTable2,
975  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
976  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
977  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
978  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
979 {
980 };
981 
982 // Specialization with one variable type
983 template <typename Derived, int NumberOfInputImages,
984 template <typename, int, typename>class VariableType0>
985 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
986  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
987  public internal::VariableTypeDispatcher<Derived, internal::JumpTable1,
988  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
989  internal::NoTypes<Derived, 1, internal::CalculateOutputSubImageArguments >,
990  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
991  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
992 {
993 };
994 
995 // Specialization with zero variable types
996 template <typename Derived, int NumberOfInputImages>
997 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, internal::NoTypes, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
998  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
999  public internal::EmptyVariableTypeDispatcher<Derived>
1000 {
1001 };
1002 
1003 #endif // of DOXYGEN_SHOULD_SKIP_THIS
1004 
1005 //----------------------------------------------------------------------------------------------------
1006 
1007 //---------------------------------------------------------------------------
1010 //---------------------------------------------------------------------------
1011 
1015 
1029 #define ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(NAME) \
1030  template<class Derived, int Step, class Args = ML_NAMESPACE::internal::CalculateOutputSubImageArguments> \
1031 class NAME : public VariableType { \
1032 public: \
1033  enum { IsEmpty = false }; \
1034  \
1035  static const char* name() { return #NAME; } \
1036  \
1037  template<typename PrevTypes, typename TargetLabelType> \
1038  bool doSwitchingCode(int switchCode, const Args& args, bool printError = true) { \
1039  static const char* switcherName = #NAME; \
1040  bool result = true; \
1041  switch (switchCode) {
1042 
1045 #define ML_IMPLEMENT_VARIABLE_TYPE_END \
1046  default: { \
1047  result = false; \
1048  if (printError) { \
1049  char buf[512]=""; \
1050  sprintf(buf, "No switch case for physical data type %d.", switchCode); \
1051  ML_PRINT_FATAL_ERROR(switcherName, ML_BAD_DATA_TYPE, buf); } \
1052  } \
1053  break; \
1054 } \
1055  return result; \
1056 } \
1057 };
1058 
1061 #define ML_IMPLEMENT_VARIABLE_TYPE_CASE(TYPE) \
1062  case TypeTraits<TYPE>::dataType: \
1063  static_cast<Derived*>(this)->template doSwitchingWithLabel<typename ML_NAMESPACE::internal::TypeTuple4Insert<Step, TYPE, PrevTypes>::Type>(args, static_cast<TargetLabelType*>(0)); \
1064  break;
1065 
1066 #define ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(DATATYPE, TYPE) \
1067  case DATATYPE: \
1068  static_cast<Derived*>(this)->template doSwitchingWithLabel<typename ML_NAMESPACE::internal::TypeTuple4Insert<Step, TYPE, PrevTypes>::Type>(args, static_cast<TargetLabelType*>(0)); \
1069  break;
1070 
1073 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT \
1074  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLfloat) \
1075  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLdouble)
1076 
1079 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER \
1080  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint8) \
1081  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint8) \
1082  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint16) \
1083  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint16) \
1084  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint32) \
1085  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint32) \
1086  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint64) \
1087  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint64)
1088 
1089 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX \
1090  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexfType, std::complex<MLfloat>) \
1091  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexdType, std::complex<MLdouble>)
1092 
1093 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED \
1094  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexfType, std::complex<MLfloat>) \
1095  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexdType, std::complex<MLdouble>) \
1096  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector2fType, Vector2f) \
1097  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector2dType, Vector2d) \
1098  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector3fType, Vector3f) \
1099  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector3dType, Vector3d) \
1100  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector6fType, Vector6f) \
1101  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector6dType, Vector6d) \
1102  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix2fType, Matrix2f) \
1103  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix2dType, Matrix2d) \
1104  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix3fType, Matrix3f) \
1105  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix3dType, Matrix3d)
1106 
1110 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(FloatTypes)
1111  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1112 ML_IMPLEMENT_VARIABLE_TYPE_END
1113 
1117 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(IntegerTypes)
1118  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1119 ML_IMPLEMENT_VARIABLE_TYPE_END
1120 
1124 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(ScalarTypes)
1125  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1126  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1127 ML_IMPLEMENT_VARIABLE_TYPE_END
1128 
1131 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(StandardTypes)
1132  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1133  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1134 ML_IMPLEMENT_VARIABLE_TYPE_END
1135 
1139 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(DefaultTypes)
1140  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1141  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1142  ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
1143 ML_IMPLEMENT_VARIABLE_TYPE_END
1144 
1147 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(AllTypes)
1148  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1149  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1150  ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
1151 ML_IMPLEMENT_VARIABLE_TYPE_END
1152 
1156 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(DefaultExtendedTypes)
1157  ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
1158 ML_IMPLEMENT_VARIABLE_TYPE_END
1159 
1163 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(ComplexTypes)
1164  ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX
1165 ML_IMPLEMENT_VARIABLE_TYPE_END
1166 
1170 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(ScalarAndComplexTypes)
1171  ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
1172  ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
1173  ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX
1174 ML_IMPLEMENT_VARIABLE_TYPE_END
1175 
1177 
1178 ML_END_NAMESPACE
1179 
1180 #endif // of __mlTypedHandlers_H
1181 
ComplexTypes
Defines a variable type for the complex datatypes (float and double) to be used with a TypedProcessAl...
DefaultExtendedTypes
Defines a variable type for the default extended datatypes to be used with a TypedProcessAllPagesHand...
DefaultTypes
Defines a variable type for all scalar and the default extended datatypes to be used with a TypedProc...
FloatTypes
Defines a variable type for all built-in floating point datatypes to be used with a TypedProcessAllPa...
IntegerTypes
Defines a variable type for all built-in integer datatypes to be used with a TypedProcessAllPagesHand...
ml::PagedImage
The class PagedImage, representing a fragmented image that manages properties and data of an image lo...
Definition: mlPagedImage.h:66
ml::PagedImage::setStateInfo
virtual MLEXPORT void setStateInfo(const std::string &info, MLErrorCode errorCode)
Sets the state information for this PagedImage to the string info and the MLErrorCode errorCode.
ml::PagedImage::isValid
bool isValid() const
Returns whether image properties are valid and up-to-date.
Definition: mlPagedImage.h:143
ml::PagedImage::setInvalid
void setInvalid()
Sets image properties invalid, i.e., isValid() returns false afterwards.
Definition: mlPagedImage.h:151
ScalarAndComplexTypes
Defines a variable type for the complex datatypes (float and double) to be used with a TypedProcessAl...
ScalarTypes
Defines a variable type for all built-in datatypes to be used with a TypedProcessAllPagesHandler/Type...
ml::SubImage
This class manages/represents a rectangular 6D image region that is organized linearly in memory.
Definition: mlSubImage.h:75
ml::TSubImage
This template class manages/represents a rectangular 6D image region in memory that is organized line...
Definition: mlTSubImage.h:110
ml::TypedCalculateOutputImageHandler
TypedCalculateOutputImageHandler can be used as a base class for a custom CalculateOutputImageHandler...
Definition: mlTypedHandlers.h:948
ml::TypedProcessAllPagesHandler
TypedProcessAllPagesHandler can be used as a base class for a custom ProcessAllPages handler and supp...
Definition: mlTypedHandlers.h:731
ml::UserThreadData
Base class for thread local data that is passed to CalculateOutputImageHandler::calculateOutputSubIma...
Definition: mlModuleInterfaces.h:31
ml::VariableType
Base class for all variable types, mainly for Doxygen documentation purpose.
Definition: mlTypedHandlers.h:91
ml::internal::TypedHandlerBase
The base class for TypedCalculateOutputImageHandler and TypedProcessAllPagesHandler.
Definition: mlTypedHandlers.h:244
ml::internal::TypedHandlerBase::setupKnownProperties
static void setupKnownProperties(PagedImage *outImg)
Sets up the properties of the outImg and its input subimages according to the settings of OutputSubIm...
Definition: mlTypedHandlers.h:544
ml::internal::TypedHandlerBase::calculateOutputSubImage
void calculateOutputSubImage(SubImage *outImg, SubImage *inImgs, UserThreadData *userThreadData) override
Overrides the calculateOutputSubImage of CalculateOutputImageHandler.
Definition: mlTypedHandlers.h:309
ml::internal::TypedHandlerBase::verifyProperties
static bool verifyProperties(PagedImage *outImg)
Verifies the properties of outImg (its data type and the datatypes of the input subimages,...
Definition: mlTypedHandlers.h:553
ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
Defines a variable type case block for all integer types.
Definition: mlTypedHandlers.h:1079
ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
Defines a variable type case block for all float types.
Definition: mlTypedHandlers.h:1073
ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX
Definition: mlTypedHandlers.h:1089
ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
Definition: mlTypedHandlers.h:1093
ML_IMPLEMENT_VARIABLE_TYPE_BEGIN
#define ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(NAME)
Macro to declare a variable type, needs to be followed by 0-N ML_IMPLEMENT_VARIABLE_TYPE_CASE macros ...
Definition: mlTypedHandlers.h:1029
ML_IMPLEMENT_VARIABLE_TYPE_END
#define ML_IMPLEMENT_VARIABLE_TYPE_END
Macro to end declaration of a variable type.
Definition: mlTypedHandlers.h:1045
MLNameFromDataType
MLEXPORT const char * MLNameFromDataType(MLDataType dataType)
Function that returns the NULL-terminated string name for data type dataType or "" in case of error o...
MLDataType
MLint32 MLDataType
MLDataType.
Definition: mlTypeDefs.h:596
ML_BAD_DATA_TYPE
#define ML_BAD_DATA_TYPE
A wrong or unexpected data type has been passed to an algorithm, which often is a programming error.
Definition: mlTypeDefs.h:782
MLEXPORT
#define MLEXPORT
To export symbols from a DLL/shared object, we need to mark them with the MLEXPORT symbol.
Definition: mlInitSystemML.h:38
_ML_COLLECT_ENUMS
#define _ML_COLLECT_ENUMS
Definition: mlTypedHandlers.h:532
_ML_OUTPUTINDEX
#define _ML_OUTPUTINDEX
Defines a special index that means to use the output image.
Definition: mlTypedHandlers.h:50
ML_N_INPUTS
#define ML_N_INPUTS
Special value that can be passed as number of inputs to the typed handlers.
Definition: mlTypedHandlers.h:44
_ML_SWITCH_SELECT_OFFSET
#define _ML_SWITCH_SELECT_OFFSET
Defines an offset for switch types (internal).
Definition: mlTypedHandlers.h:47
ml::MLGenericType
const int MLGenericType
Defines special index to use a generic type.
Definition: mlTypedHandlers.h:61
ml::MLVariableType2
const int MLVariableType2
Defines to use the result type of variable type 2.
Definition: mlTypedHandlers.h:57
ml::MLVariableType3
const int MLVariableType3
Defines to use the result type of variable type 3.
Definition: mlTypedHandlers.h:59
ml::MLVariableType0
const int MLVariableType0
Defines to use the result type of variable type 0.
Definition: mlTypedHandlers.h:53
ml::MLVariableType1
const int MLVariableType1
Defines to use the result type of variable type 1.
Definition: mlTypedHandlers.h:55
ml::DataTypeSelector
Helper template so select a data type from its type ID.
Definition: mlTypeTraits.h:81