############################################################
## Generated from hxquant2_auto.rules.xml
## Do not modify this resource file excepted for testing purpose.
############################################################


# We force the loading of the hxquant2 dynamic library
# to ensure that measure will be correctly loaded in the remaining of the file.
# hxquant2 cannot be previously loaded.

dso open "hxquant2" 

module -name "Absolute Value" \
-class "absval"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid absval $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "absval";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix abs \
}

module -name "Adaptive Thresholding" \
-class "adaptive_threshold"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation>Binarization}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid adaptive_threshold $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "adaptive_threshold";\
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this ImgGrey rename "inputGrayscaleImage" ; $this inputGrayscaleImage setLabel "Input Grayscale Image" ; $this "inputGrayscaleImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this MsrInGrey rename "measure1" ; $this measure1 setLabel "Measure 1" ; $this "measure1" setTooltip "Select a measure "; \
   $this MsrInGrey2 rename "measure2" ; $this measure2 setLabel "Measure 2" ; $this "measure2" setTooltip "Select a measure "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix binary; $this inputGrayscaleImage reposition 0 \
}

module -name "Add Image" \
-class "addimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid addimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "addimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix add \
}

module -name "Add To Label" \
-class "addmarkers"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid addmarkers $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "addmarkers";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this ILabNumber rename "labelNumber" ; $this labelNumber setLabel "Label Number" ; $this "labelNumber" setTooltip "Id of the new label "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix labels \
}

module -name "Add Value" \
-class "addvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid addvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "addvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Select a value to add "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix add \
}

module -name "Match Contrast" \
-class "adjustdynamic"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid adjustdynamic $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "adjustdynamic";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image "; \
   $this ImgIn2 rename "referenceImage" ; $this referenceImage setLabel "Reference Image" ; $this "referenceImage" setTooltip "Reference image. "; \
   $this MStatMeanVar rename "mode" ; $this mode setLabel "Mode" ; $this "mode" setTooltip "Select a choice "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix corrected \
}

module -name "Curvature-Driven Diffusion" \
-class "anisotropicdiffusion"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid anisotropicdiffusion $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "anisotropicdiffusion";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this INbIter2 rename "numberOfIterations" ; $this numberOfIterations setLabel "Number Of Iterations" ; $this "numberOfIterations" setTooltip "Enter the number of iterations (strictly positive integer) "; \
   $this FSharpness rename "sharpnessFactor" ; $this sharpnessFactor setLabel "Sharpness Factor" ; $this "sharpnessFactor" setTooltip "Enter the sharpness factor "; \
   $this FAnisotropy rename "anisotropyFactor" ; $this anisotropyFactor setLabel "Anisotropy Factor" ; $this "anisotropyFactor" setTooltip "Enter the anisotropy factor "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Degree Of Anisotropy" \
-class "anisotropy_degree"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid anisotropy_degree $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "anisotropy_degree";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this IStructSize rename "interceptDistance" ; $this interceptDistance setLabel "Intercept Distance \[px\]" ; $this "interceptDistance" setTooltip "Distance between two intercept lines "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix anisotropy \
}

module -name "Color Antialiasing" \
-class "antialiasing"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Color Image Filters}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid antialiasing $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "antialiasing";\
   $this ImgCol rename "inputColorImage" ; $this inputColorImage setLabel "Input Color Image" ; $this "inputColorImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this INbIter2 rename "numberOfIterations" ; $this numberOfIterations setLabel "Number Of Iterations" ; $this "numberOfIterations" setTooltip "Enter the number of iterations (strictly positive integer) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Area" \
-class "area"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid area $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "area";\
   $this ImgBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix area \
}

module -name "Area 3D" \
-class "area3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid area3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "area3d";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix area \
}

module -name "Auto Segment 3 Phases" \
-class "auto_segment"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid auto_segment $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [[set inputData $PRIMARY] isLabelImage] == 0 } \
-proc {  \
   $this wrap "auto_segment";\
   $this ImgInGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IARange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this MCriteria rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Select the criterion to detect thresholds on histogram "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 labels; "$this" setDefaultOutputSuffix 1 info; "$this" criterion setValue 1; "$this" inputImage connectToValueChanged __tclUpdateForAutoThresholdModule \
}

module -name "Auto Threshold High" \
-class "auto_threshold"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid auto_threshold $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [[set inputData $PRIMARY] isLabelImage] == 0 } \
-proc {  \
   $this wrap "auto_threshold";\
   $this ImgInGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MHisto rename "mode" ; $this mode setLabel "Mode" ; $this "mode" setTooltip "Mode "; \
   $this IARange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this MCriteria rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Select the criterion to detect thresholds on histogram "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 labels; "$this" setDefaultOutputSuffix 1 info; "$this" criterion setValue 1; "$this" inputImage connectToValueChanged __tclUpdateForAutoThresholdModule \
}

module -name "Auto Threshold Low" \
-class "auto_threshold_inv"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid auto_threshold_inv $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [[set inputData $PRIMARY] isLabelImage] == 0 } \
-proc {  \
   $this wrap "auto_threshold_inv";\
   $this ImgInGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MHisto rename "mode" ; $this mode setLabel "Mode" ; $this "mode" setTooltip "Mode "; \
   $this IARange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this MCriteria rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Select the criterion to detect thresholds on histogram "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 labels; "$this" setDefaultOutputSuffix 1 info; "$this" criterion setValue 1; "$this" inputImage connectToValueChanged __tclUpdateForAutoThresholdModule \
}

module -name "auto_threshold_value" \
-class "auto_threshold_value"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid auto_threshold_value $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "auto_threshold_value";\
   $this ImgInGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MHisto rename "mode" ; $this mode setLabel "Mode" ; $this "mode" setTooltip "Mode "; \
   $this IARange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this MCriteria rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Select the criterion to detect thresholds on histogram "; \
   $this finishInit; \
   "$this" criterion setValue 1 \
}

module -name "Average Object Area Per Slice" \
-class "average_object_area_per_slice"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid average_object_area_per_slice $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "average_object_area_per_slice";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Average Object Number Per Slice" \
-class "average_object_num_per_slice"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid average_object_num_per_slice $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "average_object_num_per_slice";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Average Object Thickness" \
-class "average_object_thickness"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid average_object_thickness $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "average_object_thickness";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this MTrabecularMode rename "model" ; $this model setLabel "Model" ; $this "model" setTooltip "Trabecular Mode "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Average Space Thickness" \
-class "average_space_thickness"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid average_space_thickness $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "average_space_thickness";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this MTrabecularMode rename "model" ; $this model setLabel "Model" ; $this "model" setTooltip "Trabecular Mode "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Bilateral Filter" \
-class "bilateralfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid bilateralfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "bilateralfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size (odd value) "; \
   $this FStdDev rename "similarity" ; $this similarity setLabel "Similarity" ; $this "similarity" setTooltip "Photometric similarity (strictly positive value) "; \
   $this MBilateral rename "filterMode" ; $this filterMode setLabel "Filter Mode" ; $this "filterMode" setTooltip "Filter type "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Bilateral Filter 3D" \
-class "bilateralfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid bilateralfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "bilateralfilter3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size (odd value) "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size (odd value) "; \
   $this FStdDev rename "similarity" ; $this similarity setLabel "Similarity" ; $this "similarity" setTooltip "Photometric similarity (strictly positive value) "; \
   $this MBilateral rename "filterMode" ; $this filterMode setLabel "Filter Mode" ; $this "filterMode" setTooltip "Filter type "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Chamfer - Conservative" \
-class "binseparate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid binseparate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "binseparate";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this INbIter rename "markerExtent" ; $this markerExtent setLabel "Marker Extent" ; $this "markerExtent" setTooltip "Marker contrast range (H-extrema). Increase for fewer markers "; \
   $this MSeparType rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Output image: separation lines, split objects, separated basins or joined  basins "; \
   $this MWaterParaMode rename "algorithmMode" ; $this algorithmMode setLabel "Algorithm Mode" ; $this "algorithmMode" setTooltip "Select algorithm mode for fastwatershed "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix separate \
}

module -name "Background Image" \
-class "bkgimg"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid bkgimg $PRIMARY ] == 1 && [$PRIMARY hasInterface HxUniformColorField3] == 0 } \
-proc {  \
   $this wrap "bkgimg";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix background \
}

module -name "Blend With Image" \
-class "blendimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid blendimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "blendimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this FBlend rename "weight" ; $this weight setLabel "Weigth" ; $this "weight" setTooltip "Weight "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix blend \
}

module -name "Blend With Value" \
-class "blendvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid blendvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "blendvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this FBlend rename "weight" ; $this weight setLabel "Weigth" ; $this "weight" setTooltip "Weight "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix blend \
}

module -name "Fill Image Border" \
-class "border_fill"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Separating And Filling}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid border_fill $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "border_fill";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this MConnWay2d rename "neighborhoodConnectivity" ; $this neighborhoodConnectivity setLabel "Neighborhood Connectivity" ; $this "neighborhoodConnectivity" setTooltip "Connectivity mode "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix borderFill \
}

module -name "Border Kill" \
-class "border_kill"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Features Selection}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid border_kill $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "border_kill";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix borderKill \
}

module -name "Label Boundaries" \
-class "boundary"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Features Selection}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid boundary $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "boundary";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix boundary \
}

module -name "Box Filter" \
-class "boxfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid boxfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "boxfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size "; \
   $this MAutoScale rename "autoScale" ; $this autoScale setLabel "Auto Scale" ; $this "autoScale" setTooltip "Automatic scaling "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Box Filter 3D" \
-class "boxfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid boxfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "boxfilter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Horizontal kernel size "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size "; \
   $this MAutoScale rename "autoScale" ; $this autoScale setLabel "Auto Scale" ; $this "autoScale" setTooltip "Automatic scaling "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Radial Function" \
-class "buildcirc"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Images And Fields}"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "buildcirc";\
   $this LutAnam rename "inputArray" ; $this inputArray setLabel "Input Array" ; $this "inputArray" setTooltip "Enter input array name (or select one in the list) "; \
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImgSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter size of new image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix radial \
}

module -name "Radial Function 3D" \
-class "buildcirc3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "buildcirc3d";\
   $this LutAnam rename "inputArray" ; $this inputArray setLabel "Input Array" ; $this "inputArray" setTooltip "Enter input array name (or select one in the list) "; \
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImgSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter size of new image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix radial \
}

