MeVisLab Toolbox 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"
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 people 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 
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 4 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 
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 thru.
311  CalculateOutputSubImageArguments args(outImg, inImgs, userThreadData);
312 
313  // Detect the correct datatype 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>*) {
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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
547  setupKnownPagedImgProperties(outImg, NumberOfInputImages, Derived::OutputSubImage_Type, inputTypes, inputReadOnly, Derived::getNumVariableTypes(), variableTypes);
548  }
549 
553  static bool verifyProperties(PagedImage* outImg) {
554  // collect static information
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 datatype '" << MLNameFromDataType(resultDataTypes[i]) << "' at input" << variableTypes[i] << " using variable type " << Derived::variableTypeName(i) << std::endl;
564  } else {
565  errorMessages << "Unsupported datatype '" << 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 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 3 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 2 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 1 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 0 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 
823 
835 
856 
863 
888 
896 
915 
926 
938 template <typename Derived, int NumberOfInputImages,
939 template <typename, int, typename>class VariableType0 = internal::NoTypes,
940 template <typename, int, typename>class VariableType1 = internal::NoTypes,
941 template <typename, int, typename>class VariableType2 = internal::NoTypes,
942 template <typename, int, typename>class VariableType3 = internal::NoTypes >
943 class TypedCalculateOutputImageHandler : public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
944  public internal::VariableTypeDispatcher<Derived, internal::JumpTable4,
945  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
946  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
947  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
948  VariableType3<Derived, 3, internal::CalculateOutputSubImageArguments > >
949 {
950 };
951 
952 #ifndef DOXYGEN_SHOULD_SKIP_THIS
953 
954 // Specialization with 3 variable types
955 template <typename Derived, int NumberOfInputImages,
956 template <typename, int, typename>class VariableType0,
957 template <typename, int, typename>class VariableType1,
958 template <typename, int, typename>class VariableType2>
959 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, VariableType2, internal::NoTypes> :
960  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
961  public internal::VariableTypeDispatcher<Derived, internal::JumpTable3,
962  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
963  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
964  VariableType2<Derived, 2, internal::CalculateOutputSubImageArguments >,
965  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
966 {
967 };
968 
969 // Specialization with 2 variable types
970 template <typename Derived, int NumberOfInputImages,
971 template <typename, int, typename>class VariableType0,
972 template <typename, int, typename>class VariableType1>
973 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, VariableType1, internal::NoTypes, internal::NoTypes> :
974  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
975  public internal::VariableTypeDispatcher<Derived, internal::JumpTable2,
976  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
977  VariableType1<Derived, 1, internal::CalculateOutputSubImageArguments >,
978  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
979  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
980 {
981 };
982 
983 // Specialization with 1 variable type
984 template <typename Derived, int NumberOfInputImages,
985 template <typename, int, typename>class VariableType0>
986 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, VariableType0, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
987  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
988  public internal::VariableTypeDispatcher<Derived, internal::JumpTable1,
989  VariableType0<Derived, 0, internal::CalculateOutputSubImageArguments >,
990  internal::NoTypes<Derived, 1, internal::CalculateOutputSubImageArguments >,
991  internal::NoTypes<Derived, 2, internal::CalculateOutputSubImageArguments >,
992  internal::NoTypes<Derived, 3, internal::CalculateOutputSubImageArguments > >
993 {
994 };
995 
996 // Specialization with 0 variable types
997 template <typename Derived, int NumberOfInputImages>
998 class TypedCalculateOutputImageHandler<Derived, NumberOfInputImages, internal::NoTypes, internal::NoTypes, internal::NoTypes, internal::NoTypes> :
999  public internal::TypedHandlerBase<CalculateOutputImageHandler, Derived, NumberOfInputImages>,
1000  public internal::EmptyVariableTypeDispatcher<Derived>
1001 {
1002 };
1003 
1004 #endif // of DOXYGEN_SHOULD_SKIP_THIS
1005 
1006 //----------------------------------------------------------------------------------------------------
1007 
1008 //---------------------------------------------------------------------------
1011 //---------------------------------------------------------------------------
1012 
1016 
1030 #define ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(NAME) \
1031  template<class Derived, int Step, class Args = ML_NAMESPACE::internal::CalculateOutputSubImageArguments> \
1032 class NAME : public VariableType { \
1033 public: \
1034  enum { IsEmpty = false }; \
1035  \
1036  static const char* name() { return #NAME; } \
1037  \
1038  template<typename PrevTypes, typename TargetLabelType> \
1039  bool doSwitchingCode(int switchCode, const Args& args, bool printError = true) { \
1040  static const char* switcherName = #NAME; \
1041  bool result = true; \
1042  switch (switchCode) {
1043 
1046 #define ML_IMPLEMENT_VARIABLE_TYPE_END \
1047  default: { \
1048  result = false; \
1049  if (printError) { \
1050  char buf[512]=""; \
1051  sprintf(buf, "No switch case for physical data type %d.", switchCode); \
1052  ML_PRINT_FATAL_ERROR(switcherName, ML_BAD_DATA_TYPE, buf); } \
1053  } \
1054  break; \
1055 } \
1056  return result; \
1057 } \
1058 };
1059 
1062 #define ML_IMPLEMENT_VARIABLE_TYPE_CASE(TYPE) \
1063  case TypeTraits<TYPE>::dataType: \
1064  static_cast<Derived*>(this)->template doSwitchingWithLabel<typename ML_NAMESPACE::internal::TypeTuple4Insert<Step, TYPE, PrevTypes>::Type>(args, static_cast<TargetLabelType*>(0)); \
1065  break;
1066 
1067 #define ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(DATATYPE, TYPE) \
1068  case DATATYPE: \
1069  static_cast<Derived*>(this)->template doSwitchingWithLabel<typename ML_NAMESPACE::internal::TypeTuple4Insert<Step, TYPE, PrevTypes>::Type>(args, static_cast<TargetLabelType*>(0)); \
1070  break;
1071 
1074 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT \
1075  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLfloat) \
1076  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLdouble)
1077 
1080 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER \
1081  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint8) \
1082  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint8) \
1083  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint16) \
1084  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint16) \
1085  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint32) \
1086  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint32) \
1087  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLuint64) \
1088  ML_IMPLEMENT_VARIABLE_TYPE_CASE(MLint64)
1089 
1090 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX \
1091  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexfType, std::complex<MLfloat>) \
1092  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexdType, std::complex<MLdouble>)
1093 
1094 #define ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED \
1095  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexfType, std::complex<MLfloat>) \
1096  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLComplexdType, std::complex<MLdouble>) \
1097  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector2fType, Vector2f) \
1098  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector2dType, Vector2d) \
1099  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector3fType, Vector3f) \
1100  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector3dType, Vector3d) \
1101  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector6fType, Vector6f) \
1102  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLVector6dType, Vector6d) \
1103  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix2fType, Matrix2f) \
1104  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix2dType, Matrix2d) \
1105  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix3fType, Matrix3f) \
1106  ML_IMPLEMENT_VARIABLE_EXTENDED_TYPE_CASE(MLMatrix3dType, Matrix3d)
1107 
1114 
1121 
1129 
1132 ML_IMPLEMENT_VARIABLE_TYPE_BEGIN(StandardTypes)
1136 
1145 
1153 
1160 
1167 
1176 
1178 
1179 ML_END_NAMESPACE
1180 
1181 #endif // of __mlTypedHandlers_H
1182 
@ T
Definition: SoKeyGrabber.h:71
Defines a variable type for the complex data types (float and double) to be used with a TypedProcessA...
Defines a variable type for the default extended data types to be used with a TypedProcessAllPagesHan...
Defines a variable type for all scalar and the default extended data types to be used with a TypedPro...
Defines a variable type for all built-in floating point data types to be used with a TypedProcessAllP...
Defines a variable type for all built-in integer data types to be used with a TypedProcessAllPagesHan...
Class which represents an image, which manages properties of an image and image data which is located...
Definition: mlPagedImage.h:70
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.
bool isValid() const
Returns whether image properties are valid and up-to-date.
Definition: mlPagedImage.h:147
void setInvalid()
Sets image properties invalid, i.e., isValid() returns false afterwards.
Definition: mlPagedImage.h:155
Defines a variable type for the complex data types (float and double) to be used with a TypedProcessA...
Defines a variable type for all built-in data types to be used with a TypedProcessAllPagesHandler/Typ...
This class manages/represents a rectangular 6d image region which is organized linearly in memory.
Definition: mlSubImage.h:75
This template class manages/represents a rectangular 6d image region in memory which is organized lin...
Definition: mlTSubImage.h:110
TypedCalculateOutputImageHandler can be used as a base class for an own CalculateOutputImageHandler a...
TypedProcessAllPagesHandler can be used as a base class for an own ProcessAllPages handler and suppor...
Base class for thread local data that is passed to CalculateOutputImageHandler::calculateOutputSubIma...
Base class for all variable types, mainly for doxygen documentation purpose.
The base class for TypedCalculateOutputImageHandler and TypedProcessAllPagesHandler.
static void setupKnownProperties(PagedImage *outImg)
Setup the properties of the outImg and its input sub images according to the settings of OutputSubIma...
void calculateOutputSubImage(SubImage *outImg, SubImage *inImgs, UserThreadData *userThreadData) override
Overrides the calculateOutputSubImage of CalculateOutputImageHandler.
static bool verifyProperties(PagedImage *outImg)
Verify the properties of the outImg (its datatype and the datatypes of the input sub images compared ...
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_INTEGER
Defines a variable type case block for all integer types.
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_FLOAT
Defines a variable type case block for all float types.
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_COMPLEX
#define ML_IMPLEMENT_VARIABLE_TYPE_CASES_DEFAULT_EXTENDED
#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 ...
#define ML_IMPLEMENT_VARIABLE_TYPE_END
Macro to end declaration of a variable type.
MLEXPORT const char * MLNameFromDataType(MLDataType dataType)
Function which returns the null-terminated string name for data type dataType or "" in case of error ...
MLint32 MLDataType
MLDataType.
Definition: mlTypeDefs.h:684
#define ML_BAD_DATA_TYPE
A wrong or unexpected data type has been passed to an algorithm which often is a programming error; t...
Definition: mlTypeDefs.h:884
#define MLEXPORT
To export symbols from a dll/shared object, we need to mark them with the MLEXPORT symbol.
#define _ML_COLLECT_ENUMS
#define _ML_OUTPUTINDEX
Defines special index that means to use the output image.
#define ML_N_INPUTS
Special value that can be passed as number of inputs to the typed handlers.
#define _ML_SWITCH_SELECT_OFFSET
Defines offset for switch types (internal)
const int MLGenericType
Defines special index to use a generic type.
const int MLVariableType2
Defines to use the result type of variable type 2.
const int MLVariableType3
Defines to use the result type of variable type 3.
const int MLVariableType0
Defines to use the result type of variable type 0.
const int MLVariableType1
Defines to use the result type of variable type 1.
Helper template so select a data type from its type id.
Definition: mlTypeTraits.h:81