- Generated on Thu Nov 21 2013 20:10:55 for ML Reference by
1.7.4
|
ML Reference
|
00001 // **InsertLicense** code 00002 //------------------------------------------------------------------------- 00010 //------------------------------------------------------------------------- 00011 #ifndef __mlModuleMacros_H 00012 #define __mlModuleMacros_H 00013 00014 //------------------------------------------------------------------------- 00015 // MACROS to simplify module programming 00016 //------------------------------------------------------------------------- 00017 00018 //------------------------------------------------------------------------------------ 00020 //------------------------------------------------------------------------------------ 00021 #define ML_EMPTY_PARAM 00022 00023 //------------------------------------------------------------------------------------ 00025 //------------------------------------------------------------------------------------ 00026 #define ML_INSTANTIATE_STANDARD_SIGNED_INT_TYPES(PASSED_CODE) \ 00027 PASSED_CODE(MLint8); \ 00028 PASSED_CODE(MLint16); \ 00029 PASSED_CODE(MLint32); \ 00030 PASSED_CODE(MLint64); 00031 00032 //------------------------------------------------------------------------------------ 00034 //------------------------------------------------------------------------------------ 00035 #define ML_INSTANTIATE_STANDARD_UNSIGNED_INT_TYPES(PASSED_CODE) \ 00036 PASSED_CODE(MLuint8); \ 00037 PASSED_CODE(MLuint16); \ 00038 PASSED_CODE(MLuint32); \ 00039 PASSED_CODE(MLuint64); 00040 00041 //------------------------------------------------------------------------------------ 00043 //------------------------------------------------------------------------------------ 00044 #define ML_INSTANTIATE_STANDARD_INT_TYPES(PASSED_CODE) \ 00045 ML_INSTANTIATE_STANDARD_SIGNED_INT_TYPES(PASSED_CODE) \ 00046 ML_INSTANTIATE_STANDARD_UNSIGNED_INT_TYPES(PASSED_CODE) 00047 00048 //------------------------------------------------------------------------------------ 00050 //------------------------------------------------------------------------------------ 00051 #define ML_INSTANTIATE_STANDARD_FLOAT_TYPES(PASSED_CODE) \ 00052 PASSED_CODE(MLfloat); \ 00053 PASSED_CODE(MLdouble); 00054 00055 //------------------------------------------------------------------------------------ 00074 //------------------------------------------------------------------------------------ 00075 #define ML_INSTANTIATE_STANDARD_TYPES(PASSED_CODE) \ 00076 ML_INSTANTIATE_STANDARD_INT_TYPES(PASSED_CODE) \ 00077 ML_INSTANTIATE_STANDARD_FLOAT_TYPES(PASSED_CODE) 00078 00079 //------------------------------------------------------------------------------------ 00081 //------------------------------------------------------------------------------------ 00082 #define ML_INSTANTIATE_DEFAULT_EXTENDED_TYPES(PASSED_CODE) \ 00083 PASSED_CODE(std::complex<MLfloat>); \ 00084 PASSED_CODE(std::complex<MLdouble>); \ 00085 PASSED_CODE(Vector2f); \ 00086 PASSED_CODE(Vector2d); \ 00087 PASSED_CODE(Vector3f); \ 00088 PASSED_CODE(Vector3d); \ 00089 PASSED_CODE(Vector6f); \ 00090 PASSED_CODE(Vector6d); \ 00091 PASSED_CODE(Matrix2f); \ 00092 PASSED_CODE(Matrix2d); \ 00093 PASSED_CODE(Matrix3f); \ 00094 PASSED_CODE(Matrix3d); 00095 00096 //------------------------------------------------------------------------------------ 00099 //------------------------------------------------------------------------------------ 00100 #define ML_INSTANTIATE_ALL_TYPES(PASSED_CODE) \ 00101 ML_INSTANTIATE_STANDARD_TYPES(PASSED_CODE) \ 00102 ML_INSTANTIATE_DEFAULT_EXTENDED_TYPES(PASSED_CODE) 00103 00104 00105 //------------------------------------------------------------------------------------ 00138 //------------------------------------------------------------------------------------ 00139 #define ML_IMPLEMENT_ALL_CASES(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, INFO_STRING, DUMMY_OUT_TYPE) \ 00140 switch(O_SWITCH_TYPE){ \ 00141 case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break; \ 00142 case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break; \ 00143 case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break; \ 00144 case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break; \ 00145 case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break; \ 00146 case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break; \ 00147 case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break; \ 00148 case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break; \ 00149 case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break; \ 00150 case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break; \ 00151 case MLComplexfType: SWITCH_CODE(std::complex<MLfloat> , std::complex<MLfloat> , CLASS_NAME); break; \ 00152 case MLComplexdType: SWITCH_CODE(std::complex<MLdouble>, std::complex<MLdouble>, CLASS_NAME); break; \ 00153 case MLVector2fType: SWITCH_CODE(Vector2f , Vector2f , CLASS_NAME); break; \ 00154 case MLVector2dType: SWITCH_CODE(Vector2d , Vector2d , CLASS_NAME); break; \ 00155 case MLVector3fType: SWITCH_CODE(Vector3f , Vector3f , CLASS_NAME); break; \ 00156 case MLVector3dType: SWITCH_CODE(Vector3d , Vector3d , CLASS_NAME); break; \ 00157 case MLVector6fType: SWITCH_CODE(Vector6f , Vector6f , CLASS_NAME); break; \ 00158 case MLVector6dType: SWITCH_CODE(Vector6d , Vector6d , CLASS_NAME); break; \ 00159 case MLMatrix2fType: SWITCH_CODE(Matrix2f , Matrix2f , CLASS_NAME); break; \ 00160 case MLMatrix2dType: SWITCH_CODE(Matrix2d , Matrix2d , CLASS_NAME); break; \ 00161 case MLMatrix3fType: SWITCH_CODE(Matrix3f , Matrix3f , CLASS_NAME); break; \ 00162 case MLMatrix3dType: SWITCH_CODE(Matrix3d , Matrix3d , CLASS_NAME); break; \ 00163 default: { ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, "Unsupported type case."); break; \ 00164 } \ 00165 } 00166 00167 //------------------------------------------------------------------------------------ 00169 //------------------------------------------------------------------------------------ 00170 #define ML_IMPLEMENT_SCALAR_TYPE_CASES(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, INFO_STRING, DUMMY_OUT_TYPE) \ 00171 switch(O_SWITCH_TYPE){ \ 00172 case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break; \ 00173 case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break; \ 00174 case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break; \ 00175 case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break; \ 00176 case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break; \ 00177 case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break; \ 00178 case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break; \ 00179 case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break; \ 00180 case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break; \ 00181 case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break; \ 00182 default: { ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, "Unsupported type case."); break; \ 00183 } \ 00184 } 00185 00186 //------------------------------------------------------------------------------------ 00216 //------------------------------------------------------------------------------------ 00217 #define ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, INFO_STRING, OUTPUT_TYPE) \ 00218 switch (static_cast<int>(IN_SWITCH_TYPE)){ \ 00219 case MLint8Type: SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); break; \ 00220 case MLuint8Type: SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); break; \ 00221 case MLint16Type: SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); break; \ 00222 case MLuint16Type: SWITCH_CODE(OUTPUT_TYPE, MLuint16 , CLASS_NAME); break; \ 00223 case MLint32Type: SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); break; \ 00224 case MLuint32Type: SWITCH_CODE(OUTPUT_TYPE, MLuint32 , CLASS_NAME); break; \ 00225 case MLint64Type: SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); break; \ 00226 case MLuint64Type: SWITCH_CODE(OUTPUT_TYPE, MLuint64 , CLASS_NAME); break; \ 00227 case MLfloatType: SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); break; \ 00228 case MLdoubleType: SWITCH_CODE(OUTPUT_TYPE, MLdouble , CLASS_NAME); break; \ 00229 case MLComplexfType: SWITCH_CODE(OUTPUT_TYPE, std::complex<MLfloat> , CLASS_NAME); break; \ 00230 case MLComplexdType: SWITCH_CODE(OUTPUT_TYPE, std::complex<MLdouble>, CLASS_NAME); break; \ 00231 case MLVector2fType: SWITCH_CODE(OUTPUT_TYPE, Vector2f , CLASS_NAME); break; \ 00232 case MLVector2dType: SWITCH_CODE(OUTPUT_TYPE, Vector2d , CLASS_NAME); break; \ 00233 case MLVector3fType: SWITCH_CODE(OUTPUT_TYPE, Vector3f , CLASS_NAME); break; \ 00234 case MLVector3dType: SWITCH_CODE(OUTPUT_TYPE, Vector3d , CLASS_NAME); break; \ 00235 case MLVector6fType: SWITCH_CODE(OUTPUT_TYPE, Vector6f , CLASS_NAME); break; \ 00236 case MLVector6dType: SWITCH_CODE(OUTPUT_TYPE, Vector6d , CLASS_NAME); break; \ 00237 case MLMatrix2fType: SWITCH_CODE(OUTPUT_TYPE, Matrix2f , CLASS_NAME); break; \ 00238 case MLMatrix2dType: SWITCH_CODE(OUTPUT_TYPE, Matrix2d , CLASS_NAME); break; \ 00239 case MLMatrix3fType: SWITCH_CODE(OUTPUT_TYPE, Matrix3f , CLASS_NAME); break; \ 00240 case MLMatrix3dType: SWITCH_CODE(OUTPUT_TYPE, Matrix3d , CLASS_NAME); break; \ 00241 default:{ \ 00242 char buf[512]=""; \ 00243 sprintf(buf, "Type not supported, case type %d does not exist.", IN_SWITCH_TYPE); \ 00244 ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, buf); } \ 00245 } 00246 00247 //------------------------------------------------------------------------------------ 00249 //------------------------------------------------------------------------------------ 00250 #define ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, INFO_STRING, OUTPUT_TYPE) \ 00251 switch (static_cast<int>(IN_SWITCH_TYPE)){ \ 00252 case MLint8Type: SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); break; \ 00253 case MLuint8Type: SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); break; \ 00254 case MLint16Type: SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); break; \ 00255 case MLuint16Type: SWITCH_CODE(OUTPUT_TYPE, MLuint16 , CLASS_NAME); break; \ 00256 case MLint32Type: SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); break; \ 00257 case MLuint32Type: SWITCH_CODE(OUTPUT_TYPE, MLuint32 , CLASS_NAME); break; \ 00258 case MLint64Type: SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); break; \ 00259 case MLuint64Type: SWITCH_CODE(OUTPUT_TYPE, MLuint64 , CLASS_NAME); break; \ 00260 case MLfloatType: SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); break; \ 00261 case MLdoubleType: SWITCH_CODE(OUTPUT_TYPE, MLdouble , CLASS_NAME); break; \ 00262 default:{ \ 00263 char buf[512]=""; \ 00264 sprintf(buf, "Type not supported, case type %d does not exist.", IN_SWITCH_TYPE); \ 00265 ML_PRINT_FATAL_ERROR(INFO_STRING, ML_BAD_DATA_TYPE, buf); } \ 00266 } 00267 00268 #ifdef ML_DEPRECATED 00269 00270 00271 00272 00273 #define ML_IMPLEMENT_DD_CASES ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES 00274 00275 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00276 #pragma deprecated("ML_IMPLEMENT_DD_CASES") 00277 #endif 00278 00279 00280 #endif // ML_DEPRECATED 00281 00282 #define ML_IMPLEMENT_SCALAR_CASES_WITH_DEFAULT(CLASS_NAME, SWITCH_CODE, O_SWITCH_TYPE, DEFAULT_CODE, DUMMY_OUT_TYPE) \ 00283 switch (static_cast<int>(O_SWITCH_TYPE)){ \ 00284 case MLint8Type: { SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); } break; \ 00285 case MLuint8Type: { SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); } break; \ 00286 case MLint16Type: { SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); } break; \ 00287 case MLuint16Type: { SWITCH_CODE(MLuint16, MLuint16, CLASS_NAME); } break; \ 00288 case MLint32Type: { SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); } break; \ 00289 case MLuint32Type: { SWITCH_CODE(MLuint32, MLuint32, CLASS_NAME); } break; \ 00290 case MLint64Type: { SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); } break; \ 00291 case MLuint64Type: { SWITCH_CODE(MLuint64, MLuint64, CLASS_NAME); } break; \ 00292 case MLfloatType: { SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); } break; \ 00293 case MLdoubleType: { SWITCH_CODE(MLdouble, MLdouble, CLASS_NAME); } break; \ 00294 default: { DEFAULT_CODE(DUMMY_OUT_TYPE, CLASS_NAME); } \ 00295 } 00296 00297 #define ML_IMPLEMENT_DIFFERENT_INOUT_SCALAR_CASES_WITH_DEFAULT(CLASS_NAME, SWITCH_CODE, IN_SWITCH_TYPE, DEFAULT_CODE, OUTPUT_TYPE) \ 00298 switch (static_cast<int>(IN_SWITCH_TYPE)){ \ 00299 case MLint8Type: { SWITCH_CODE(OUTPUT_TYPE, MLint8 , CLASS_NAME); } break; \ 00300 case MLuint8Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint8 , CLASS_NAME); } break; \ 00301 case MLint16Type: { SWITCH_CODE(OUTPUT_TYPE, MLint16 , CLASS_NAME); } break; \ 00302 case MLuint16Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint16, CLASS_NAME); } break; \ 00303 case MLint32Type: { SWITCH_CODE(OUTPUT_TYPE, MLint32 , CLASS_NAME); } break; \ 00304 case MLuint32Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint32, CLASS_NAME); } break; \ 00305 case MLint64Type: { SWITCH_CODE(OUTPUT_TYPE, MLint64 , CLASS_NAME); } break; \ 00306 case MLuint64Type: { SWITCH_CODE(OUTPUT_TYPE, MLuint64, CLASS_NAME); } break; \ 00307 case MLfloatType: { SWITCH_CODE(OUTPUT_TYPE, MLfloat , CLASS_NAME); } break; \ 00308 case MLdoubleType: { SWITCH_CODE(OUTPUT_TYPE, MLdouble, CLASS_NAME); } break; \ 00309 default:{ DEFAULT_CODE(OUTPUT_TYPE, CLASS_NAME); } \ 00310 } 00311 00312 00313 //------------------------------------------------------------------------------------ 00315 00316 //------------------------------------------------------------------------------------ 00317 #define ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint8Type: SWITCH_CODE(MLint8 , MLint8 , CLASS_NAME); break; 00318 #define ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint8Type: SWITCH_CODE(MLuint8 , MLuint8 , CLASS_NAME); break; 00319 #define ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint16Type: SWITCH_CODE(MLint16 , MLint16 , CLASS_NAME); break; 00320 #define ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint16Type: SWITCH_CODE(MLuint16 , MLuint16 , CLASS_NAME); break; 00321 #define ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint32Type: SWITCH_CODE(MLint32 , MLint32 , CLASS_NAME); break; 00322 #define ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint32Type: SWITCH_CODE(MLuint32 , MLuint32 , CLASS_NAME); break; 00323 #define ML_IMPLEMENT_INT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLint64Type: SWITCH_CODE(MLint64 , MLint64 , CLASS_NAME); break; 00324 #define ML_IMPLEMENT_UINT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLuint64Type: SWITCH_CODE(MLuint64 , MLuint64 , CLASS_NAME); break; 00325 #define ML_IMPLEMENT_FLOAT_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLfloatType: SWITCH_CODE(MLfloat , MLfloat , CLASS_NAME); break; 00326 #define ML_IMPLEMENT_DOUBLE_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLdoubleType: SWITCH_CODE(MLdouble , MLdouble , CLASS_NAME); break; 00327 #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; 00328 #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; 00329 #define ML_IMPLEMENT_VECTOR2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector2fType: SWITCH_CODE(Vector2f , Vector2f , CLASS_NAME); break; 00330 #define ML_IMPLEMENT_VECTOR2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector2dType: SWITCH_CODE(Vector2d , Vector2d , CLASS_NAME); break; 00331 #define ML_IMPLEMENT_VECTOR3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector3fType: SWITCH_CODE(Vector3f , Vector3f , CLASS_NAME); break; 00332 #define ML_IMPLEMENT_VECTOR3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector3dType: SWITCH_CODE(Vector3d , Vector3d , CLASS_NAME); break; 00333 #define ML_IMPLEMENT_VECTOR6F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector6fType: SWITCH_CODE(Vector6f , Vector6f , CLASS_NAME); break; 00334 #define ML_IMPLEMENT_VECTOR6D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLVector6dType: SWITCH_CODE(Vector6d , Vector6d , CLASS_NAME); break; 00335 #define ML_IMPLEMENT_MATRIX2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix2fType: SWITCH_CODE(Matrix2f , Matrix2f , CLASS_NAME); break; 00336 #define ML_IMPLEMENT_MATRIX2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix2dType: SWITCH_CODE(Matrix2d , Matrix2d , CLASS_NAME); break; 00337 #define ML_IMPLEMENT_MATRIX3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix3fType: SWITCH_CODE(Matrix3f , Matrix3f , CLASS_NAME); break; 00338 #define ML_IMPLEMENT_MATRIX3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) case MLMatrix3dType: SWITCH_CODE(Matrix3d , Matrix3d , CLASS_NAME); break; 00339 00340 00341 //------------------------------------------------------------------------------------ 00343 00344 //------------------------------------------------------------------------------------ 00346 #define ML_IMPLEMENT_INT_CASES_WO_INT64(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\ 00347 ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00348 ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00349 ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00350 ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00351 ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00352 ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) 00353 00355 #define ML_IMPLEMENT_INT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00356 ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00357 ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00358 ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00359 ML_IMPLEMENT_UINT16_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00360 ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00361 ML_IMPLEMENT_UINT32_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00362 ML_IMPLEMENT_INT64_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00363 ML_IMPLEMENT_UINT64_CASE(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) 00364 00366 #define ML_IMPLEMENT_FLOAT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\ 00367 ML_IMPLEMENT_FLOAT_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00368 ML_IMPLEMENT_DOUBLE_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00369 00370 00371 #define ML_IMPLEMENT_COMPLEX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY)\ 00372 ML_IMPLEMENT_COMPLEXF_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00373 ML_IMPLEMENT_COMPLEXD_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) 00374 00375 #define ML_IMPLEMENT_VECTOR_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00376 ML_IMPLEMENT_VECTOR2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00377 ML_IMPLEMENT_VECTOR2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00378 ML_IMPLEMENT_VECTOR3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00379 ML_IMPLEMENT_VECTOR3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00380 ML_IMPLEMENT_VECTOR6F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00381 ML_IMPLEMENT_VECTOR6D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) 00382 00383 #define ML_IMPLEMENT_MATRIX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00384 ML_IMPLEMENT_MATRIX2F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00385 ML_IMPLEMENT_MATRIX2D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00386 ML_IMPLEMENT_MATRIX3F_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00387 ML_IMPLEMENT_MATRIX3D_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) 00388 00390 #define ML_IMPLEMENT_INT_FLOAT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\ 00391 ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00392 ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) 00393 00395 #define ML_IMPLEMENT_INT_FLOAT_CASES_WO_INT64(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\ 00396 ML_IMPLEMENT_INT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00397 ML_IMPLEMENT_UINT8_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00398 ML_IMPLEMENT_INT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00399 ML_IMPLEMENT_UINT16_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00400 ML_IMPLEMENT_INT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00401 ML_IMPLEMENT_UINT32_CASE( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00402 ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) 00403 00405 #define ML_IMPLEMENT_DEFAULT_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00406 ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00407 ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00408 ML_IMPLEMENT_COMPLEX_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00409 ML_IMPLEMENT_VECTOR_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00410 ML_IMPLEMENT_MATRIX_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY, INFO_DUMMY, INTYPE_DUMMY) \ 00411 00412 00413 #define ML_IMPLEMENT_SCALAR_CASES(CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3)\ 00414 ML_IMPLEMENT_INT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) \ 00415 ML_IMPLEMENT_FLOAT_CASES( CLASS_NAME, SWITCH_CODE, OST_DUMMY1, OST_DUMMY2, OST_DUMMY3) 00416 00420 #define ML_IMPLEMENT_DEFAULT_HANDLING(CALLING_POSITION_STRING) \ 00421 default: { \ 00422 ML_PRINT_FATAL_ERROR(CALLING_POSITION_STRING, \ 00423 ML_BAD_DATA_TYPE, \ 00424 "Type case not executed."); \ 00425 break; \ 00426 } \ 00427 00428 00429 00430 //------------------------------------------------------------------------------------ 00431 00432 //------------------------------------------------------------------------------------ 00442 //------------------------------------------------------------------------------------ 00443 #define _ML_TYPE_SWITCH_INTERN(DTSWITCHES, METHOD_PREFIX, DOUBLE_COLON, SWITCH_CODE, OUT_SWITCH_TYPE, CALLING_POSITION_STRING, INPTR, CLASS_NAME) \ 00444 \ 00445 void METHOD_PREFIX DOUBLE_COLON calculateOutputSubImage(SubImage *outSubImg, int outIndex, INPTR) \ 00446 { \ 00447 ML_TRACE_IN( "mlModuleMacros--calculateOutputSubImage( )" ); \ 00448 switch(OUT_SWITCH_TYPE){ \ 00449 DTSWITCHES(CLASS_NAME, SWITCH_CODE, OUT_SWITCH_TYPE, CALLING_POSITION_STRING, INTYPE_DUMMY)\ 00450 ML_IMPLEMENT_DEFAULT_HANDLING(CALLING_POSITION_STRING) \ 00451 } \ 00452 } 00453 00454 //------------------------------------------------------------------------------------ 00457 //------------------------------------------------------------------------------------ 00458 #define _ML_TYPE_SWITCH_C(DTSWITCHES, SWITCH_CODE, CALLING_POSITION_STRING, INPTR, CLASS_NAME) \ 00459 _ML_TYPE_SWITCH_INTERN(DTSWITCHES, CLASS_NAME, ::, SWITCH_CODE, outSubImg->getDataType(), CALLING_POSITION_STRING, INPTR, CLASS_NAME) 00460 00461 //------------------------------------------------------------------------------------ 00464 //------------------------------------------------------------------------------------ 00465 #define _ML_TYPE_SWITCH_H(DTSWITCHES, SWITCH_CODE, CALLING_POSITION_STRING, INPTR) \ 00466 _ML_TYPE_SWITCH_INTERN(DTSWITCHES, ML_EMPTY_PARAM, ML_EMPTY_PARAM, SWITCH_CODE, outSubImg->getDataType(), CALLING_POSITION_STRING, INPTR, CLASS_NAME) 00467 00468 00469 00470 00471 //--------------------------------------------------------------------------------------------------- 00472 // 00473 // 00474 // 00475 // Macros to support calculateOutputSubImage implementations with identical 00476 // input and output data types. 00477 // 00478 // 00479 // 00480 //--------------------------------------------------------------------------------------------------- 00481 00482 // The call to calculateOutputSubImage is non-const by default. 00483 // Enabling the ML_CALCULATEOUTPUTSUBIMAGE_IS_CONST macro allows to 00484 // make the call to calculateOutputSubImage const. This facilitates 00485 // ensuring that a module's calculateOutputSubImage method is thread-safe. 00486 #ifdef ML_CALCULATEOUTPUTSUBIMAGE_IS_CONST 00487 #define _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME) \ 00488 static_cast<const CLASS_NAME*>(this)->calculateOutputSubImage 00489 #else 00490 #define _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME) calculateOutputSubImage 00491 #endif 00492 00493 //--------------------------------------------------------------------------------------------------- 00494 // Support for 0 inputs. 00495 //--------------------------------------------------------------------------------------------------- 00497 #define _ML_SWITCH_CODE_0(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00498 {\ 00499 TSubImage<OUTDTYPE> tOutSubImg(*outSubImg);\ 00500 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&tOutSubImg,outIndex);\ 00501 } 00502 00508 #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); 00509 00511 #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); 00512 00515 #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); 00516 00518 #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 *); 00519 00521 #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 *); 00522 00524 #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 *); 00525 00526 00527 #ifdef ML_DEPRECATED 00528 00529 00530 00531 00532 #define CALC_OUTSUBIMAGE0_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES_CPP 00533 00534 00535 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES_CPP 00536 00537 00538 #define CALC_OUTSUBIMAGE0_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH_CPP 00539 00540 00541 #define CALC_OUTSUBIMAGE0 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES 00542 00543 00544 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_SCALAR_TYPES 00545 00546 00547 #define CALC_OUTSUBIMAGE0_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_WITH_CUSTOM_SWITCH 00548 00549 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00550 #pragma deprecated("CALC_OUTSUBIMAGE0_CPP", "CALC_OUTSUBIMAGE0_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0_CPP", "CALC_OUTSUBIMAGE0", "CALC_OUTSUBIMAGE0_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_0") 00551 #endif 00552 00554 #endif // ML_DEPRECATED 00555 00556 00557 00558 //--------------------------------------------------------------------------------------------------- 00559 // Support for 1 input. 00560 //--------------------------------------------------------------------------------------------------- 00562 #define _ML_SWITCH_CODE_1(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00563 { \ 00564 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg); \ 00565 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[0]);\ 00566 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\ 00567 &typedInSubImg1);\ 00568 } 00569 00571 00572 #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); 00573 #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); 00574 #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); 00575 00576 00578 00579 #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); 00580 #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); 00581 #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); 00582 00583 00584 #ifdef ML_DEPRECATED 00585 00586 00587 00588 00589 #define CALC_OUTSUBIMAGE1_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES_CPP 00590 00591 00592 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES_CPP 00593 00594 00595 #define CALC_OUTSUBIMAGE1_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH_CPP 00596 00597 00598 #define CALC_OUTSUBIMAGE1 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES 00599 00600 00601 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_SCALAR_TYPES 00602 00603 00604 #define CALC_OUTSUBIMAGE1_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_WITH_CUSTOM_SWITCH 00605 00606 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00607 #pragma deprecated("CALC_OUTSUBIMAGE1_CPP", "CALC_OUTSUBIMAGE1_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_CPP", "CALC_OUTSUBIMAGE1", "CALC_OUTSUBIMAGE1_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1") 00608 #endif 00609 00611 #endif // ML_DEPRECATED 00612 00613 00614 //--------------------------------------------------------------------------------------------------- 00615 // Support for 2 inputs. 00616 //--------------------------------------------------------------------------------------------------- 00618 #define _ML_SWITCH_CODE_2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00619 { \ 00620 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\ 00621 TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\ 00622 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\ 00623 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,&typedInSubImg0,&typedInSubImg1);\ 00624 } 00625 00627 00628 #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); 00629 #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); 00630 #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); 00631 00632 00634 00635 #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); 00636 #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); 00637 #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); 00638 00639 00640 00641 #ifdef ML_DEPRECATED 00642 00643 00644 00645 00646 #define CALC_OUTSUBIMAGE2_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES_CPP 00647 00648 00649 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES_CPP 00650 00651 00652 #define CALC_OUTSUBIMAGE2_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH_CPP 00653 00654 00655 #define CALC_OUTSUBIMAGE2 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES 00656 00657 00658 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_SCALAR_TYPES 00659 00660 00661 #define CALC_OUTSUBIMAGE2_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_WITH_CUSTOM_SWITCH 00662 00663 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00664 #pragma deprecated("CALC_OUTSUBIMAGE2_CPP", "CALC_OUTSUBIMAGE2_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_CPP", "CALC_OUTSUBIMAGE2", "CALC_OUTSUBIMAGE2_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2") 00665 #endif 00666 00668 #endif // ML_DEPRECATED 00669 00670 00671 00672 //--------------------------------------------------------------------------------------------------- 00673 // Support for 3 inputs. 00674 //--------------------------------------------------------------------------------------------------- 00676 #define _ML_SWITCH_CODE_3(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00677 { \ 00678 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\ 00679 TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\ 00680 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\ 00681 TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\ 00682 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\ 00683 &typedInSubImg0, &typedInSubImg1,\ 00684 &typedInSubImg2);\ 00685 } 00686 00688 00689 #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); 00690 #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); 00691 #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); 00692 00693 00695 00696 #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); 00697 #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); 00698 #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); 00699 00700 00701 00702 #ifdef ML_DEPRECATED 00703 00704 00705 00706 00707 #define CALC_OUTSUBIMAGE3_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES_CPP 00708 00709 00710 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES_CPP 00711 00712 00713 #define CALC_OUTSUBIMAGE3_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH_CPP 00714 00715 00716 #define CALC_OUTSUBIMAGE3 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES 00717 00718 00719 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_SCALAR_TYPES 00720 00721 00722 #define CALC_OUTSUBIMAGE3_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_WITH_CUSTOM_SWITCH 00723 00724 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00725 #pragma deprecated("CALC_OUTSUBIMAGE3_CPP", "CALC_OUTSUBIMAGE3_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_CPP", "CALC_OUTSUBIMAGE3", "CALC_OUTSUBIMAGE3_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3") 00726 #endif 00727 00729 #endif // ML_DEPRECATED 00730 00731 00732 //--------------------------------------------------------------------------------------------------- 00733 // Support for 4 inputs. 00734 //--------------------------------------------------------------------------------------------------- 00736 #define _ML_SWITCH_CODE_4(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00737 { \ 00738 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\ 00739 TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\ 00740 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\ 00741 TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\ 00742 TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\ 00743 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\ 00744 &typedInSubImg0, &typedInSubImg1,\ 00745 &typedInSubImg2, &typedInSubImg3);\ 00746 } 00747 00749 00750 #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); 00751 #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); 00752 #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); 00753 00754 00756 00757 #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); 00758 #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); 00759 #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); 00760 00761 00762 00763 #ifdef ML_DEPRECATED 00764 00765 00766 00767 00768 #define CALC_OUTSUBIMAGE4_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES_CPP 00769 00770 00771 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES_CPP 00772 00773 00774 #define CALC_OUTSUBIMAGE4_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH_CPP 00775 00776 00777 #define CALC_OUTSUBIMAGE4 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES 00778 00779 00780 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_SCALAR_TYPES 00781 00782 00783 #define CALC_OUTSUBIMAGE4_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_WITH_CUSTOM_SWITCH 00784 00785 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00786 #pragma deprecated("CALC_OUTSUBIMAGE4_CPP", "CALC_OUTSUBIMAGE4_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_CPP", "CALC_OUTSUBIMAGE4", "CALC_OUTSUBIMAGE4_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4") 00787 #endif 00788 00790 #endif // ML_DEPRECATED 00791 00792 00793 //--------------------------------------------------------------------------------------------------- 00794 // Support for 5 inputs. 00795 //--------------------------------------------------------------------------------------------------- 00797 #define _ML_SWITCH_CODE_5(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00798 { \ 00799 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\ 00800 TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\ 00801 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\ 00802 TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\ 00803 TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\ 00804 TSubImage<INDTYPE> typedInSubImg4(inSubImgs[4]);\ 00805 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\ 00806 &typedInSubImg0, &typedInSubImg1,\ 00807 &typedInSubImg2, &typedInSubImg3,\ 00808 &typedInSubImg4);\ 00809 } 00810 00812 00813 #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); 00814 #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); 00815 #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); 00816 00817 00819 00820 #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); 00821 #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); 00822 #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); 00823 00824 00825 00826 #ifdef ML_DEPRECATED 00827 00828 00829 00830 00831 #define CALC_OUTSUBIMAGE5_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES_CPP 00832 00833 00834 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES_CPP 00835 00836 00837 #define CALC_OUTSUBIMAGE5_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH_CPP 00838 00839 00840 #define CALC_OUTSUBIMAGE5 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES 00841 00842 00843 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_SCALAR_TYPES 00844 00845 00846 #define CALC_OUTSUBIMAGE5_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_WITH_CUSTOM_SWITCH 00847 00848 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00849 #pragma deprecated("CALC_OUTSUBIMAGE5_CPP", "CALC_OUTSUBIMAGE5_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_CPP", "CALC_OUTSUBIMAGE5", "CALC_OUTSUBIMAGE5_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5") 00850 #endif 00851 00853 #endif // ML_DEPRECATED 00854 00855 00856 //--------------------------------------------------------------------------------------------------- 00857 // Support for 10 inputs. 00858 //--------------------------------------------------------------------------------------------------- 00860 #define _ML_SWITCH_CODE_10(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00861 { \ 00862 TSubImage<OUTDTYPE> typedOutSubImg(*outSubImg);\ 00863 TSubImage<INDTYPE> typedInSubImg0(inSubImgs[0]);\ 00864 TSubImage<INDTYPE> typedInSubImg1(inSubImgs[1]);\ 00865 TSubImage<INDTYPE> typedInSubImg2(inSubImgs[2]);\ 00866 TSubImage<INDTYPE> typedInSubImg3(inSubImgs[3]);\ 00867 TSubImage<INDTYPE> typedInSubImg4(inSubImgs[4]);\ 00868 TSubImage<INDTYPE> typedInSubImg5(inSubImgs[5]);\ 00869 TSubImage<INDTYPE> typedInSubImg6(inSubImgs[6]);\ 00870 TSubImage<INDTYPE> typedInSubImg7(inSubImgs[7]);\ 00871 TSubImage<INDTYPE> typedInSubImg8(inSubImgs[8]);\ 00872 TSubImage<INDTYPE> typedInSubImg9(inSubImgs[9]);\ 00873 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&typedOutSubImg,outIndex,\ 00874 &typedInSubImg0, &typedInSubImg1, \ 00875 &typedInSubImg2, &typedInSubImg3, \ 00876 &typedInSubImg4, &typedInSubImg5, \ 00877 &typedInSubImg6, &typedInSubImg7, \ 00878 &typedInSubImg8, &typedInSubImg9);\ 00879 } 00880 00882 00883 #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); 00884 #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); 00885 #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); 00886 00887 00889 00890 #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); 00891 #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); 00892 #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); 00893 00894 00895 00896 #ifdef ML_DEPRECATED 00897 00898 00899 00900 00901 #define CALC_OUTSUBIMAGE10_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES_CPP 00902 00903 00904 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES_CPP 00905 00906 00907 #define CALC_OUTSUBIMAGE10_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH_CPP 00908 00909 00910 #define CALC_OUTSUBIMAGE10 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES 00911 00912 00913 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10 ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_SCALAR_TYPES 00914 00915 00916 #define CALC_OUTSUBIMAGE10_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_WITH_CUSTOM_SWITCH 00917 00918 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00919 #pragma deprecated("CALC_OUTSUBIMAGE10_CPP", "CALC_OUTSUBIMAGE10_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_CPP", "CALC_OUTSUBIMAGE10", "CALC_OUTSUBIMAGE10_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10") 00920 #endif 00921 00923 #endif // ML_DEPRECATED 00924 00925 //--------------------------------------------------------------------------------------------------- 00927 00928 00943 #define _ML_SWITCH_CODE_N(OUTDTYPE, INDTYPE, CLASS_NAME) \ 00944 { \ 00945 /* Get number of inputs. */ \ 00946 const MLssize_t numIns = static_cast<MLssize_t>(this->getInputNum()); \ 00947 \ 00948 /* Create typed version of output buffer. */ \ 00949 TSubImage<OUTDTYPE> outSubImgT(*outSubImg); \ 00950 \ 00951 /* Implement special cases with automatic object creation, */ \ 00952 /* because it is much faster. */ \ 00953 if (numIns < 3){ \ 00954 switch(numIns){ \ 00955 /***** Optimization for 1 input. *****/ \ 00956 case 0:{ \ 00957 /* Calculate output subimage. */ \ 00958 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, \ 00959 (TSubImage<INDTYPE>**)NULL); \ 00960 } \ 00961 return; \ 00962 \ 00963 /***** Optimization for 1 input. *****/ \ 00964 case 1:{ \ 00965 /* Create typed version of input buffer. */ \ 00966 /* and create a pointer array with one element. */ \ 00967 TSubImage<INDTYPE> inSubImgT(inSubImgs[0]); \ 00968 TSubImage<INDTYPE> *inArr = &inSubImgT; \ 00969 \ 00970 /* Calculate output subimage. */ \ 00971 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, &inArr); \ 00972 } \ 00973 return; \ 00974 \ 00975 /***** Optimization for 2 inputs. *****/ \ 00976 case 2:{ \ 00977 TSubImage<INDTYPE> inSubImg0T(inSubImgs[0]); \ 00978 TSubImage<INDTYPE> inSubImg1T(inSubImgs[1]); \ 00979 TSubImage<INDTYPE> *inArr[2]; \ 00980 inArr[0] = &inSubImg0T; \ 00981 inArr[1] = &inSubImg1T; \ 00982 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, inArr); \ 00983 } \ 00984 return; \ 00985 \ 00986 /***** Should be impossible to reach here *****/ \ 00987 default:{ \ 00988 ML_PRINT_FATAL_ERROR("_ML_SWITCH_CODE_N", \ 00989 ML_PROGRAMMING_ERROR, \ 00990 "Invalid case switch detected, " \ 00991 "ignoring case and not processing page"); \ 00992 } \ 00993 } \ 00994 } /* if (numIns < 3) */ \ 00995 else{ \ 00996 /***** Any other number of inputs. *****/ \ 00997 /* Create an array for all pointers to input subimages. */ \ 00998 TSubImage<INDTYPE> **inArr = NULL; \ 00999 ML_CHECK_NEW(inArr, TSubImage<INDTYPE>*[numIns]); \ 01000 bool okay = inArr != NULL; \ 01001 \ 01002 /* Count number of created subimages. */ \ 01003 MLssize_t createdTSubs=0; \ 01004 \ 01005 /* For each untyped input subimage create a typed one and */ \ 01006 /* store its pointer into the array. */ \ 01007 for (MLssize_t c=0; okay && (c < numIns); c++){ \ 01008 ML_CHECK_NEW(inArr[c], TSubImage<INDTYPE>(inSubImgs[c])); \ 01009 if (inArr[c]){ createdTSubs++; } else { okay = false; } \ 01010 } \ 01011 \ 01012 /* Call the correct template version of calculateOutputSubImage. */ \ 01013 if (okay){ \ 01014 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSubImgT, outIndex, inArr); \ 01015 } \ 01016 else{ \ 01017 ML_PRINT_FATAL_ERROR(#CLASS_NAME, ML_NO_MEMORY, \ 01018 "Not calculating page."); \ 01019 } \ 01020 \ 01021 /* Clean up created subimages and array of subimage pointers. */ \ 01022 if (inArr){ \ 01023 for (MLssize_t d=0; d < createdTSubs; d++){ \ 01024 ML_DELETE(inArr[d]); \ 01025 } \ 01026 ML_DELETE_ARRAY(inArr); \ 01027 } \ 01028 } /* else (numIns < 3) */ \ 01029 } 01030 01031 01038 01039 #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); 01040 01042 #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); 01043 01046 #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); 01047 01048 01050 01051 #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); 01052 #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); 01053 #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); 01054 01055 01056 01057 #ifdef ML_DEPRECATED 01058 01059 01060 01061 01062 #define CALC_OUTSUBIMAGEN_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES_CPP 01063 01064 01065 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES_CPP 01066 01067 01068 #define CALC_OUTSUBIMAGEN_CPP_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH_CPP 01069 01070 01071 #define CALC_OUTSUBIMAGEN ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES 01072 01073 01074 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_SCALAR_TYPES 01075 01076 01077 #define CALC_OUTSUBIMAGEN_ANY ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_WITH_CUSTOM_SWITCH 01078 01081 #define calcOutSubImageT calculateOutputSubImage 01082 01083 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01084 #pragma deprecated("CALC_OUTSUBIMAGEN_CPP", "CALC_OUTSUBIMAGEN_CPP_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_CPP", "CALC_OUTSUBIMAGEN", "CALC_OUTSUBIMAGEN_ANY", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N") 01085 #endif 01086 01088 #endif // ML_DEPRECATED 01089 01090 01091 01092 01093 //--------------------------------------------------------------------------------------------------- 01094 // 01095 // 01096 // 01097 // Macros to support different input and output data types. 01098 // Note that these macros produce significantly more code. 01099 // 01100 // 01101 // 01102 //--------------------------------------------------------------------------------------------------- 01103 01104 //--------------------------------------------------------------------------------------------------- 01111 01113 #define _ML_SWITCH_CODE1_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01114 { TSubImage<INDTYPE> inSIT(inSubImgs[0]); _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &inSIT); } 01115 01117 #define _ML_SWITCH_CODE1_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01118 { \ 01119 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01120 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01121 _ML_SWITCH_CODE1_DD_L2, \ 01122 inSubImgs[0].getDataType(), \ 01123 "_ML_SWITCH_CODE1_DD", \ 01124 INDTYPE); \ 01125 } 01126 01128 #define _ML_SWITCH_CODE1S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01129 { \ 01130 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01131 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01132 _ML_SWITCH_CODE1_DD_L2, \ 01133 inSubImgs[0].getDataType(), \ 01134 "_ML_SWITCH_CODE1_DD", \ 01135 INDTYPE); \ 01136 } 01137 01139 01140 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01141 _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); 01142 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01143 _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); 01144 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01145 _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); 01146 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01147 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01148 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01149 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE1S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01150 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01151 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE1_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01152 01153 01154 01155 #ifdef ML_DEPRECATED 01156 01157 01158 01159 01160 #define CALC_OUTSUBIMAGE1_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01161 01162 01163 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01164 01165 01166 #define CALC_OUTSUBIMAGE1_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01167 01168 01169 #define CALC_OUTSUBIMAGE1_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES 01170 01171 01172 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_SCALAR_INOUT_DATATYPES 01173 01174 01175 #define CALC_OUTSUBIMAGE1_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01176 01177 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01178 #pragma deprecated("CALC_OUTSUBIMAGE1_CPP_DD", "CALC_OUTSUBIMAGE1_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE1_DD", "CALC_OUTSUBIMAGE1_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_1_DIFFERENT_INOUT_DATATYPES") 01179 #endif 01180 01182 #endif // ML_DEPRECATED 01183 01184 01185 01186 //--------------------------------------------------------------------------------------------------- 01193 01195 #define _ML_SWITCH_CODE2_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01196 { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]); _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1); } 01197 01199 #define _ML_SWITCH_CODE2_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01200 { \ 01201 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01202 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01203 _ML_SWITCH_CODE2_DD_L2, \ 01204 inSubImgs[0].getDataType(), \ 01205 "_ML_SWITCH_CODE2_DD", \ 01206 INDTYPE); \ 01207 } 01208 01210 #define _ML_SWITCH_CODE2S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01211 { \ 01212 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01213 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01214 _ML_SWITCH_CODE2_DD_L2, \ 01215 inSubImgs[0].getDataType(), \ 01216 "_ML_SWITCH_CODE2_DD", \ 01217 INDTYPE); \ 01218 } 01219 01221 01222 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01223 _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); 01224 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01225 _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); 01226 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01227 _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); 01228 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01229 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01230 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01231 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE2S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01232 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01233 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE2_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01234 01235 01236 01237 #ifdef ML_DEPRECATED 01238 01239 01240 01241 01242 #define CALC_OUTSUBIMAGE2_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01243 01244 01245 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01246 01247 01248 #define CALC_OUTSUBIMAGE2_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01249 01250 01251 #define CALC_OUTSUBIMAGE2_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES 01252 01253 01254 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_SCALAR_INOUT_DATATYPES 01255 01256 01257 #define CALC_OUTSUBIMAGE2_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01258 01259 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01260 #pragma deprecated("CALC_OUTSUBIMAGE2_CPP_DD", "CALC_OUTSUBIMAGE2_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE2_DD", "CALC_OUTSUBIMAGE2_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_2_DIFFERENT_INOUT_DATATYPES") 01261 #endif 01262 01264 #endif // ML_DEPRECATED 01265 01266 01267 //--------------------------------------------------------------------------------------------------- 01276 01278 #define _ML_SWITCH_CODE3_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01279 { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]); \ 01280 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2); } 01281 01283 #define _ML_SWITCH_CODE3_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01284 { \ 01285 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01286 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01287 _ML_SWITCH_CODE3_DD_L2, \ 01288 inSubImgs[0].getDataType(), \ 01289 "_ML_SWITCH_CODE3_DD", \ 01290 INDTYPE); \ 01291 } 01292 01294 #define _ML_SWITCH_CODE3S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01295 { \ 01296 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01297 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01298 _ML_SWITCH_CODE3_DD_L2, \ 01299 inSubImgs[0].getDataType(), \ 01300 "_ML_SWITCH_CODE3_DD", \ 01301 INDTYPE); \ 01302 } 01303 01305 01306 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01307 _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); 01308 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01309 _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); 01310 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01311 _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); 01312 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01313 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01314 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01315 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE3S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01316 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01317 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE3_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01318 01319 01320 01321 #ifdef ML_DEPRECATED 01322 01323 01324 01325 01326 #define CALC_OUTSUBIMAGE3_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01327 01328 01329 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01330 01331 01332 #define CALC_OUTSUBIMAGE3_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01333 01334 01335 #define CALC_OUTSUBIMAGE3_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES 01336 01337 01338 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_SCALAR_INOUT_DATATYPES 01339 01340 01341 #define CALC_OUTSUBIMAGE3_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01342 01343 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01344 #pragma deprecated("CALC_OUTSUBIMAGE3_CPP_DD", "CALC_OUTSUBIMAGE3_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE3_DD", "CALC_OUTSUBIMAGE3_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_3_DIFFERENT_INOUT_DATATYPES") 01345 #endif 01346 01348 #endif // ML_DEPRECATED 01349 01350 01351 01352 //--------------------------------------------------------------------------------------------------- 01361 01363 #define _ML_SWITCH_CODE4_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01364 { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]); \ 01365 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3); } 01366 01368 #define _ML_SWITCH_CODE4_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01369 { \ 01370 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01371 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01372 _ML_SWITCH_CODE4_DD_L2, \ 01373 inSubImgs[0].getDataType(), \ 01374 "_ML_SWITCH_CODE4_DD", \ 01375 INDTYPE); \ 01376 } 01377 01379 #define _ML_SWITCH_CODE4S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01380 { \ 01381 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01382 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01383 _ML_SWITCH_CODE4_DD_L2, \ 01384 inSubImgs[0].getDataType(), \ 01385 "_ML_SWITCH_CODE4_DD", \ 01386 INDTYPE); \ 01387 } 01388 01390 01391 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01392 _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); 01393 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01394 _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); 01395 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01396 _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); 01397 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01398 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01399 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01400 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE4S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01401 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01402 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE4_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01403 01404 01405 01406 #ifdef ML_DEPRECATED 01407 01408 01409 01410 01411 #define CALC_OUTSUBIMAGE4_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01412 01413 01414 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01415 01416 01417 #define CALC_OUTSUBIMAGE4_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01418 01419 01420 #define CALC_OUTSUBIMAGE4_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES 01421 01422 01423 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_SCALAR_INOUT_DATATYPES 01424 01425 01426 #define CALC_OUTSUBIMAGE4_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01427 01428 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01429 #pragma deprecated("CALC_OUTSUBIMAGE4_CPP_DD", "CALC_OUTSUBIMAGE4_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE4_DD", "CALC_OUTSUBIMAGE4_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_4_DIFFERENT_INOUT_DATATYPES") 01430 #endif 01431 01433 #endif // ML_DEPRECATED 01434 01435 01436 01437 //--------------------------------------------------------------------------------------------------- 01447 01449 #define _ML_SWITCH_CODE5_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01450 { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]), it4(inSubImgs[4]); \ 01451 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3, &it4); } 01452 01454 #define _ML_SWITCH_CODE5_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01455 { \ 01456 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01457 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01458 _ML_SWITCH_CODE5_DD_L2, \ 01459 inSubImgs[0].getDataType(), \ 01460 "_ML_SWITCH_CODE5_DD", \ 01461 INDTYPE); \ 01462 } 01463 01465 #define _ML_SWITCH_CODE5S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01466 { \ 01467 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01468 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01469 _ML_SWITCH_CODE5_DD_L2, \ 01470 inSubImgs[0].getDataType(), \ 01471 "_ML_SWITCH_CODE5_DD", \ 01472 INDTYPE); \ 01473 } 01474 01476 01477 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01478 _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); 01479 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01480 _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); 01481 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01482 _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); 01483 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01484 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01485 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01486 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE5S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01487 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01488 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE5_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01489 01490 01491 01492 #ifdef ML_DEPRECATED 01493 01494 01495 01496 01497 #define CALC_OUTSUBIMAGE5_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01498 01499 01500 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01501 01502 01503 #define CALC_OUTSUBIMAGE5_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01504 01505 01506 #define CALC_OUTSUBIMAGE5_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES 01507 01508 01509 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_SCALAR_INOUT_DATATYPES 01510 01511 01512 #define CALC_OUTSUBIMAGE5_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01513 01514 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01515 #pragma deprecated("CALC_OUTSUBIMAGE5_CPP_DD", "CALC_OUTSUBIMAGE5_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE5_DD", "CALC_OUTSUBIMAGE5_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_5_DIFFERENT_INOUT_DATATYPES") 01516 #endif 01517 01519 #endif // ML_DEPRECATED 01520 01521 01522 01523 //--------------------------------------------------------------------------------------------------- 01535 01537 #define _ML_SWITCH_CODE10_DD_L2(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01538 { TSubImage<INDTYPE> it0(inSubImgs[0]), it1(inSubImgs[1]), it2(inSubImgs[2]), it3(inSubImgs[3]), it4(inSubImgs[4]); \ 01539 TSubImage<INDTYPE> it5(inSubImgs[5]), it6(inSubImgs[6]), it7(inSubImgs[7]), it8(inSubImgs[8]), it9(inSubImgs[9]); \ 01540 _ML_CALCULATEOUTPUTCALL_HELPER(CLASS_NAME)(&outSI, outIndex, &it0, &it1, &it2, &it3, &it4, &it5, &it6, &it7, &it8, &it9); } 01541 01543 #define _ML_SWITCH_CODE10_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01544 { \ 01545 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01546 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01547 _ML_SWITCH_CODE10_DD_L2, \ 01548 inSubImgs[0].getDataType(), \ 01549 "_ML_SWITCH_CODE10_DD", \ 01550 INDTYPE); \ 01551 } 01552 01554 #define _ML_SWITCH_CODE10S_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01555 { \ 01556 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01557 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01558 _ML_SWITCH_CODE10_DD_L2, \ 01559 inSubImgs[0].getDataType(), \ 01560 "_ML_SWITCH_CODE10_DD", \ 01561 INDTYPE); \ 01562 } 01563 01565 01566 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01567 _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); 01568 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01569 _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); 01570 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01571 _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); 01572 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01573 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01574 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01575 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODE10S_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01576 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01577 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODE10_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01578 01579 01580 01581 #ifdef ML_DEPRECATED 01582 01583 01584 01585 01586 #define CALC_OUTSUBIMAGE10_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01587 01588 01589 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01590 01591 01592 #define CALC_OUTSUBIMAGE10_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01593 01594 01595 #define CALC_OUTSUBIMAGE10_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES 01596 01597 01598 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_SCALAR_INOUT_DATATYPES 01599 01600 01601 #define CALC_OUTSUBIMAGE10_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01602 01603 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01604 #pragma deprecated("CALC_OUTSUBIMAGE10_CPP_DD", "CALC_OUTSUBIMAGE10_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGE10_DD", "CALC_OUTSUBIMAGE10_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_10_DIFFERENT_INOUT_DATATYPES") 01605 #endif 01606 01608 #endif // ML_DEPRECATED 01609 01610 01611 01612 //--------------------------------------------------------------------------------------------------- 01624 01626 #define _ML_SWITCH_CODEN_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01627 { \ 01628 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01629 ML_IMPLEMENT_DIFFERENT_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01630 _ML_SWITCH_CODE_N, \ 01631 inSubImgs[0].getDataType(), \ 01632 "_ML_SWITCH_CODEN_DD", \ 01633 INDTYPE); \ 01634 } 01635 01637 #define _ML_SWITCH_CODENS_DD(OUTDTYPE, INDTYPE, CLASS_NAME) \ 01638 { \ 01639 TSubImage<OUTDTYPE> outSI(*outSubImg); \ 01640 ML_IMPLEMENT_DIFFERENT_SCALAR_INOUT_DATATYPES_CASES(CLASS_NAME, \ 01641 _ML_SWITCH_CODE_N, \ 01642 inSubImgs[0].getDataType(), \ 01643 "_ML_SWITCH_CODEN_DD", \ 01644 INDTYPE); \ 01645 } 01646 01648 01649 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01650 _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); 01651 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP(CLASS_NAME) \ 01652 _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); 01653 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP(CLASS_NAME, DTSWITCHES) \ 01654 _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); 01655 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES(CLASS_NAME) \ 01656 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_DEFAULT_CASES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_DEFAULT_INOUT_DATATYPES", SubImage *inSubImgs); 01657 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES(CLASS_NAME) \ 01658 _ML_TYPE_SWITCH_H(ML_IMPLEMENT_SCALAR_CASES, _ML_SWITCH_CODENS_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES", SubImage *inSubImgs); 01659 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH(CLASS_NAME, DTSWITCHES) \ 01660 _ML_TYPE_SWITCH_H(DTSWITCHES, _ML_SWITCH_CODEN_DD, "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH", SubImage *inSubImgs); 01661 01662 01663 01664 #ifdef ML_DEPRECATED 01665 01666 01667 01668 01669 #define CALC_OUTSUBIMAGEN_CPP_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01670 01671 01672 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_CPP ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES_CPP 01673 01674 01675 #define CALC_OUTSUBIMAGEN_CPP_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH_CPP 01676 01677 01678 #define CALC_OUTSUBIMAGEN_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES 01679 01680 01681 #define ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_SCALAR_INOUT_DATATYPES 01682 01683 01684 #define CALC_OUTSUBIMAGEN_ANY_DD ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_WITH_CUSTOM_SWITCH 01685 01686 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 01687 #pragma deprecated("CALC_OUTSUBIMAGEN_CPP_DD", "CALC_OUTSUBIMAGEN_CPP_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES_CPP", "CALC_OUTSUBIMAGEN_DD", "CALC_OUTSUBIMAGEN_ANY_DD", "ML_CALCULATEOUTPUTSUBIMAGE_NUM_INPUTS_N_DIFFERENT_INOUT_DATATYPES") 01688 #endif 01689 01691 #endif // ML_DEPRECATED 01692 01693 01694 01695 #endif //of __mlModuleMacros_H 01696 01697
1.7.4