module -name "Oriented Lines" \
-class "buildline"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Images And Fields}"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "buildline";\
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Line orientation regarding X axis "; \
   $this FOffset rename "offset" ; $this offset setLabel "Offset" ; $this "offset" setTooltip "Distance between two elements "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix lines \
}

module -name "Oriented Lines 3D" \
-class "buildline3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "buildline3d";\
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this IImaSizeZ rename "sizeZ" ; $this sizeZ setLabel "Size Z \[px\]" ; $this "sizeZ" setTooltip "Z size of the new image "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Line orientation regarding XoY plan "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Line orientation regarding XoZ plan "; \
   $this FRotAgl rename "rollAngle" ; $this rollAngle setLabel "Roll Angle" ; $this "rollAngle" setTooltip "Grid orientation orthogonaly to line direction "; \
   $this FOffset rename "offset" ; $this offset setLabel "Offset" ; $this "offset" setTooltip "Distance between two elements "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix lines \
}

module -name "Fit Cylinder" \
-class "buildmaskcylinder"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid buildmaskcylinder $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "buildmaskcylinder";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this IPlane rename "sliceNumber" ; $this sliceNumber setLabel "Slice Number" ; $this "sliceNumber" setTooltip "Select an index of plane ( one-based ) "; \
   $this IZSample rename "cylinderHeight" ; $this cylinderHeight setLabel "Cylinder Height \[px\]" ; $this "cylinderHeight" setTooltip "Select the cylinder height "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix mask \
}

module -name "Catchment Basins" \
-class "catchbasin"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid catchbasin $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "catchbasin";\
   $this ImgGrey rename "inputGrayscaleImage" ; $this inputGrayscaleImage setLabel "Input Grayscale Image" ; $this "inputGrayscaleImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input marker (label) image (or select one in the list) "; \
   $this MWaterParaMode rename "algorithmMode" ; $this algorithmMode setLabel "Algorithm Mode" ; $this "algorithmMode" setTooltip "Select algorithm mode for fastwatershed "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   $this algorithmMode setValue 1 ; $this fire; $this setDefaultOutputSuffix watershed \
}

module -name "Swap Quadrants" \
-class "center"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Frequency Domain}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid center $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "center";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix swap \
}

module -name "Radial Integral" \
-class "circular_profil"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid circular_profil $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "circular_profil";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MInputType rename "imageMode" ; $this imageMode setLabel "Image Mode" ; $this "imageMode" setTooltip "input image type (ex: frequency if the image is resulting from an fft) "; \
   $this MCumMeasure rename "cumulative" ; $this cumulative setLabel "Cumulative" ; $this "cumulative" setTooltip "Cumulated measure "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix profile \
}

module -name "Cube" \
-class "closing"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid closing $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "closing";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Color" \
-class "colorclose"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid colorclose $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "colorclose";\
   $this ImgCol rename "inputImage" ; $this inputImage setLabel "Input Color Image" ; $this "inputImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MMorCrit rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Criterion "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Color" \
-class "colordilate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid colordilate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "colordilate";\
   $this ImgCol rename "inputImage" ; $this inputImage setLabel "Input Color Image" ; $this "inputImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MMorCrit rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Criterion "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Color" \
-class "colorerode"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid colorerode $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "colorerode";\
   $this ImgCol rename "inputImage" ; $this inputImage setLabel "Input Color Image" ; $this "inputImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MMorCrit rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Criterion "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Color" \
-class "coloropen"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid coloropen $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "coloropen";\
   $this ImgCol rename "inputImage" ; $this inputImage setLabel "Input Color Image" ; $this "inputImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MMorCrit rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Criterion "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Convex Hull" \
-class "convex_hull"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Separating And Filling}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid convex_hull $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "convex_hull";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix convexHull \
}

module -name "Ridge Detection" \
-class "crete"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Edge Marking}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid crete $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "crete";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix ridge \
}

module -name "Image Curvature" \
-class "curvature2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid curvature2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "curvature2d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix curvature \
}

module -name "Image Curvature 3D" \
-class "curvature3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid curvature3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "curvature3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix curvature \
}

module -name "Deblur" \
-class "deblur"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Sharpening}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid deblur $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "deblur";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input Image "; \
   $this FSharpen rename "sharpeningFactor" ; $this sharpeningFactor setLabel "Sharpening Factor" ; $this "sharpeningFactor" setTooltip "Sharpening factor "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Decorrelation Stretch" \
-class "decorrelstrech"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Color Image Filters}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid decorrelstrech $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "decorrelstrech";\
   $this ImgCol rename "inputColorImage" ; $this inputColorImage setLabel "Input Color Image" ; $this "inputColorImage" setTooltip "Enter input color image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Delineate" \
-class "delineate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Sharpening}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid delineate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "delineate";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Delineate 3D" \
-class "delineate3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid delineate3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "delineate3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Despeckle" \
-class "despecklefilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid despecklefilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "despecklefilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size (odd value) "; \
   $this FStdDev rename "thresholdFactor" ; $this thresholdFactor setLabel "Threshold Factor" ; $this "thresholdFactor" setTooltip "Stddev threshold factor (strictly positive value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Despeckle 3D" \
-class "despecklefilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid despecklefilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "despecklefilter3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Hrizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size (odd value) "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size (odd value) "; \
   $this FStdDev rename "thresholdFactor" ; $this thresholdFactor setLabel "Threshold Factor" ; $this "thresholdFactor" setTooltip "Stddev threshold factor (strictly positive value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Cube" \
-class "dilate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dilate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dilate";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Fill Label Boundaries" \
-class "dilatebasin"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dilatebasin $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dilatebasin";\
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix expanded \
}

module -name "Fill All Image" \
-class "dilateextrlab"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dilateextrlab $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dilateextrlab";\
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix expanded \
}

module -name "Disc" \
-class "diskclosing"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskclosing $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskclosing";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   $this precision setValue 1; $this precision hide; $this setDefaultOutputSuffix closing \
}

module -name "Disc 3D" \
-class "diskclosing3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskclosing3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskclosing3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Disc" \
-class "diskdilate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskdilate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskdilate";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   $this precision setValue 1; $this precision hide; $this setDefaultOutputSuffix dilated \
}

module -name "Disc 3D" \
-class "diskdilate3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskdilate3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskdilate3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Disc" \
-class "diskerode"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskerode $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskerode";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   $this precision setValue 1; $this precision hide; $this setDefaultOutputSuffix eroded \
}

module -name "Disc 3D" \
-class "diskerode3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskerode3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskerode3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Disc" \
-class "diskopening"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskopening $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskopening";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   $this precision setValue 1; $this precision hide; $this setDefaultOutputSuffix opening \
}

module -name "Disc 3D" \
-class "diskopening3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid diskopening3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "diskopening3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Chamfer Distance Map" \
-class "dist557"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Distance Maps}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dist557 $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dist557";\
   $this ImgBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix distmap \
}

module -name "Chessboard Distance Map" \
-class "distance"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Distance Maps}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid distance $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "distance";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix distmap \
}

module -name "Closest Boundary Points" \
-class "distcont"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Distance Maps}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid distcont $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "distcont";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 distmap; "$this" setDefaultOutputSuffix 1 px; "$this" setDefaultOutputSuffix 2 py \
}

module -name "Closest Boundary Points 3D" \
-class "distcont3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid distcont3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "distcont3d";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 distmap; "$this" setDefaultOutputSuffix 1 px; "$this" setDefaultOutputSuffix 2 py; "$this" setDefaultOutputSuffix 3 pz \
}

module -name "Geodesic Distance Map" \
-class "distmask"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Distance Maps}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid distmask $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "distmask";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInMsk rename "inputImage" ; $this inputImage setLabel "Input Image Mask" ; $this "inputImage" setTooltip "Enter the binary image for the forbidden area (compute distance only outside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix distmap \
}

module -name "Chamfer Distance Map 3D" \
-class "distxxx"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid distxxx $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "distxxx";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this FDistX rename "faceDistance" ; $this faceDistance setLabel "Face Distance" ; $this "faceDistance" setTooltip "Distance between 2 pixels with max 3D connexity "; \
   $this FDistXY rename "edgeDistance" ; $this edgeDistance setLabel "Edge Distance" ; $this "edgeDistance" setTooltip "Distance between 2 pixels with middle 3D connexity "; \
   $this FDistXYZ rename "cornerDistance" ; $this cornerDistance setLabel "Corner Distance" ; $this "cornerDistance" setTooltip "Distance between 2 pixels with min 3D connexity "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix distmap \
}

module -name "Divide By Image" \
-class "divideimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid divideimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "divideimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix divide \
}

module -name "Divide By Value" \
-class "dividevalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dividevalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dividevalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this FNotNullValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Enter the value to divide "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix divide \
}

module -name "DoB Filter" \
-class "dob_filter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Laplacian}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dob_filter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dob_filter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ISmallSize rename "smallBoxSize" ; $this smallBoxSize setLabel "Small Box Size \[px\]" ; $this "smallBoxSize" setTooltip "Enter the size of the small box "; \
   $this ILargeSize rename "largeBoxSize" ; $this largeBoxSize setLabel "Large Box Size \[px\]" ; $this "largeBoxSize" setTooltip "Enter the size of the large box "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "DoB Filter 3D" \
-class "dob_filter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dob_filter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dob_filter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ISmallSize rename "smallBoxSize" ; $this smallBoxSize setLabel "Small Box Size \[px\]" ; $this "smallBoxSize" setTooltip "Enter the size of the small box "; \
   $this ILargeSize rename "largeBoxSize" ; $this largeBoxSize setLabel "Large Box Size \[px\]" ; $this "largeBoxSize" setTooltip "Enter the size of the large box "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Reconstruction By Erosion" \
-class "dualreconstruct"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid dualreconstruct $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "dualreconstruct";\
   $this ImgRctGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image to reconstruct (or select one in the list) "; \
   $this ImgMarkerGrey rename "inputMarkerImage" ; $this inputMarkerImage setLabel "Input Marker Image" ; $this "inputMarkerImage" setTooltip "Enter input marker (gray) image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix reconstructed \
}

module -name "Eccentricity" \
-class "eccentricity"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid eccentricity $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "eccentricity";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eccentricity \
}

