///////////////////////////////////////////////////////////////// // // Filename : MILIM.H // Revision : 10.40.0640 // // Copyright © Matrox Electronic Systems Ltd., 1992-2020. // All Rights Reserved // ///////////////////////////////////////////////////////////////// #ifndef __MILIM_H__ #define __MILIM_H__ /************************************************************************/ /* MimAlloc() */ /************************************************************************/ #define M_DEINTERLACE_CONTEXT 1L #define M_FLAT_FIELD_CONTEXT 3L #define M_DEAD_PIXEL_CONTEXT 4L #define M_REARRANGE_CONTEXT 5L #define M_STAT_MULTIPLE_CONTEXT 6L #define M_MATCH_CONTEXT 7L #define M_PROJECT_SHAPE_CONTEXT 8L #define M_WAVELET_TRANSFORM_CONTEXT 9L #define M_WAVELET_TRANSFORM_CUSTOM_CONTEXT 10L #define M_FIND_ORIENTATION_CONTEXT 11L #define M_LOCATE_PEAK_1D_CONTEXT 12L #define M_HISTOGRAM_EQUALIZE_ADAPTIVE_CONTEXT 13L #define M_BINARIZE_ADAPTIVE_CONTEXT 14L #define M_BINARIZE_ADAPTIVE_FROM_SEED_CONTEXT 15L #define M_STATISTICS_CONTEXT 16L #define M_STATISTICS_CUMULATIVE_CONTEXT 17L #define M_AUGMENTATION_CONTEXT 18L #define M_LINEAR_FILTER_IIR_CONTEXT 19L /************************************************************************/ /* MimGetResult() */ /************************************************************************/ #define M_VALUE 0L #define M_POSITION_X 0x00003400L #define M_POSITION_Y 0x00004400L #define M_NB_EVENT 5L #define M_NUMBER 1009L // Already defined elsewhere #define M_TOTAL_NUMBER 1010L // Already defined elsewhere #define M_NUMBER_OF_LEVELS 1797L #define M_WAVELET_TYPE 1802L // Already defined elsewhere #define M_TRANSFORMATION_MODE 1824L // Already defined elsewhere #define M_WAVELET_SIZE 1856L #define M_WAVELET_DRAW_SIZE_X_WITH_PADDING 1857L #define M_WAVELET_DRAW_SIZE_Y_WITH_PADDING 1858L #define M_REAL_PART 0x1000L #define M_IMAGINARY_PART 0x2000L #define M_TRANSFORMATION_DOMAIN 1864L #define M_ORIGINAL_IMAGE_SIZE_X 1869L #define M_ORIGINAL_IMAGE_SIZE_Y 1870L #define M_WAVELET_DRAW_SIZE_X 1871L #define M_WAVELET_DRAW_SIZE_Y 1872L #define M_ALLOCATED_TYPE 2183L /************************************************************************/ /* MimGetResult/MimHistogram() */ /************************************************************************/ #define M_CUMULATIVE_VALUE 1L #define M_PERCENTAGE 2L // to be used as a complement to M_VALUE and M_CUMULATIVE_VALUE #define M_PERCENTILE_VALUE 0x10L // can also be used as a complement to M_GREATER/... with MimBinarize #define M_PERCENTILE_VALUE_RESULT_SIZE 101L // 0 to 100% #define M_HIST_REAL_SIZE 102L // Real size of histogram obtain from automatic bin size. #define M_HIST_VALUE_OFFSET 103L // Source value of the first bin. #define M_HIST_VALUE_RANGE 104L // Source value range. /************************************************************************/ /* MimGetResult/MimAugment() */ /************************************************************************/ #define M_AUG_ROTATION_ANGLE 3265L #define M_AUG_TRANSLATION_X 3266L #define M_AUG_TRANSLATION_Y 3267L #define M_AUG_SCALE_FACTOR 3268L #define M_AUG_ASPECT_RATIO 3269L #define M_AUG_ASPECT_RATIO_MODE 3373L #define M_AUG_FLIP_DIRECTION 3374L #define M_AUG_SHEAR_X 3270L #define M_AUG_SHEAR_Y 3271L #define M_AUG_DILATION_NB_ITERATIONS 3272L #define M_AUG_EROSION_NB_ITERATIONS 3273L #define M_AUG_DILATION_ASYM_NB_ITERATIONS 3274L #define M_AUG_DILATION_ASYM_SUBAREA 3275L #define M_AUG_EROSION_ASYM_NB_ITERATIONS 3276L #define M_AUG_EROSION_ASYM_SUBAREA 3277L #define M_AUG_LIGHTING_DIRECTIONAL_ANGLE 3278L #define M_AUG_SATURATION_GAIN 3279L #define M_AUG_HSV_VALUE_GAIN 3280L #define M_AUG_HUE_OFFSET 3281L #define M_AUG_SMOOTH_DERICHE_VALUE 3282L #define M_AUG_BLUR_MOTION_SIZE 3283L #define M_AUG_BLUR_MOTION_ANGLE 3284L #define M_AUG_SHARPEN_DERICHE_VALUE 3285L #define M_AUG_SMOOTH_GAUSSIAN_STDDEV 3286L #define M_AUG_CROP_TOP_LEFT_X 3287L #define M_AUG_CROP_TOP_LEFT_Y 3288L #define M_AUG_CROP_BOTTOM_RIGHT_X 3289L #define M_AUG_CROP_BOTTOM_RIGHT_Y 3290L #define M_AUG_NOISE_SALT_PEPPER_DENSITY 3375L #define M_AUG_NOISE_MULTIPLICATIVE_STDDEV 3376L #define M_AUG_NOISE_GAUSSIAN_ADDITIVE_STDDEV 3377L #define M_AUG_INTENSITY_MULTIPLY_VALUE 3365L #define M_AUG_INTENSITY_ADD_VALUE 3366L #define M_AUG_GAMMA_VALUE_BAND_0 3367L #define M_AUG_GAMMA_VALUE_BAND_1 3369L #define M_AUG_GAMMA_VALUE_BAND_2 3371L #define M_AUG_SEED_USED 3423L /* Result vectors */ #define M_AUG_OPERATIONS_ENABLED 3291L #define M_AUG_OPERATIONS_APPLIED 3292L #define M_AUG_OPERATION_RESULT_TYPES 3293L #define M_AUG_OPERATION_RESULT_VALUES 3294L #define M_AUG_OPERATION_ASSOCIATED_WITH_RESULT_TYPES 3295L #define M_AUG_REVERSE_TRANSFORMATION_MATRIX 3399L /************************************************************************/ /* MimGetResultSingle() */ /************************************************************************/ #define M_WAVELET_COEFFICIENTS_IMAGE_ID 1850L #define M_WAVELET_LEVEL_SIZE_X 1798L #define M_WAVELET_LEVEL_SIZE_Y 1799L #define M_WAVELET_LEVEL_PADDING_OFFSET_X 1866L #define M_WAVELET_LEVEL_PADDING_OFFSET_Y 1867L #define M_PREDEFINED 1967L #define M_COMPLEX 1968L #define M_HORIZONTAL_LEVEL_TAG 0x01000000L #define M_HORIZONTAL_LEVEL(a) (M_HORIZONTAL_LEVEL_TAG + (a)) #define M_VERTICAL_LEVEL_TAG 0x02000000L #define M_VERTICAL_LEVEL(a) (M_VERTICAL_LEVEL_TAG + (a)) #define M_DIAGONAL_LEVEL_TAG 0x04000000L #define M_DIAGONAL_LEVEL(a) (M_DIAGONAL_LEVEL_TAG + (a)) #define M_APPROXIMATION 0x08000000L /************************************************************************/ /* MimGetResult2d()/MimStatMultiple */ /************************************************************************/ #define M_MAX 0x04000000L //Already defined elsewhere #define M_MAX_ABS 0x00800000L //Already defined elsewhere #define M_MEAN 0x08000000L //Already defined elsewhere #define M_MIN 0x02000000L //Already defined elsewhere #define M_MIN_ABS 0x00200000L //Already defined elsewhere #define M_STANDARD_DEVIATION 0x10000000L //Already defined elsewhere #define M_SUM 0x00004000L //Already defined elsewhere #define M_SUM_ABS 0x00000008L //Already defined elsewhere #define M_SUM_OF_SQUARES 0x00000400L //Already defined elsewhere /************************************************************************/ /* MimControl()/MimInquire() */ /************************************************************************/ #define M_IN_IM_CONTROL_MIL_ID_RANGE(X) ((X) == M_DARK_IMAGE || \ (X) == M_OFFSET_IMAGE || \ (X) == M_FLAT_IMAGE || \ (X) == M_DEAD_PIXELS || \ (X) == M_MODEL_IMAGE || \ (X) == M_MASK_IMAGE) // To avoid eventual clashes with M_TYPE_XXX, we must use the mask before checking the value itself. #define M_MASK_MIM_INQUIRE_TYPE 0x0001FFFF #define M_RESULT_SIZE 0L #define M_RESULT_TYPE 1L #define M_DEINTERLACE_TYPE 2L #define M_DISCARD_FIELD 3L #define M_FIRST_FIELD 4L #define M_MOTION_DETECT_NUM_FRAMES 5L #define M_MOTION_DETECT_THRESHOLD 6L #define M_MOTION_DETECT_REFERENCE_FRAME 7L #define M_MOTION_DETECT_OUTPUT 8L #define M_SOURCE_FIRST_IMAGE 9L #define M_SOURCE_START_IMAGE M_SOURCE_FIRST_IMAGE #if OldDefinesSupport #define M_EXTENDED_CONTEXT_TYPE 10L MIL_DEPRECATED(M_EXTENDED_CONTEXT_TYPE, 1010) #endif #define M_EXTENDED_CONTEXT_TYPE_DEPRECATED 10L #define M_EXTENDED_RESULT_TYPE 11L #define M_INTERNAL_CONTEXT_TYPE 2906L #define M_ASSOCIATED_CONTEXT_TYPE 2968L // Inquire and control types for M_FLAT_FIELD_CONTEXT. #define M_DARK_IMAGE 200L #define M_OFFSET_IMAGE 201L #define M_FLAT_IMAGE 202L #define M_DARK_CONST 203L #define M_OFFSET_CONST 204L #define M_FLAT_CONST 205L #define M_GAIN_CONST 206L #define M_DARK_IMAGE_NB_BANDS 207L #define M_DARK_IMAGE_WIDTH 208L #define M_DARK_IMAGE_HEIGHT 209L #define M_DARK_IMAGE_TYPE 210L #define M_OFFSET_IMAGE_NB_BANDS 212L #define M_OFFSET_IMAGE_WIDTH 213L #define M_OFFSET_IMAGE_HEIGHT 214L #define M_OFFSET_IMAGE_TYPE 215L #define M_FLAT_IMAGE_NB_BANDS 217L #define M_FLAT_IMAGE_WIDTH 218L #define M_FLAT_IMAGE_HEIGHT 219L #define M_FLAT_IMAGE_TYPE 220L #define M_EFFECTIVE_GAIN_CONST 221L #define M_INVALID_CONST 0x40000000L // Inquire and control types for M_REARRANGE_CONTEXT. #define M_X_SOURCE 300L #define M_Y_SOURCE 301L #define M_XY_SOURCE 302L #define M_X_DESTINATION 303L #define M_Y_DESTINATION 304L #define M_XY_DESTINATION 305L #define M_X_SIZE 306L #define M_Y_SIZE 307L #define M_XY_SIZE 308L #define M_X_SOURCE_ARRAY_SIZE 309L #define M_Y_SOURCE_ARRAY_SIZE 310L #define M_XY_SOURCE_ARRAY_SIZE 311L #define M_X_DESTINATION_ARRAY_SIZE 312L #define M_Y_DESTINATION_ARRAY_SIZE 313L #define M_XY_DESTINATION_ARRAY_SIZE 314L #define M_X_SIZE_ARRAY_SIZE 315L #define M_Y_SIZE_ARRAY_SIZE 316L #define M_XY_SIZE_ARRAY_SIZE 317L // Inquire and control types for M_DEAD_PIXEL_CONTEXT. #define M_DEAD_PIXELS 80L #define M_X_DEAD_PIXELS 81L #define M_Y_DEAD_PIXELS 82L #define M_XY_DEAD_PIXELS 83L #define M_X_DEAD_PIXELS_ARRAY_SIZE 84L #define M_Y_DEAD_PIXELS_ARRAY_SIZE 85L #define M_XY_DEAD_PIXELS_ARRAY_SIZE 86L #define M_DEAD_PIXELS_IMAGE_NB_BANDS 87L //Inquire only #define M_DEAD_PIXELS_IMAGE_WIDTH 88L //Inquire only #define M_DEAD_PIXELS_IMAGE_HEIGHT 89L //Inquire only #define M_DEAD_PIXELS_IMAGE_TYPE 91L //Inquire only #define M_DEAD_PIXELS_IMAGE_ATTRIBUTE 92L //Inquire only // Inquire and control types for M_STAT_MULTIPLE_CONTEXT. #define M_TYPE 1008L //Already defined elsewhere #define M_SIZE_X 1536L //Already defined elsewhere #define M_SIZE_Y 1537L //Already defined elsewhere #define M_2D 90L //See MimStat for M_TYPE possible values. // Inquire and control types for M_MATCH_CONTEXT. #define M_MODEL_IMAGE 1019L #define M_MASK_IMAGE 1020L //Already defined in milreg.h #define M_MAX_SCORE 100L #define M_SCORE_TYPE 37L //Already defined elsewhere #define M_MODEL_STEP 33L //Already defined elsewhere #define M_MODE 103L //Already defined elsewhere #define M_CORRELATE_NORMALIZED 1L //Mode value. #define M_CORRELATE 2L //Mode value. #define M_ABS_SUM_OF_DIFFERENCES 3L //Mode value. #define M_MAX_DEPTH MIL_MAKE_CONST(0xFFFFFFFF, 0x00000000FFFFFFFF) //M_MAX_SCORE value. #define M_NORM 4000L //Already defined elsewhere, ScoreType value. #define M_SQR_NORM 4001L //Already defined elsewhere, ScoreType value. #define M_NORM_CLIP 4002L //ScoreType value. #define M_NORM_CLIP_SQR 4003L //ScoreType value. #define M_MODEL_IMAGE_NB_BANDS 105L //Inquire only #define M_MODEL_IMAGE_WIDTH 106L //Inquire only #define M_MODEL_IMAGE_HEIGHT 107L //Inquire only #define M_MODEL_IMAGE_TYPE 108L //Inquire only #define M_MODEL_IMAGE_ATTRIBUTE 109L //Inquire only #define M_MASK_IMAGE_NB_BANDS 110L //Inquire only #define M_MASK_IMAGE_WIDTH 111L //Inquire only #define M_MASK_IMAGE_HEIGHT 112L //Inquire only #define M_MASK_IMAGE_TYPE 113L //Inquire only #define M_MASK_IMAGE_ATTRIBUTE 114L //Inquire only // Inquire and control types for M_WAVELET_TRANSFORM_CONTEXT. #define M_WAVELET_TYPE 1802L #define M_CUSTOM 2 //WaveletType value #define M_DAUBECHIES_1 3L //WaveletType value #define M_DAUBECHIES_2 4L //WaveletType value #define M_DAUBECHIES_3 5L //WaveletType value #define M_DAUBECHIES_4 6L //WaveletType value #define M_DAUBECHIES_5 7L //WaveletType value #define M_DAUBECHIES_6 8L //WaveletType value #define M_DAUBECHIES_7 9L //WaveletType value #define M_DAUBECHIES_8 10L //WaveletType value #define M_DAUBECHIES_3_COMPLEX 11L //WaveletType value #define M_DAUBECHIES_5_COMPLEX 12L //WaveletType value #define M_DAUBECHIES_7_COMPLEX 13L //WaveletType value #define M_SYMLET_1 14L //WaveletType value #define M_SYMLET_2 15L //WaveletType value #define M_SYMLET_3 16L //WaveletType value #define M_SYMLET_4 17L //WaveletType value #define M_SYMLET_5 18L //WaveletType value #define M_SYMLET_6 19L //WaveletType value #define M_SYMLET_7 20L //WaveletType value #define M_SYMLET_8 21L //WaveletType value #define M_HAAR 1L //WaveletType value #define M_TRANSFORMATION_MODE 1824L #define M_DYADIC 1825L //DecompositionMode value #define M_UNDECIMATED 1826L //DecompositionMode value #define M_FILTER_FORWARD_LOW_PASS_ID 1820L // MimWaveletSetFilter #define M_FILTER_REVERSE_LOW_PASS_ID 1821L // MimWaveletSetFilter #define M_FILTER_FORWARD_HIGH_PASS_ID 1822L // MimWaveletSetFilter #define M_FILTER_REVERSE_HIGH_PASS_ID 1823L // MimWaveletSetFilter #define M_WAVELET_VALIDITY 1827L // MimInquire #define M_WAVELET_CONTEXT_TYPE 1828L // MimInquire #define M_REAL_PART 0x1000L // MimInquire #define M_IMAGINARY_PART 0x2000L // MimInquire // Inquire and control types for M_FIND_ORIENTATION_CONTEXT. #define M_INTERPOLATION_MODE 3018L //Defined in mildisplay.h #define M_FREQUENCY_CUTOFF_RATIO_LOW 1830L //Low frequency cut off #define M_FREQUENCY_CUTOFF_RATIO_HIGH 1831L //High frequency cut off #define M_CLIP_CENTER 106L //Mode value #define M_RESIZE_DOWN 107L //Mode value #define M_RESIZE_UP 108L //Mode value #define M_CENTERED_WINDOW (M_PSEUDO_ID | 0x40) #define M_SCORE 0x00001400L //Defined in milgab.h #define M_BORDER_ATTENUATION 109L // Inquire and control types for M_HISTOGRAM_EQUALIZE_ADAPTIVE_CONTEXT. #define M_NUMBER_OF_TILES_X 250L // Number of tiles in X #define M_NUMBER_OF_TILES_Y 251L // Number of tiles in Y #define M_CLIP_LIMIT 252L // Mormalized clip limit. #define M_HIST_SIZE 253L // Number of histogram bins. #define M_ACCORDING_TO_SOURCE -1L // Number of bin determine from source range. #define M_OPERATION M_METHOD // Already defined elsewhere. Histogram equalization distrition. #define M_UNIFORM 1 // Already defined elsewhere #define M_EXPONENTIAL 2 // Already defined elsewhere #define M_RAYLEIGH 3 // Already defined elsewhere #define M_HYPER_CUBE_ROOT 4 // Already defined elsewhere #define M_HYPER_LOG 5 // Already defined elsewhere #define M_ALPHA_VALUE 5278L // Already defined elsewhere // Inquire and control types for M_LOCATE_PEAK_1D_CONTEXT. #define M_SCAN_LANE_DIRECTION 1 #define M_PEAK_VALUE_MODE 2 #define M_PEAK_INTENSITY_MODE 3 #define M_NUMBER_OF_PEAKS 4 #define M_SORT_CRITERION 5 #define M_PEAK_WIDTH_NOMINAL 6 #define M_PEAK_WIDTH_DELTA 7 #define M_FRAME_SIZE 8 #define M_FULL_SIZE 0L // Already defined in mildisplay.h #define M_SELECT_PEAK(a,b) ((MIL_INT64)((MIL_UINT64)(a) << 32 | (MIL_UINT64)(b))) //Common to many objects. #define M_MODE 103L // Already defined in another header file. #define M_LINES 0x00000080L #define M_RECTS 0x00000100L #define M_AVERAGE 0x00000020L #define M_DISCARD 0x00000021L #define M_BOB 0x00000022L #define M_ADAPTIVE_AVERAGE 0x00000023L #define M_ADAPTIVE_DISCARD 0x00000024L #define M_ADAPTIVE_BOB 0x00000025L #define M_ADAPTATIVE_AVERAGE M_ADAPTIVE_AVERAGE #define M_ADAPTATIVE_DISCARD M_ADAPTIVE_DISCARD #define M_ADAPTATIVE_BOB M_ADAPTIVE_BOB #define M_ODD_FIELD 1L #define M_EVEN_FIELD 2L #define M_FIRST_FRAME 0x40000001L #define M_CENTER_FRAME 0x40000002L #define M_LAST_FRAME 0x40000003L #define M_RESULT_OUTPUT_UNITS 1300L #define M_NUMBER_OF_FRAMES 1080L // Control values for M_RESULT_OUTPUT_UNITS #define M_PIXEL 0x1000L #define M_WORLD 0x2000L #define M_ACCORDING_TO_CALIBRATION 1301L // Control for M_HIST_LIST #define M_HIST_BIN_SIZE_MODE 400L // ControlType to specify binning mode. #define M_REGULAR 0x00020000L // Define elsewhere. Default mode used before, with no binning and // just ignore values that don't fit in the size of the result. #define M_FIT_SRC_RANGE 0x01 // Use the size as the number of bin and a simple algo for indexing. #define M_FIT_SRC_DATA 0x02 // Use the size as the number of bin and a simple algo for indexing. #define M_FREEDMAN 0x03 // MIL automaticly determine optimal bin size/number of bin using Freedman algorithm. #define M_HIST_SMOOTHING_ITERATIONS 401L // Number of smoothing pass to do as post processing. // Inquire and control types for M_LINEAR_FILTER_IIR_CONTEXT. #define M_FILTER_TYPE 1046L // Already defined in miledge.h, milmeas.h #define M_SHEN 0x802L // FilterType value. #define M_DERICHE M_ID_OFFSET_OF_DEFAULT_KERNEL + 10L // FilterType value. Already defined in miledge.h #define M_VLIET 0x803L // FilterType value. #define M_SMOOTHNESS 108L // Already defined in milmod.h, milmeas.h #define M_FILTER_SMOOTHNESS M_SMOOTHNESS // Already defined in milmeas.h #define M_FILTER_SMOOTHNESS_TYPE 2842L #define M_NORMALIZED 0x00000002L // Smoothness type value. #define M_NATIVE 0x00000003L // Smoothness type value. #define M_FILTER_RESPONSE_TYPE 2843L #define M_SLOPE 2844L // Response type value. #define M_STEP 2845L // Response type value. #define M_FILTER_ASPECT_RATIO 2846L #define M_FILTER_DEFAULT_SHARPEN_PARAM 4056L /************************************************************************/ /* MimFindExtreme() */ /************************************************************************/ #define M_MIN_VALUE MAKE_INT64(0x0000010000000000) #define M_MAX_VALUE MAKE_INT64(0x0000020000000000) #define M_MIN_ABS_VALUE 4L #define M_MAX_ABS_VALUE 8L /************************************************************************/ /* MimStat() */ /************************************************************************/ #define M_MIN_ABS 0x00200000L //Already defined elsewhere #define M_MAX_ABS 0x00800000L //Already defined elsewhere #define M_SUM_ABS 0x00000008L //Already defined elsewhere #define M_SUM_OF_SQUARES 0x00000400L //Already defined elsewhere #define M_SUM 0x00004000L //Already defined in milocr.h #define M_MEAN 0x08000000L //Already defined in milmeas.h #define M_STANDARD_DEVIATION 0x10000000L //Already defined in milmeas.h #define M_NUMBER 1009L // Already defined elsewhere 0x000003F1 #define M_ANGULAR_DATA_MEAN 0x00000004L #define M_ANGULAR_DATA_COHERENCE 0x00000800L #define M_ORIENTATION_DATA_MEAN 0x00001000L #define M_ORIENTATION_DATA_COHERENCE 0x00002000L /************************************************************************/ /* MimStatCalculate() */ /************************************************************************/ #define M_STAT_TYPE 2149 #define M_GLCM_STAT_TYPE 2150 #define M_GLCM_PAIR_OFFSET_X 2151 #define M_GLCM_PAIR_OFFSET_Y 2152 #define M_STEP_SIZE_X 2153 #define M_STEP_SIZE_Y 2160 #define M_GLCM_QUANTIFICATION 2161 #define M_STAT_GLCM_DISSIMILARITY 2162 #define M_STAT_GLCM_ENERGY 2163 #define M_STAT_GLCM_ENTROPY 2164 #define M_STAT_GLCM_HOMOGENEITY 2165 #define M_CONDITION 2167 #define M_COND_LOW 2168 #define M_COND_HIGH 2172 #define M_STAT_GLCM_CORRELATION 2173 #define M_STAT_GLCM_CONTRAST 2174 /* These defines preserve the values of their non-prefixed counterpart where possible. */ #define M_STAT_MIN 2502 #define M_STAT_MAX 2503 #define M_STAT_MIN_ABS 2504 #define M_STAT_MAX_ABS 2505 #define M_STAT_SUM_ABS 2506 #define M_STAT_SUM_OF_SQUARES 2507 #define M_STAT_SUM 2508 #define M_STAT_MEAN 2509 #define M_STAT_STANDARD_DEVIATION 2510 #define M_STAT_NUMBER 1009L // Same as M_NUMBER #define M_STAT_ANGULAR_DATA_MEAN 2511 #define M_STAT_ANGULAR_DATA_COHERENCE 2512 #define M_STAT_ORIENTATION_DATA_MEAN 2513 #define M_STAT_ORIENTATION_DATA_COHERENCE 2514 /************************************************************************/ /* MimArith() */ /************************************************************************/ #define M_CONSTANT 0x8000L #define M_FIXED_POINT 0x00004000L #define M_FLOAT_PROC 0x40000000L #define M_LOGICAL 0x08000000L #define M_SOURCE_VALUE 0x00010000L #define M_ADD 0x0000L #define M_ADD_CONST (M_ADD | M_CONSTANT) #define M_SUB 0x0001L #define M_SUB_CONST (M_SUB | M_CONSTANT) #define M_NEG_SUB 0x000AL #define M_CONST_SUB (M_NEG_SUB | M_CONSTANT) #define M_SUB_ABS 0x0011L #define M_SUB_CONST_ABS (M_SUB_ABS | M_CONSTANT) #define M_MIN 0x02000000L #define M_MIN_CONST (M_MIN | M_CONSTANT) #define M_MAX 0x04000000L #define M_MAX_CONST (M_MAX | M_CONSTANT) #define M_OR 0x0016L #define M_OR_CONST (M_OR | M_CONSTANT) #define M_AND 0x0017L #define M_AND_CONST (M_AND | M_CONSTANT) #define M_XOR 0x0018L #define M_XOR_CONST (M_XOR | M_CONSTANT) #define M_NOR 0x0019L #define M_NOR_CONST (M_NOR | M_CONSTANT) #define M_NAND 0x001AL #define M_NAND_CONST (M_NAND | M_CONSTANT) #define M_XNOR 0x001BL #define M_XNOR_CONST (M_XNOR | M_CONSTANT) #define M_NOT 0x0014L #define M_NEG 0x0023L #define M_ABS 0x000CL #define M_PASS 0x0002L #define M_CONST_PASS (M_PASS | M_CONSTANT) #define M_MULT 0x0100L #define M_MULT_CONST (M_MULT | M_CONSTANT) #define M_DIV 0x0101L #define M_DIV_CONST (M_DIV | M_CONSTANT) #define M_INV_DIV 0x0102L #define M_CONST_DIV (M_INV_DIV | M_CONSTANT) #define M_SQRT 0x0103L #define M_SQUARE_ROOT M_SQRT #define M_SQUARE 0x00000020L // Already defined in milmod.h #define M_CUBE 0x0104L #define M_LN 0x0105L #define M_LOG10 0x0106L #define M_LOG2 0x0107L #define M_EXP_CONST 0x0108L #define M_CONST_EXP 0x0109L #define M_EXP 0x010AL // Also defined in mil.h for MgenLutFunction #define M_LOG_CONST 0x010BL #define M_CONST_LOG 0x010CL #define M_LOG 0x010DL // Also defined in mil.h for MgenLutFunction #define M_ATAN2 0x010EL #define M_INTEGRAL 0x010FL #define M_AVG 0x0110L #define M_ABS_SUB 0x0111L #define M_MIN_ABS 0x00200000L // Already defined elsewhere #define M_MAX_ABS 0x00800000L // Already defined elsewhere // Note that those are valid only with M_LOGICAL, avoiding conflict with other flags. #define M_EQUAL 3L #define M_NOT_EQUAL 4L #define M_GREATER 5L #define M_LESS 6L #define M_GREATER_OR_EQUAL 7L #define M_LESS_OR_EQUAL 8L #define M_EQUAL_CONST (M_EQUAL | M_CONSTANT) #define M_NOT_EQUAL_CONST (M_NOT_EQUAL | M_CONSTANT) #define M_GREATER_CONST (M_GREATER | M_CONSTANT) #define M_LESS_CONST (M_LESS | M_CONSTANT) #define M_GREATER_OR_EQUAL_CONST (M_GREATER_OR_EQUAL | M_CONSTANT) #define M_LESS_OR_EQUAL_CONST (M_LESS_OR_EQUAL | M_CONSTANT) /************************************************************************/ /* MimArithMultiple() */ /************************************************************************/ #define M_OFFSET_GAIN 0x0000L #define M_WEIGHTED_AVERAGE 0x0001L #define M_MULTIPLY_ACCUMULATE_1 0x0002L #define M_MULTIPLY_ACCUMULATE_2 0x0004L /************************************************************************/ /* MimFlip() */ /************************************************************************/ #define M_FLIP_VERTICAL 1L #define M_FLIP_HORIZONTAL 2L /************************************************************************/ /* MimBinarize(), MimClip(), MimLocateEvent(), MimStat() */ /* Some of these defines are also define in milutil.h */ /************************************************************************/ #define M_IN_RANGE 1L #define M_OUT_RANGE 2L #define M_EQUAL 3L #define M_NOT_EQUAL 4L #define M_GREATER 5L #define M_LESS 6L #define M_GREATER_OR_EQUAL 7L #define M_LESS_OR_EQUAL 8L #define M_MASK 0x00001000L #define M_ALL 0x40000000L /************************************************************************/ /* These flags are specific to MimLocateEvent() */ /************************************************************************/ //The encoding for extremum mode is done on 11 bits, with the 8 lower bits //indicating we use > or >= (0 or 1) for a specific neighbor, the bit 8 is used //to select minimum or maximum (0 or 1) and bit 9 for the special case strickly //greater than any one and greater or equal to all others. Bit 10 is indicating //that one mode is selected. Note that for the neighbor position, we use the //same convention than MimConnectMap. // n3 n2 n1 // n4 X n0 // n5 n6 n7 #define M_LOCATE_EVENT_EXTREMUM_MODE_SHIFT 17L // =utilities= #define M_LOCAL_MAX_NOT_STRICT (0x05FFL << M_LOCATE_EVENT_EXTREMUM_MODE_SHIFT) //Greater or equal to all #define M_LOCAL_MAX_STRICT_MEDIUM (0x0587L << M_LOCATE_EVENT_EXTREMUM_MODE_SHIFT) //Greater right #define M_LOCAL_MIN_NOT_STRICT (0x04FFL << M_LOCATE_EVENT_EXTREMUM_MODE_SHIFT) //Less or equal to all #define M_LOCAL_MIN_STRICT_MEDIUM (0x0487L << M_LOCATE_EVENT_EXTREMUM_MODE_SHIFT) //Less right /************************************************************************/ /* MimBinarize() */ /************************************************************************/ // reserve bits 4-7 to the binarization method #define M_BINARIZATION_METHOD_MASK 0x0F0L //#define M_PERCENTILE_VALUE 0x10L // already defined at the beginning of the file #define M_TRIANGLE_BISECTION_DARK 0x20L #define M_TRIANGLE_BISECTION_BRIGHT 0x30L #define M_BIMODAL 0x40L #define M_FIXED 0x50L #define M_DISCRETE_RANGE 0x1000L #define M_RETURN_VALUE_AS_FLOAT_IN_INT 0x2000L /************************************************************************/ /* MimConvolve() */ /************************************************************************/ #define M_ID_OFFSET_OF_DEFAULT_KERNEL (0x00100000L|M_PSEUDO_ID) #define M_ID_OFFSET_OF_EDGE_DETECTVAR (0x00100100L|M_PSEUDO_ID) #define M_SMOOTH (M_ID_OFFSET_OF_DEFAULT_KERNEL + 0L) #define M_LAPLACIAN_EDGE (M_ID_OFFSET_OF_DEFAULT_KERNEL + 1L) #define M_LAPLACIAN_EDGE2 (M_ID_OFFSET_OF_DEFAULT_KERNEL + 2L) #define M_SHARPEN (M_ID_OFFSET_OF_DEFAULT_KERNEL + 3L) #define M_SHARPEN2 (M_ID_OFFSET_OF_DEFAULT_KERNEL + 4L) #define M_HORIZ_EDGE (M_ID_OFFSET_OF_DEFAULT_KERNEL + 5L) #define M_VERT_EDGE (M_ID_OFFSET_OF_DEFAULT_KERNEL + 6L) #define M_EDGE_DETECT (M_ID_OFFSET_OF_DEFAULT_KERNEL + 7L) #define M_EDGE_DETECT2 (M_ID_OFFSET_OF_DEFAULT_KERNEL + 8L) #define M_EDGE_DETECT_SQR (M_ID_OFFSET_OF_DEFAULT_KERNEL + 9L) #define M_FIRST_DERIVATIVE_X (M_ID_OFFSET_OF_DEFAULT_KERNEL + 10L) #define M_FIRST_DERIVATIVE_Y (M_ID_OFFSET_OF_DEFAULT_KERNEL + 11L) #define M_SECOND_DERIVATIVE_X (M_ID_OFFSET_OF_DEFAULT_KERNEL + 12L) #define M_SECOND_DERIVATIVE_Y (M_ID_OFFSET_OF_DEFAULT_KERNEL + 13L) #define M_SECOND_DERIVATIVE_XY (M_ID_OFFSET_OF_DEFAULT_KERNEL + 14L) #define M_HORIZONTAL_EDGE_SOBEL (M_ID_OFFSET_OF_DEFAULT_KERNEL + 15L) #define M_VERTICAL_EDGE_SOBEL (M_ID_OFFSET_OF_DEFAULT_KERNEL + 16L) #define M_HORIZONTAL_EDGE_PREWITT (M_ID_OFFSET_OF_DEFAULT_KERNEL + 17L) #define M_VERTICAL_EDGE_PREWITT (M_ID_OFFSET_OF_DEFAULT_KERNEL + 18L) #define M_SOBEL_X (M_ID_OFFSET_OF_DEFAULT_KERNEL + 19L) #define M_SOBEL_Y (M_ID_OFFSET_OF_DEFAULT_KERNEL + 20L) #define M_PREWITT_X (M_ID_OFFSET_OF_DEFAULT_KERNEL + 21L) #define M_PREWITT_Y (M_ID_OFFSET_OF_DEFAULT_KERNEL + 22L) #define M_LAPLACIAN_ISO_8 (M_ID_OFFSET_OF_DEFAULT_KERNEL + 23L) #define M_EDGE_DETECTVAR(Val) (M_ID_OFFSET_OF_EDGE_DETECTVAR + Val) #define M_EDGE_DETECT_SOBEL_FAST M_EDGE_DETECT #define M_EDGE_DETECT_PREWITT_FAST M_EDGE_DETECT2 #define M_LAPLACIAN_4 M_LAPLACIAN_EDGE #define M_LAPLACIAN_8 M_LAPLACIAN_EDGE2 #define M_SHARPEN_4 M_SHARPEN2 #define M_SHARPEN_8 M_SHARPEN #define M_OVERSCAN_ENABLE 0x00008000L #define M_OVERSCAN_DISABLE 0x00080000L #define M_OVERSCAN_FAST 0x00040000L #if OldDefinesSupport #define M_SHEN_PREDEFINED_KERNEL (0x10000000L|M_ID_OFFSET_OF_DEFAULT_KERNEL) #define M_DERICHE_PREDEFINED_KERNEL (0x20000000L|M_ID_OFFSET_OF_DEFAULT_KERNEL) #define M_SHEN_PREDEFINED_KERNEL_INVALID_TYPE (0x01000000L|M_SHEN_PREDEFINED_KERNEL) #define M_SHEN_PREDEFINED_KERNEL_INVALID_FACTOR (0x02000000L|M_SHEN_PREDEFINED_KERNEL) #define M_DERICHE_PREDEFINED_KERNEL_INVALID_TYPE (0x01000000L|M_DERICHE_PREDEFINED_KERNEL) #define M_DERICHE_PREDEFINED_KERNEL_INVALID_FACTOR (0x02000000L|M_DERICHE_PREDEFINED_KERNEL) #define M_IS_SHEN_PREDEFINED_KERNEL(KernelId) (((KernelId) & M_SHEN_PREDEFINED_KERNEL) == M_SHEN_PREDEFINED_KERNEL) #define M_IS_DERICHE_PREDEFINED_KERNEL(KernelId) (((KernelId) & M_DERICHE_PREDEFINED_KERNEL) == M_DERICHE_PREDEFINED_KERNEL) #define M_SHEN_FILTER(FilterOperation, FilterSmoothness) (((((FilterOperation) & M_ID_OFFSET_OF_DEFAULT_KERNEL) != M_ID_OFFSET_OF_DEFAULT_KERNEL) && (FilterOperation!=M_DEFAULT)) ? M_SHEN_PREDEFINED_KERNEL_INVALID_TYPE : \ ((((FilterOperation) & (~(M_ID_OFFSET_OF_DEFAULT_KERNEL | 0xFF))) != 0) && (FilterOperation!=M_DEFAULT)) ? M_SHEN_PREDEFINED_KERNEL_INVALID_TYPE : \ (((((FilterSmoothness) < 0) || ((FilterSmoothness) > 100))) && (FilterSmoothness!=M_DEFAULT)) ? M_SHEN_PREDEFINED_KERNEL_INVALID_FACTOR : \ M_SHEN_PREDEFINED_KERNEL | ((FilterOperation==M_DEFAULT) ? 0x80 : FilterOperation) | ((FilterSmoothness==M_DEFAULT)?(0xFF00):(((long) FilterSmoothness) << 8)) ) MIL_DEPRECATED(M_SHEN_FILTER, 1040) // Use new M_LINEAR_FILTER_IIR_CONTEXT with MimConvolve or MimDerivative instead. #define M_DERICHE_FILTER(FilterOperation, FilterSmoothness) (((((FilterOperation) & M_ID_OFFSET_OF_DEFAULT_KERNEL) != M_ID_OFFSET_OF_DEFAULT_KERNEL) && (FilterOperation!=M_DEFAULT)) ? M_DERICHE_PREDEFINED_KERNEL_INVALID_TYPE : \ ((((FilterOperation) & (~(M_ID_OFFSET_OF_DEFAULT_KERNEL | 0xFF))) != 0) && (FilterOperation!=M_DEFAULT)) ? M_DERICHE_PREDEFINED_KERNEL_INVALID_TYPE : \ (((((FilterSmoothness) < 0) || ((FilterSmoothness) > 100))) && (FilterSmoothness!=M_DEFAULT)) ? M_DERICHE_PREDEFINED_KERNEL_INVALID_FACTOR : \ M_DERICHE_PREDEFINED_KERNEL | ((FilterOperation==M_DEFAULT) ? 0x80 : FilterOperation) | ((FilterSmoothness==M_DEFAULT)?(0xFF00):(((long) FilterSmoothness) << 8)) ) MIL_DEPRECATED(M_DERICHE_FILTER, 1040) // Use new M_LINEAR_FILTER_IIR_CONTEXT with MimConvolve or MimDerivative instead. #endif /************************************************************************/ /* MimDifferential() */ /************************************************************************/ #define M_GAUSSIAN_CURVATURE 2691L // Already defined. #define M_GRADIENT 3306L #define M_GRADIENT_SQR 3307L #define M_HESSIAN 3308L #define M_JACOBIAN 3309L #define M_LAPLACIAN 3310L #define M_MEAN_CURVATURE 2692L // Already defined. #define M_SHARPEN (M_ID_OFFSET_OF_DEFAULT_KERNEL + 3L) // Already defined for MimConvolve. /************************************************************************/ /* MimEdgeDetect() */ /************************************************************************/ #if M_MIL_LITE || MIL_COMPILE_VERSION >= MIL_COMPILE_TRUNK_VERSION #define M_SOBEL M_EDGE_DETECT_SOBEL_FAST #endif #define M_NOT_WRITE_ANGLE 1L #define M_NOT_WRITE_INT 2L #define M_FAST_ANGLE 4L #define M_FAST_GRADIENT 8L #define M_FAST_EDGE_DETECT (M_FAST_ANGLE + M_FAST_GRADIENT) #define M_REGULAR_ANGLE 16L #define M_REGULAR_GRADIENT 64L #define M_REGULAR_EDGE_DETECT (M_REGULAR_ANGLE + M_REGULAR_GRADIENT) #define M_USE_RESERVED_ANGLE_VALUE 128L /************************************************************************/ /* MimRank() */ /************************************************************************/ #define M_MEDIAN 0x10000L #define M_3X3_RECT (M_ID_OFFSET_OF_DEFAULT_KERNEL + 20L) #define M_3X3_CROSS (M_ID_OFFSET_OF_DEFAULT_KERNEL + 21L) #define M_5X5_RECT (M_ID_OFFSET_OF_DEFAULT_KERNEL + 30L) /************************************************************************/ /* MimMorphic(), ... */ /************************************************************************/ #define M_ERODE 1L #define M_DILATE 2L #define M_THIN 3L #define M_THICK 4L #define M_HIT_OR_MISS 5L #define M_MATCH 6L #define M_AREA_OPEN 7L #define M_AREA_CLOSE 8L #define M_TOP_HAT 9L #define M_BOTTOM_HAT 10L #define M_LEVEL 11L // These flags are already defined elsewhere. We use the same values here. #define M_OPEN 0x00000010L #define M_CLOSE 0x00000020L /************************************************************************/ /* MimErode() */ /************************************************************************/ #define M_BINARY_ULTIMATE 1L #define M_BINARY_ULTIMATE_ACCUMULATE 2460L /************************************************************************/ /* MimThin() */ /************************************************************************/ #define M_TO_SKELETON -1L #define M_BINARY2 1L #define M_BINARY3 2L #define M_OVERSCAN_REPLACE_MAX 0x10 #define M_OVERSCAN_REPLACE_MIN 0x20 /************************************************************************/ /* MimThick() */ /************************************************************************/ #define M_TO_IDEMPOTENCE M_TO_SKELETON /************************************************************************/ /* MimDistance() */ /************************************************************************/ #define M_CHAMFER_3_4 0x01 #define M_CITY_BLOCK 0x02 #define M_CHESSBOARD 0x04 #define M_FORWARD 0x01 #define M_BACKWARD 0x02 #define M_OVERSCAN_TO_DO 0x04 #define M_BOTH 0x07 /************************************************************************/ /* MimWatershed() */ /************************************************************************/ #define M_WATERSHED 0x0001 #define M_BASIN 0x0002 #define M_MINIMA_FILL 0x0004 #define M_MAXIMA_FILL 0x0008 #define M_4_CONNECTED 0x00000010L #define M_8_CONNECTED 0x00000020L #define M_REGULAR 0x00020000L #define M_STRAIGHT_WATERSHED 0x0080 #define M_SKIP_LAST_LEVEL 0x0100 #define M_FILL_SOURCE 0x0200 #define M_LABELLED_MARKER 0x0400 #define M_LABELED_MARKER M_LABELLED_MARKER #define M_METHOD_1 0x1000 #define M_METHOD_2 0x2000 #define M_BASIN_4_CONNECTED 0x4000 #define M_BASIN_8_CONNECTED 0x8000 /************************************************************************/ /* MimProject() */ /************************************************************************/ #define M_0_DEGREE 0.0 #define M_90_DEGREE 90.0 #define M_180_DEGREE 180.0 #define M_270_DEGREE 270.0 /************************************************************************/ /* MimResize(), MimTranslate() and MimRotate() */ /************************************************************************/ #define M_OVERSCAN_DISABLE 0x00080000L #define M_OVERSCAN_ENABLE 0x00008000L #define M_OVERSCAN_FAST 0x00040000L #define M_INTERPOLATE 0x00000004L #define M_BILINEAR 0x00000008L #define M_BICUBIC 0x00000010L #define M_AVERAGE 0x00000020L #define M_NEAREST_NEIGHBOR 0x00000040L #define M_OVERSCAN_CLEAR 0x00000080L #define M_FIT_ALL_ANGLE 0x00000100L #define M_BINARY 0x00001000L #define M_FAST 0x00002000L #define M_REGULAR 0x00020000L /************************************************************************/ /* MimResize */ /************************************************************************/ #define M_FILL_DESTINATION -1 // DO NOT MODIFY, WITHOUT CODE MODIFICATION /************************************************************************/ /* MimHistogramEqualize() */ /************************************************************************/ #define M_UNIFORM 1 #define M_EXPONENTIAL 2 #define M_RAYLEIGH 3 #define M_HYPER_CUBE_ROOT 4 #define M_HYPER_LOG 5 /************************************************************************/ /* MimConvert() */ /************************************************************************/ #define M_REGULAR 0x00020000L #define M_FAST 0x00002000L #define M_MASK 0x00001000L #define M_ID_OFFSET_OF_DEFAULT_CONVERT (0x00200000L|M_PSEUDO_ID) #define M_RGB_TO_HSL (M_ID_OFFSET_OF_DEFAULT_CONVERT + 1L) // Same as Mil.h #define M_RGB_TO_HLS M_RGB_TO_HSL // Obsolete #define M_RGB_TO_L (M_ID_OFFSET_OF_DEFAULT_CONVERT + 2L) // Same as Mil.h #define M_HSL_TO_RGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 3L) // Same as Mil.h #define M_HLS_TO_RGB M_HSL_TO_RGB // Obsolete #define M_L_TO_RGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 4L) // Same as Mil.h #define M_RGB_TO_Y (M_ID_OFFSET_OF_DEFAULT_CONVERT + 5L) // Same as Mil.h #define M_RGB_TO_H (M_ID_OFFSET_OF_DEFAULT_CONVERT + 6L) // Same as Mil.h #define M_RGB_TO_YUV16 (M_ID_OFFSET_OF_DEFAULT_CONVERT + 101L) // Same as Mil.h #define M_YUV16_TO_RGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 301L) // Same as Mil.h #define M_RGB_NORMALIZE (M_ID_OFFSET_OF_DEFAULT_CONVERT + 10L) #define M_RGB_TO_HSV (M_ID_OFFSET_OF_DEFAULT_CONVERT + 11L) // Same as Mildev.h #define M_HSV_TO_RGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 12L) // Same as Mildev.h #define M_SRGB_LINEAR_TO_LAB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 500L) #define M_SRGB_TO_LAB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 501L) #define M_LAB_TO_SRGB_LINEAR (M_ID_OFFSET_OF_DEFAULT_CONVERT + 502L) #define M_LAB_TO_SRGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 503L) #define M_SRGB_LINEAR_TO_LCH (M_ID_OFFSET_OF_DEFAULT_CONVERT + 504L) #define M_SRGB_TO_LCH (M_ID_OFFSET_OF_DEFAULT_CONVERT + 505L) #define M_LCH_TO_SRGB_LINEAR (M_ID_OFFSET_OF_DEFAULT_CONVERT + 506L) #define M_LCH_TO_SRGB (M_ID_OFFSET_OF_DEFAULT_CONVERT + 507L) #define M_MATRIX_ID(x) (x) // Obsolete from MIL 9 // If the conversion type is set to M_DEFAULT, the conversion will be // choosen according to the type of buffers passed to the function. #define M_DEFAULT 0x10000000L // These can be added to the conversion type to speed-up the // process ( M_FAST ) or have a better precision ( M_REGULAR ). // Not all conversion are affected by this flag. #define M_REGULAR 0x00020000L #define M_FAST 0x00002000L /************************************************************************/ /* MimWarp() */ /************************************************************************/ /* 8 bits reserved for number of fractional bits */ #define M_WARP_MATRIX 0x00100000L #define M_WARP_POLYNOMIAL 0x00200000L #define M_WARP_LUT 0x00400000L #define M_OVERSCAN_ENABLE 0x00008000L #define M_OVERSCAN_DISABLE 0x00080000L #define M_OVERSCAN_FAST 0x00040000L #define M_OVERSCAN_CLEAR 0x00000080L #define M_FIXED_POINT 0x00004000L /************************************************************************/ /* MimTransform() */ /************************************************************************/ #define M_FFT 1L #define M_DCT8X8 2L #define M_DCT 3L #define M_POLAR 5L #define M_FORWARD 0x01 #define M_REVERSE 4L #define M_NORMALIZED 0x00000002L #define M_NORMALIZE M_NORMALIZED #define M_1D_ROWS 0x00000010L #define M_1D_COLUMNS 0x00000020L #define M_REAL 0x00000040L #define M_CENTER 0x00000080L #define M_MAGNITUDE 0x00000100L #define M_PHASE 0x00000200L #define M_LOG_SCALE 0x00000400L #define M_FAST_PHASE 0x00000800L #define M_SQUARE_MAGNITUDE 0x00001000L #define M_NORMALIZE_PHASE 0x00002000L #define M_NORMALIZE_PHASE_255 0x00008000L #define M_CLOCKWISE_PHASE 0x00010000L #define M_USE_CORDIC 0x00020000L #define M_INTERNAL_FFT_NEW 0x00000008L /************************************************************************/ /* MimWaveletTransform() */ /************************************************************************/ #define M_FORWARD 0x01 // Already defined elsewhere #define M_REVERSE 4L // Already defined elsewhere #define M_COPY 0x00020000L // Already defined elsewhere /************************************************************************/ /* MimWaveletDenoise () */ /************************************************************************/ #define M_DENOISE_PSEUDO_ID (0x00100100L|M_PSEUDO_ID) // =utilities #define M_BAYES_SHRINK (M_DENOISE_PSEUDO_ID + 2L) #define M_SURE_SHRINK (M_DENOISE_PSEUDO_ID + 3L) #define M_NEIGH_SHRINK (M_DENOISE_PSEUDO_ID + 4L) /************************************************************************/ /* MimPolarTransform() */ /************************************************************************/ #define M_RECTANGULAR_TO_POLAR 0x00000001L #define M_POLAR_TO_RECTANGULAR 0x00000002L #define M_FIXED_POINT 0x00004000L #define M_RECTANGULAR_TO_POLAR_LUT 0x00008000L #define M_POLAR_TO_RECTANGULAR_LUT 0x00010000L /************************************************************************/ /* MimDraw() */ /************************************************************************/ #define M_DRAW_PEAKS 0x01000000L #define M_DRAW_DARK_IMAGE 0x02000000L #define M_DRAW_OFFSET_IMAGE 0x04000000L #define M_DRAW_FLAT_IMAGE 0x08000000L #define M_DOTS 0x00000040L #define M_LINES 0x00000080L #define M_1D_ROWS 0x00000010L // Already defined elsewhere #define M_1D_COLUMNS 0x00000020L // Already defined elsewhere #define M_DRAW_STAT_RESULT 0x00000100L #define M_DRAW_WAVELET 0x00010000L #define M_DRAW_WAVELET_WITH_PADDING 0x00000800L #define M_DRAW_MODEL 0x00001000L #define M_DRAW_MASK 0x200000L // Already defined elsewhere #define M_DRAW_PATH 0x00000200L #define M_DRAW_DEAD_PIXELS 0x00000400L #define M_DRAW_IMAGE_ORIENTATION 0x00002000L #define M_DRAW_DEPTH_MAP_ROW 0x00004000L #define M_DRAW_INTENSITY_MAP_ROW 0x00008000L #define M_DRAW_GLCM_MATRIX 0x00100000L #define M_AUTO_SCALE 2L // Already defined in mil.h #define M_SATURATION 0x2000L // Already defined in mil.h #define M_DRAW_AUG_IMAGE 0x00020000L // TOMODIFY: review this value /************************************************************************/ /* MimStatMultiple() */ /************************************************************************/ #define M_CALCULATE 1L // Already defined elsewhere #define M_PREPROCESS 0x00000002L // Already defined elsewhere #define M_REMOVE 0x00000004L #define M_RESET_EXTREMES 0x00000008L /************************************************************************/ /* MimFlatField(), MimDeadPixelCorrection(), MimRearrange() and */ /* MimStatMultiple() */ /************************************************************************/ #define M_PREPROCESS 0x00000002L /************************************************************************/ /* MimProjectShape(), MgenLutWarp() */ /************************************************************************/ #define M_OPTIMAL_SIZE_X 0x1L #define M_OPTIMAL_SIZE_Y 0x2L #define M_PATH_LIST 0x3L #define M_X_PATH_LIST 0x4L #define M_Y_PATH_LIST 0x5L #define M_XY_PATH_LIST 0x6L #define M_PATH_WIDTH_LIST 0x7L /************************************************************************/ /* MimLocatepeak1d() */ /************************************************************************/ #define M_SCAN_LANE_INDEX 0x000100000L #define M_RANK_INDEX 0x000200000L #define M_PEAK_POSITION 0x000400000L #define M_PEAK_POSITION_X 0x000800000L #define M_PEAK_POSITION_Y 0x001000000L #define M_NUMBER 1009L // defined in milmeas.h #define M_PEAK_INTENSITY_RANGE 0x000008000L #define M_PEAK_INTENSITY 0x000010000L #define M_FRAME_INDEX 0x002000000L #define M_PEAK_WIDTH 11L #define M_NUMBER_OF_SCAN_LANES 0x000020000L #define M_INCLUDE_MISSING_DATA 0x000040000L #define M_ONLY_MISSING_DATA 0x000080000L #define M_STATUS 0x00008002L // Already defined elsewhere /************************************************************************/ /* MimBinarizeAdaptive() */ /************************************************************************/ #define M_THRESHOLD_MODE 33L // Already defined in miledge.h #define M_NIBLACK 1880L #define M_BERNSEN 1881L #define M_LOCAL_MEAN 1882L #define M_PSEUDOMEDIAN 1883L #define M_LOCAL_DIMENSION 1884L #define M_MINIMUM_CONTRAST 600L // Also defined in milstr.h #define M_GLOBAL_MAX 1885L #define M_GLOBAL_MIN 1886L #define M_NIBLACK_BIAS 1887L #define M_GLOBAL_OFFSET 1888L //#define M_HYSTERESIS 31L #define M_NIBLACK_BIAS_SECOND_PASS 1889L #define M_GLOBAL_OFFSET_SECOND_PASS 1890L #define M_AVERAGE_MODE 1891L //#define M_UNIFORM 1L #define M_GAUSSIAN 0x805L //also defined in miledge.h #define M_RECONSTRUCT 1892L #define M_NB_ITERATIONS 1893L #define M_NB_SEED_ITERATIONS 1894L #define M_TOGGLE 1895L #define M_THRESHOLD_TYPE 3000L /************************************************************************/ /* MimAugment() */ /************************************************************************/ #define M_SAVE_REPORT 0x200L // already defined in milcode.h #define M_PRIORITY 0x00004000L #define M_PROBABILITY 0x00008000L // STRUCTURE #define M_AUG_DILATION_OP 3098L #define M_AUG_EROSION_OP 3099L #define M_AUG_DILATION_ASYM_OP 3100L #define M_AUG_EROSION_ASYM_OP 3101L // GEOMETRIQUE #define M_AUG_FLIP_OP 2870L #define M_AUG_CROP_OP 3102L // AFFINE #define M_AUG_ROTATION_OP 3103L #define M_AUG_SCALE_OP 3104L #define M_AUG_TRANSLATION_X_OP 3105L #define M_AUG_TRANSLATION_Y_OP 3106L #define M_AUG_ASPECT_RATIO_OP 3107L #define M_AUG_SHEAR_X_OP 2892L #define M_AUG_SHEAR_Y_OP 2893L // INTENSITY #define M_AUG_INTENSITY_MULTIPLY_OP 2940L #define M_AUG_INTENSITY_ADD_OP 2887L #define M_AUG_GAMMA_OP 2962L #define M_AUG_LIGHTING_DIRECTIONAL_OP 3108L #define M_AUG_SATURATION_GAIN_OP 2910L #define M_AUG_HUE_OFFSET_OP 2917L #define M_AUG_HSV_VALUE_GAIN_OP 2914L // FILTER #define M_AUG_SMOOTH_DERICHE_OP 2920L #define M_AUG_SMOOTH_GAUSSIAN_OP 2932L #define M_AUG_BLUR_MOTION_OP 2923L #define M_AUG_SHARPEN_DERICHE_OP 2928L // NOISE #define M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP 2955L #define M_AUG_NOISE_MULTIPLICATIVE_OP 2950L #define M_AUG_NOISE_SALT_PEPPER_OP 2947L // Augmentation Control parameters #define M_AUG_DILATION_OP_NB_ITERATIONS_MAX 2873L #define M_AUG_EROSION_OP_NB_ITERATIONS_MAX 2875L #define M_AUG_DILATION_ASYM_OP_NB_ITERATIONS_MAX 2881L #define M_AUG_EROSION_ASYM_OP_NB_ITERATIONS_MAX 2882L #define M_AUG_FLIP_OP_DIRECTION 3120L #define M_AUG_CROP_OP_FACTOR_X 2884L #define M_AUG_CROP_OP_FACTOR_Y 2885L #define M_AUG_CROP_OP_RESIZE 2886L #define M_AUG_SCALE_OP_FACTOR_MAX 2876L #define M_AUG_SCALE_OP_FACTOR_MIN 2877L #define M_AUG_ROTATION_OP_ANGLE_MAX 2805L #define M_AUG_ROTATION_OP_ANGLE_REF 3348L #define M_AUG_ROTATION_OP_ANGLE_DELTA 3349L #define M_AUG_ROTATION_OP_ANGLE_STEP 3350L #define M_AUG_ROTATION_OP_ANGLE_MIN 3351L #define M_AUG_TRANSLATION_X_OP_MAX 2868L #define M_AUG_TRANSLATION_Y_OP_MAX 2869L #define M_AUG_ASPECT_RATIO_OP_MIN 2878L #define M_AUG_ASPECT_RATIO_OP_MAX 2879L #define M_AUG_ASPECT_RATIO_OP_MODE 2880L #define M_AUG_SHEAR_X_OP_MIN 2888L #define M_AUG_SHEAR_X_OP_MAX 2889L #define M_AUG_SHEAR_Y_OP_MIN 2890L #define M_AUG_SHEAR_Y_OP_MAX 2891L #define M_AUG_LIGHTING_DIRECTIONAL_OP_ANGLE_MAX 2894L #define M_AUG_LIGHTING_DIRECTIONAL_OP_INTENSITY_MIN 2895L #define M_AUG_LIGHTING_DIRECTIONAL_OP_INTENSITY_MAX 2896L #define M_AUG_SATURATION_GAIN_OP_MIN 2911L #define M_AUG_SATURATION_GAIN_OP_MAX 2912L #define M_AUG_HUE_OFFSET_OP_MIN 2915L #define M_AUG_HUE_OFFSET_OP_MAX 2916L #define M_AUG_HSV_VALUE_GAIN_OP_MIN 2918L #define M_AUG_HSV_VALUE_GAIN_OP_MAX 2919L #define M_GAIN_CONST 206L // Already defined for M_FLAT_FIELD_CONTEXT #define M_AUG_INTENSITY_MULTIPLY_OP_VALUE M_GAIN_CONST #define M_AUG_INTENSITY_MULTIPLY_OP_DELTA 2941L #define M_AUG_INTENSITY_MULTIPLY_OP_MODE 2959L #define M_OFFSET_CONST 204L // Already defined for M_FLAT_FIELD_CONTEXT #define M_AUG_INTENSITY_ADD_OP_VALUE M_OFFSET_CONST #define M_AUG_INTENSITY_ADD_OP_DELTA 2958L #define M_AUG_INTENSITY_ADD_OP_MODE 2883L #define M_GAMMA 6672L // Already defined mil.h #define M_AUG_GAMMA_OP_VALUE M_GAMMA #define M_AUG_GAMMA_OP_DELTA 2963L #define M_AUG_GAMMA_OP_MODE 2942L #define M_AUG_SMOOTH_DERICHE_OP_FACTOR_MIN 2921L #define M_AUG_SMOOTH_DERICHE_OP_FACTOR_MAX 2922L #define M_AUG_SMOOTH_GAUSSIAN_OP_STDDEV_MIN 2933L #define M_AUG_SMOOTH_GAUSSIAN_OP_STDDEV_MAX 2934L #define M_AUG_BLUR_MOTION_OP_SIZE_MIN 2924L #define M_AUG_BLUR_MOTION_OP_SIZE_MAX 2925L #define M_AUG_BLUR_MOTION_OP_ANGLE_MIN 2926L #define M_AUG_BLUR_MOTION_OP_ANGLE_MAX 2927L #define M_AUG_SHARPEN_DERICHE_OP_FACTOR_MIN 2929L #define M_AUG_SHARPEN_DERICHE_OP_FACTOR_MAX 2930L #define M_AUG_NOISE_SALT_PEPPER_OP_DENSITY 2948L #define M_AUG_NOISE_SALT_PEPPER_OP_DENSITY_DELTA 2949L #define M_AUG_NOISE_MULTIPLICATIVE_OP_STDDEV 2951L #define M_AUG_NOISE_MULTIPLICATIVE_OP_STDDEV_DELTA 2952L #define M_AUG_NOISE_MULTIPLICATIVE_OP_INTENSITY_MIN 2953L #define M_AUG_NOISE_MULTIPLICATIVE_OP_DISTRIBUTION 2954L #define M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP_STDDEV 2956L #define M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP_STDDEV_DELTA 2957L #define M_AUG_RNG_INIT_VALUE 2867L #define M_AUG_SEED_MODE 3421L //#define M_AUG_CONTEXT_SEED 3422L #define M_AUG_OPTIMAL_SIZE_X 3419L #define M_AUG_OPTIMAL_SIZE_Y 3420L /* Parameter value */ #define M_ALL_BANDS M_ALL_BAND // Already defined mil.h #define M_PER_BAND 2966L #define M_UNIFORM 1 // Already defined MimHistogramEqualize() #define M_GAUSSIAN 0x805L // Already defined in miledge.h #define M_RGB 8L // Already defined in mil.h #define M_LEFT_HALF M_LEFT #define M_RIGHT_HALF M_RIGHT #define M_UPPER_HALF M_TOP #define M_LOWER_HALF M_BOTTOM #define M_NORMAL 8L // Already defined in mil.h #define M_INVERT 2L // Arleady defined in milocr.h #define M_RNG_AUTO 3422L #define M_RNG_INIT_VALUE 3464L #define M_USER_DEFINED_SEED 3465L #define M_AUTO_VALUE MAKE_INT64(0x0000000100000000) /************************************************************************/ /* MimStatCalculate() */ /************************************************************************/ /************************************************************************/ /* MimFilterAdaptive() */ /************************************************************************/ #define M_BILATERAL (M_PSEUDO_ID | 0x400) #if OldDefinesSupport #define M_NOPEL (M_PSEUDO_ID | 0x401) MIL_DEPRECATED(M_NOPEL, 1040) // Use M_NOISE_PEAK_REMOVAL instead. #endif #define M_NOISE_PEAK_REMOVAL (M_PSEUDO_ID | 0x402) #define M_MEDIAN 0x10000L // Already defined elsewhere. #define M_MEAN 0x08000000L // Already defined elsewhere. #define M_EXTREME 3393L /************************************************************************/ /* MimRemap() */ /************************************************************************/ // Control for M_HIST_LIST #define M_FIT_SRC_RANGE 0x01 // Already defined as control for M_HIST_LIST. #define M_FIT_SRC_DATA 0x02 // Already defined as control for M_HIST_LIST. #define M_CENTERED 0x00010000 #ifdef __cplusplus inline MIL_INT64 ExtractTypeFromValue(MIL_INT64 Value, MIL_INT64 Type1, MIL_INT64 Type2 = 0, MIL_INT64 Type3 = 0, MIL_INT64 Type4 = 0, MIL_INT64 Type5 = 0, MIL_INT64 Type6 = 0, MIL_INT64 Type7 = 0, MIL_INT64 Type8 = 0) { MIL_INT64 Type = (Value & M_HLVLDATATYPE_MASK); if (Type) // type specified. { // If the extracted type doesn't match one of the allowed types, set it to 0. if (Type != Type1 && Type != Type2 && Type != Type3 && Type != Type4 && Type != Type5 && Type != Type6 && Type != Type7 && Type != Type8) { Type = 0; } } return Type; } #endif /* C++ directive if needed */ #ifdef __cplusplus extern "C" { #endif /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* POINT TO POINT : */ /* -------------------------------------------------------------- */ #if M_MIL_USE_64BIT #define MimArith(Src1, Src2, Dest, Op) MimArithDouble(M_MILID_TO_DOUBLE(Src1), M_MILID_TO_DOUBLE(Src2), Dest, Op) #else #define MimArithDouble MimArith #endif MIL_DLLFUNC void MFTYPE MimArithDouble (MIL_DOUBLE Src1ImageBufIdOrConst, MIL_DOUBLE Src2ImageBufIdOrConst, MIL_ID DstImageBufId, MIL_INT64 Operation); #if M_MIL_USE_64BIT #define MimArithMultiple(Src1, Src2, Src3, Src4, Src5, Dest, Op, OpFlag) MimArithMultipleDouble(M_MILID_TO_DOUBLE(Src1), M_MILID_TO_DOUBLE(Src2), M_MILID_TO_DOUBLE(Src3), Src4, Src5, Dest, Op, OpFlag) #else #define MimArithMultipleDouble MimArithMultiple #endif MIL_DLLFUNC void MFTYPE MimArithMultipleDouble(MIL_DOUBLE Src1ImageBufId, MIL_DOUBLE Src2ImageBufIdOrConst, MIL_DOUBLE Src3ImageBufIdOrConst, MIL_DOUBLE Src4Const, MIL_DOUBLE Src5Const, MIL_ID DstImageBufId, MIL_INT64 Operation, MIL_INT64 OperationFlag); MIL_DLLFUNC void MFTYPE MimLutMap (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID LutBufId); MIL_DLLFUNC void MFTYPE MimShift (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbBitsToShift); MIL_DLLFUNC MIL_INT MFTYPE MimBinarizeDouble (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ConditionAndThreshMode, MIL_DOUBLE LowParam, MIL_DOUBLE HighParam); MIL_DLLFUNC void MFTYPE MimClipDouble (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh, MIL_DOUBLE WriteLow, MIL_DOUBLE WriteHigh); MIL_DLLFUNC void MFTYPE MimFlatField (MIL_ID FlatFieldContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* NEIGHBOURHOOD : */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimDeinterlace (MIL_ID DeinterlaceContextImId, const MIL_ID *SrcImageArrayPtr, const MIL_ID *DstImageArrayPtr, MIL_INT SrcImageCount, MIL_INT DstImageCount, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* GEOMETRICAL: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimResize (MIL_ID SrcImageBufId, MIL_ID DstImageOrArrayBufId, MIL_DOUBLE ScaleFactorX, MIL_DOUBLE ScaleFactorY, MIL_INT64 InterpolationMode); MIL_DLLFUNC void MFTYPE MimRotate (MIL_ID SrcImageBufId, MIL_ID DstImageOrArrayBufId, MIL_DOUBLE Angle, MIL_DOUBLE SrcCenX, MIL_DOUBLE SrcCenY, MIL_DOUBLE DstCenX, MIL_DOUBLE DstCenY, MIL_INT64 InterpolationMode); MIL_DLLFUNC void MFTYPE MimFlip (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 Operation, MIL_INT64 OpFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* STATISTICAL: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimHistogram (MIL_ID SrcImageBufId, MIL_ID HistResultImId); MIL_DLLFUNC void MFTYPE MimHistogramEqualizeDouble(MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 Operation, MIL_DOUBLE Alpha, MIL_DOUBLE Min, MIL_DOUBLE Max); MIL_DLLFUNC void MFTYPE MimFindExtreme (MIL_ID SrcImageBufId, MIL_ID ExtremeResultImId, MIL_INT64 ExtremeType); MIL_DLLFUNC MIL_ID MFTYPE MimAllocResult (MIL_ID SysId, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_ID* ResultImIdPtr); MIL_DLLFUNC void MFTYPE MimFree (MIL_ID ContextOrResultImId); MIL_DLLFUNC MIL_INT MFTYPE MimInquire (MIL_ID ContextOrResultImId, MIL_INT64 InquireType, void* UserVarPtr); MIL_DLLFUNC void MFTYPE MimGetResult2d (MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, void* UserArrayPtr); MIL_DLLFUNC void MFTYPE MimGetResult1d (MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, void* UserArrayPtr); MIL_DLLFUNC void MFTYPE MimGetResult (MIL_ID ResultImId, MIL_INT64 ResultType, void* UserArrayPtr); /* */ MIL_DLLFUNC void MFTYPE MimGetResultSingleInt64 (MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, void* UserArrayPtr); MIL_DLLFUNC MIL_ID MFTYPE MimAlloc (MIL_ID SysId, MIL_INT64 ContextType, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr); #if M_MIL_USE_64BIT // Prototypes for 64 bits OSs MIL_DLLFUNC void MFTYPE MimControlInt64 (MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_INT64 ControlValue); MIL_DLLFUNC void MFTYPE MimControlDouble (MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_DOUBLE ControlValue); #else // Prototypes for 32 bits OSs #define MimControlDouble MimControl #define MimControlInt64 MimControl MIL_DLLFUNC void MFTYPE MimControl (MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_DOUBLE ControlValue); #endif MIL_DLLFUNC MIL_INT MFTYPE MimGet (MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, void * Param1Ptr, void * Param2Ptr, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimPut (MIL_ID ContextImId, MIL_INT64 PutType, MIL_INT ArraySize, const void *Param1Ptr, const void *Param2Ptr, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* CONVERSION: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimConvert (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID ArrayBufIdOrConversionType); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* BUF: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimRearrange (MIL_ID RearrangeContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); #if M_MIL_USE_UNICODE MIL_DLLFUNC MIL_ID MFTYPE MimRestoreA (MIL_CONST_TEXTA_PTR FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr); MIL_DLLFUNC void MFTYPE MimSaveA (MIL_CONST_TEXTA_PTR FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimStreamA (MIL_TEXTA_PTR MemPtrOrFileName, MIL_ID SysId, MIL_INT64 Operation, MIL_INT64 StreamType, MIL_DOUBLE Version, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr, MIL_INT* SizeByteVarPtr); MIL_DLLFUNC MIL_ID MFTYPE MimRestoreW (MIL_CONST_TEXTW_PTR FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID *ContextImIdPtr); MIL_DLLFUNC void MFTYPE MimSaveW (MIL_CONST_TEXTW_PTR FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimStreamW (MIL_TEXTW_PTR MemPtrOrFileName, MIL_ID SysId, MIL_INT64 Operation, MIL_INT64 StreamType, MIL_DOUBLE Version, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr, MIL_INT* SizeByteVarPtr); #if M_MIL_UNICODE_API #define MimRestore MimRestoreW #define MimSave MimSaveW #define MimStream MimStreamW #else #define MimRestore MimRestoreA #define MimSave MimSaveA #define MimStream MimStreamA #endif #else MIL_DLLFUNC MIL_ID MFTYPE MimRestore (MIL_CONST_TEXT_PTR FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID *ContextImIdPtr); MIL_DLLFUNC void MFTYPE MimSave (MIL_CONST_TEXT_PTR FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimStream (MIL_TEXT_PTR MemPtrOrFileName, MIL_ID SysId, MIL_INT64 Operation, MIL_INT64 StreamType, MIL_DOUBLE Version, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr, MIL_INT* SizeByteVarPtr); #endif //#if M_MIL_USE_UNICODE #if (!M_MIL_LITE) /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* NEIGHBOURHOOD : */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimConvolve (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID FilterContextImOrKernelBufId); MIL_DLLFUNC void MFTYPE MimRank (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID StructElemBufId, MIL_INT Rank, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimEdgeDetectMIL_INT (MIL_ID SrcImageBufId, MIL_ID DstIntensityImageBufId, MIL_ID DstAngleImageBufId, MIL_ID KernelId, MIL_INT64 ControlFlag, MIL_INT Threshold); MIL_DLLFUNC void MFTYPE MimMatch (MIL_ID MatchContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimBinarizeAdaptive ( MIL_ID AdaptiveBinarizeContextImId, MIL_ID SrcImageBufId, MIL_ID SeedImage1BufId, MIL_ID SeedImage2BufId, MIL_ID BinarizedImageBufId, MIL_ID ThresholdImageBufId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimAugment(MIL_ID AugmentationContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufOrAugmentationResultImId, MIL_INT64 SeedValue, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimFilterAdaptive(MIL_ID AdaptiveFilterContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_DOUBLE Param1, MIL_DOUBLE Param2, MIL_DOUBLE Param3, MIL_INT64 ControlFlag ); MIL_DLLFUNC void MFTYPE MimDifferential(MIL_ID Drv1ImageBufIdOrFilterContextImId, MIL_ID SrcOrDrv2ImageBufId, MIL_ID SrcOrDrv3ImageBufId, MIL_ID Drv4ImageBufId, MIL_ID Drv5ImageBufId, MIL_ID Dst1ImageBufId, MIL_ID Dst2ImageBufId, MIL_DOUBLE Param, MIL_INT64 Operation, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* MORPHOLOGICAL: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimLabel (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimConnectMap (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID LutBufId); MIL_DLLFUNC void MFTYPE MimDilate (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimErode (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimClose (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimOpen (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimMorphic (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID StructElemBufId, MIL_INT64 Operation, MIL_INT NbIterationOrArea, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimThin (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimThick (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT NbIteration, MIL_INT64 ProcMode); MIL_DLLFUNC void MFTYPE MimDistance (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 DistanceTransform); MIL_DLLFUNC void MFTYPE MimWatershed (MIL_ID SrcImageBufId, MIL_ID MarkerImageBufId, MIL_ID DstImageBufId, MIL_INT MinVariation, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimZoneOfInfluence (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 OperationFlag); MIL_DLLFUNC void MFTYPE MimDeadPixelCorrection(MIL_ID DeadPixelContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* GEOMETRICAL: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimTranslate (MIL_ID SrcImageBufId, MIL_ID DstImageOrArrayBufId, MIL_DOUBLE DisplacementX, MIL_DOUBLE DisplacementY, MIL_INT64 InterpolationMode); MIL_DLLFUNC void MFTYPE MimWarp (MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_ID WarpParam1BufId, MIL_ID WarpParam2BufId, MIL_INT64 OperationMode, MIL_INT64 InterpolationMode); MIL_DLLFUNC void MFTYPE MimWarpList(MIL_ID WarpParamBufId, MIL_INT64 TransformType, MIL_INT NumPoints, const MIL_DOUBLE* SrcCoordXArrayPtr, const MIL_DOUBLE* SrcCoordYArrayPtr, MIL_DOUBLE* DstCoordXArrayPtr, MIL_DOUBLE* DstCoordYArrayPtr, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimPolarTransform (MIL_ID SrcImageOrDstXLutBufId, MIL_ID DstImageOrYLutBufId, MIL_DOUBLE CenterPosX, MIL_DOUBLE CenterPosY, MIL_DOUBLE StartRadius, MIL_DOUBLE EndRadius, MIL_DOUBLE StartAngle, MIL_DOUBLE EndAngle, MIL_INT64 OperationMode, MIL_INT64 InterpolationMode, MIL_DOUBLE *DstSizeXPtr, MIL_DOUBLE *DstSizeYPtr); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* STATISTICAL: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimBoundingBox(MIL_ID SrcImageBufId, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh, MIL_INT64 BoxDefinitionType, MIL_INT* TopLeftX, MIL_INT* TopLeftY, MIL_INT* BottomRightX, MIL_INT* BottomRightY, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimProject (MIL_ID SrcImageBufId, MIL_ID ProjResultImId, MIL_DOUBLE ProjectionAngle); #if M_MILIM_FUNCTION_DEPRECATION_WARNING MIL_DEPRECATED(MimProject, 1060) // Use MimProjection instead. #endif MIL_DLLFUNC void MFTYPE MimProjection(MIL_ID SrcImageBufId, MIL_ID DstImageBufOrResultImId, MIL_DOUBLE ProjectionAxisAngle, MIL_INT64 Operation, MIL_DOUBLE OperationValue); #if M_MIL_USE_64BIT #define MimStat(Src, Result, Type, Condition, CondLow, CondHigh) MimStatDouble(Src, Result, Type, Condition, M_MILID_TO_DOUBLE(CondLow), CondHigh) #else #define MimStatDouble MimStat #endif MIL_DLLFUNC void MFTYPE MimStatDouble (MIL_ID SrcImageBufId, MIL_ID StatResultImId, MIL_INT64 StatType, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh); #if M_MILIM_FUNCTION_DEPRECATION_WARNING MIL_DEPRECATED(MimStat, 1060) // Use MimStatCalculate instead. #endif MIL_DLLFUNC void MFTYPE MimStatMultiple (MIL_ID StatMultipleContextImId, MIL_ID SrcImageBufId, MIL_ID StatMultipleResultImId, MIL_INT64 ControlFlag); #if M_MILIM_FUNCTION_DEPRECATION_WARNING MIL_DEPRECATED(MimStatMultiple, 1060) // Use MimStatCalculate instead. #endif MIL_DLLFUNC MIL_INT MFTYPE MimLocateEventDouble (MIL_ID SrcImageBufId, MIL_ID EventResultImId, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh); MIL_DLLFUNC void MFTYPE MimLocatePeak1dDouble(MIL_ID ContextId, MIL_ID SrcImageBufId, MIL_ID ResultId, MIL_INT PeakWidthNominal, MIL_INT PeakWidthDelta, MIL_DOUBLE MinContrast, MIL_INT64 ControlFlag, MIL_DOUBLE ControlValue); MIL_DLLFUNC MIL_INT MFTYPE MimCountDifference (MIL_ID Src1ImageBufId, MIL_ID Src2ImageBufId, MIL_ID CountResultImId); MIL_DLLFUNC void MFTYPE MimHistogramEqualizeAdaptive(MIL_ID AdaptiveEqualizeContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimFindOrientation(MIL_ID OrientationContextImId, MIL_ID SrcImageBufId, MIL_ID OrientationResultImId, MIL_INT64 ControlFlag); MIL_DLLFUNC void MFTYPE MimStatCalculate(MIL_ID StatContextImId, MIL_ID SrcImageBufId, MIL_ID StatResultImId, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* REMAPPING: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimRemap(MIL_ID RemapContextImId, MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* TRANSFORM: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimTransform (MIL_ID SrcImageRBufId, MIL_ID SrcImageIBufId, MIL_ID DstImageRBufId, MIL_ID DstImageIBufId, MIL_INT64 TransformType, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* WAVELET TRANSFORM: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimWaveletTransform (MIL_ID WaveletContextImId, MIL_ID SrcImageBufOrWaveletResultImId, MIL_ID DstImageBufOrWaveletResultImId, MIL_INT64 TransformType, MIL_INT Level, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* WAVELET DENOISE: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimWaveletDenoise (MIL_ID WaveletContextImId, MIL_ID SrcImageBufOrWaveletResultImId, MIL_ID DstImageBufOrWaveletResultImId, MIL_INT Level, MIL_ID DenoisingType, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* SET FILTER FOR WAVELET TRANSFORM: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimWaveletSetFilter (MIL_ID WaveletContextImId, MIL_ID LowForwardRealFilterId, MIL_ID HighForwardRealFilterId, MIL_ID LowReverseRealFilterId, MIL_ID HighReverseRealFilterId, MIL_ID LowForwardImaginaryFilterId, MIL_ID HighForwardImaginaryFilterId, MIL_ID LowReverseImaginaryFilterId, MIL_ID HighReverseImaginaryFilterId, MIL_INT64 ControlFlag); /* -------------------------------------------------------------- */ /* -------------------------------------------------------------- */ /* DRAW: */ /* -------------------------------------------------------------- */ MIL_DLLFUNC void MFTYPE MimDrawDouble (MIL_ID ContextGraId, MIL_ID Src1MilId, MIL_ID Src2MilId, MIL_ID DstImageBufOrListGraId, MIL_INT64 Operation, MIL_DOUBLE Param1, MIL_DOUBLE Param2, MIL_INT64 ControlFlag); #endif // (!MIL_LITE) #ifdef __cplusplus } // extern "C" #endif #ifdef __cplusplus inline void MFTYPE MimStreamCpp(MilStreamParam MemPtrOrFileName, MIL_ID SysId, MIL_INT64 Operation, MIL_INT64 StreamType, MIL_DOUBLE Version, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr, MIL_INT* SizeByteVarPtr) { MimStream(MemPtrOrFileName.m_Param, SysId, Operation, StreamType, Version, ControlFlag, ContextImIdPtr, SizeByteVarPtr); } #undef MimStream #define MimStream MimStreamCpp #endif // __cplusplus #ifdef __cplusplus inline bool M_IN_IM_INQUIRE_DOUBLE_RANGE(MIL_ID ContextOrResultId, MIL_INT64 InquireType) { if(M_NB_ELEMENTS_BIT_SET(InquireType)) { return false; } switch (InquireType & M_MASK_MIM_INQUIRE_TYPE) { case M_FILTER_SMOOTHNESS: // case M_MODEL_IMAGE_TYPE: { MIL_INT ContextType = MimInquire(ContextOrResultId, M_INTERNAL_CONTEXT_TYPE, M_NULL); if (ContextType == M_LINEAR_FILTER_IIR_CONTEXT) { return true; } return false; // if (ContextType == M_MATCH_CONTEXT) } case M_DARK_CONST: case M_OFFSET_CONST: case M_FLAT_CONST: case M_GAIN_CONST: case M_EFFECTIVE_GAIN_CONST: case M_MAX_SCORE: case M_CLIP_LIMIT: case M_ALPHA_VALUE: case M_FREQUENCY_CUTOFF_RATIO_HIGH: case M_FREQUENCY_CUTOFF_RATIO_LOW: case M_MINIMUM_CONTRAST: case M_GLOBAL_MAX: case M_GLOBAL_MIN: case M_NIBLACK_BIAS: case M_GLOBAL_OFFSET: case M_NIBLACK_BIAS_SECOND_PASS: case M_GLOBAL_OFFSET_SECOND_PASS: case M_COND_HIGH: case M_COND_LOW: case M_FILTER_ASPECT_RATIO: case M_FILTER_DEFAULT_SHARPEN_PARAM: case M_AUG_ROTATION_OP_ANGLE_MAX: case M_AUG_ROTATION_OP_ANGLE_REF: case M_AUG_ROTATION_OP_ANGLE_DELTA: case M_AUG_ROTATION_OP_ANGLE_STEP: case M_AUG_TRANSLATION_X_OP_MAX: case M_AUG_TRANSLATION_Y_OP_MAX: case M_AUG_SCALE_OP_FACTOR_MIN: case M_AUG_SCALE_OP_FACTOR_MAX: case M_AUG_ASPECT_RATIO_OP_MIN: case M_AUG_ASPECT_RATIO_OP_MAX: case M_AUG_CROP_OP_FACTOR_X: case M_AUG_CROP_OP_FACTOR_Y: case M_AUG_SHEAR_X_OP_MIN: case M_AUG_SHEAR_X_OP_MAX: case M_AUG_SHEAR_Y_OP_MIN: case M_AUG_SHEAR_Y_OP_MAX: case M_AUG_LIGHTING_DIRECTIONAL_OP_INTENSITY_MAX: case M_AUG_LIGHTING_DIRECTIONAL_OP_INTENSITY_MIN: case M_AUG_LIGHTING_DIRECTIONAL_OP_ANGLE_MAX: case M_AUG_SATURATION_GAIN_OP_MIN: case M_AUG_SATURATION_GAIN_OP_MAX: case M_AUG_HSV_VALUE_GAIN_OP_MIN: case M_AUG_HSV_VALUE_GAIN_OP_MAX: case M_AUG_HUE_OFFSET_OP_MIN: case M_AUG_HUE_OFFSET_OP_MAX: case M_AUG_SMOOTH_DERICHE_OP_FACTOR_MIN: case M_AUG_SMOOTH_DERICHE_OP_FACTOR_MAX: case M_AUG_BLUR_MOTION_OP_ANGLE_MIN: case M_AUG_BLUR_MOTION_OP_ANGLE_MAX: case M_AUG_SHARPEN_DERICHE_OP_FACTOR_MIN: case M_AUG_SHARPEN_DERICHE_OP_FACTOR_MAX: case M_AUG_SMOOTH_GAUSSIAN_OP_STDDEV_MAX: case M_AUG_SMOOTH_GAUSSIAN_OP_STDDEV_MIN: case M_AUG_NOISE_SALT_PEPPER_OP_DENSITY: case M_AUG_NOISE_SALT_PEPPER_OP_DENSITY_DELTA: case M_AUG_NOISE_MULTIPLICATIVE_OP_STDDEV: case M_AUG_NOISE_MULTIPLICATIVE_OP_STDDEV_DELTA: case M_AUG_NOISE_MULTIPLICATIVE_OP_INTENSITY_MIN: case M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP_STDDEV: case M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP_STDDEV_DELTA: case M_AUG_INTENSITY_MULTIPLY_OP_DELTA: case M_AUG_INTENSITY_ADD_OP_DELTA: case M_GAMMA: case M_AUG_GAMMA_OP_DELTA: case M_AUG_DILATION_OP + M_PROBABILITY: case M_AUG_EROSION_OP + M_PROBABILITY: case M_AUG_DILATION_ASYM_OP + M_PROBABILITY: case M_AUG_EROSION_ASYM_OP + M_PROBABILITY: case M_AUG_FLIP_OP + M_PROBABILITY: case M_AUG_CROP_OP + M_PROBABILITY: case M_AUG_ROTATION_OP + M_PROBABILITY: case M_AUG_SCALE_OP + M_PROBABILITY: case M_AUG_TRANSLATION_X_OP + M_PROBABILITY: case M_AUG_TRANSLATION_Y_OP + M_PROBABILITY: case M_AUG_ASPECT_RATIO_OP + M_PROBABILITY: case M_AUG_SHEAR_X_OP + M_PROBABILITY: case M_AUG_SHEAR_Y_OP + M_PROBABILITY: case M_AUG_INTENSITY_MULTIPLY_OP + M_PROBABILITY: case M_AUG_INTENSITY_ADD_OP + M_PROBABILITY: case M_AUG_GAMMA_OP + M_PROBABILITY: case M_AUG_LIGHTING_DIRECTIONAL_OP + M_PROBABILITY: case M_AUG_SATURATION_GAIN_OP + M_PROBABILITY: case M_AUG_HUE_OFFSET_OP + M_PROBABILITY: case M_AUG_HSV_VALUE_GAIN_OP + M_PROBABILITY: case M_AUG_SMOOTH_DERICHE_OP + M_PROBABILITY: case M_AUG_SMOOTH_GAUSSIAN_OP + M_PROBABILITY: case M_AUG_BLUR_MOTION_OP + M_PROBABILITY: case M_AUG_SHARPEN_DERICHE_OP + M_PROBABILITY: case M_AUG_NOISE_GAUSSIAN_ADDITIVE_OP + M_PROBABILITY: case M_AUG_NOISE_MULTIPLICATIVE_OP + M_PROBABILITY: case M_AUG_NOISE_SALT_PEPPER_OP + M_PROBABILITY: { return true; } default: { break; } } return false; } inline bool M_IN_IM_INQUIRE_MIL_INT64_RANGE(MIL_ID ContextOrResultId, MIL_INT64 InquireType) { UNREFERENCED_PARAMETER(ContextOrResultId); if(M_NB_ELEMENTS_BIT_SET(InquireType)) { return false; } switch (InquireType & M_MASK_MIM_INQUIRE_TYPE) { case M_EXTENDED_CONTEXT_TYPE_DEPRECATED: case M_EXTENDED_RESULT_TYPE: case M_DEAD_PIXELS_IMAGE_ATTRIBUTE: case M_MODEL_IMAGE_ATTRIBUTE: case M_MASK_IMAGE_ATTRIBUTE: case M_ALLOCATED_TYPE: { return true; } default: { break; } } return false; } inline bool M_IM_INQUIRE_MUST_HAVE_USER_PTR(MIL_ID ContextOrResultId, MIL_INT64 InquireType) { #if M_MIL_USE_64BIT return M_IN_IM_INQUIRE_DOUBLE_RANGE(ContextOrResultId, InquireType); #else return (M_IN_IM_INQUIRE_DOUBLE_RANGE(ContextOrResultId, InquireType) || M_IN_IM_INQUIRE_MIL_INT64_RANGE(ContextOrResultId, InquireType)); #endif } #endif #if M_MIL_USE_64BIT #ifdef __cplusplus ////////////////////////////////////////////////////////////// // MbufControl function definition when compiling c++ files ////////////////////////////////////////////////////////////// #if !M_MIL_USE_LINUX inline void MimControl(MIL_ID ContextOrResultImId, MIL_INT64 ControlType, int ControlValue) { MimControlInt64(ContextOrResultImId, ControlType, ControlValue); }; #endif inline void MimControl(MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_INT32 ControlValue) { MimControlInt64(ContextOrResultImId, ControlType, ControlValue); } inline void MimControl(MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_INT64 ControlValue) { MimControlInt64(ContextOrResultImId, ControlType, ControlValue); } inline void MimControl(MIL_ID ContextOrResultImId, MIL_INT64 ControlType, MIL_DOUBLE ControlValue) { MimControlDouble(ContextOrResultImId, ControlType, ControlValue); } #else ////////////////////////////////////////////////////////////// // For C file, call the default function, i.e. Int64 one ////////////////////////////////////////////////////////////// #define MimControl MimControlInt64 #endif // __cplusplus #endif // M_MIL_USE_64BIT #if(defined(__cplusplus)) ////////////////////////////////////////////////////////////// // MbufBinarize function definition when compiling c++ files ////////////////////////////////////////////////////////////// inline MIL_INT MFTYPE MimBinarize(MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 ConditionAndThreshMode, MIL_DOUBLE LowParam, MIL_DOUBLE HighParam) { return MimBinarizeDouble(SrcImageBufId, DstImageBufId, ConditionAndThreshMode, LowParam, HighParam); } inline void MFTYPE MimClip(MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh, MIL_DOUBLE WriteLow, MIL_DOUBLE WriteHigh) { MimClipDouble(SrcImageBufId, DstImageBufId, Condition, CondLow, CondHigh, WriteLow, WriteHigh); } inline void MFTYPE MimHistogramEqualize(MIL_ID SrcImageBufId, MIL_ID DstImageBufId, MIL_INT64 EqualizationType, MIL_DOUBLE Alpha, MIL_DOUBLE Min, MIL_DOUBLE Max) { MimHistogramEqualizeDouble(SrcImageBufId, DstImageBufId, EqualizationType, Alpha, Min, Max); } #if (!M_MIL_LITE) inline void MFTYPE MimDraw(MIL_ID ContextGraId, MIL_ID Src1MilId, MIL_ID Src2MilId, MIL_ID DstImageBufOrListGraId, MIL_INT64 Operation, MIL_DOUBLE Param1, MIL_DOUBLE Param2, MIL_INT64 ControlFlag) { MimDrawDouble(ContextGraId, Src1MilId, Src2MilId, DstImageBufOrListGraId, Operation, Param1, Param2, ControlFlag); } inline void MFTYPE MimEdgeDetect(MIL_ID SrcImageBufId, MIL_ID DstIntensityImageBufId, MIL_ID DstAngleImageBufId, MIL_ID KernelId, MIL_INT64 ControlFlag, MIL_INT Threshold) { MimEdgeDetectMIL_INT(SrcImageBufId, DstIntensityImageBufId, DstAngleImageBufId, KernelId, ControlFlag, Threshold); } inline MIL_INT MFTYPE MimLocateEvent(MIL_ID SrcImageBufId, MIL_ID EventResultImId, MIL_INT64 Condition, MIL_DOUBLE CondLow, MIL_DOUBLE CondHigh) { return MimLocateEventDouble(SrcImageBufId, EventResultImId, Condition, CondLow, CondHigh); } inline void MFTYPE MimLocatePeak1d(MIL_ID ContextId, MIL_ID SrcImageBufId, MIL_ID ResultId, MIL_INT PeakWidthNominal, MIL_INT PeakWidthDelta, MIL_DOUBLE MinContrast, MIL_INT64 ControlFlag, MIL_DOUBLE ControlValue) { MimLocatePeak1dDouble(ContextId, SrcImageBufId, ResultId, PeakWidthNominal, PeakWidthDelta, MinContrast, ControlFlag, ControlValue); } #endif #else //#if(!defined(__cplusplus)) #define MimBinarize MimBinarizeDouble #define MimClip MimClipDouble #define MimHistogramEqualize MimHistogramEqualizeDouble #if (!M_MIL_LITE) #define MimDraw MimDrawDouble #define MimEdgeDetect MimEdgeDetectMIL_INT #define MimLocateEvent MimLocateEventDouble #define MimLocatePeak1d MimLocatePeak1dDouble #endif #endif //#if(defined(__cplusplus)) #define MimGetResultSingle MimGetResultSingleInt64 #if M_MIL_USE_SAFE_TYPE ////////////////////////////////////////////////////////////// // See milos.h for explanation about these functions. ////////////////////////////////////////////////////////////// //------------------------------------------------------------------------------------- // MimGetResult inline void MFTYPE MimGetResultUnsafe (MIL_ID ResultImId, MIL_INT64 ResultType, void *UserArrayPtr); inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, int UserArrayPtr); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, std::nullptr_t ); #endif inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr); inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr); inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, float *UserArrayPtr); inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr); inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr); #endif //------------------------------------------------------------------------------------- // MimGetResult1d inline void MFTYPE MimGetResult1dUnsafe (MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, void *UserArrayPtr); inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, int UserArrayPtr); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, std::nullptr_t ); #endif inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr); inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr); inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, float *UserArrayPtr); inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr); inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr); #endif //------------------------------------------------------------------------------------- // MimGetResult2d inline void MFTYPE MimGetResult2dUnsafe (MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, void *UserArrayPtr); inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, int UserArrayPtr); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, std::nullptr_t ); #endif inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_INT32 *UserArrayPtr); inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_INT64 *UserArrayPtr); inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, float *UserArrayPtr); inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_DOUBLE *UserArrayPtr); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_UINT32 *UserArrayPtr); inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_UINT64 *UserArrayPtr); #endif //------------------------------------------------------------------------------------- // MimGetResultSingle inline void MFTYPE MimGetResultSingleUnsafe (MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, void *UserArrayPtr); inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, int UserArrayPtr); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, std::nullptr_t ); #endif inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr); inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr); inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, float *UserArrayPtr); inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr); inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr); #endif //#if(defined(__cplusplus)) //------------------------------------------------------------------------------------- // MimGet inline MIL_INT MFTYPE MimGetUnsafe (MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, void *Param1Ptr, void *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, int *Param1Ptr, int *Param2Ptr, MIL_INT64 ControlFlag); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, std::nullptr_t , std::nullptr_t , MIL_INT64 ControlFlag); #endif inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_INT32 *Param1Ptr, MIL_INT32 *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_INT64 *Param1Ptr, MIL_INT64 *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, float *Param1Ptr, float *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_DOUBLE *Param1Ptr, MIL_DOUBLE *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, char *Param1Ptr, char *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, short *Param1Ptr, short *Param2Ptr, MIL_INT64 ControlFlag); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT32 *Param1Ptr, MIL_UINT32 *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT64 *Param1Ptr, MIL_UINT64 *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT8 *Param1Ptr, MIL_UINT8 *Param2Ptr, MIL_INT64 ControlFlag); inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT16 *Param1Ptr, MIL_UINT16 *Param2Ptr, MIL_INT64 ControlFlag); #endif // ---------------------------------------------------------- // MimInquire inline MIL_INT MFTYPE MimInquireUnsafe (MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, void * ValuePtr); inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, int ValuePtr); #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, std::nullptr_t ); #endif inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, MIL_INT32 * ValuePtr); inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, MIL_INT64 * ValuePtr); inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, MIL_DOUBLE * ValuePtr); #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, MIL_UINT32 * ValuePtr); inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultImId, MIL_INT64 ParamToInquire, MIL_UINT64 * ValuePtr); #endif // ------------------------------------------------------------------------- // MimGetResult inline MIL_INT64 RequiredTypeFromBufType(MIL_ID ResultImId) { MIL_INT Type = MbufInquire(ResultImId, M_TYPE, M_NULL); if (Type == 32+M_FLOAT) { return M_TYPE_FLOAT; } else if (Type == 64+M_FLOAT) { return M_TYPE_DOUBLE; } return M_TYPE_MIL_INT; } inline bool IsAugmentResult(MIL_INT64 ResultType, MIL_INT64* ResultDataType) { bool bAskAvailable = (ResultType & M_AVAILABLE) == M_AVAILABLE; MIL_INT64 ResultTypeStripped = ResultType & ~M_AVAILABLE; bool bIsAugmentResultType = false; switch(ResultTypeStripped) { case M_AUG_DILATION_NB_ITERATIONS: case M_AUG_EROSION_NB_ITERATIONS: case M_AUG_DILATION_ASYM_NB_ITERATIONS: case M_AUG_DILATION_ASYM_SUBAREA: case M_AUG_EROSION_ASYM_NB_ITERATIONS: case M_AUG_EROSION_ASYM_SUBAREA: case M_AUG_FLIP_DIRECTION: case M_AUG_CROP_TOP_LEFT_X: case M_AUG_CROP_TOP_LEFT_Y: case M_AUG_CROP_BOTTOM_RIGHT_X: case M_AUG_CROP_BOTTOM_RIGHT_Y: case M_AUG_ROTATION_ANGLE: case M_AUG_SCALE_FACTOR: case M_AUG_TRANSLATION_X: case M_AUG_TRANSLATION_Y: case M_AUG_ASPECT_RATIO: case M_AUG_ASPECT_RATIO_MODE: case M_AUG_SHEAR_X: case M_AUG_SHEAR_Y: case M_AUG_INTENSITY_MULTIPLY_VALUE: case M_AUG_INTENSITY_ADD_VALUE: case M_AUG_GAMMA_VALUE_BAND_0: case M_AUG_GAMMA_VALUE_BAND_1: case M_AUG_GAMMA_VALUE_BAND_2: case M_AUG_LIGHTING_DIRECTIONAL_ANGLE: case M_AUG_SATURATION_GAIN: case M_AUG_HUE_OFFSET: case M_AUG_HSV_VALUE_GAIN: case M_AUG_SMOOTH_DERICHE_VALUE: case M_AUG_SMOOTH_GAUSSIAN_STDDEV: case M_AUG_BLUR_MOTION_SIZE: case M_AUG_BLUR_MOTION_ANGLE: case M_AUG_SHARPEN_DERICHE_VALUE: case M_AUG_NOISE_GAUSSIAN_ADDITIVE_STDDEV: case M_AUG_NOISE_MULTIPLICATIVE_STDDEV: case M_AUG_NOISE_SALT_PEPPER_DENSITY: case M_AUG_OPTIMAL_SIZE_X: case M_AUG_OPTIMAL_SIZE_Y: case M_AUG_SEED_USED: case M_AUG_REVERSE_TRANSFORMATION_MATRIX: case M_AUG_OPERATIONS_ENABLED: case M_AUG_OPERATIONS_APPLIED: case M_AUG_OPERATION_RESULT_TYPES: case M_AUG_OPERATION_ASSOCIATED_WITH_RESULT_TYPES: *ResultDataType = M_TYPE_MIL_DOUBLE; bIsAugmentResultType = true; break; default: bIsAugmentResultType = false; break; } if(bIsAugmentResultType) { if(bAskAvailable) *ResultDataType = M_TYPE_MIL_INT; return true; } else return false; } inline MIL_INT64 MimGetResultRequiredType(MIL_ID ResultImId, MIL_INT64 ResultType) { /* MimAugment Result specific (include M_AVAILABLE) which is not available for other M_IM_RESULT */ MIL_INT64 AugmentResultDataType; if(IsAugmentResult(ResultType, &AugmentResultDataType)) return AugmentResultDataType; /* Other M_IM_RESULT*/ switch (ResultType) { case M_NB_EVENT: case M_POSITION_X: case M_POSITION_Y: { // For these results, the doc specifies that MIL_INT is returned // except when allocated with 32+M_FLOAT, where a float is returned. return RequiredTypeFromBufType(ResultImId); } break; case M_VALUE: { // For M_VALUE, the doc specifies that MIL_INT is returned // except for M_PROJ_LIST, M_EXTREME_LIST, M_EVENT_LIST // allocated with 32+M_FLOAT, where a float is returned. MIL_INT64 IdResultType = 0; MimInquire(ResultImId, M_EXTENDED_RESULT_TYPE, &IdResultType); switch (IdResultType) { case M_PROJ_LIST: case M_EXTREME_LIST: case M_EVENT_LIST: { return RequiredTypeFromBufType(ResultImId); } break; default: return M_TYPE_MIL_INT; break; } } break; case M_ANGLE: case M_SCORE: { MIL_INT64 IdResultType = 0; MimInquire(ResultImId, M_EXTENDED_RESULT_TYPE, &IdResultType); switch (IdResultType) { case M_FIND_ORIENTATION_LIST: { return RequiredTypeFromBufType(ResultImId); } break; default: return M_TYPE_MIL_INT; break; } } break; case M_VALUE+M_PERCENTAGE: case M_CUMULATIVE_VALUE+M_PERCENTAGE: case M_PERCENTILE_VALUE: case M_NUMBER_OF_LEVELS: case M_TRANSFORMATION_MODE: case M_WAVELET_TYPE: case M_WAVELET_SIZE: case M_WAVELET_DRAW_SIZE_X: case M_WAVELET_DRAW_SIZE_Y: case M_WAVELET_DRAW_SIZE_X_WITH_PADDING: case M_WAVELET_DRAW_SIZE_Y_WITH_PADDING: case M_TRANSFORMATION_DOMAIN: case M_HIST_VALUE_OFFSET: case M_HIST_VALUE_RANGE: case M_HIST_REAL_SIZE: case M_ORIGINAL_IMAGE_SIZE_X: case M_ORIGINAL_IMAGE_SIZE_Y: return M_TYPE_MIL_INT; break; case M_CUMULATIVE_VALUE: /* case M_VALID: */ { MIL_INT64 IdResultType = 0; MimInquire(ResultImId, M_EXTENDED_RESULT_TYPE, &IdResultType); switch (IdResultType) { case M_PROJ_LIST: { return RequiredTypeFromBufType(ResultImId); break; } default: { return M_TYPE_MIL_INT; break; } } break; } case M_WAVELET_COEFFICIENTS_IMAGE_ID: case M_WAVELET_COEFFICIENTS_IMAGE_ID + M_REAL_PART: case M_WAVELET_COEFFICIENTS_IMAGE_ID + M_IMAGINARY_PART: return M_TYPE_MIL_ID; break; case M_WAVELET_LEVEL_SIZE_X: case M_WAVELET_LEVEL_SIZE_Y: case M_WAVELET_LEVEL_PADDING_OFFSET_X: case M_WAVELET_LEVEL_PADDING_OFFSET_Y: return M_TYPE_DOUBLE; break; case M_ASSOCIATED_CONTEXT_TYPE: return M_TYPE_MIL_INT; break; default: { MIL_INT64 IdResultType = 0; MimInquire(ResultImId, M_EXTENDED_RESULT_TYPE, &IdResultType); if (M_LOCATE_PEAK_1D_RESULT == IdResultType) return M_TYPE_MIL_INT; } return M_TYPE_DOUBLE; break; } } inline MIL_INT64 MimGetRequiredType(MIL_INT64 ResultType) { UNREFERENCED_PARAMETER(ResultType); return M_TYPE_MIL_INT; } inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, int UserArrayPtr) { if (UserArrayPtr) SafeTypeError(MIL_TEXT("MimGetResult")); MimGetResult(ResultImId, ResultType, NULL); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, std::nullptr_t) { MimGetResult(ResultImId, ResultType, NULL); } #endif inline void MimGetResultSafeTypeExecute (MIL_ID ResultImId, MIL_INT64 ResultType, void *UserArrayPtr, MIL_INT64 GivenType) { MIL_INT64 RequiredType = ExtractTypeFromValue(ResultType, M_TYPE_DOUBLE, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64, M_TYPE_FLOAT); if (RequiredType == 0) RequiredType = MimGetResultRequiredType(ResultImId, ResultType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimGetResult")); MimGetResult(ResultImId, ResultType, UserArrayPtr); } inline void MFTYPE MimGetResultUnsafe (MIL_ID ResultImId, MIL_INT64 ResultType, void *UserArrayPtr) {MimGetResult (ResultImId, ResultType, UserArrayPtr);} inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, float *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_FLOAT);} inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_DOUBLE);} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResultSafeType(MIL_ID ResultImId, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr) {MimGetResultSafeTypeExecute(ResultImId, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} #endif // ------------------------------------------------------------------------- // MimGetResult1d inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, int UserArrayPtr) { if (UserArrayPtr) SafeTypeError(MIL_TEXT("MimGetResult1d")); MimGetResult1d(ResultImId, OffEntry, NbEntries, ResultType, NULL); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, std::nullptr_t) { MimGetResult1d(ResultImId, OffEntry, NbEntries, ResultType, NULL); } #endif inline void MimGetResult1dSafeTypeExecute (MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, void *UserArrayPtr, MIL_INT64 GivenType) { MIL_INT64 RequiredType = ExtractTypeFromValue(ResultType, M_TYPE_DOUBLE, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64, M_TYPE_FLOAT); if (RequiredType == 0) RequiredType = MimGetResultRequiredType(ResultImId, ResultType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimGetResult1d")); MimGetResult1d(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr); } inline void MFTYPE MimGetResult1dUnsafe (MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, void *UserArrayPtr){MimGetResult1d (ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr);} inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, float *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_FLOAT);} inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_DOUBLE);} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResult1dSafeType(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr){MimGetResult1dSafeTypeExecute(ResultImId, OffEntry, NbEntries, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} #endif // ------------------------------------------------------------------------- // MimGetResult2d inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, int UserArrayPtr) { if(UserArrayPtr) SafeTypeError(MIL_TEXT("MimGetResult2d")); MimGetResult2d(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, NULL); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, std::nullptr_t) { MimGetResult2d(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, NULL); } #endif inline void MimGetResult2dSafeTypeExecute (MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, void *UserArrayPtr, MIL_INT64 GivenType) { MIL_INT64 RequiredType = ExtractTypeFromValue(ResultType, M_TYPE_DOUBLE, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64, M_TYPE_FLOAT); if (RequiredType == 0) RequiredType = MimGetResultRequiredType(ResultImId, ResultType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimGetResult2d")); MimGetResult2d(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr); } inline void MFTYPE MimGetResult2dUnsafe (MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, void *UserArrayPtr){MimGetResult2d (ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr);} inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_INT32 *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_INT64 *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_MIL_INT64);} inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, float *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_FLOAT);} inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_DOUBLE *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_DOUBLE);} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_UINT32 *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResult2dSafeType(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, MIL_UINT64 *UserArrayPtr){MimGetResult2dSafeTypeExecute(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, UserArrayPtr, M_TYPE_MIL_INT64);} #endif // ------------------------------------------------------------------------- // MimGetResultSingle inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, int UserArrayPtr) { if(UserArrayPtr) SafeTypeError(MIL_TEXT("MimGetResultSingle")); MimGetResultSingleInt64(ResultImId, Index1, Index2,ResultType, NULL); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, std::nullptr_t) { MimGetResultSingleInt64(ResultImId, Index1, Index2, ResultType, NULL); } #endif inline void MFTYPE MimGetResultSingleSafeTypeExecute (MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, void *UserArrayPtr, MIL_INT64 GivenType) { MIL_INT64 RequiredType = ExtractTypeFromValue(ResultType, M_TYPE_DOUBLE, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64, M_TYPE_FLOAT, M_TYPE_MIL_ID); if (RequiredType == 0) RequiredType = MimGetResultRequiredType(ResultImId, ResultType); ReplaceTypeMilIdByTypeMilIntXX(&RequiredType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimGetResultSingle")); MimGetResultSingleInt64(ResultImId, Index1, Index2, ResultType, UserArrayPtr); } inline void MFTYPE MimGetResultSingleUnsafe (MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, void *UserArrayPtr){MimGetResultSingleInt64 (ResultImId, Index1, Index2, ResultType, UserArrayPtr);} inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_INT32 *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_INT64 *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, float *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_FLOAT);} inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_DOUBLE *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_DOUBLE);} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_UINT32 *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_MIL_INT32);} inline void MFTYPE MimGetResultSingleSafeType(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, MIL_UINT64 *UserArrayPtr){MimGetResultSingleSafeTypeExecute(ResultImId, Index1, Index2, ResultType, UserArrayPtr, M_TYPE_MIL_INT64);} #endif // ------------------------------------------------------------------------- // MimGet inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, int Param1Ptr, int ParamPtr2, MIL_INT64 ControlFlag) { if(Param1Ptr) SafeTypeError(MIL_TEXT("MimGet")); if(ParamPtr2) SafeTypeError(MIL_TEXT("MimGet")); return MimGet(ContextImId, GetType, ArraySize, NULL, NULL, ControlFlag); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, std::nullptr_t, std::nullptr_t, MIL_INT64 ControlFlag) { return MimGet(ContextImId, GetType, ArraySize, NULL, NULL, ControlFlag); } #endif inline MIL_INT MimGetSafeTypeExecute (MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, void *Param1Ptr, void *ParamPtr2, MIL_INT64 ControlFlag, MIL_INT64 GivenType) { MIL_INT64 RequiredType = ExtractTypeFromValue(GetType, M_TYPE_DOUBLE, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64, M_TYPE_FLOAT, M_TYPE_MIL_ID, M_TYPE_CHAR, M_TYPE_SHORT); if (RequiredType == 0) RequiredType = MimGetRequiredType(GetType); ReplaceTypeMilIdByTypeMilIntXX(&RequiredType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimGet")); return MimGet(ContextImId, GetType, ArraySize, Param1Ptr, ParamPtr2, ControlFlag); } inline MIL_INT MFTYPE MimGetUnsafe (MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, void *Param1Ptr, void *Param2Ptr, MIL_INT64 ControlFlag){return MimGet (ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_INT32 *Param1Ptr, MIL_INT32 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_MIL_INT32);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_INT64 *Param1Ptr, MIL_INT64 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_MIL_INT64);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, float *Param1Ptr, float *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_FLOAT);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_DOUBLE *Param1Ptr, MIL_DOUBLE *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_DOUBLE);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, char *Param1Ptr, char *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_CHAR);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, short *Param1Ptr, short *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_SHORT);} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT32 *Param1Ptr, MIL_UINT32 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_MIL_INT32);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT64 *Param1Ptr, MIL_UINT64 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_MIL_INT64);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT8 *Param1Ptr, MIL_UINT8 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_CHAR);} inline MIL_INT MFTYPE MimGetSafeType(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, MIL_UINT16 *Param1Ptr, MIL_UINT16 *Param2Ptr, MIL_INT64 ControlFlag){return MimGetSafeTypeExecute(ContextImId, GetType, ArraySize, Param1Ptr, Param2Ptr, ControlFlag, M_TYPE_SHORT);} #endif // ---------------------------------------------------------- // MimInquire inline MIL_INT64 MimInquireRequiredType(MIL_ID ContextOrResultId, MIL_INT64 InquireType) { MIL_INT64 DataType = ExtractTypeFromValue(InquireType, M_TYPE_DOUBLE, M_TYPE_MIL_ID, M_TYPE_MIL_INT32, M_TYPE_MIL_INT64); if (DataType) return DataType; if (M_IN_IM_INQUIRE_DOUBLE_RANGE(ContextOrResultId, InquireType)) return M_TYPE_DOUBLE; if (M_IN_IM_INQUIRE_MIL_INT64_RANGE(ContextOrResultId, InquireType)) return M_TYPE_MIL_INT64; return M_TYPE_MIL_INT; } inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, int UserVarPtr) { bool MustHaveUserPointer = M_IM_INQUIRE_MUST_HAVE_USER_PTR(ContextOrResultId, InquireType); if (UserVarPtr || MustHaveUserPointer) SafeTypeError(MIL_TEXT("MimInquire")); return MimInquire(ContextOrResultId, InquireType, NULL); } #if M_MIL_SAFE_TYPE_M_NULL_PTR_TYPE_EXISTS inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, std::nullptr_t) { bool MustHaveUserPointer = M_IM_INQUIRE_MUST_HAVE_USER_PTR(ContextOrResultId, InquireType); if(MustHaveUserPointer) SafeTypeError(MIL_TEXT("MimInquire")); return MimInquire(ContextOrResultId, InquireType, NULL); } #endif inline MIL_INT MFTYPE MimInquireSafeTypeExecute (MIL_ID ContextOrResultId, MIL_INT64 InquireType, void *UserVarPtr, MIL_INT64 GivenType) { MIL_INT64 RequiredType = MimInquireRequiredType(ContextOrResultId, InquireType); ReplaceTypeMilIdByTypeMilIntXX(&RequiredType); if (RequiredType != GivenType) SafeTypeError(MIL_TEXT("MimInquire")); return MimInquire(ContextOrResultId, InquireType, UserVarPtr); } inline MIL_INT MFTYPE MimInquireUnsafe (MIL_ID ContextOrResultId, MIL_INT64 InquireType, void *UserVarPtr) {return MimInquire (ContextOrResultId, InquireType, UserVarPtr );} inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, MIL_INT32 *UserVarPtr) {return MimInquireSafeTypeExecute(ContextOrResultId, InquireType, UserVarPtr, M_TYPE_MIL_INT32);} inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, MIL_INT64 *UserVarPtr) {return MimInquireSafeTypeExecute(ContextOrResultId, InquireType, UserVarPtr, M_TYPE_MIL_INT64);} inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, MIL_DOUBLE *UserVarPtr) {return MimInquireSafeTypeExecute(ContextOrResultId, InquireType, UserVarPtr, M_TYPE_DOUBLE );} #if M_MIL_SAFE_TYPE_SUPPORTS_UNSIGNED inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, MIL_UINT32 *UserVarPtr) {return MimInquireSafeTypeExecute(ContextOrResultId, InquireType, UserVarPtr, M_TYPE_MIL_INT32);} inline MIL_INT MFTYPE MimInquireSafeType(MIL_ID ContextOrResultId, MIL_INT64 InquireType, MIL_UINT64 *UserVarPtr) {return MimInquireSafeTypeExecute(ContextOrResultId, InquireType, UserVarPtr, M_TYPE_MIL_INT64);} #endif #define MimGet MimGetSafeType #define MimGetResult MimGetResultSafeType #define MimGetResult1d MimGetResult1dSafeType #define MimGetResult2d MimGetResult2dSafeType #if (defined(MimGetResultSingle)) #undef MimGetResultSingle #endif #define MimGetResultSingle MimGetResultSingleSafeType #define MimInquire MimInquireSafeType #else // #if M_MIL_USE_SAFE_TYPE #define MimGetUnsafe MimGet #define MimGetResultUnsafe MimGetResult #define MimGetResult1dUnsafe MimGetResult1d #define MimGetResult2dUnsafe MimGetResult2d #define MimGetResultSingleUnsafe MimGetResultSingle #define MimInquireUnsafe MimInquire #endif // #if M_MIL_USE_SAFE_TYPE // ---------------------------------------------------------- // Overload for std::vector. #if defined(M_MIL_USE_VECTOR) && M_MIL_USE_VECTOR template inline void MFTYPE MimGetResult(MIL_ID ResultImId, MIL_INT64 ResultType, std::vector &UserArrayPtr) { //! If the given MIL data type is not the same as the SrcType, change it to the correct one //! and give a warning. MIL_INT64 InternalTrueDataTypeForStdVector = MilTraits::TypeFlag; #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(ResultType) != 0) { SafeTypeError(MIL_TEXT("MimGetResult"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } #endif ResultType = M_STRIP_HLVLDATATYPE(ResultType) + InternalTrueDataTypeForStdVector; MIL_INT InternalNumberOfElementsForStdVector = 0; MimGetResult(ResultImId, M_STRIP_HLVLDATATYPE(ResultType) + M_NB_ELEMENTS + M_TYPE_MIL_INT, &InternalNumberOfElementsForStdVector); UserArrayPtr.resize(InternalNumberOfElementsForStdVector); if(InternalNumberOfElementsForStdVector > 0) { MimGetResult(ResultImId, ResultType, &UserArrayPtr[0]); } } template inline void MFTYPE MimGetResultSingle(MIL_ID ResultImId, MIL_INT64 Index1, MIL_INT64 Index2, MIL_INT64 ResultType, std::vector &UserArrayPtr) { //! If the given MIL data type is not the same as the SrcType, change it to the correct one //! and give a warning. MIL_INT64 InternalTrueDataTypeForStdVector = MilTraits::TypeFlag; #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(ResultType) != 0) { SafeTypeError(MIL_TEXT("MimGetResultSingle"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } #endif ResultType = M_STRIP_HLVLDATATYPE(ResultType) + InternalTrueDataTypeForStdVector; MIL_INT InternalNumberOfElementsForStdVector = 0; MimGetResultSingle(ResultImId, Index1, Index2, M_STRIP_HLVLDATATYPE(ResultType) + M_NB_ELEMENTS + M_TYPE_MIL_INT, &InternalNumberOfElementsForStdVector); UserArrayPtr.resize(InternalNumberOfElementsForStdVector); if(InternalNumberOfElementsForStdVector > 0) { MimGetResultSingle(ResultImId, Index1, Index2, ResultType, &UserArrayPtr[0]); } } // ---------------------------------------------------------- // Overloads for std::vector in MimDeinterlace. inline void MFTYPE MimDeinterlace(MIL_ID DeinterlaceContextImId, const std::vector& SrcImageArrayPtr, const std::vector& DstImageArrayPtr, MIL_INT SrcImageCount, MIL_INT DstImageCount, MIL_INT64 ControlFlag) { #if M_MIL_USE_SAFE_TYPE if(SrcImageCount <= 0) { SafeTypeError(MIL_TEXT("MimDeinterlace"), MIL_TEXT("SrcImageCount parameter must be greater than zero.")); } if(DstImageCount <= 0) { SafeTypeError(MIL_TEXT("MimDeinterlace"), MIL_TEXT("DstImageCount parameter must be greater than zero.")); } if(SrcImageArrayPtr.empty() || DstImageArrayPtr.empty()) { SafeTypeError(MIL_TEXT("MimDeinterlace"), MIL_TEXT("The input vectors cannot be empty.")); } if(SrcImageCount > (MIL_INT)SrcImageArrayPtr.size() && SrcImageCount != M_DEFAULT) { SafeTypeError(MIL_TEXT("MimDeinterlace"), MIL_TEXT("SrcImageCount parameter must be smaller or equal (M_DEFAULT) to the size of input vector.")); } if(DstImageCount > (MIL_INT)DstImageArrayPtr.size() && DstImageCount != M_DEFAULT) { SafeTypeError(MIL_TEXT("MimDeinterlace"), MIL_TEXT("DstImageCount parameter must be smaller or equal (M_DEFAULT) to the size of input vector.")); } #endif if(SrcImageCount == M_DEFAULT || SrcImageCount > (MIL_INT)SrcImageArrayPtr.size()) { SrcImageCount = (MIL_INT)SrcImageArrayPtr.size(); } if(DstImageCount == M_DEFAULT || DstImageCount > (MIL_INT)DstImageArrayPtr.size()) { DstImageCount = (MIL_INT)DstImageArrayPtr.size(); } MimDeinterlace(DeinterlaceContextImId, &SrcImageArrayPtr[0], &DstImageArrayPtr[0], SrcImageCount, DstImageCount, ControlFlag); } // ---------------------------------------------------------- // Overloads for std::vector in MimGet with two output parameters template inline MIL_INT MFTYPE MimGet(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, std::vector &Param1Ptr, std::vector &Param2Ptr, MIL_INT64 ControlFlag) { #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(GetType) != 0) { SafeTypeError(MIL_TEXT("MimGet"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } #endif GetType = M_STRIP_HLVLDATATYPE(GetType) + MilTraits::TypeFlag; bool InternalArraySizeSpecified = true; if(ArraySize == M_DEFAULT) { InternalArraySizeSpecified = false; ArraySize = 0; ArraySize = MimGet(ContextImId, M_STRIP_HLVLDATATYPE(GetType), M_NULL, M_NULL, M_NULL, ControlFlag); } if(ArraySize >= 0) { Param1Ptr.resize(ArraySize); Param2Ptr.resize(ArraySize); } // Call the original function in case the ArraySize parameter is specified. // It is to allow the MIL function to pop an MIL error if the ArraySize is invalid. // But, if the ArraySize is M_DEFAULT and that M3dmapGet outputs an MIL error, // the following condition will ensure to not recall the same function. if(ArraySize > 0 || InternalArraySizeSpecified) { MIL_INT InternalNbEntriesForStdVector = MimGet(ContextImId, GetType, ArraySize, &Param1Ptr[0], &Param2Ptr[0], ControlFlag); if(InternalNbEntriesForStdVector < ArraySize && ArraySize != M_DEFAULT) { Param1Ptr.resize(InternalNbEntriesForStdVector); Param2Ptr.resize(InternalNbEntriesForStdVector); } return InternalNbEntriesForStdVector; } return 0; } // ---------------------------------------------------------- // Overloads for std::vector in MimGet with only one output parameter. template inline MIL_INT MFTYPE MimGet(MIL_ID ContextImId, MIL_INT64 GetType, MIL_INT ArraySize, std::vector &Param1Ptr, void* Param2Ptr, MIL_INT64 ControlFlag) { #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(GetType) != 0) SafeTypeError(MIL_TEXT("MimGet"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); #endif GetType = M_STRIP_HLVLDATATYPE(GetType) + MilTraits::TypeFlag; if(ArraySize == M_DEFAULT) { ArraySize = 0; ArraySize = MimGet(ContextImId, M_STRIP_HLVLDATATYPE(GetType), M_NULL, M_NULL, M_NULL, ControlFlag); } if(ArraySize >= 0) Param1Ptr.resize(ArraySize); if(ArraySize > 0) { MIL_INT InternalNbEntriesForStdVector = MimGet(ContextImId, GetType, ArraySize, &Param1Ptr[0], (UserType*)Param2Ptr, ControlFlag); if(InternalNbEntriesForStdVector < ArraySize && ArraySize != M_DEFAULT) Param1Ptr.resize(InternalNbEntriesForStdVector); return InternalNbEntriesForStdVector; } return 0; } // ---------------------------------------------------------- // Overloads for std::vector in MimGetResult1d. template inline void MFTYPE MimGetResult1d(MIL_ID ResultImId, MIL_INT OffEntry, MIL_INT NbEntries, MIL_INT64 ResultType, std::vector &UserArrayPtr) { #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(ResultType) != 0) { SafeTypeError(MIL_TEXT("MimGetResult1d"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } if(NbEntries <= 0) { SafeTypeError(MIL_TEXT("MimGetResult1d"), MIL_TEXT("NbEntries must be greater than zero.")); } #endif ResultType = M_STRIP_HLVLDATATYPE(ResultType) + MilTraits::TypeFlag; UserArrayPtr.resize(NbEntries); MimGetResult1d(ResultImId, OffEntry, NbEntries, ResultType, &UserArrayPtr[0]); } // ---------------------------------------------------------- // Overloads for std::vector in MimGetResult2d. template inline void MimGetResult2d(MIL_ID ResultImId, MIL_INT OffsetX, MIL_INT OffsetY, MIL_INT SizeX, MIL_INT SizeY, MIL_INT64 ResultType, MIL_INT64 ControlFlag, std::vector &UserArrayPtr) { #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(ResultType) != 0) { SafeTypeError(MIL_TEXT("MimGetResult2d"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } if(SizeX <= 0 || SizeY <= 0) { SafeTypeError(MIL_TEXT("MimGetResult2d"), MIL_TEXT("SizeX and SizeY must be greater than zero.")); } #endif ResultType = M_STRIP_HLVLDATATYPE(ResultType) + MilTraits::TypeFlag; UserArrayPtr.resize(SizeX*SizeY); MimGetResult2d(ResultImId, OffsetX, OffsetY, SizeX, SizeY, ResultType, ControlFlag, &UserArrayPtr[0]); } // ---------------------------------------------------------- // Overloads for std::vector in MimPut. template inline void MFTYPE MimPut(MIL_ID ContextImId, MIL_INT64 PutType, MIL_INT ArraySize, const std::vector& Param1Ptr, const std::vector& Param2Ptr, MIL_INT64 ControlFlag) { #if M_MIL_USE_SAFE_TYPE if(M_GET_HLVLDATATYPE(PutType) != 0) { SafeTypeError(MIL_TEXT("MimPut"), MIL_TEXT("Combination value for the required data type is not supported with std::vector overload.")); } if(ArraySize <= 0) { SafeTypeError(MIL_TEXT("MimPut"), MIL_TEXT("ArraySize parameter must be greater than zero.")); } if(Param1Ptr.empty()) { SafeTypeError(MIL_TEXT("MimPut"), MIL_TEXT("The input vectors cannot be empty.")); } if(Param1Ptr.size() != Param2Ptr.size()) { SafeTypeError(MIL_TEXT("MimPut"), MIL_TEXT("The input vectors must have the same size.")); } if(ArraySize > (MIL_INT)Param1Ptr.size() && ArraySize != M_DEFAULT) { SafeTypeError(MIL_TEXT("MimPut"), MIL_TEXT("ArraySize parameter must be smaller or equal (M_DEFAULT) to the size of input vectors.")); } #endif PutType = M_STRIP_HLVLDATATYPE(PutType) + MilTraits::TypeFlag; if(ArraySize == M_DEFAULT || ArraySize > (MIL_INT)Param1Ptr.size()) { ArraySize = (MIL_INT)Param1Ptr.size(); } MimPut(ContextImId, PutType, ArraySize, &Param1Ptr[0], &Param2Ptr[0], ControlFlag); } #if (!M_MIL_LITE) // ---------------------------------------------------------- // Overloads for std::vector in MimWarpList. inline void MFTYPE MimWarpList(MIL_ID WarpParamBufId, MIL_INT64 TransformType, MIL_INT NumPoints, const std::vector& SrcCoordXArrayPtr, const std::vector& SrcCoordYArrayPtr, std::vector& DstCoordXArrayPtr, std::vector& DstCoordYArrayPtr, MIL_INT64 ControlFlag) { #if M_MIL_USE_SAFE_TYPE if(NumPoints <= 0) { SafeTypeError(MIL_TEXT("MimWarpList"), MIL_TEXT("NumPoints parameter must be greater than zero.")); } if(SrcCoordXArrayPtr.empty()) { SafeTypeError(MIL_TEXT("MimWarpList"), MIL_TEXT("The input vectors cannot be empty.")); } if(SrcCoordXArrayPtr.size() != SrcCoordYArrayPtr.size()) { SafeTypeError(MIL_TEXT("MimWarpList"), MIL_TEXT("The input vectors must have the same size.")); } if(NumPoints > (MIL_INT)SrcCoordXArrayPtr.size() && NumPoints != M_DEFAULT) { SafeTypeError(MIL_TEXT("MimWarpList"), MIL_TEXT("NumPoints parameter must be smaller or equal (M_DEFAULT) to the size of input vectors.")); } #endif if(NumPoints == M_DEFAULT || NumPoints > (MIL_INT)SrcCoordXArrayPtr.size()) { NumPoints = (MIL_INT)SrcCoordXArrayPtr.size(); } DstCoordXArrayPtr.resize(NumPoints); DstCoordYArrayPtr.resize(NumPoints); MimWarpList(WarpParamBufId, TransformType, NumPoints, &SrcCoordXArrayPtr[0], &SrcCoordYArrayPtr[0], &DstCoordXArrayPtr[0], &DstCoordYArrayPtr[0], ControlFlag); } #endif // (!MIL_LITE) // ---------------------------------------------------------- // Overloads for std::vector in MxxxStream. inline void MFTYPE MimStream(std::vector &MemPtrOrFileName, MIL_ID SysId, MIL_INT64 Operation, MIL_INT64 StreamType, MIL_DOUBLE Version, MIL_INT64 ControlFlag, MIL_ID* McontextIdPtr, MIL_INT* SizeByteVarPtr) { MxxxStreamForStdVector(MemPtrOrFileName, SysId, Operation, StreamType, Version, ControlFlag, McontextIdPtr, SizeByteVarPtr, MimStream); } #endif // defined(M_MIL_USE_VECTOR) && M_MIL_USE_VECTOR #if M_MIL_USE_STRING /***************************************************************************/ /* IM MODULE */ /***************************************************************************/ #if M_MIL_USE_UNICODE #if M_MIL_UNICODE_API inline void MFTYPE MimSaveW(const MIL_STRING& FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag) { return MimSaveW(FileName.c_str(), ContextImId, ControlFlag); } inline MIL_ID MFTYPE MimRestoreW(const MIL_STRING& FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr) { return MimRestoreW(FileName.c_str(), SysId, ControlFlag, ContextImIdPtr); } #else inline void MFTYPE MimSaveA(const MIL_STRING& FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag) { return MimSaveA(FileName.c_str(), ContextImId, ControlFlag); } inline MIL_ID MFTYPE MimRestoreA(const MIL_STRING& FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr) { return MimRestoreA(FileName.c_str(), SysId, ControlFlag, ContextImIdPtr); } #endif /* M_MIL_UNICODE_API */ #else inline void MFTYPE MimSave(const MIL_STRING& FileName, MIL_ID ContextImId, MIL_INT64 ControlFlag) { return MimSave(FileName.c_str(), ContextImId, ControlFlag); } inline MIL_ID MFTYPE MimRestore(const MIL_STRING& FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_ID* ContextImIdPtr) { return MimRestore(FileName.c_str(), SysId, ControlFlag, ContextImIdPtr); } #endif /* M_MIL_USE_UNICODE */ #endif /* M_MIL_USE_STRING */ //////////////////////////////////////////////////////////////////////////////// // MIL_UNIQUE_ID support #if M_MIL_USE_MIL_UNIQUE_ID #if M_MIL_USE_SAFE_TYPE template <> inline bool MilIsCorrectObjectType<&MimFree>(MIL_INT64 ObjectType) { const MIL_INT64 AllImTypes = M_IM_ALLOC_RESULT_BUFFER_TYPES | M_IM_CONTEXT | M_IM_RESULT_OBJECT_TYPES; return (ObjectType & M_USER_ATTRIBUTE) == 0 && (ObjectType & AllImTypes) != 0; } #endif typedef MIL_UNIQUE_ID<&MimFree> MIL_UNIQUE_IM_ID; #if M_MIL_USE_MOVE_SEMANTICS inline MIL_UNIQUE_IM_ID MimAlloc(MIL_ID SysId, MIL_INT64 ContextType, MIL_INT64 ControlFlag, MIL_UNIQUE_ID_TAG) { return MIL_UNIQUE_IM_ID(MimAlloc(SysId, ContextType, ControlFlag, M_NULL)); } inline MIL_UNIQUE_IM_ID MimAllocResult(MIL_ID SysId, MIL_INT NbEntries, MIL_INT64 ResultType, MIL_UNIQUE_ID_TAG) { return MIL_UNIQUE_IM_ID(MimAllocResult(SysId, NbEntries, ResultType, M_NULL)); } inline MIL_UNIQUE_IM_ID MimRestore(MIL_CONST_TEXT_PTR FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_UNIQUE_ID_TAG) { return MIL_UNIQUE_IM_ID(MimRestore(FileName, SysId, ControlFlag, M_NULL)); } #if M_MIL_USE_STRING inline MIL_UNIQUE_IM_ID MimRestore(const MIL_STRING& FileName, MIL_ID SysId, MIL_INT64 ControlFlag, MIL_UNIQUE_ID_TAG) { return MIL_UNIQUE_IM_ID(MimRestore(FileName, SysId, ControlFlag, M_NULL)); } #endif // M_MIL_USE_STRING template inline void MimFree(const MIL_UNIQUE_ID&) = delete; inline void MimDeinterlace( MIL_ID DeinterlaceContextImId, MilConstArrayIdParam SrcImageArrayPtr , MilConstArrayIdParam DstImageArrayPtr , MIL_INT SrcImageCount , MIL_INT DstImageCount , MIL_INT64 ControlFlag ) { MimDeinterlace(DeinterlaceContextImId, SrcImageArrayPtr.m_IdArrayPtr, DstImageArrayPtr.m_IdArrayPtr, SrcImageCount, DstImageCount, ControlFlag); } inline void MimStream(MilStreamParam MemPtrOrFileName, MIL_ID SysId , MIL_INT64 Operation , MIL_INT64 StreamType , MIL_DOUBLE Version , MIL_INT64 ControlFlag , MIL_UNIQUE_IM_ID* ContextImIdPtr , MIL_INT* SizeByteVarPtr ) { MxxxStreamForMilUniqueId(MemPtrOrFileName, SysId, Operation, StreamType, Version, ControlFlag, ContextImIdPtr, SizeByteVarPtr, MimStream); } #endif // M_MIL_USE_MOVE_SEMANTICS #endif // M_MIL_USE_MIL_UNIQUE_ID // End of MIL_UNIQUE_ID support //////////////////////////////////////////////////////////////////////////////// #endif //__MILIM_H__