ML Reference
mlModuleMacros.h
Go to the documentation of this file.
1 /*************************************************************************************
2 **
3 ** Copyright 2007, 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_MODULE_MACROS_H
14 #define ML_MODULE_MACROS_H
15 
16 #include <mlMacros.h>
17 
20 
21 //-------------------------------------------------------------------------
22 // MACROS to simplify module programming
23 //-------------------------------------------------------------------------
24 
25 //------------------------------------------------------------------------------------
27 //------------------------------------------------------------------------------------
28 #define ML_EMPTY_PARAM
29 
30 //------------------------------------------------------------------------------------
32 //------------------------------------------------------------------------------------
33 #define ML_INSTANTIATE_STANDARD_SIGNED_INT_TYPES(PASSED_CODE) \
34  PASSED_CODE(MLint8); \
35  PASSED_CODE(MLint16); \
36  PASSED_CODE(MLint32); \
37  PASSED_CODE(MLint64);
38 
39 //------------------------------------------------------------------------------------
41 //------------------------------------------------------------------------------------
42 #define ML_INSTANTIATE_STANDARD_UNSIGNED_INT_TYPES(PASSED_CODE) \
43  PASSED_CODE(MLuint8); \
44  PASSED_CODE(MLuint16); \
45  PASSED_CODE(MLuint32); \
46  PASSED_CODE(MLuint64);
47 
48 //------------------------------------------------------------------------------------
50 //------------------------------------------------------------------------------------
51 #define ML_INSTANTIATE_STANDARD_INT_TYPES(PASSED_CODE) \
52  ML_INSTANTIATE_STANDARD_SIGNED_INT_TYPES(PASSED_CODE) \
53  ML_INSTANTIATE_STANDARD_UNSIGNED_INT_TYPES(PASSED_CODE)
54 
55 //------------------------------------------------------------------------------------
57 //------------------------------------------------------------------------------------
58 #define ML_INSTANTIATE_STANDARD_FLOAT_TYPES(PASSED_CODE) \
59  PASSED_CODE(MLfloat); \
60  PASSED_CODE(MLdouble);
61 
62 //------------------------------------------------------------------------------------
81 //------------------------------------------------------------------------------------
82 #define ML_INSTANTIATE_STANDARD_TYPES(PASSED_CODE) \
83  ML_INSTANTIATE_STANDARD_INT_TYPES(PASSED_CODE) \
84  ML_INSTANTIATE_STANDARD_FLOAT_TYPES(PASSED_CODE)
85 
86 //------------------------------------------------------------------------------------
88 //------------------------------------------------------------------------------------
89 #define ML_INSTANTIATE_DEFAULT_EXTENDED_TYPES(PASSED_CODE) \
90  PASSED_CODE(std::complex<MLfloat>); \
91  PASSED_CODE(std::complex<MLdouble>); \
92  PASSED_CODE(Vector2f); \
93  PASSED_CODE(Vector2d); \
94  PASSED_CODE(Vector3f); \
95  PASSED_CODE(Vector3d); \
96  PASSED_CODE(Vector6f); \
97  PASSED_CODE(Vector6d); \
98  PASSED_CODE(Matrix2f); \
99  PASSED_CODE(Matrix2d); \
100  PASSED_CODE(Matrix3f); \
101  PASSED_CODE(Matrix3d);
102 
103 //------------------------------------------------------------------------------------
106 //------------------------------------------------------------------------------------
107 #define ML_INSTANTIATE_ALL_TYPES(PASSED_CODE) \
108  ML_INSTANTIATE_STANDARD_TYPES(PASSED_CODE) \
109  ML_INSTANTIATE_DEFAULT_EXTENDED_TYPES(PASSED_CODE)
110 
111 
112 //------------------------------------------------------------------------------------
145 //------------------------------------------------------------------------------------
146 #define ML_IMPLEMENT_ALL_CASES(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, INFO_STRING, DUMMY_OUT_TYPE) \
147  switch(O_SWITCH_TYPE){ \
148  case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break; \
149  case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break; \
150  case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break; \
151  case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break; \
152  case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break; \
153  case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break; \
154  case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break; \
155  case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break; \
156  case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break; \
157  case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break; \
158  case MLComplexfType: SWITCH_CODE(std::complex<MLfloat> , std::complex<MLfloat> , CLASS_NAME); break; \
159  case MLComplexdType: SWITCH_CODE(std::complex<MLdouble>, std::complex<MLdouble>, CLASS_NAME); break; \
160  case MLVector2fType: SWITCH_CODE(Vector2f , Vector2f , CLASS_NAME); break; \
161  case MLVector2dType: SWITCH_CODE(Vector2d , Vector2d , CLASS_NAME); break; \
162  case MLVector3fType: SWITCH_CODE(Vector3f , Vector3f , CLASS_NAME); break; \
163  case MLVector3dType: SWITCH_CODE(Vector3d , Vector3d , CLASS_NAME); break; \
164  case MLVector6fType: SWITCH_CODE(Vector6f , Vector6f , CLASS_NAME); break; \
165  case MLVector6dType: SWITCH_CODE(Vector6d , Vector6d , CLASS_NAME); break; \
166  case MLMatrix2fType: SWITCH_CODE(Matrix2f , Matrix2f , CLASS_NAME); break; \
167  case MLMatrix2dType: SWITCH_CODE(Matrix2d , Matrix2d , CLASS_NAME); break; \
168  case MLMatrix3fType: SWITCH_CODE(Matrix3f , Matrix3f , CLASS_NAME); break; \
169  case MLMatrix3dType: SWITCH_CODE(Matrix3d , Matrix3d , CLASS_NAME); break; \
170  default: { ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, "Unsupported type case."); break; \
171  } \
172  }
173 
174 //------------------------------------------------------------------------------------
176 //------------------------------------------------------------------------------------
177 #define ML_IMPLEMENT_SCALAR_TYPE_CASES(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, INFO_STRING, DUMMY_OUT_TYPE) \
178  switch(O_SWITCH_TYPE){ \
179  case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break; \
180  case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break; \
181  case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break; \
182  case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break; \
183  case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break; \
184  case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break; \
185  case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break; \
186  case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break; \
187  case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break; \
188  case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break; \
189  default: { ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, "Unsupported type case."); break; \
190  } \
191  }
192 
193 //------------------------------------------------------------------------------------
223 //------------------------------------------------------------------------------------
224 #define ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, INFO_STRING, OUTPUT_TYPE) \
225  switch (static_cast<int>(IN_SWITCH_TYPE)){ \
226  case MLint8Type: SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); break; \
227  case MLuint8Type: SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); break; \
228  case MLint16Type: SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); break; \
229  case MLuint16Type: SWITCH_CODE(OUTPUT_TYPE, MLuint16 , CLASS_NAME); break; \
230  case MLint32Type: SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); break; \
231  case MLuint32Type: SWITCH_CODE(OUTPUT_TYPE, MLuint32 , CLASS_NAME); break; \
232  case MLint64Type: SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); break; \
233  case MLuint64Type: SWITCH_CODE(OUTPUT_TYPE, MLuint64 , CLASS_NAME); break; \
234  case MLfloatType: SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); break; \
235  case MLdoubleType: SWITCH_CODE(OUTPUT_TYPE, MLdouble , CLASS_NAME); break; \
236  case MLComplexfType: SWITCH_CODE(OUTPUT_TYPE, std::complex<MLfloat> , CLASS_NAME); break; \
237  case MLComplexdType: SWITCH_CODE(OUTPUT_TYPE, std::complex<MLdouble>, CLASS_NAME); break; \
238  case MLVector2fType: SWITCH_CODE(OUTPUT_TYPE, Vector2f , CLASS_NAME); break; \
239  case MLVector2dType: SWITCH_CODE(OUTPUT_TYPE, Vector2d , CLASS_NAME); break; \
240  case MLVector3fType: SWITCH_CODE(OUTPUT_TYPE, Vector3f , CLASS_NAME); break; \
241  case MLVector3dType: SWITCH_CODE(OUTPUT_TYPE, Vector3d , CLASS_NAME); break; \
242  case MLVector6fType: SWITCH_CODE(OUTPUT_TYPE, Vector6f , CLASS_NAME); break; \
243  case MLVector6dType: SWITCH_CODE(OUTPUT_TYPE, Vector6d , CLASS_NAME); break; \
244  case MLMatrix2fType: SWITCH_CODE(OUTPUT_TYPE, Matrix2f , CLASS_NAME); break; \
245  case MLMatrix2dType: SWITCH_CODE(OUTPUT_TYPE, Matrix2d , CLASS_NAME); break; \
246  case MLMatrix3fType: SWITCH_CODE(OUTPUT_TYPE, Matrix3f , CLASS_NAME); break; \
247  case MLMatrix3dType: SWITCH_CODE(OUTPUT_TYPE, Matrix3d , CLASS_NAME); break; \
248  default:{ \
249  char buf[512]=""; \
250  sprintf(buf, "Type not supported, case type %d does not exist.", IN_SWITCH_TYPE); \
251  ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, buf); } \
252  }
253 
254 //------------------------------------------------------------------------------------
256 //------------------------------------------------------------------------------------
257 #define ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, INFO_STRING, OUTPUT_TYPE) \
258  switch (static_cast<int>(IN_SWITCH_TYPE)){ \
259  case MLint8Type: SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); break; \
260  case MLuint8Type: SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); break; \
261  case MLint16Type: SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); break; \
262  case MLuint16Type: SWITCH_CODE(OUTPUT_TYPE, MLuint16 , CLASS_NAME); break; \
263  case MLint32Type: SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); break; \
264  case MLuint32Type: SWITCH_CODE(OUTPUT_TYPE, MLuint32 , CLASS_NAME); break; \
265  case MLint64Type: SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); break; \
266  case MLuint64Type: SWITCH_CODE(OUTPUT_TYPE, MLuint64 , CLASS_NAME); break; \
267  case MLfloatType: SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); break; \
268  case MLdoubleType: SWITCH_CODE(OUTPUT_TYPE, MLdouble , CLASS_NAME); break; \
269  default:{ \
270  char buf[512]=""; \
271  sprintf(buf, "Type not supported, case type %d does not exist.", IN_SWITCH_TYPE); \
272  ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, buf); } \
273  }
274 
275 
276 #define ML_IMPLEMENT_SCALAR_CASES_WITH_DEFAULT(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, DEFAULT_CODE, DUMMY_OUT_TYPE) \
277  switch (static_cast<int>(O_SWITCH_TYPE)){ \
278  case MLint8Type: { SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); } break; \
279  case MLuint8Type: { SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); } break; \
280  case MLint16Type: { SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); } break; \
281  case MLuint16Type: { SWITCH_CODE(MLuint16, MLuint16, CLASS_NAME); } break; \
282  case MLint32Type: { SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); } break; \
283  case MLuint32Type: { SWITCH_CODE(MLuint32, MLuint32, CLASS_NAME); } break; \
284  case MLint64Type: { SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); } break; \
285  case MLuint64Type: { SWITCH_CODE(MLuint64, MLuint64, CLASS_NAME); } break; \
286  case MLfloatType: { SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); } break; \
287  case MLdoubleType: { SWITCH_CODE(MLdouble, MLdouble, CLASS_NAME); } break; \
288  default: { DEFAULT_CODE(DUMMY_OUT_TYPE, CLASS_NAME); } \
289  }
290 
291 #define ML_IMPLEMENT_DIFFERENT_INOUT_SCALAR_CASES_WITH_DEFAULT(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, DEFAULT_CODE, OUTPUT_TYPE) \
292  switch (static_cast<int>(IN_SWITCH_TYPE)){ \
293  case MLint8Type: { SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); } break; \
294  case MLuint8Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); } break; \
295  case MLint16Type: { SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); } break; \
296  case MLuint16Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint16, CLASS_NAME); } break; \
297  case MLint32Type: { SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); } break; \
298  case MLuint32Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint32, CLASS_NAME); } break; \
299  case MLint64Type: { SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); } break; \
300  case MLuint64Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint64, CLASS_NAME); } break; \
301  case MLfloatType: { SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); } break; \
302  case MLdoubleType: { SWITCH_CODE(OUTPUT_TYPE, MLdouble, CLASS_NAME); } break; \
303  default:{ DEFAULT_CODE(OUTPUT_TYPE, CLASS_NAME); } \
304  }
305 
306 
307 //------------------------------------------------------------------------------------
310 //------------------------------------------------------------------------------------
311 #define ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break;
312 #define ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break;
313 #define ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break;
314 #define ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break;
315 #define ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break;
316 #define ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break;
317 #define ML_IMPLEMENT_INT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break;
318 #define ML_IMPLEMENT_UINT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break;
319 #define ML_IMPLEMENT_FLOAT_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break;
320 #define ML_IMPLEMENT_DOUBLE_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break;
321 #define ML_IMPLEMENT_COMPLEXF_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLComplexfType: SWITCH_CODE(std::complex<MLfloat> , std::complex<MLfloat> , CLASS_NAME); break;
322 #define ML_IMPLEMENT_COMPLEXD_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLComplexdType: SWITCH_CODE(std::complex<MLdouble>, std::complex<MLdouble>, CLASS_NAME); break;
323 #define ML_IMPLEMENT_VECTOR2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector2fType: SWITCH_CODE(Vector2f , Vector2f , CLASS_NAME); break;
324 #define ML_IMPLEMENT_VECTOR2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector2dType: SWITCH_CODE(Vector2d , Vector2d , CLASS_NAME); break;
325 #define ML_IMPLEMENT_VECTOR3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector3fType: SWITCH_CODE(Vector3f , Vector3f , CLASS_NAME); break;
326 #define ML_IMPLEMENT_VECTOR3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector3dType: SWITCH_CODE(Vector3d , Vector3d , CLASS_NAME); break;
327 #define ML_IMPLEMENT_VECTOR6F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector6fType: SWITCH_CODE(Vector6f , Vector6f , CLASS_NAME); break;
328 #define ML_IMPLEMENT_VECTOR6D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector6dType: SWITCH_CODE(Vector6d , Vector6d , CLASS_NAME); break;
329 #define ML_IMPLEMENT_MATRIX2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix2fType: SWITCH_CODE(Matrix2f , Matrix2f , CLASS_NAME); break;
330 #define ML_IMPLEMENT_MATRIX2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix2dType: SWITCH_CODE(Matrix2d , Matrix2d , CLASS_NAME); break;
331 #define ML_IMPLEMENT_MATRIX3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix3fType: SWITCH_CODE(Matrix3f , Matrix3f , CLASS_NAME); break;
332 #define ML_IMPLEMENT_MATRIX3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix3dType: SWITCH_CODE(Matrix3d , Matrix3d , CLASS_NAME); break;
334 
335 //------------------------------------------------------------------------------------
338 //------------------------------------------------------------------------------------
340 #define ML_IMPLEMENT_INT_CASES_WO_INT64(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\
341  ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
342  ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
343  ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
344  ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
345  ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
346  ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)
347 
349 #define ML_IMPLEMENT_INT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
350  ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
351  ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
352  ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
353  ML_IMPLEMENT_UINT16_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
354  ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
355  ML_IMPLEMENT_UINT32_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
356  ML_IMPLEMENT_INT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
357  ML_IMPLEMENT_UINT64_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)
358 
360 #define ML_IMPLEMENT_FLOAT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\
361  ML_IMPLEMENT_FLOAT_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
362  ML_IMPLEMENT_DOUBLE_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
363 
365 #define ML_IMPLEMENT_COMPLEX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)\
366  ML_IMPLEMENT_COMPLEXF_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
367  ML_IMPLEMENT_COMPLEXD_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)
368 
369 #define ML_IMPLEMENT_VECTOR_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
370  ML_IMPLEMENT_VECTOR2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
371  ML_IMPLEMENT_VECTOR2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
372  ML_IMPLEMENT_VECTOR3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
373  ML_IMPLEMENT_VECTOR3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
374  ML_IMPLEMENT_VECTOR6F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
375  ML_IMPLEMENT_VECTOR6D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)
376 
377 #define ML_IMPLEMENT_MATRIX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
378  ML_IMPLEMENT_MATRIX2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
379  ML_IMPLEMENT_MATRIX2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
380  ML_IMPLEMENT_MATRIX3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
381  ML_IMPLEMENT_MATRIX3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)
382 
384 #define ML_IMPLEMENT_INT_FLOAT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\
385  ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
386  ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)
387 
389 #define ML_IMPLEMENT_INT_FLOAT_CASES_WO_INT64(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\
390  ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
391  ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
392  ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
393  ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
394  ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
395  ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
396  ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)
397 
399 #define ML_IMPLEMENT_DEFAULT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
400  ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
401  ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
402  ML_IMPLEMENT_COMPLEX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
403  ML_IMPLEMENT_VECTOR_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
404  ML_IMPLEMENT_MATRIX_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \
405 
407 #define ML_IMPLEMENT_SCALAR_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\
408  ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \
409  ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)
410 
414 #define ML_IMPLEMENT_DEFAULT_HANDLING(CALLING_POSITION_STRING) \
415  default: { \
416  ML_PRINT_FATAL_ERROR(CALLING_POSITION_STRING, \
417  ML_BAD_DATA_TYPE, \
418  "Type case not executed."); \
419  break; \
420  } \
421 
423 
424 //------------------------------------------------------------------------------------
425 
426 //------------------------------------------------------------------------------------
436 //------------------------------------------------------------------------------------
437 #define _ML_TYPE_SWITCH_INTERN(DTSWITCHES, METHOD_PREFIX, METHOD_SUFFIX, DOUBLE_COLON, SWITCH_CODE, OUT_SWITCH_TYPE, CALLING_POSITION_STRING, INPTR, CLASS_NAME) \
438  \
439  void METHOD_PREFIX DOUBLE_COLON calculateOutputSubImage(SubImage *outSubImg, int outIndex, INPTR) METHOD_SUFFIX \
440  { \
441  switch(OUT_SWITCH_TYPE){ \
442  DTSWITCHES(CLASS_NAME, SWITCH_CODE, OUT_SWITCH_TYPE, CALLING_POSITION_STRING, INTYPE_DUMMY) \
443  ML_IMPLEMENT_DEFAULT_HANDLING(CALLING_POSITION_STRING) \
444  } \
445  }
446 
447 //------------------------------------------------------------------------------------
450 //------------------------------------------------------------------------------------
451 #define _ML_TYPE_SWITCH_C(DTSWITCHES, SWITCH_CODE, CALLING_POSITION_STRING, INPTR, CLASS_NAME) \
452  _ML_TYPE_SWITCH_INTERN(DTSWITCHES, CLASS_NAME, ML_EMPTY_PARAM, ::, SWITCH_CODE, outSubImg->getDataType(), CALLING_POSITION_STRING, INPTR, CLASS_NAME)
453 
454 //------------------------------------------------------------------------------------
457 //------------------------------------------------------------------------------------
458 #define _ML_TYPE_SWITCH_H(DTSWITCHES, SWITCH_CODE, CALLING_POSITION_STRING, INPTR) \
459  _ML_TYPE_SWITCH_INTERN(DTSWITCHES, ML_EMPTY_PARAM, override, ML_EMPTY_PARAM, SWITCH_CODE, outSubImg->getDataType(), CALLING_POSITION_STRING, INPTR, CLASS_NAME)
460 
461 
462 
463 
464 //---------------------------------------------------------------------------------------------------
465 //
466 //
467 //
468 // Macros to support calculateOutputSubImage implementations with identical
469 // input and output data types.
470 //
471 //
472 //
473 //---------------------------------------------------------------------------------------------------
474 
475 // The call to calculateOutputSubImage is non-const by default.
476 // Enabling the ML_CALCULATEOUTPUTSUBIMAGE_IS_CONST macro allows to
477 // make the call to calculateOutputSubImage const. This facilitates
478 // ensuring that a module's calculateOutputSubImage method is thread-safe.
479 #ifdef ML_CALCULATEOUTPUTSUBIMAGE_IS_CONST
480  #define _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME) \
481  static_cast<const CLASS_NAME*>(this)->calculateOutputSubImage
482 #else
483  #define _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME) calculateOutputSubImage
484 #endif
485 
486 //---------------------------------------------------------------------------------------------------
487 // Support for 0 inputs.
488 //---------------------------------------------------------------------------------------------------
490 #define _ML_SWITCH_CODE_0(OUTDTYPE, INDTYPE, CLASS_NAME) \
491  {\
492  TSubImage<OUTDTYPE> tOutSubImg(*outSubImg);\
493  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&tOutSubImg,outIndex);\
494  }
495 
501 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_DEFAULT_TYPES_CPP", SubImage *, CLASS_NAME);
502 
504 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES_CPP", SubImage *, CLASS_NAME);
505 
508 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH_CPP", SubImage *, CLASS_NAME);
509 
511 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_DEFAULT_TYPES", SubImage *);
512 
514 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES", SubImage *);
515 
517 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_0, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH", SubImage *);
518 
519 
520 //---------------------------------------------------------------------------------------------------
521 // Support for 1 input.
522 //---------------------------------------------------------------------------------------------------
524 #define _ML_SWITCH_CODE_1(OUTDTYPE, INDTYPE, CLASS_NAME) \
525  { \
526  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg); \
527  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[0]);\
528  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\
529  &typedInSubImg1);\
530  }
531 
534 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
535 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
536 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
538 
541 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DEFAULT_TYPES", SubImage *inSubImgs);
542 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES", SubImage *inSubImgs);
543 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_1, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
545 
546 
547 //---------------------------------------------------------------------------------------------------
548 // Support for 2 inputs.
549 //---------------------------------------------------------------------------------------------------
551 #define _ML_SWITCH_CODE_2(OUTDTYPE, INDTYPE, CLASS_NAME) \
552  { \
553  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\
554  TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\
555  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\
556  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,&typedInSubImg0,&typedInSubImg1);\
557  }
558 
561 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
562 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
563 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
565 
568 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DEFAULT_TYPES", SubImage *inSubImgs);
569 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES", SubImage *inSubImgs);
570 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_2, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
572 
573 
574 //---------------------------------------------------------------------------------------------------
575 // Support for 3 inputs.
576 //---------------------------------------------------------------------------------------------------
578 #define _ML_SWITCH_CODE_3(OUTDTYPE, INDTYPE, CLASS_NAME) \
579  { \
580  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\
581  TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\
582  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\
583  TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\
584  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\
585  &typedInSubImg0, &typedInSubImg1,\
586  &typedInSubImg2);\
587  }
588 
591 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
592 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
593 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
595 
598 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DEFAULT_TYPES", SubImage *inSubImgs);
599 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES", SubImage *inSubImgs);
600 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_3, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
602 
603 
604 //---------------------------------------------------------------------------------------------------
605 // Support for 4 inputs.
606 //---------------------------------------------------------------------------------------------------
608 #define _ML_SWITCH_CODE_4(OUTDTYPE, INDTYPE, CLASS_NAME) \
609  { \
610  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\
611  TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\
612  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\
613  TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\
614  TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\
615  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\
616  &typedInSubImg0, &typedInSubImg1,\
617  &typedInSubImg2, &typedInSubImg3);\
618  }
619 
622 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
623 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
624 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
626 
629 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DEFAULT_TYPES", SubImage *inSubImgs);
630 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES", SubImage *inSubImgs);
631 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_4, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
633 
634 
635 //---------------------------------------------------------------------------------------------------
636 // Support for 5 inputs.
637 //---------------------------------------------------------------------------------------------------
639 #define _ML_SWITCH_CODE_5(OUTDTYPE, INDTYPE, CLASS_NAME) \
640  { \
641  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\
642  TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\
643  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\
644  TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\
645  TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\
646  TSubImage<INDTYPE> typedInSubImg4(inSubImgs[4]);\
647  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\
648  &typedInSubImg0, &typedInSubImg1,\
649  &typedInSubImg2, &typedInSubImg3,\
650  &typedInSubImg4);\
651  }
652 
655 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
656 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
657 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
659 
662 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DEFAULT_TYPES", SubImage *inSubImgs);
663 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES", SubImage *inSubImgs);
664 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_5, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
666 
667 
668 //---------------------------------------------------------------------------------------------------
669 // Support for 10 inputs.
670 //---------------------------------------------------------------------------------------------------
672 #define _ML_SWITCH_CODE_10(OUTDTYPE, INDTYPE, CLASS_NAME) \
673  { \
674  TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\
675  TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\
676  TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\
677  TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\
678  TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\
679  TSubImage<INDTYPE> typedInSubImg4(inSubImgs[4]);\
680  TSubImage<INDTYPE> typedInSubImg5(inSubImgs[5]);\
681  TSubImage<INDTYPE> typedInSubImg6(inSubImgs[6]);\
682  TSubImage<INDTYPE> typedInSubImg7(inSubImgs[7]);\
683  TSubImage<INDTYPE> typedInSubImg8(inSubImgs[8]);\
684  TSubImage<INDTYPE> typedInSubImg9(inSubImgs[9]);\
685  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\
686  &typedInSubImg0, &typedInSubImg1, \
687  &typedInSubImg2, &typedInSubImg3, \
688  &typedInSubImg4, &typedInSubImg5, \
689  &typedInSubImg6, &typedInSubImg7, \
690  &typedInSubImg8, &typedInSubImg9);\
691  }
692 
695 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
696 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
697 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
699 
702 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DEFAULT_TYPES", SubImage *inSubImgs);
703 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES", SubImage *inSubImgs);
704 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_10, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
706 
707 
708 //---------------------------------------------------------------------------------------------------
711 
726 #define _ML_SWITCH_CODE_N(OUTDTYPE, INDTYPE, CLASS_NAME) \
727  { \
728  /* Get number of inputs. */ \
729  const MLssize_t numIns = static_cast<MLssize_t>(this->getNumInputImages()); \
730  \
731  /* Create typed version of output buffer. */ \
732  TSubImage<OUTDTYPE> outSubImgT(*outSubImg); \
733  \
734  /* Implement special cases with automatic object creation, */ \
735  /* because it is much faster. */ \
736  if (numIns < 3){ \
737  switch(numIns){ \
738  /***** Optimization for 1 input. *****/ \
739  case 0:{ \
740  /* Calculate output subimage. */ \
741  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, \
742  (TSubImage<INDTYPE>**)NULL); \
743  } \
744  return; \
745  \
746  /***** Optimization for 1 input. *****/ \
747  case 1:{ \
748  /* Create typed version of input buffer. */ \
749  /* and create a pointer array with one element. */ \
750  TSubImage<INDTYPE> inSubImgT(inSubImgs[0]); \
751  TSubImage<INDTYPE> *inArr = &inSubImgT; \
752  \
753  /* Calculate output subimage. */ \
754  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, &inArr); \
755  } \
756  return; \
757  \
758  /***** Optimization for 2 inputs. *****/ \
759  case 2:{ \
760  TSubImage<INDTYPE> inSubImg0T(inSubImgs[0]); \
761  TSubImage<INDTYPE> inSubImg1T(inSubImgs[1]); \
762  TSubImage<INDTYPE> *inArr[2]; \
763  inArr[0] = &inSubImg0T; \
764  inArr[1] = &inSubImg1T; \
765  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, inArr); \
766  } \
767  return; \
768  \
769  /***** Should be impossible to reach here *****/ \
770  default:{ \
771  ML_PRINT_FATAL_ERROR("_ML_SWITCH_CODE_N", \
772  ML_PROGRAMMING_ERROR, \
773  "Invalid case switch detected, " \
774  "ignoring case and not processing page"); \
775  } \
776  } \
777  } /* if (numIns < 3) */ \
778  else{ \
779  /***** Any other number of inputs. *****/ \
780  /* Create an array for all pointers to input subimages. */ \
781  TSubImage<INDTYPE> **inArr = NULL; \
782  inArr = new TSubImage<INDTYPE>*[numIns]; \
783  bool okay = inArr != NULL; \
784  \
785  /* Count number of created subimages. */ \
786  MLssize_t createdTSubs=0; \
787  \
788  /* For each untyped input subimage create a typed one and */ \
789  /* store its pointer into the array. */ \
790  for (MLssize_t c=0; okay && (c < numIns); c++){ \
791  inArr[c] = new TSubImage<INDTYPE>(inSubImgs[c]); \
792  if (inArr[c]){ createdTSubs++; } else { okay = false; } \
793  } \
794  \
795  /* Call the correct template version of calculateOutputSubImage. */ \
796  if (okay){ \
797  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, inArr); \
798  } \
799  else{ \
800  ML_PRINT_FATAL_ERROR(#CLASS_NAME, ML_NO_MEMORY, \
801  "Not calculating page."); \
802  } \
803  \
804  /* Clean up created subimages and array of subimage pointers. */ \
805  if (inArr){ \
806  for (MLssize_t d=0; d < createdTSubs; d++){ \
807  delete inArr[d]; \
808  } \
809  delete [] inArr; \
810  } \
811  } /* else (numIns < 3) */ \
812  }
814 
822 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DEFAULT_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DEFAULT_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
823 
825 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES_CPP(CLASS_NAME) _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
826 
829 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
831 
834 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DEFAULT_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DEFAULT_TYPES", SubImage *inSubImgs);
835 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES(CLASS_NAME) _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES", SubImage *inSubImgs);
836 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE_N, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
838 
839 
840 //---------------------------------------------------------------------------------------------------
841 //
842 //
843 //
844 // Macros to support different input and output data types.
845 // Note that these macros produce significantly more code.
846 //
847 //
848 //
849 //---------------------------------------------------------------------------------------------------
850 
851 //---------------------------------------------------------------------------------------------------
858 
860 #define _ML_SWITCH_CODE1_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
861  { TSubImage<INDTYPE> inSIT(inSubImgs[0]); _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &inSIT); }
862 
864 #define _ML_SWITCH_CODE1_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
865  { \
866  TSubImage<OUTDTYPE> outSI(*outSubImg); \
867  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
868  _ML_SWITCH_CODE1_DD_L2, \
869  inSubImgs[0].getDataType(), \
870  "_ML_SWITCH_CODE1_DD", \
871  INDTYPE); \
872  }
873 
875 #define _ML_SWITCH_CODE1S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
876  { \
877  TSubImage<OUTDTYPE> outSI(*outSubImg); \
878  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
879  _ML_SWITCH_CODE1_DD_L2, \
880  inSubImgs[0].getDataType(), \
881  "_ML_SWITCH_CODE1_DD", \
882  INDTYPE); \
883  }
884 
887 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
888  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
889 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
890  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE1S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
891 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
892  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
893 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
894  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
895 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
896  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE1S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
897 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
898  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
900 
901 
902 //---------------------------------------------------------------------------------------------------
909 
911 #define _ML_SWITCH_CODE2_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
912  { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]); _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1); }
913 
915 #define _ML_SWITCH_CODE2_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
916  { \
917  TSubImage<OUTDTYPE> outSI(*outSubImg); \
918  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
919  _ML_SWITCH_CODE2_DD_L2, \
920  inSubImgs[0].getDataType(), \
921  "_ML_SWITCH_CODE2_DD", \
922  INDTYPE); \
923  }
924 
926 #define _ML_SWITCH_CODE2S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
927  { \
928  TSubImage<OUTDTYPE> outSI(*outSubImg); \
929  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
930  _ML_SWITCH_CODE2_DD_L2, \
931  inSubImgs[0].getDataType(), \
932  "_ML_SWITCH_CODE2_DD", \
933  INDTYPE); \
934  }
935 
938 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
939  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
940 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
941  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE2S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
942 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
943  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
944 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
945  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
946 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
947  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE2S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
948 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
949  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
951 
952 
953 //---------------------------------------------------------------------------------------------------
962 
964 #define _ML_SWITCH_CODE3_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
965  { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]); \
966  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2); }
967 
969 #define _ML_SWITCH_CODE3_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
970  { \
971  TSubImage<OUTDTYPE> outSI(*outSubImg); \
972  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
973  _ML_SWITCH_CODE3_DD_L2, \
974  inSubImgs[0].getDataType(), \
975  "_ML_SWITCH_CODE3_DD", \
976  INDTYPE); \
977  }
978 
980 #define _ML_SWITCH_CODE3S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
981  { \
982  TSubImage<OUTDTYPE> outSI(*outSubImg); \
983  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
984  _ML_SWITCH_CODE3_DD_L2, \
985  inSubImgs[0].getDataType(), \
986  "_ML_SWITCH_CODE3_DD", \
987  INDTYPE); \
988  }
989 
992 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
993  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
994 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
995  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE3S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
996 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
997  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
998 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
999  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
1000 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
1001  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE3S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
1002 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
1003  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
1005 
1006 
1007 //---------------------------------------------------------------------------------------------------
1016 
1018 #define _ML_SWITCH_CODE4_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
1019  { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]); \
1020  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3); }
1021 
1023 #define _ML_SWITCH_CODE4_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1024  { \
1025  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1026  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
1027  _ML_SWITCH_CODE4_DD_L2, \
1028  inSubImgs[0].getDataType(), \
1029  "_ML_SWITCH_CODE4_DD", \
1030  INDTYPE); \
1031  }
1032 
1034 #define _ML_SWITCH_CODE4S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1035  { \
1036  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1037  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
1038  _ML_SWITCH_CODE4_DD_L2, \
1039  inSubImgs[0].getDataType(), \
1040  "_ML_SWITCH_CODE4_DD", \
1041  INDTYPE); \
1042  }
1043 
1046 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
1047  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1048 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
1049  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE4S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1050 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
1051  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
1052 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
1053  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
1054 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
1055  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE4S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
1056 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
1057  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
1059 
1060 
1061 //---------------------------------------------------------------------------------------------------
1071 
1073 #define _ML_SWITCH_CODE5_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
1074  { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]), it4(inSubImgs[4]); \
1075  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3, &it4); }
1076 
1078 #define _ML_SWITCH_CODE5_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1079  { \
1080  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1081  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
1082  _ML_SWITCH_CODE5_DD_L2, \
1083  inSubImgs[0].getDataType(), \
1084  "_ML_SWITCH_CODE5_DD", \
1085  INDTYPE); \
1086  }
1087 
1089 #define _ML_SWITCH_CODE5S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1090  { \
1091  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1092  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
1093  _ML_SWITCH_CODE5_DD_L2, \
1094  inSubImgs[0].getDataType(), \
1095  "_ML_SWITCH_CODE5_DD", \
1096  INDTYPE); \
1097  }
1098 
1101 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
1102  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1103 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
1104  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE5S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1105 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
1106  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
1107 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
1108  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
1109 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
1110  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE5S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
1111 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
1112  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
1114 
1115 
1116 //---------------------------------------------------------------------------------------------------
1128 
1130 #define _ML_SWITCH_CODE10_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \
1131  { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]), it4(inSubImgs[4]); \
1132  TSubImage<INDTYPE> it5(inSubImgs[5]), it6(inSubImgs[6]), it7(inSubImgs[7]), it8(inSubImgs[8]), it9(inSubImgs[9]); \
1133  _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3, &it4, &it5, &it6, &it7, &it8, &it9); }
1134 
1136 #define _ML_SWITCH_CODE10_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1137  { \
1138  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1139  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
1140  _ML_SWITCH_CODE10_DD_L2, \
1141  inSubImgs[0].getDataType(), \
1142  "_ML_SWITCH_CODE10_DD", \
1143  INDTYPE); \
1144  }
1145 
1147 #define _ML_SWITCH_CODE10S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1148  { \
1149  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1150  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
1151  _ML_SWITCH_CODE10_DD_L2, \
1152  inSubImgs[0].getDataType(), \
1153  "_ML_SWITCH_CODE10_DD", \
1154  INDTYPE); \
1155  }
1156 
1159 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
1160  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1161 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
1162  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE10S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1163 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
1164  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
1165 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
1166  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
1167 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
1168  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE10S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
1169 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
1170  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
1172 
1173 
1174 //---------------------------------------------------------------------------------------------------
1186 
1188 #define _ML_SWITCH_CODEN_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1189  { \
1190  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1191  ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \
1192  _ML_SWITCH_CODE_N, \
1193  inSubImgs[0].getDataType(), \
1194  "_ML_SWITCH_CODEN_DD", \
1195  INDTYPE); \
1196  }
1197 
1199 #define _ML_SWITCH_CODENS_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \
1200  { \
1201  TSubImage<OUTDTYPE> outSI(*outSubImg); \
1202  ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \
1203  _ML_SWITCH_CODE_N, \
1204  inSubImgs[0].getDataType(), \
1205  "_ML_SWITCH_CODEN_DD", \
1206  INDTYPE); \
1207  }
1208 
1211 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \
1212  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1213 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \
1214  _ML_TYPE_SWITCH_C(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODENS_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP", SubImage *inSubImgs, CLASS_NAME);
1215 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \
1216  _ML_TYPE_SWITCH_C(DTSWITCHES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP", SubImage *inSubImgs, CLASS_NAME);
1217 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \
1218  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs);
1219 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \
1220  _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODENS_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs);
1221 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \
1222  _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs);
1224 
1225 
1226 #endif //of __mlModuleMacros_H
1227 
1228