module -name "Histogram Equalization" \
-class "equalize"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid equalize $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "equalize";\
   $this ImgGrey1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this MHisto rename "rangeMode" ; $this rangeMode setLabel "Range Mode" ; $this "rangeMode" setTooltip "Select a choice "; \
   $this IAInRange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this IAOutRange rename "outputRange" ; $this outputRange setLabel "Output Range" ; $this "outputRange" setTooltip "Output range "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix corrected \
}

module -name "Cube" \
-class "erode"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid erode $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "erode";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Euler Number" \
-class "euler"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)} {Measure And Analyze>Global Measures}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid euler $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "euler";\
   $this ImgBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix euler \
}

module -name "Euler Number 3D" \
-class "euler3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid euler3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "euler3d";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix euler \
}

module -name "Exponential" \
-class "exponential"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid exponential $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "exponential";\
   $this ImgReal rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter floating point image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix exp \
}

module -name "Regional Maxima" \
-class "fastmaxima"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid fastmaxima $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "fastmaxima";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix maxima \
}

module -name "Regional Minima" \
-class "fastminima"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid fastminima $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "fastminima";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix minima \
}

module -name "Watershed" \
-class "fastwatershed"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid fastwatershed $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "fastwatershed";\
   $this ImgGrey rename "inputGrayscaleImage" ; $this inputGrayscaleImage setLabel "Input Grayscale Image" ; $this "inputGrayscaleImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input marker (label) image (or select one in the list) "; \
   $this MWaterParaMode rename "algorithmMode" ; $this algorithmMode setLabel "Algorithm Mode" ; $this "algorithmMode" setTooltip "Select algorithm mode for fastwatershed "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   $this algorithmMode setValue 1 ; $this fire; $this setDefaultOutputSuffix watershed \
}

module -name "Percolation Threshold" \
-class "findporolevelrange"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Propagation}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid findporolevelrange $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "findporolevelrange";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IARangeAnam rename "searchRange" ; $this searchRange setLabel "Search range" ; $this "searchRange" setTooltip "Search window for threshold "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix percolation \
}

module -name "First Connected Component" \
-class "first_object"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid first_object $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "first_object";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix first \
}

module -name "Flow Inpainting" \
-class "flowinpainting"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid flowinpainting $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "flowinpainting";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgBin rename "inputMask" ; $this inputMask setLabel "Input Mask" ; $this "inputMask" setTooltip "Enter input binary image (or select one in the list) "; \
   $this INbIter2 rename "numberOfIterations" ; $this numberOfIterations setLabel "Number Of Iterations" ; $this "numberOfIterations" setTooltip "Enter the number of iterations (strictly positive integer) "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Fractal Dimension" \
-class "fractal"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid fractal $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "fractal";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this MYesNo rename "useOnlyBorders" ; $this useOnlyBorders setLabel "Use Only Borders" ; $this "useOnlyBorders" setTooltip "Use only the object borders to compute measure "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix fractal \
}

module -name "Fragmentation Index" \
-class "fragmentation"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid fragmentation $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "fragmentation";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter structuring element for dilation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix fragmentation \
}

module -name "Ganglia Count" \
-class "ganglia_count"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "Measure"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ganglia_count $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ganglia_count";\
   $this ImgLabBin rename "ganglia" ; $this ganglia setLabel "Labeled Ganglia" ; $this "ganglia" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this ImgLab rename "pores" ; $this pores setLabel "Labeled Pores" ; $this "pores" setTooltip "Enter input label image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
}

module -name "Ganglia Intersect" \
-class "ganglia_intersect"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "Measure"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ganglia_intersect $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ganglia_intersect";\
   $this ImgLabBin rename "ganglia" ; $this ganglia setLabel "Labeled Ganglia" ; $this "ganglia" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this ImgLab rename "pores" ; $this pores setLabel "Labeled Pores" ; $this "pores" setTooltip "Enter input label image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
}

module -name "Gaussian Filter" \
-class "gaussianfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gaussianfilter $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "gaussianfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MGaussKnlType rename "kernelType" ; $this kernelType setLabel "Kernel Type" ; $this "kernelType" setTooltip "Kernel type for gaussian smoothing "; \
   $this FStdDevGaussX rename "standardDeviationX" ; $this standardDeviationX setLabel "Standard Deviation X" ; $this "standardDeviationX" setTooltip "Standard deviation along X axis "; \
   $this FStdDevGaussY rename "standardDeviationY" ; $this standardDeviationY setLabel "Standard Deviation Y" ; $this "standardDeviationY" setTooltip "Standard deviation along Y axis "; \
   $this IAKnlSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Kernel size "; \
   $this MAutoScale rename "autoScale" ; $this autoScale setLabel "Auto Scale" ; $this "autoScale" setTooltip "Automatic scaling "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Gaussian Filter 3D" \
-class "gaussianfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gaussianfilter3d $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "gaussianfilter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this MGaussKnlType rename "kernelType" ; $this kernelType setLabel "Kernel Type" ; $this "kernelType" setTooltip "Kernel type for gaussian smoothing "; \
   $this FStdDevGaussX rename "standardDeviationX" ; $this standardDeviationX setLabel "Standard Deviation X" ; $this "standardDeviationX" setTooltip "Standard deviation along X axis "; \
   $this FStdDevGaussY rename "standardDeviationY" ; $this standardDeviationY setLabel "Standard Deviation Y" ; $this "standardDeviationY" setTooltip "Standard deviation along Y axis "; \
   $this FStdDevGaussZ rename "standardDeviationZ" ; $this standardDeviationZ setLabel "Standard Deviation Z" ; $this "standardDeviationZ" setTooltip "Standard deviation along Z axis "; \
   $this IAKnl3DSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Kernel size "; \
   $this MAutoScale rename "autoScale" ; $this autoScale setLabel "Auto Scale" ; $this "autoScale" setTooltip "Automatic scaling "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Measure Gaussian Noise" \
-class "gaussiannoise"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gaussiannoise $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "gaussiannoise";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Maxima Imposition" \
-class "gdsmax"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gdsmax $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "gdsmax";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix maxImposed \
}

module -name "Minima Imposition" \
-class "gdsmin"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gdsmin $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "gdsmin";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix minImposed \
}

module -name "Output Binary" \
-class "getfastporobin"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getfastporobin $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getfastporobin";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this MZDirection rename "propagationDirection" ; $this propagationDirection setLabel "Propagation Direction" ; $this "propagationDirection" setTooltip "Propagation direction "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 binary; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Output Label" \
-class "getfastporolab"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getfastporolab $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getfastporolab";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this MZDirection rename "propagationDirection" ; $this propagationDirection setLabel "Propagation Direction" ; $this "propagationDirection" setTooltip "Propagation direction "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 binary; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Label Interfaces" \
-class "getmultiphase"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Features Selection}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getmultiphase $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getmultiphase";\
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this INbIter rename "numberOfPhases" ; $this numberOfPhases setLabel "Number Of Phases" ; $this "numberOfPhases" setTooltip "Number of phases "; \
   $this MYesNo rename "onlyBlackVoxels" ; $this onlyBlackVoxels setLabel "Only Black Voxels" ; $this "onlyBlackVoxels" setTooltip "Use only pixels with intensity = 0 "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix interfaces \
}

module -name "Output Binary Without Seeds" \
-class "getporobin"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getporobin $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getporobin";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 binary; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Propagation Distance" \
-class "getporodist"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Propagation}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getporodist $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getporodist";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this MZDirection rename "propagationDirection" ; $this propagationDirection setLabel "Propagation Direction" ; $this "propagationDirection" setTooltip "Propagation direction "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 distmap; "$this" setDefaultOutputSuffix 0 table \
}

module -name "Output Label Without Seeds" \
-class "getporolab"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getporolab $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getporolab";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 binary; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Estimate Shortest Path" \
-class "getshortestpath"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Propagation}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid getshortestpath $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "getshortestpath";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IARange rename "maskAndSeedValues" ; $this maskAndSeedValues setLabel "Mask And Seed Values" ; $this "maskAndSeedValues" setTooltip "Intensity values for forbiden areas and propagation seed areas "; \
   $this IContrast rename "maximumThreshold" ; $this maximumThreshold setLabel "Maximum Threshold" ; $this "maximumThreshold" setTooltip "Maximum intensity for propagation "; \
   $this MAxis rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Propagation axis "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix estimatedPath \
}

module -name "Global Analysis" \
-class "global_analyze"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid global_analyze $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "global_analyze";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt rename "inputIntensityImage" ; $this inputIntensityImage setLabel "Input Intensity Image" ; $this "inputIntensityImage" setTooltip "Enter intensity image (or select one in the list) "; \
   $this MAppMode rename "appendMode" ; $this appendMode setLabel "Append Mode" ; $this "appendMode" setTooltip "analysis mode "; \
   $this MMsrGrp rename "measureGroup" ; $this measureGroup setLabel "Measure Group" ; $this "measureGroup" setTooltip "Select a measure group in the list "; \
   $this finishInit; \
   $this appendMode hide; "$this" setDefaultOutputSuffix analysis \
}

module -name "Image Gradient" \
-class "gradient"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Gradient}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gradient $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "gradient";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MGradFunc rename "gradientType" ; $this gradientType setLabel "Gradient Type" ; $this "gradientType" setTooltip "Select a choice "; \
   $this MGradOut rename "gradientOptions" ; $this gradientOptions setLabel "Gradient Options" ; $this "gradientOptions" setTooltip "Select a choice "; \
   $this FStdDevGauss rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   $this gradientType setValue 3; "$this" setDefaultOutputSuffix grad \
}

module -name "Image Gradient 3D" \
-class "gradient3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid gradient3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "gradient3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this MGradFunc3d rename "gradientType" ; $this gradientType setLabel "Gradient Type" ; $this "gradientType" setTooltip "Select a choice "; \
   $this MGradOut3d rename "gradientOptions" ; $this gradientOptions setLabel "Gradient Options" ; $this "gradientOptions" setTooltip "Select a choice "; \
   $this FStdDevGauss rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix grad \
}

module -name "H-Extrema Watershed" \
-class "greyseparate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Separating And Filling}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid greyseparate $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "greyseparate";\
   $this ImgGrey rename "inputGrayscaleImage" ; $this inputGrayscaleImage setLabel "Input Grayscale Image" ; $this "inputGrayscaleImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this MSeparate rename "objectType" ; $this objectType setLabel "Object type" ; $this "objectType" setTooltip "Separate white or black objects "; \
   $this INbIter rename "markerExtent" ; $this markerExtent setLabel "Marker extent" ; $this "markerExtent" setTooltip "Marker contrast range (H-extrema). Increase for fewer markers "; \
   $this MSeparType rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Output image: separation lines, split objects, separated basins or joined  basins "; \
   $this MWaterParaMode rename "algorithmMode" ; $this algorithmMode setLabel "Algorithm Mode" ; $this "algorithmMode" setTooltip "Select algorithm mode for fastwatershed "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix watershed \
}

module -name "Fill Holes" \
-class "hole_fill2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Separating And Filling}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid hole_fill2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "hole_fill2d";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this MConnWay2d rename "neighborhoodConnectivity" ; $this neighborhoodConnectivity setLabel "Neighborhood Connectivity" ; $this "neighborhoodConnectivity" setTooltip "Connectivity mode "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filled \
}

module -name "Fill Holes 3D" \
-class "hole_fill3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid hole_fill3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "hole_fill3d";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filled \
}

module -name "Hysteresis Thresholding" \
-class "hysteresis"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation>Binarization}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid hysteresis $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  &&  [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "hysteresis";\
   $this ImgInGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FAThrLevelInv rename "thresholds" ; $this thresholds setLabel "Thresholds (Low/High)" ; $this "thresholds" setTooltip "Low and High threshold levels "; \
   $this INbIter rename "length" ; $this length setLabel "Length \[px\]" ; $this "length" setTooltip "Enter the maximum length allowed for pixel in fuzzy zone (0:until convergence) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix binary; "$this" thresholds setState 0 128 1 255 \
}

module -name "Total Image Boundary Area" \
-class "image_boundary_area"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid image_boundary_area $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "image_boundary_area";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Total Image Volume" \
-class "image_volume"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid image_volume $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isBinaryImage] == 1 } \
-proc {  \
   $this wrap "image_volume";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Moments Of Inertia" \
-class "inertia"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid inertia $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "inertia";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix moments \
}

module -name "Moments Of Inertia 3D" \
-class "inertia3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid inertia3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "inertia3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix moments \
}

module -name "Inertia Moment" \
-class "inertia_moment"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid inertia_moment $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "inertia_moment";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Enter the angle of the rotation in degrees "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Curvature Integrals" \
-class "integral_curvature"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid integral_curvature $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "integral_curvature";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Diametrical Variation" \
-class "intercept"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid intercept $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "intercept";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Intensity Auto Classification" \
-class "k_means_classification"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation>Classification}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid k_means_classification $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 && [$PRIMARY isBinaryImage] == 0 } \
-proc {  \
   $this wrap "k_means_classification";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ICoef rename "classNumber" ; $this classNumber setLabel "Number of Classes" ; $this "classNumber" setTooltip "Number of Classes "; \
   $this IPercent rename "precomputing" ; $this precomputing setLabel "Pre-Computing (%)" ; $this "precomputing" setTooltip "Select pre-computing used data ratio "; \
   $this finishInit; \
   "$this" classNumber setMinMax 1 [$this classNumber getMaxValue] \
}

module -name "Labeling" \
-class "label"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid label $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "label";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix labels \
}

module -name "Volume Fraction" \
-class "label_ratio"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid label_ratio $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "label_ratio";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Line" \
-class "lclosing"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lclosing $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lclosing";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Enter the angle of the rotation in degrees "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Line 3D" \
-class "lclosing3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lclosing3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lclosing3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Line" \
-class "ldilate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ldilate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ldilate";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Enter the angle of the rotation in degrees "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Line 3D" \
-class "ldilate3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ldilate3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ldilate3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Line" \
-class "lerode"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lerode $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lerode";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Enter the angle of the rotation in degrees "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Line 3D" \
-class "lerode3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lerode3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lerode3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Gradient Local Maxima" \
-class "lmaxima"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Edge Marking}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lmaxima $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lmaxima";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgGradAmpl rename "gradientAmplitude" ; $this gradientAmplitude setLabel "Gradient Amplitude" ; $this "gradientAmplitude" setTooltip "Enter gradient amplitude (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Gradient Local Maxima 3D" \
-class "lmaxima3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lmaxima3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lmaxima3d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgZGrad rename "inputGradientZ" ; $this inputGradientZ setLabel "Input Gradient Z" ; $this "inputGradientZ" setTooltip "Enter input Z-Gradient (or select one in the list) "; \
   $this ImgGradAmpl rename "gradientAmplitude" ; $this gradientAmplitude setLabel "Gradient Amplitude" ; $this "gradientAmplitude" setTooltip "Enter gradient amplitude (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Orientation Matching" \
-class "localfixedorient"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid localfixedorient $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "localfixedorient";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "blockSize" ; $this blockSize setLabel "Block Size \[px\]" ; $this "blockSize" setTooltip "Block size "; \
   $this MAutoScale rename "blockOverlap" ; $this blockOverlap setLabel "Block Overlap" ; $this "blockOverlap" setTooltip "Block overlap "; \
   $this IXSample rename "minThreshold" ; $this minThreshold setLabel "Min Threshold" ; $this "minThreshold" setTooltip "min threshold "; \
   $this IYSample rename "maxThreshold" ; $this maxThreshold setLabel "Max Threshold" ; $this "maxThreshold" setTooltip "max threshold "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Theta angle "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Phi angle "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 orientView; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Orientation Map" \
-class "localorient"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid localorient $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "localorient";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "blockSize" ; $this blockSize setLabel "Block Size \[px\]" ; $this "blockSize" setTooltip "Block size "; \
   $this MAutoScale rename "blockOverlap" ; $this blockOverlap setLabel "Block Overlap" ; $this "blockOverlap" setTooltip "Block overlap "; \
   $this IXSample rename "minThreshold" ; $this minThreshold setLabel "Min Threshold" ; $this "minThreshold" setTooltip "min threshold "; \
   $this IYSample rename "maxThreshold" ; $this maxThreshold setLabel "Max Threshold" ; $this "maxThreshold" setTooltip "max threshold "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 orientView; "$this" setDefaultOutputSuffix 1 table \
}

module -name "Logarithm" \
-class "logarithm"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logarithm $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "logarithm";\
   $this ImgReal rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter floating point image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix log \
}

module -name "AND Image" \
-class "logical_andimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_andimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_andimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix and \
}

module -name "AND Value" \
-class "logical_andvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_andvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_andvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix and \
}

module -name "NAND Image" \
-class "logical_nandimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_nandimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_nandimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nand \
}

module -name "NAND Value" \
-class "logical_nandvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_nandvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_nandvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nand \
}

module -name "NOR Image" \
-class "logical_norimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_norimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_norimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nor \
}

module -name "NOR Value" \
-class "logical_norvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_norvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_norvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nor \
}

module -name "NOT" \
-class "logical_not"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_not $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_not";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix not \
}

module -name "NXOR Image" \
-class "logical_nxorimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_nxorimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_nxorimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nxor \
}

module -name "NXOR Value" \
-class "logical_nxorvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_nxorvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_nxorvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix nxor \
}

module -name "OR Image" \
-class "logical_orimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_orimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_orimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix or \
}

module -name "OR Value" \
-class "logical_orvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_orvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_orvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix or \
}

module -name "AND NOT Image" \
-class "logical_subimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_subimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_subimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sub \
}

module -name "AND NOT Value" \
-class "logical_subvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_subvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_subvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sub \
}

module -name "XOR Image" \
-class "logical_xorimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_xorimage $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_xorimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix xor \
}

module -name "XOR Value" \
-class "logical_xorvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid logical_xorvalue $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "logical_xorvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image operand "; \
   $this IContrast rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix xor \
}

module -name "Line" \
-class "lopening"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lopening $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lopening";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRotAgl rename "rotationAngle" ; $this rotationAngle setLabel "Rotation Angle" ; $this "rotationAngle" setTooltip "Angle of the rotation in degrees "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "The half-kernel size (in pixels or voxels) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Line 3D" \
-class "lopening3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid lopening3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "lopening3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRotSphTheta rename "thetaAngle" ; $this thetaAngle setLabel "Theta Angle" ; $this "thetaAngle" setTooltip "Enter angle of rotation around OZ axis (in degrees) "; \
   $this FRotSphPhi rename "phiAngle" ; $this phiAngle setLabel "Phi Angle" ; $this "phiAngle" setTooltip "Enter angle of rotation around projected OY axis (in degrees) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Majority Filter" \
-class "majorityfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid majorityfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "majorityfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size (odd value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Majority Filter 3D" \
-class "majorityfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid majorityfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "majorityfilter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size (odd value) "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size (odd value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Mask" \
-class "mask"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid mask $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "mask";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix masked; "$this" enableMaterialBundlesCopy 1 \
}

module -name "Max Absolute Value" \
-class "maxabs"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid maxabs $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "maxabs";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter 2nd input image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix maxabs \
}

module -name "Maximum With Image" \
-class "maximumimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid maximumimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "maximumimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter 2nd input image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix max \
}

module -name "Maximum With Value" \
-class "maximumvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid maximumvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "maximumvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix max \
}

module -name "Filter By Measure" \
-class "measurefilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Individual Measures}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid measurefilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "measurefilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt rename "inputIntensityImage" ; $this inputIntensityImage setLabel "Input Intensity Image" ; $this "inputIntensityImage" setTooltip "Enter intensity image (or select one in the list) "; \
   $this MsrInMsr rename "measure" ; $this measure setLabel "Measure" ; $this "measure" setTooltip "Select a measure "; \
   $this MMeasureFilterType rename "measureFilterType" ; $this measureFilterType setLabel "Measure Filter Type" ; $this "measureFilterType" setTooltip "Data filter type "; \
   $this INbPattern rename "numberOfPatterns" ; $this numberOfPatterns setLabel "Number Of Objects" ; $this "numberOfPatterns" setTooltip "Number of patterns to be detected "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix labels \
}

module -name "Median Filter" \
-class "medianfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid medianfilter $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "medianfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "iterations" ; $this iterations setLabel "Iterations" ; $this "iterations" setTooltip "Enter the number of iterations (to increment or decrement) "; \
   $this MMedian2DShape rename "type" ; $this type setLabel "Type" ; $this "type" setTooltip "Type "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Median Filter 3D" \
-class "medianfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid medianfilter3d $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "medianfilter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "iterations" ; $this iterations setLabel "Iterations" ; $this "iterations" setTooltip "Enter the number of iterations (to increment or decrement) "; \
   $this MMedian3DShape rename "type" ; $this type setLabel "Type" ; $this "type" setTooltip "Type "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "H-Maxima" \
-class "merge_maxima"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid merge_maxima $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "merge_maxima";\
   $this ImgGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IContrast rename "contrast" ; $this contrast setLabel "Contrast" ; $this "contrast" setTooltip "Enter the contrast ( to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix hMaxima \
}

module -name "H-Minima" \
-class "merge_minima"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid merge_minima $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "merge_minima";\
   $this ImgGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IContrast rename "contrast" ; $this contrast setLabel "Contrast" ; $this "contrast" setTooltip "Enter the contrast ( to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix hMinima \
}

module -name "Combine By Mask" \
-class "mergemask"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid mergemask $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "mergemask";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter 2nd input image (or select one in the list) "; \
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix merged \
}

module -name "Minimum With Image" \
-class "minimumimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid minimumimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "minimumimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "2nd input image "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix min \
}

module -name "Minimum With Value" \
-class "minimumvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid minimumvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "minimumvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input image "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Operand value "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix min \
}

module -name "Morphological Gradient" \
-class "morphogradient"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Gradient}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid morphogradient $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "morphogradient";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input Image "; \
   $this MMorphoGradMode rename "mode" ; $this mode setLabel "Mode" ; $this "mode" setTooltip "Select computation mode for morphological gradient "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix grad \
}

module -name "Morphological Laplacian" \
-class "morpholaplacian"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Laplacian}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid morpholaplacian $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "morpholaplacian";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Input Image "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix laplacian \
}

module -name "Multiply By Image" \
-class "multiplyimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid multiplyimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "multiplyimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix mult \
}

module -name "Multiply By Value" \
-class "multiplyvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid multiplyvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "multiplyvalue";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Enter the value to multiply "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix mult \
}

module -name "Nagao Filter" \
-class "nagaofilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid nagaofilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "nagaofilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MNagaoMode rename "filterType" ; $this filterType setLabel "Filter Type" ; $this "filterType" setTooltip "Filter type "; \
   $this MNagaoMethod rename "filterMethod" ; $this filterMethod setLabel "Filter Method" ; $this "filterMethod" setTooltip "Filter method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Nagao Filter 3D" \
-class "nagmodfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid nagmodfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "nagmodfilter3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MNagaoMethod rename "filterMethod" ; $this filterMethod setLabel "Filter Method" ; $this "filterMethod" setTooltip "Filter method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Invert" \
-class "negative"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid negative $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "negative";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this INbSigbits rename "numberOfSignificantBits" ; $this numberOfSignificantBits setLabel "Number Of Significant Bits" ; $this "numberOfSignificantBits" setTooltip "Number of significant bits "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix inverted \
}

module -name "Normalize Grayscale" \
-class "normalize"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid normalize $PRIMARY ] == 1 && [$PRIMARY hasInterface HxUniformColorField3] == 0 } \
-proc {  \
   $this wrap "normalize";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MPercentHisto rename "rangeMode" ; $this rangeMode setLabel "Range Mode" ; $this "rangeMode" setTooltip "Select a choice "; \
   $this FAPercentage rename "percentage" ; $this percentage setLabel "Percentage Range" ; $this "percentage" setTooltip "Low and High percentage "; \
   $this FARangeIn rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this FARangeOut rename "outputRange" ; $this outputRange setLabel "Output Range" ; $this "outputRange" setTooltip "Output range "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix corrected \
}

module -name "Reconstruction By Dilation" \
-class "numreconstruct"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid numreconstruct $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "numreconstruct";\
   $this ImgRctGrey rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image to reconstruct (or select one in the list) "; \
   $this ImgMarkerGrey rename "inputMarkerImage" ; $this inputMarkerImage setLabel "Input Marker Image" ; $this "inputMarkerImage" setTooltip "Enter input marker (gray) image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix reconstructed \
}

module -name "Object Boundary Area" \
-class "object_boundary_area"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_boundary_area $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_boundary_area";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Object Image Ratio" \
-class "object_image_ratio"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_image_ratio $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_image_ratio";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Object Linear Density" \
-class "object_linear_density"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_linear_density $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_linear_density";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this MTrabecularMode rename "model" ; $this model setLabel "Model" ; $this "model" setTooltip "Trabecular Mode "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Object Specific Surface" \
-class "object_specific_surface"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_specific_surface $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_specific_surface";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Object Surface Density" \
-class "object_surface_density"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_surface_density $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_surface_density";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Object Volume" \
-class "object_volume"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid object_volume $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "object_volume";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Cube" \
-class "opening"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid opening $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "opening";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Centered" \
-class "pgradient_centered2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_centered2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_centered2d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this IARotCenter rename "center" ; $this center setLabel "Center" ; $this "center" setTooltip "Object center "; \
   $this MGradNormOrTan rename "normalAndTangent" ; $this normalAndTangent setLabel "Normal And Tangent" ; $this "normalAndTangent" setTooltip "Select a choice "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal; "$this" setDefaultOutputSuffix 1 tangential; "$this" center setValue 0 0; "$this" center setValue 1 0 \
}

module -name "Centered 3D" \
-class "pgradient_centered3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_centered3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_centered3d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgZGrad rename "inputGradientZ" ; $this inputGradientZ setLabel "Input Gradient Z" ; $this "inputGradientZ" setTooltip "Enter input Z-Gradient (or select one in the list) "; \
   $this IA3DSize rename "center" ; $this center setLabel "Center" ; $this "center" setTooltip "Object center "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal; "$this" center setValue 0 0; "$this" center setValue 1 0; "$this" center setValue 2 0 \
}

module -name "Contour" \
-class "pgradient_contour2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_contour2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_contour2d";\
   $this ImgGrey1 rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgGrey2 rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this MGradNormOrTan rename "normalAndTangent" ; $this normalAndTangent setLabel "Normal And Tangent" ; $this "normalAndTangent" setTooltip "Select a choice "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal; "$this" setDefaultOutputSuffix 1 tangential \
}

module -name "Contour 3D" \
-class "pgradient_contour3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_contour3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_contour3d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgZGrad rename "inputGradientZ" ; $this inputGradientZ setLabel "Input Gradient Z" ; $this "inputGradientZ" setTooltip "Enter input Z-Gradient (or select one in the list) "; \
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal \
}

module -name "Label" \
-class "pgradient_label2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_label2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_label2d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this MGradNormOrTan rename "normalAndTangent" ; $this normalAndTangent setLabel "Normal And Tangent" ; $this "normalAndTangent" setTooltip "Select a choice "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal; "$this" setDefaultOutputSuffix 1 tangential \
}

module -name "Label 3D" \
-class "pgradient_label3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid pgradient_label3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "pgradient_label3d";\
   $this ImgXGrad rename "inputGradientX" ; $this inputGradientX setLabel "Input Gradient X" ; $this "inputGradientX" setTooltip "Enter input X-Gradient (or select one in the list) "; \
   $this ImgYGrad rename "inputGradientY" ; $this inputGradientY setLabel "Input Gradient Y" ; $this "inputGradientY" setTooltip "Enter input Y-Gradient (or select one in the list) "; \
   $this ImgZGrad rename "inputGradientZ" ; $this inputGradientZ setLabel "Input Gradient Z" ; $this "inputGradientZ" setTooltip "Enter input Z-Gradient (or select one in the list) "; \
   $this ImgLab rename "inputLabelImage" ; $this inputLabelImage setLabel "Input Label Image" ; $this "inputLabelImage" setTooltip "Enter input label image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 normal \
}

module -name "ASBMR Porosity" \
-class "porosity"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid porosity $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "porosity";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Uniform" \
-class "random"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "random";\
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this FMean rename "mean" ; $this mean setLabel "Mean" ; $this "mean" setTooltip "mean of random values "; \
   $this FRange rename "range" ; $this range setLabel "Range" ; $this "range" setTooltip "Range of random values "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix random \
}

module -name "Uniform 3D" \
-class "random3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "random3d";\
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this IImaSizeZ rename "sizeZ" ; $this sizeZ setLabel "Size Z \[px\]" ; $this "sizeZ" setTooltip "Z size of the new image "; \
   $this FMean rename "mean" ; $this mean setLabel "Mean" ; $this "mean" setTooltip "mean of random values "; \
   $this FRange rename "range" ; $this range setLabel "Range" ; $this "range" setTooltip "Range of random values "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix random \
}

module -name "Gaussian" \
-class "randomgauss"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "randomgauss";\
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this FMean rename "mean" ; $this mean setLabel "Mean" ; $this "mean" setTooltip "mean of random values "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix random \
}

module -name "Gaussian 3D" \
-class "randomgauss3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary ""  \
-dso "hxquant2" \
-proc {  \
   $this wrap "randomgauss3d";\
   $this MConvert rename "outputType" ; $this outputType setLabel "Output Type" ; $this "outputType" setTooltip "Arithmetic format "; \
   $this IImaSizeX rename "sizeX" ; $this sizeX setLabel "Size X \[px\]" ; $this "sizeX" setTooltip "X size of the new image "; \
   $this IImaSizeY rename "sizeY" ; $this sizeY setLabel "Size Y \[px\]" ; $this "sizeY" setTooltip "Y size of the new image "; \
   $this IImaSizeZ rename "sizeZ" ; $this sizeZ setLabel "Size Z \[px\]" ; $this "sizeZ" setTooltip "Z size of the new image "; \
   $this FMean rename "mean" ; $this mean setLabel "Mean" ; $this "mean" setTooltip "mean of random values "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix random \
}

module -name "Reconstruction From Markers" \
-class "reconstruct"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations} {Image Processing>Features Selection}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid reconstruct $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "reconstruct";\
   $this ImgBin1 rename "inputMaskImage" ; $this inputMaskImage setLabel "Input Mask Image" ; $this "inputMaskImage" setTooltip "Mask image constraining reconstruction "; \
   $this ImgBin2 rename "inputMarkerImage" ; $this inputMarkerImage setLabel "Input Marker Image" ; $this "inputMarkerImage" setTooltip "Marker image containing seeds for reconstruction "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" inputMarkerImage reposition 0; "$this" setDefaultOutputSuffix binary \
}

module -name "Recursive Exponential Filter" \
-class "recursive"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid recursive $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "recursive";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ISpread rename "spread" ; $this spread setLabel "Spread" ; $this "spread" setTooltip "Spread "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Recursive Exponential Filter 3D" \
-class "recursive3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid recursive3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "recursive3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ISpread rename "spread" ; $this spread setLabel "Spread" ; $this "spread" setTooltip "Spread "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Remove Small Holes" \
-class "removalsmallholes"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid removalsmallholes $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "removalsmallholes";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this FValue rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Maximum size of holes to delete (in pixel) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Remove Small Spots" \
-class "removalsmallspots"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid removalsmallspots $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "removalsmallspots";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this FValue rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Maximum size of objects to delete "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Recursive Gaussian Filter" \
-class "rgaussianfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid rgaussianfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "rgaussianfilter";\
   $this ImgIn rename "ImgIn" ; $this ImgIn setLabel "Input Image" ; $this "ImgIn" setTooltip "Enter input image (or select one in the list) "; \
   $this MCoordinateType rename "MCoordinateType" ; $this MCoordinateType setLabel "Coordinate Type" ; $this "MCoordinateType" setTooltip "Select the type of coordinate "; \
   $this FStdDevGaussX rename "FStdDevGaussX" ; $this FStdDevGaussX setLabel "Standard Deviation X \[px\]" ; $this "FStdDevGaussX" setTooltip "Standard deviation along X axis "; \
   $this FStdDevGaussY rename "FStdDevGaussY" ; $this FStdDevGaussY setLabel "Standard Deviation Y \[px\]" ; $this "FStdDevGaussY" setTooltip "Standard deviation along Y axis "; \
   $this FRealSizeX rename "FRealSizeX" ; $this FRealSizeX setLabel "Standard Deviation X" ; $this "FRealSizeX" setTooltip "Standard deviation along X axis (calibration unit) "; \
   $this FRealSizeY rename "FRealSizeY" ; $this FRealSizeY setLabel "Standard Deviation Y" ; $this "FRealSizeY" setTooltip "Standard deviation along Y axis (calibration unit) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Recursive Gaussian Filter 3D" \
-class "rgaussianfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid rgaussianfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "rgaussianfilter3d";\
   $this ImgIn3D rename "ImgIn" ; $this ImgIn setLabel "Input Image" ; $this "ImgIn" setTooltip "Enter input grey level image (or select one in the list) "; \
   $this MCoordinateType rename "MCoordinateType" ; $this MCoordinateType setLabel "Coordinate Type" ; $this "MCoordinateType" setTooltip "Select the type of coordinate "; \
   $this FStdDevGaussX rename "FStdDevGaussX" ; $this FStdDevGaussX setLabel "Standard Deviation X \[px\]" ; $this "FStdDevGaussX" setTooltip "Standard deviation along X axis "; \
   $this FStdDevGaussY rename "FStdDevGaussY" ; $this FStdDevGaussY setLabel "Standard Deviation Y \[px\]" ; $this "FStdDevGaussY" setTooltip "Standard deviation along Y axis "; \
   $this FStdDevGaussZ rename "FStdDevGaussZ" ; $this FStdDevGaussZ setLabel "Standard Deviation Z \[px\]" ; $this "FStdDevGaussZ" setTooltip "Standard deviation along Z axis "; \
   $this FRealSizeX rename "FRealSizeX" ; $this FRealSizeX setLabel "Standard Deviation X" ; $this "FRealSizeX" setTooltip "Standard deviation along X axis (calibration unit) "; \
   $this FRealSizeY rename "FRealSizeY" ; $this FRealSizeY setLabel "Standard Deviation Y" ; $this "FRealSizeY" setTooltip "Standard deviation along Y axis (calibration unit) "; \
   $this FRealSizeZ rename "FRealSizeZ" ; $this FRealSizeZ setLabel "Standard Deviation Z" ; $this "FRealSizeZ" setTooltip "Standard deviation along Z axis (calibration unit) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Dijkstra Shortest Path" \
-class "ridgelineimg"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Edge Marking}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ridgelineimg $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ridgelineimg";\
   $this ImgGrey rename "inputGrayscaleImage" ; $this inputGrayscaleImage setLabel "Input Grayscale Image" ; $this "inputGrayscaleImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ImgInt2 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this MAxisXY rename "axis" ; $this axis setLabel "Axis" ; $this "axis" setTooltip "Select axis "; \
   $this MTeinteLD rename "intensityMode" ; $this intensityMode setLabel "Intensity Mode" ; $this "intensityMode" setTooltip "Select the type of enclosed objects "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix path \
}

module -name "Recursive Laplacian" \
-class "rlaplacian"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Edge Detection>Laplacian}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid rlaplacian $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "rlaplacian";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ISpread rename "spread" ; $this spread setLabel "Spread" ; $this "spread" setTooltip "Spread "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix laplacian \
}

module -name "Recursive Laplacian 3D" \
-class "rlaplacian3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid rlaplacian3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "rlaplacian3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this ISpread rename "spread" ; $this spread setLabel "Spread" ; $this "spread" setTooltip "Spread "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix laplacian \
}

module -name "Polar To Cartesian" \
-class "rthetatoxy"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Frequency Domain}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid rthetatoxy $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "rthetatoxy";\
   $this ImgModul rename "inputModulus" ; $this inputModulus setLabel "Input Modulus" ; $this "inputModulus" setTooltip "Enter input modulus (or select one in the list) "; \
   $this ImgPhase rename "inputPhase" ; $this inputPhase setLabel "Input Phase" ; $this "inputPhase" setTooltip "Enter input phase (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 x; "$this" setDefaultOutputSuffix 1 y \
}

module -name "Separable Median Filter" \
-class "separablemedian"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid separablemedian $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "separablemedian";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Separable Median Filter 3D" \
-class "separablemedian3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid separablemedian3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "separablemedian3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Append" \
-class "seqconcat"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Volume Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid seqconcat $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "seqconcat";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter 2nd input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix append \
}

module -name "Shade" \
-class "shade"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Sharpening}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid shade $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "shade";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix shaded \
}

module -name "Shading Correction" \
-class "shading_corimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid shading_corimage $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 } \
-proc {  \
   $this wrap "shading_corimage";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgInt2 rename "blackReference" ; $this blackReference setLabel "Black Reference" ; $this "blackReference" setTooltip "Enter input black reference value or image (or select one in the list) "; \
   $this ImgInt3 rename "whiteReference" ; $this whiteReference setLabel "White Reference" ; $this "whiteReference" setTooltip "Enter input white reference image (or select one in the list) "; \
   $this FNorm rename "normalizationFactor" ; $this normalizationFactor setLabel "Normalization Factor" ; $this "normalizationFactor" setTooltip "Normalization factor "; \
   $this interpretation hide; \
   $this interpretation setValue 0; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix corrected \
}

module -name "Bit Shift" \
-class "shift"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Logical Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid shift $PRIMARY ] == 1 && [$PRIMARY primType] != 3 && [$PRIMARY primType] != 4 } \
-proc {  \
   $this wrap "shift";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this INbbits rename "numberOfShiftBits" ; $this numberOfShiftBits setLabel "Number Of Shift Bits" ; $this "numberOfShiftBits" setTooltip "Number of bits to shift "; \
   $this MShiftDir rename "shiftDirection" ; $this shiftDirection setLabel "Shift Direction" ; $this "shiftDirection" setTooltip "Shifting to "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix bitshift \
}

module -name "Sigma Filter" \
-class "sigmafilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid sigmafilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "sigmafilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size (odd value) "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this INbSigbits rename "populationThreshold" ; $this populationThreshold setLabel "Population Threshold" ; $this "populationThreshold" setTooltip "Population threshold "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Sigma Filter 3D" \
-class "sigmafilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid sigmafilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "sigmafilter3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size (odd value) "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size (odd value) "; \
   $this FStdDev rename "standardDeviation" ; $this standardDeviation setLabel "Standard Deviation" ; $this "standardDeviation" setTooltip "Standard deviation "; \
   $this INbSigbits rename "populationThreshold" ; $this populationThreshold setLabel "Population Threshold" ; $this "populationThreshold" setTooltip "Population threshold "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Influence Zones" \
-class "skiz"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Separating And Filling}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid skiz $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "skiz";\
   $this ImgLabBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary or label image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix zones \
}

module -name "SNN Filter" \
-class "snnfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Smoothing And Denoising}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid snnfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "snnfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Enter horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Enter vertical kernel size (odd value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "SNN Filter 3D" \
-class "snnfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid snnfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "snnfilter3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IKnlX rename "kernelSizeX" ; $this kernelSizeX setLabel "Kernel Size X \[px\]" ; $this "kernelSizeX" setTooltip "Horizontal kernel size (odd value) "; \
   $this IKnlY rename "kernelSizeY" ; $this kernelSizeY setLabel "Kernel Size Y \[px\]" ; $this "kernelSizeY" setTooltip "Vertical kernel size (odd value) "; \
   $this IKnlZ rename "kernelSizeZ" ; $this kernelSizeZ setLabel "Kernel Size Z \[px\]" ; $this "kernelSizeZ" setTooltip "Depth kernel size (odd value) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Ball" \
-class "sphereclosing3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid sphereclosing3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "sphereclosing3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Ball" \
-class "spheredilate3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid spheredilate3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "spheredilate3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix dilated \
}

module -name "Ball" \
-class "sphereerode3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid sphereerode3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "sphereerode3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Ball" \
-class "sphereopening3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid sphereopening3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "sphereopening3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this MPrecision rename "precision" ; $this precision setLabel "Precision" ; $this "precision" setTooltip "Select precision for computation method "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Square" \
-class "square"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid square $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "square";\
   $this ImgReal rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter floating point image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sqr \
}

module -name "Square Root" \
-class "square_root"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Grayscale Transforms}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid square_root $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "square_root";\
   $this ImgReal rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter floating point image (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sqrt \
}

module -name "Overall" \
-class "statistics"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid statistics $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "statistics";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MHisto rename "rangeMode" ; $this rangeMode setLabel "Range Mode" ; $this "rangeMode" setTooltip "Select a choice "; \
   $this IARange rename "inputRange" ; $this inputRange setLabel "Input Range" ; $this "inputRange" setTooltip "Input range "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix statistics \
}

module -name "Within Mask" \
-class "statmask"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid statmask $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "statmask";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Image Mask" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix statistics \
}

module -name "Structure Model index" \
-class "structure_model_index"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Morphometry (ASBMR)}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid structure_model_index $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "structure_model_index";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this IStructSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Enter the size of structuring element ( to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix measure \
}

module -name "Subtract Image" \
-class "subtractimage"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid subtractimage $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "subtractimage";\
   $this ImgIn1 rename "inputImage1" ; $this inputImage1 setLabel "Input Image 1" ; $this "inputImage1" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this ImgIn2 rename "inputImage2" ; $this inputImage2 setLabel "Input Image 2" ; $this "inputImage2" setTooltip "Enter input image 2 or a number (or select one in the list) "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sub \
}

module -name "Subtract Value" \
-class "subtractvalue"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Arithmetics Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid subtractvalue $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "subtractvalue";\
   $this ImgIn1 rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter 1st input image (or select one in the list) "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Enter the value to subtract "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix sub \
}

module -name "Texture Supervised Classification" \
-class "tex_classification"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Experimental>Image Segmentation>Classification}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid tex_classification $PRIMARY ] == 1 && [$PRIMARY hasInterface HxUniformColorField3] == 0 } \
-proc {  \
   $this wrap "tex_classification";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this ImgLab rename "trainingImage" ; $this trainingImage setLabel "Training Image" ; $this "trainingImage" setTooltip "Enter training image (or select one in the list) "; \
   $this MltChc_TextureFeatures rename "featureType" ; $this featureType setLabel "Feature Type" ; $this "featureType" setTooltip "Select the types of textural features that should be learned "; \
   $this INbIter2 rename "radius" ; $this radius setLabel "Radius" ; $this "radius" setTooltip "Radius of disk/sphere for computing texture features "; \
   $this MTextonShape rename "textonShape" ; $this textonShape setLabel "Texton Shape" ; $this "textonShape" setTooltip "Shape of the texture pattern used for computing cooccurrence based features "; \
   $this ICoef rename "textonSize" ; $this textonSize setLabel "Texton Size" ; $this "textonSize" setTooltip "Size of the texture pattern used for computing cooccurence based features "; \
   $this FAlpha rename "featureRejection" ; $this featureRejection setLabel "Feature Rejection (%)" ; $this "featureRejection" setTooltip "Threshold in percent for rejecting non discriminant features "; \
   $this FDist rename "thresholdDistance" ; $this thresholdDistance setLabel "Threshold Distance" ; $this "thresholdDistance" setTooltip "Threshold for rejecting uncertain pixels, i.e.when it is too far from the retained class, and assigning it 0 rather than a wrong label "; \
   $this interpretation hide; \
   $this finishInit; \
   "$this" featureRejection setMinMax 1 100; "$this" radius setMinMax 1 [$this radius getMaxValue]; "$this" textonSize setMinMax 1 [$this textonSize getMaxValue] \
}

module -name "Threshold by Criterion" \
-class "threshold_criterion"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Segmentation>Binarization}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid threshold_criterion $PRIMARY ] == 1 && [$PRIMARY hasInterface HxUniformColorField3] == 0 } \
-proc {  \
   $this wrap "threshold_criterion";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this MCmp rename "criterion" ; $this criterion setLabel "Criterion" ; $this "criterion" setTooltip "Select a comparison criterion "; \
   $this FValue rename "value" ; $this value setLabel "Value" ; $this "value" setTooltip "Enter a floating value "; \
   $this finishInit; \
}

module -name "Centroid Path Tortuosity" \
-class "tortuosity"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Propagation}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid tortuosity $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "tortuosity";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix tortuosity \
}

module -name "Ultimate Erosion" \
-class "ultimate"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Morphological Operations}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid ultimate $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "ultimate";\
   $this ImgBin rename "inputBinaryImage" ; $this inputBinaryImage setLabel "Input Binary Image" ; $this "inputBinaryImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this showPortNeighbourhood; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix eroded \
}

module -name "Minimal Linear" \
-class "unionlclosing"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid unionlclosing $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "unionlclosing";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this INbAngl rename "numberOfAngles" ; $this numberOfAngles setLabel "Number Of Angles" ; $this "numberOfAngles" setTooltip "Number of angles "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix closing \
}

module -name "Maximal Linear" \
-class "unionlopening"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid unionlopening $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "unionlopening";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the half-kernel size (to increment or decrement) "; \
   $this INbAngl rename "numberOfAngles" ; $this numberOfAngles setLabel "Number Of Angles" ; $this "numberOfAngles" setTooltip "Number of angles "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix opening \
}

module -name "Unsharp Masking" \
-class "unsharpmaskfilter"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Sharpening}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid unsharpmaskfilter $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "unsharpmaskfilter";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this FRange rename "edgeSize" ; $this edgeSize setLabel "Edge Size \[px\]" ; $this "edgeSize" setTooltip "Radius of the desired edges "; \
   $this FStdDev rename "edgeContrast" ; $this edgeContrast setLabel "Edge Contrast" ; $this "edgeContrast" setTooltip "Contrast amount added at the edges "; \
   $this FThr rename "brightnessThreshold" ; $this brightnessThreshold setLabel "Brightness Threshold" ; $this "brightnessThreshold" setTooltip "Minimum brightnesst threshold "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Unsharp Masking 3D" \
-class "unsharpmaskfilter3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid unsharpmaskfilter3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "unsharpmaskfilter3d";\
   $this ImgIn3D rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input gray level image (or select one in the list) "; \
   $this FRange rename "edgeSize" ; $this edgeSize setLabel "Edge Size \[px\]" ; $this "edgeSize" setTooltip "Radius of the desired edges "; \
   $this FStdDev rename "edgeContrast" ; $this edgeContrast setLabel "Edge Contrast" ; $this "edgeContrast" setTooltip "Contrast amount added at the edges "; \
   $this FThr rename "brightnessThreshold" ; $this brightnessThreshold setLabel "Brightness Threshold" ; $this "brightnessThreshold" setTooltip "Minimum brightnesst threshold "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix filtered \
}

module -name "Variance" \
-class "variance"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid variance $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "variance";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this IStructSize rename "size" ; $this size setLabel "Size \[px\]" ; $this "size" setTooltip "Enter the size of structuring element (+/- to increment or decrement) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix variance \
}

module -name "Intensity Integral" \
-class "volume"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze>Global Measures}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid volume $PRIMARY ] == 1 && [$PRIMARY hasInterface HxVisilogImageInterface] == 1  && [$PRIMARY isLabelImage] == 0 && [$PRIMARY isBinaryImage] == 0 } \
-proc {  \
   $this wrap "volume";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix volume \
}

module -name "Volume 3D" \
-class "volume3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid volume3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "volume3d";\
   $this ImgIn rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input image (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix volume \
}

module -name "Local Density Map" \
-class "volumedensity2d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Measure And Analyze}"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid volumedensity2d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "volumedensity2d";\
   $this ImgBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter input binary image (or select one in the list) "; \
   $this ImgBin1 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this IAKnlSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Kernel size "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix density \
}

module -name "Local Density Map 3D" \
-class "volumedensity3d"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "None"  \
-primary " HxIM6AsExternalData  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid volumedensity3d $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "volumedensity3d";\
   $this ImgIn3DBin rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter the name of a 3D binary image "; \
   $this ImgBin1 rename "inputImageMask" ; $this inputImageMask setLabel "Input Image Mask" ; $this "inputImageMask" setTooltip "Enter the binary image for the mask or empty (command looks for only inside) "; \
   $this IAKnl3DSize rename "kernelSize" ; $this kernelSize setLabel "Kernel Size \[px\]" ; $this "kernelSize" setTooltip "Kernel size "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix density \
}

module -name "Cartesian To Polar" \
-class "xytortheta"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Image Processing>Frequency Domain}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformScalarField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid xytortheta $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "xytortheta";\
   $this ImgReal rename "inputRealPart" ; $this inputRealPart setLabel "Input Real Part" ; $this "inputRealPart" setTooltip "Enter input real part (or select one in the list) "; \
   $this ImgImag rename "inputImaginaryPart" ; $this inputImaginaryPart setLabel "Input Imaginary Part" ; $this "inputImaginaryPart" setTooltip "Enter input imaginary part (or select one in the list) "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 r; "$this" setDefaultOutputSuffix 1 theta \
}

module -name "Image Stack Projection" \
-class "zstack"  \
-language "visilog" \
-icon "TVDefCompute" \
-color "#F97C7A" \
-category "{Compute>Volume Operations}"  \
-primary " HxVolumeDataObject  HxIM6AsExternalData  HxUniformColorField3  HxUniformScalarField3  HxUniformLabelField3 "  \
-dso "hxquant2" \
-check { [ HxQuant2GenericModule_isInputValid zstack $PRIMARY ] == 1 } \
-proc {  \
   $this wrap "zstack";\
   $this ImgSeq rename "inputImage" ; $this inputImage setLabel "Input Image" ; $this "inputImage" setTooltip "Enter a Visilog sequence (or select one in the list) "; \
   $this MZStack rename "processing" ; $this processing setLabel "Processing" ; $this "processing" setTooltip "Select the type of process "; \
   $this MNormalize rename "normalizationOption" ; $this normalizationOption setLabel "Normalization Option" ; $this "normalizationOption" setTooltip "Enter normalization option "; \
   $this ISmoothSize rename "smoothingSize" ; $this smoothingSize setLabel "Smoothing Size \[px\]" ; $this "smoothingSize" setTooltip "Enter the size for the smooth process "; \
   $this MZStackGrad rename "gradient" ; $this gradient setLabel "Gradient" ; $this "gradient" setTooltip "Select the type of process "; \
   $this finishInit; \
   "$this" setDefaultOutputSuffix 0 projection; "$this" setDefaultOutputSuffix 1 depth \
}

labelMeasure setVisible "Anisotropy" "Inertia" 
labelMeasure setVisible "Area" "Geometry" 
labelMeasure setVisible "Area3d" "Geometry" 
labelMeasure setVisible "AreaFraction" "Geometry" 
labelMeasure setVisible "BaryCenterX" "Locate" 
labelMeasure setVisible "BaryCenterY" "Locate" 
labelMeasure setVisible "BaryCenterZ" "Locate" 
labelMeasure setVisible "BinMom2x" "Inertia" 
labelMeasure setVisible "BinMom2y" "Inertia" 
labelMeasure setVisible "BinMom2z" "Inertia" 
labelMeasure setVisible "BinMomxy" "Inertia" 
labelMeasure setVisible "BinMomxz" "Inertia" 
labelMeasure setVisible "BinMomyz" "Inertia" 
labelMeasure setVisible "BorderVoxelCount" "Geometry" 
labelMeasure setVisible "BoundingBoxDx" "Locate" 
labelMeasure setVisible "BoundingBoxDy" "Locate" 
labelMeasure setVisible "BoundingBoxDz" "Locate" 
labelMeasure setVisible "BoundingBoxOx" "Locate" 
labelMeasure setVisible "BoundingBoxOy" "Locate" 
labelMeasure setVisible "BoundingBoxOz" "Locate" 
labelMeasure setVisible "Breadth3d" "Feret" 
labelMeasure setVisible "BreadthOrientPhi" "Feret" 
labelMeasure setVisible "BreadthOrientTheta" "Feret" 
labelMeasure setVisible "CircleDifArea" "Segment" 
labelMeasure setVisible "CnvxArea" "Segment" 
labelMeasure setVisible "CnvxPerimeter" "Segment" 
labelMeasure setVisible "CooccurrenceASM" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceCon" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceCor" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceDEn" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceDVa" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceDirX" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceDirY" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceEnt" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceIC1" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceIC2" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceIDM" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceNbPix" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceSAv" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceSEn" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceSSV" "Cooccurrence" 
labelMeasure setVisible "CooccurrenceSVa" "Cooccurrence" 
labelMeasure setVisible "CroftonPerimeter" "Geometry" 
labelMeasure setVisible "Distance" "Segment" 
labelMeasure setVisible "EigenVal1" "Inertia" 
labelMeasure setVisible "EigenVal2" "Inertia" 
labelMeasure setVisible "EigenVal3" "Inertia" 
labelMeasure setVisible "EigenVec1X" "Inertia" 
labelMeasure setVisible "EigenVec1Y" "Inertia" 
labelMeasure setVisible "EigenVec1Z" "Inertia" 
labelMeasure setVisible "EigenVec2X" "Inertia" 
labelMeasure setVisible "EigenVec2Y" "Inertia" 
labelMeasure setVisible "EigenVec2Z" "Inertia" 
labelMeasure setVisible "EigenVec3X" "Inertia" 
labelMeasure setVisible "EigenVec3Y" "Inertia" 
labelMeasure setVisible "EigenVec3Z" "Inertia" 
labelMeasure setVisible "EllipseDifArea" "Segment" 
labelMeasure setVisible "Elongation" "Inertia" 
labelMeasure setVisible "EnclCircleDifArea" "Segment" 
labelMeasure setVisible "EqDiameter" "Geometry" 
labelMeasure setVisible "Euler" "Geometry" 
labelMeasure setVisible "Euler3D" "Geometry" 
labelMeasure setVisible "Excentricity" "Geometry" 
labelMeasure setVisible "ExtentMax1" "Inertia" 
labelMeasure setVisible "ExtentMax2" "Inertia" 
labelMeasure setVisible "ExtentMax3" "Inertia" 
labelMeasure setVisible "ExtentMin1" "Inertia" 
labelMeasure setVisible "ExtentMin2" "Inertia" 
labelMeasure setVisible "ExtentMin3" "Inertia" 
labelMeasure setVisible "FeretDiameter" "Feret" 
labelMeasure setVisible "FeretInputX" "Feret" 
labelMeasure setVisible "FeretInputY" "Feret" 
labelMeasure setVisible "FeretOutputX" "Feret" 
labelMeasure setVisible "FeretOutputY" "Feret" 
labelMeasure setVisible "FeretShape" "Feret" 
labelMeasure setVisible "FeretShape3d" "Feret" 
labelMeasure setVisible "FirstPointX" "Locate" 
labelMeasure setVisible "FirstPointY" "Locate" 
labelMeasure setVisible "FirstPointZ" "Locate" 
labelMeasure setVisible "Flatness" "Inertia" 
labelMeasure setVisible "GreyAnisotropy" "Inertia" 
labelMeasure setVisible "GreyBaryCenterX" "Locate" 
labelMeasure setVisible "GreyBaryCenterY" "Locate" 
labelMeasure setVisible "GreyBaryCenterZ" "Locate" 
labelMeasure setVisible "GreyEigenVal1" "Inertia" 
labelMeasure setVisible "GreyEigenVal2" "Inertia" 
labelMeasure setVisible "GreyEigenVal3" "Inertia" 
labelMeasure setVisible "GreyEigenVec1X" "Inertia" 
labelMeasure setVisible "GreyEigenVec1Y" "Inertia" 
labelMeasure setVisible "GreyEigenVec1Z" "Inertia" 
labelMeasure setVisible "GreyEigenVec2X" "Inertia" 
labelMeasure setVisible "GreyEigenVec2Y" "Inertia" 
labelMeasure setVisible "GreyEigenVec2Z" "Inertia" 
labelMeasure setVisible "GreyEigenVec3X" "Inertia" 
labelMeasure setVisible "GreyEigenVec3Y" "Inertia" 
labelMeasure setVisible "GreyEigenVec3Z" "Inertia" 
labelMeasure setVisible "GreyElongation" "Inertia" 
labelMeasure setVisible "GreyExtentMax1" "Inertia" 
labelMeasure setVisible "GreyExtentMax2" "Inertia" 
labelMeasure setVisible "GreyExtentMax3" "Inertia" 
labelMeasure setVisible "GreyExtentMin1" "Inertia" 
labelMeasure setVisible "GreyExtentMin2" "Inertia" 
labelMeasure setVisible "GreyExtentMin3" "Inertia" 
labelMeasure setVisible "GreyFlatness" "Inertia" 
labelMeasure setVisible "GreyMoment2X" "Inertia" 
labelMeasure setVisible "GreyMoment2Y" "Inertia" 
labelMeasure setVisible "GreyMoment2Z" "Inertia" 
labelMeasure setVisible "GreyMomentXY" "Inertia" 
labelMeasure setVisible "GreyMomentXZ" "Inertia" 
labelMeasure setVisible "GreyMomentYZ" "Inertia" 
labelMeasure setVisible "HistoKurtosis" "Histogram" 
labelMeasure setVisible "HistoMean" "Histogram" 
labelMeasure setVisible "HistoPeak" "Histogram" 
labelMeasure setVisible "HistoQuantile10" "Histogram" 
labelMeasure setVisible "HistoQuantile25" "Histogram" 
labelMeasure setVisible "HistoQuantile50" "Histogram" 
labelMeasure setVisible "HistoQuantile75" "Histogram" 
labelMeasure setVisible "HistoQuantile90" "Histogram" 
labelMeasure setVisible "HistoQuantileR1" "Histogram" 
labelMeasure setVisible "HistoQuantileR2" "Histogram" 
labelMeasure setVisible "HistoQuantileR3" "Histogram" 
labelMeasure setVisible "HistoQuantileR4" "Histogram" 
labelMeasure setVisible "HistoQuantileR5" "Histogram" 
labelMeasure setVisible "HistoQuantileR6" "Histogram" 
labelMeasure setVisible "HistoSkewness" "Histogram" 
labelMeasure setVisible "HistoStddev" "Histogram" 
labelMeasure setVisible "HistoVariance" "Histogram" 
labelMeasure setVisible "InsideLength" "Segment" 
labelMeasure setVisible "IntegralMeanCurvature" "Geometry" 
labelMeasure setVisible "IntegralTotalCurvature" "Geometry" 
labelMeasure setVisible "Intercept0" "Intercept" 
labelMeasure setVisible "Intercept135" "Intercept" 
labelMeasure setVisible "Intercept45" "Intercept" 
labelMeasure setVisible "Intercept90" "Intercept" 
labelMeasure setVisible "Length" "Feret" 
labelMeasure setVisible "Length3d" "Feret" 
labelMeasure setVisible "LengthOrientPhi" "Feret" 
labelMeasure setVisible "LengthOrientTheta" "Feret" 
labelMeasure setVisible "LengthOrientation" "Feret" 
labelMeasure setVisible "Majority" "Intensity" 
labelMeasure setVisible "Maximum" "Intensity" 
labelMeasure setVisible "Mean" "Intensity" 
labelMeasure setVisible "Median" "Intensity" 
labelMeasure setVisible "Minimum" "Intensity" 
labelMeasure setVisible "NbHoles" "Geometry" 
labelMeasure setVisible "Orientation" "Geometry" 
labelMeasure setVisible "Orientation2Phi" "Geometry" 
labelMeasure setVisible "Orientation2Theta" "Geometry" 
labelMeasure setVisible "OrientationPhi" "Geometry" 
labelMeasure setVisible "OrientationTheta" "Geometry" 
labelMeasure setVisible "Perimeter" "Geometry" 
labelMeasure setVisible "Rugosity" "Segment" 
labelMeasure setVisible "SegArea" "Segment" 
labelMeasure setVisible "SegMRACenterX" "Segment" 
labelMeasure setVisible "SegMRACenterY" "Segment" 
labelMeasure setVisible "SegMRALength" "Segment" 
labelMeasure setVisible "SegMRAOrientation" "Segment" 
labelMeasure setVisible "SegMRAWidth" "Segment" 
labelMeasure setVisible "SegNbHoles" "Segment" 
labelMeasure setVisible "SegPerimeter" "Segment" 
labelMeasure setVisible "Shape_AP" "Geometry" 
labelMeasure setVisible "Shape_VA3d" "Geometry" 
labelMeasure setVisible "Stddev" "Intensity" 
labelMeasure setVisible "Symmetry" "Geometry" 
labelMeasure setVisible "Thickness3d" "Geometry" 
labelMeasure setVisible "Volume" "Geometry" 
labelMeasure setVisible "Volume2" "Geometry" 
labelMeasure setVisible "Volume3d" "Geometry" 
labelMeasure setVisible "VoxelFaceArea" "Geometry" 
labelMeasure setVisible "Width" "Feret" 
labelMeasure setVisible "Width3d" "Feret" 
labelMeasure setVisible "WidthOrientPhi" "Feret" 
labelMeasure setVisible "WidthOrientTheta" "Feret" 
labelMeasure setVisible "WidthOrientation" "Feret"