├── SimpleFilters ├── Testing │ ├── CMakeLists.txt │ └── Python │ │ ├── CMakeLists.txt │ │ └── SimpleFiltersModuleTest.py ├── Resources │ ├── Icons │ │ ├── ITK.png │ │ ├── Fiducials.png │ │ └── ScriptedLoadableModuleTemplate.png │ └── json │ │ ├── CastImageFilter.json │ │ ├── RoundImageFilter.json │ │ ├── LogImageFilter.json │ │ ├── ComplexToPhaseImageFilter.json │ │ ├── ComplexToModulusImageFilter.json │ │ ├── Log10ImageFilter.json │ │ ├── SqrtImageFilter.json │ │ ├── TanImageFilter.json │ │ ├── ExpImageFilter.json │ │ ├── ComplexToRealImageFilter.json │ │ ├── ComplexToImaginaryImageFilter.json │ │ ├── SinImageFilter.json │ │ ├── SquareImageFilter.json │ │ ├── ExpNegativeImageFilter.json │ │ ├── ModulusImageFilter.json │ │ ├── TernaryAddImageFilter.json │ │ ├── EdgePotentialImageFilter.json │ │ ├── MagnitudeAndPhaseToComplexImageFilter.json │ │ ├── AbsImageFilter.json │ │ ├── SobelEdgeDetectionImageFilter.json │ │ ├── MultiplyImageFilter.json │ │ ├── DivideImageFilter.json │ │ ├── AtanImageFilter.json │ │ ├── MaximumImageFilter.json │ │ ├── MinimumImageFilter.json │ │ ├── InverseFFTImageFilter.json │ │ ├── VectorMagnitudeImageFilter.json │ │ ├── BoundedReciprocalImageFilter.json │ │ ├── AsinImageFilter.json │ │ ├── TernaryMagnitudeImageFilter.json │ │ ├── AcosImageFilter.json │ │ ├── TernaryMagnitudeSquaredImageFilter.json │ │ ├── NotImageFilter.json │ │ ├── Atan2ImageFilter.json │ │ ├── GradientMagnitudeImageFilter.json │ │ ├── AndImageFilter.json │ │ ├── OrImageFilter.json │ │ ├── XorImageFilter.json │ │ ├── BinomialBlurImageFilter.json │ │ ├── CosImageFilter.json │ │ ├── PowImageFilter.json │ │ ├── ForwardFFTImageFilter.json │ │ ├── BitwiseNotImageFilter.json │ │ ├── MeanProjectionImageFilter.json │ │ ├── StandardDeviationProjectionImageFilter.json │ │ ├── NormalizeImageFilter.json │ │ ├── SumProjectionImageFilter.json │ │ ├── InvertIntensityImageFilter.json │ │ ├── BinaryThinningImageFilter.json │ │ ├── ValuedRegionalMinimaImageFilter.json │ │ ├── MorphologicalGradientImageFilter.json │ │ ├── ValuedRegionalMaximaImageFilter.json │ │ ├── BinaryMagnitudeImageFilter.json │ │ ├── RealToHalfHermitianForwardFFTImageFilter.json │ │ ├── RealAndImaginaryToComplexImageFilter.json │ │ ├── GrayscaleErodeImageFilter.json │ │ ├── GrayscaleDilateImageFilter.json │ │ ├── MeanImageFilter.json │ │ ├── VectorConnectedComponentImageFilter.json │ │ ├── DivideFloorImageFilter.json │ │ ├── GradientMagnitudeRecursiveGaussianImageFilter.json │ │ ├── LaplacianRecursiveGaussianImageFilter.json │ │ ├── DivideRealImageFilter.json │ │ ├── AbsoluteValueDifferenceImageFilter.json │ │ ├── ComposeImageFilter.json │ │ ├── MedianImageFilter.json │ │ ├── WhiteTopHatImageFilter.json │ │ ├── LaplacianImageFilter.json │ │ ├── MinimumMaximumImageFilter.json │ │ ├── NormalizeToConstantImageFilter.json │ │ ├── VectorIndexSelectionCastImageFilter.json │ │ ├── HalfHermitianToRealInverseFFTImageFilter.json │ │ ├── SubtractImageFilter.json │ │ ├── BoxMeanImageFilter.json │ │ ├── BoxSigmaImageFilter.json │ │ ├── SquaredDifferenceImageFilter.json │ │ ├── BlackTopHatImageFilter.json │ │ ├── FFTShiftImageFilter.json │ │ ├── GrayscaleMorphologicalClosingImageFilter.json │ │ ├── SigmoidImageFilter.json │ │ ├── MinimumProjectionImageFilter.json │ │ ├── LaplacianSharpeningImageFilter.json │ │ ├── NormalizedCorrelationImageFilter.json │ │ ├── ShiftScaleImageFilter.json │ │ ├── UnaryMinusImageFilter.json │ │ ├── MaximumProjectionImageFilter.json │ │ ├── MedianProjectionImageFilter.json │ │ ├── CyclicShiftImageFilter.json │ │ ├── SaltAndPepperNoiseImageFilter.json │ │ ├── ReconstructionByDilationImageFilter.json │ │ ├── ReconstructionByErosionImageFilter.json │ │ ├── SpeckleNoiseImageFilter.json │ │ ├── FastApproximateRankImageFilter.json │ │ ├── CheckerBoardImageFilter.json │ │ ├── FFTConvolutionImageFilter.json │ │ ├── BinShrinkImageFilter.json │ │ ├── NoiseImageFilter.json │ │ ├── RescaleIntensityImageFilter.json │ │ ├── AddImageFilter.json │ │ ├── IsoContourDistanceImageFilter.json │ │ ├── LabelContourImageFilter.json │ │ ├── InvertDisplacementFieldImageFilter.json │ │ ├── HMaximaImageFilter.json │ │ ├── IterativeInverseDisplacementFieldImageFilter.json │ │ ├── PhysicalPointImageSource.json │ │ ├── VotingBinaryHoleFillingImageFilter.json │ │ ├── WrapPadImageFilter.json │ │ ├── ZeroFluxNeumannPadImageFilter.json │ │ ├── BinaryNotImageFilter.json │ │ ├── LabelToRGBImageFilter.json │ │ └── NaryAddImageFilter.json └── CMakeLists.txt ├── SimpleFilters.png ├── .gitignore ├── README.md ├── CMakeLists.txt └── Utilities └── JSONGenerateWikiDocs.py /SimpleFilters/Testing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(Python) 2 | -------------------------------------------------------------------------------- /SimpleFilters.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SimpleITK/SlicerSimpleFilters/master/SimpleFilters.png -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | build 3 | *.o 4 | \#*\# 5 | *\# 6 | *~ 7 | *.pyc 8 | *.orig 9 | sitk-tmp 10 | -------------------------------------------------------------------------------- /SimpleFilters/Testing/Python/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | slicer_add_python_unittest(SCRIPT SimpleFiltersModuleTest.py) 3 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/Icons/ITK.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SimpleITK/SlicerSimpleFilters/master/SimpleFilters/Resources/Icons/ITK.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | SlicerSimpleFilters 2 | =================== 3 | 4 | A Module for Slicer to provide a simple GUI to image filters from the Insight Toolkit. 5 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/Icons/Fiducials.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SimpleITK/SlicerSimpleFilters/master/SimpleFilters/Resources/Icons/Fiducials.png -------------------------------------------------------------------------------- /SimpleFilters/Resources/Icons/ScriptedLoadableModuleTemplate.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SimpleITK/SlicerSimpleFilters/master/SimpleFilters/Resources/Icons/ScriptedLoadableModuleTemplate.png -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/CastImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "CastImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "number_of_inputs" : 1, 5 | "doc" : "", 6 | "pixel_types" : "not used", 7 | "output_pixel_type" : "not used", 8 | "members" : [ 9 | { 10 | "name" : "OutputPixelType", 11 | "type" : "PixelIDValueEnum", 12 | "default" : "not used", 13 | "briefdescriptionSet" : "Output pixel type to convert image to." 14 | } 15 | ], 16 | "briefdescription" : "Casts input image's pixels to output pixel type.\n", 17 | "detaileddescription" : "This filter converts images between many pixel types. The pixels are converted with a static_cast and results of overflow my give system dependent results." 18 | } 19 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/RoundImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "RoundImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "RealPixelIDTypeList", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "default", 12 | "description" : "Simply run with default settings", 13 | "settings" : [], 14 | "md5hash" : "3ccccde44efaa3d688a86e94335c1f16", 15 | "inputs" : [ 16 | "Input/RA-Float.nrrd" 17 | ] 18 | } 19 | ], 20 | "briefdescription" : "Rounds the value of each pixel.", 21 | "detaileddescription" : "The computations are performed using itk::Math::Round(x).", 22 | "itk_module" : "ITKImageIntensity" 23 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LogImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LogImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the log() of each pixel.", 22 | "detaileddescription" : "", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ComplexToPhaseImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ComplexToPhaseImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "output_pixel_type" : "typename InputImageType::PixelType::value_type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test Complex to Phase", 14 | "tolerance" : "0.0001", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-FFT-Complex.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes pixel-wise the modulus of a complex image.", 22 | "detaileddescription" : "", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ComplexToModulusImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ComplexToModulusImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "output_pixel_type" : "typename InputImageType::PixelType::value_type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test Complex to modulus", 14 | "tolerance" : "0.01", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-FFT-Complex.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes pixel-wise the Modulus of a complex image.", 22 | "detaileddescription" : "", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/Log10ImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "Log10ImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the log10 of each pixel.", 22 | "detaileddescription" : "The computation is performed using std::log10(x).", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SqrtImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SqrtImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the square root of each pixel.", 22 | "detaileddescription" : "The computations are performed using std::sqrt(x).", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/TanImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "TanImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the tangent of each input pixel.", 22 | "detaileddescription" : "The computations are performed using std::tan(x).", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ExpImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ExpImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the exponential function of each pixel.", 22 | "detaileddescription" : "The computation is performed using std::exp(x).", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ComplexToRealImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ComplexToRealImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "output_pixel_type" : "typename InputImageType::PixelType::value_type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test Complex to real", 14 | "md5hash" : "3278e36babb23c17fecc09d2e1b3f575", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-FFT-Complex.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes pixel-wise the real(x) part of a complex image.", 22 | "detaileddescription" : "", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ComplexToImaginaryImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ComplexToImaginaryImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "output_pixel_type" : "typename InputImageType::PixelType::value_type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test Complex to imaginary", 14 | "md5hash" : "3be155009ce0f99e56293002c4ba1b2a", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-FFT-Complex.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes pixel-wise the imaginary part of a complex image.", 22 | "detaileddescription" : "", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SinImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SinImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the sine of each pixel.", 22 | "detaileddescription" : "The computations are performed using std::sin(x).\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the sine of each pixel.", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SquareImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SquareImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "314065b457b66e102b9cafd7c49be6b3", 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the square of the intensity values pixel-wise.", 22 | "detaileddescription" : "\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Square every pixel in an image", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | #----------------------------------------------------------------------------- 2 | set(MODULE_NAME SimpleFilters) 3 | 4 | #----------------------------------------------------------------------------- 5 | set(MODULE_PYTHON_SCRIPTS 6 | ${MODULE_NAME}.py 7 | ) 8 | 9 | file(GLOB SimpleFilters_JSON RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "Resources/json/*.json") 10 | set(MODULE_PYTHON_RESOURCES 11 | "Resources/Icons/ITK.png" 12 | "Resources/Icons/Fiducials.png" 13 | ${SimpleFilters_JSON} 14 | ) 15 | 16 | #----------------------------------------------------------------------------- 17 | slicerMacroBuildScriptedModule( 18 | NAME ${MODULE_NAME} 19 | SCRIPTS ${MODULE_PYTHON_SCRIPTS} 20 | RESOURCES ${MODULE_PYTHON_RESOURCES} 21 | WITH_GENERIC_TESTS 22 | ) 23 | 24 | #----------------------------------------------------------------------------- 25 | if(BUILD_TESTING) 26 | 27 | # Additional build-time testing 28 | add_subdirectory(Testing) 29 | endif() 30 | 31 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ExpNegativeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ExpNegativeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the function exp(-K.x) for each input pixel.", 22 | "detaileddescription" : "Every output pixel is equal to std::exp(-K.x ). where x is the intensity of the homologous input pixel, and K is a user-provided constant.", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ModulusImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ModulusImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "uint32_t", 6 | "number_of_inputs" : 2, 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "defaults", 12 | "description" : "Simply run with default settings", 13 | "settings" : [], 14 | "md5hash" : "12fd4fb023059d4659d30ee449bb6599", 15 | "inputs" : [ 16 | "Input/STAPLE1.png", 17 | "Input/STAPLE2.png" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the modulus (x % dividend) pixel-wise.", 22 | "detaileddescription" : "The input pixel type must support the c++ modulus operator (%).\n\nIf the dividend is zero, the maximum value will be returned.\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/TernaryAddImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "TernaryAddImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 3, 6 | "doc" : "", 7 | "filter_type" : "itk::TernaryAddImageFilter", 8 | "pixel_types" : "NonLabelPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2d", 13 | "description" : "2D", 14 | "inputs" : [ 15 | "Input/STAPLE1.png", 16 | "Input/STAPLE2.png", 17 | "Input/STAPLE1.png" 18 | ], 19 | "settings" : [], 20 | "md5hash" : "dbe269ea2abf0fbe16e9e5d633afea51" 21 | } 22 | ], 23 | "briefdescription" : "Pixel-wise addition of three images.", 24 | "detaileddescription" : "This class is templated over the types of the three input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.", 25 | "itk_module" : "ITKImageIntensity", 26 | "itk_group" : "ImageIntensity" 27 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/EdgePotentialImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "EdgePotentialImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "VectorPixelIDTypeList", 8 | "output_pixel_type" : "typename itk::NumericTraits::ValueType>::RealType", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : "0.0001", 16 | "inputs" : [ 17 | "Input/RA-Gradient.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the edge potential of an image from the image gradient.", 22 | "detaileddescription" : "Input to this filter should be a CovariantVector image representing the image gradient.\n\nThe filter expect both the input and output images to have the same number of dimensions, and the output to be of a scalar image type.", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MagnitudeAndPhaseToComplexImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MagnitudeAndPhaseToComplexImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "RealPixelIDTypeList", 9 | "output_pixel_type" : "std::complex", 10 | "members" : [], 11 | "tests" : [ 12 | { 13 | "tag" : "defaults", 14 | "description" : "Test defaults", 15 | "tolerance" : "0.0015", 16 | "settings" : [], 17 | "inputs" : [ 18 | "Input/RA-Slice-Float.nrrd", 19 | "Input/RA-Slice-Float.nrrd" 20 | ] 21 | } 22 | ], 23 | "briefdescription" : "Implements pixel-wise conversion of magnitude and phase data into complex voxels.", 24 | "detaileddescription" : "This filter is parametrized over the types of the two input images and the type of the output image.\n\nThe filter expect all images to have the same dimension (e.g. all 2D, or all 3D, or all ND)", 25 | "itk_module" : "ITKImageIntensity", 26 | "itk_group" : "ImageIntensity" 27 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AbsImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AbsImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Compute the voxel-wise absolute value of an image", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "float", 13 | "description" : "Abs of a float image", 14 | "tolerance" : 0.01, 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-Slice-Float.nrrd" 18 | ] 19 | }, 20 | { 21 | "tag" : "short", 22 | "description" : "Abs of a short image", 23 | "tolerance" : 0.01, 24 | "settings" : [], 25 | "inputs" : [ 26 | "Input/RA-Slice-Short.nrrd" 27 | ] 28 | } 29 | ], 30 | "briefdescription" : "Computes the absolute value of each pixel.", 31 | "detaileddescription" : "itk::Math::abs() is used to perform the computation.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the absolute value of an image", 32 | "itk_module" : "ITKImageIntensity", 33 | "itk_group" : "ImageIntensity" 34 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SobelEdgeDetectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SobelEdgeDetectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "RealPixelIDTypeList", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "defaults", 12 | "description" : "Simply run with default settings", 13 | "settings" : [], 14 | "tolerance" : 0.01, 15 | "inputs" : [ 16 | "Input/RA-Float.nrrd" 17 | ] 18 | } 19 | ], 20 | "briefdescription" : "A 2D or 3D edge detection using the Sobel operator.", 21 | "detaileddescription" : "This filter uses the Sobel operator to calculate the image gradient and then finds the magnitude of this gradient vector. The Sobel gradient magnitude (square-root sum of squares) is an indication of edge strength.\n\n\\see ImageToImageFilter \n\n\\see SobelOperator \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li SobelEdgeDetectionImageFilter", 22 | "itk_module" : "ITKImageFeature", 23 | "itk_group" : "ImageFeature" 24 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MultiplyImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MultiplyImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "typelist::Append::Type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "1f733047e37adf9589c695500820110b", 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd", 18 | "Input/Ramp-One-Zero-Float.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Pixel-wise multiplication of two images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Multiply two images together \n\n\\li Multiply every pixel in an image by a constant", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.13.0) 2 | 3 | project(SimpleFilters) 4 | 5 | #----------------------------------------------------------------------------- 6 | set(EXTENSION_HOMEPAGE "http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/SimpleFilters") 7 | set(EXTENSION_CATEGORY "Filtering") 8 | set(EXTENSION_CONTRIBUTORS "Bradley Lowekamp (MSC/NLM), Steve Pieper (Isomics), Jean-Christophe Fillion-Robin (Kitware)" ) 9 | set(EXTENSION_DESCRIPTION "This is a meta module which contains interfaces for many Simple ITK image filters.") 10 | set(EXTENSION_ICONURL "http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Extensions/Testing/SimpleFilters/SimpleFilters.png?revision=21747&view=co") 11 | set(EXTENSION_SCREENSHOTURLS "http://wiki.slicer.org/slicerWiki/images/e/e2/Slicer-r19441-SimpleFilters-screenshot.png") 12 | 13 | #----------------------------------------------------------------------------- 14 | find_package(Slicer REQUIRED) 15 | include(${Slicer_USE_FILE}) 16 | 17 | #----------------------------------------------------------------------------- 18 | add_subdirectory(SimpleFilters) 19 | 20 | #----------------------------------------------------------------------------- 21 | include(${Slicer_EXTENSION_CPACK}) 22 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/DivideImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "DivideImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "typelist::Append::Type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "af2d18b65fdfa4f9cb1e84c777b4a72b", 16 | "inputs" : [ 17 | "Input/Ramp-Up-Short.nrrd", 18 | "Input/Ramp-Down-Short.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Pixel-wise division of two images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. When the divisor is zero, the division result is set to the maximum number that can be represented by default to avoid exception. Numeric conversions (castings) are done by the C++ defaults.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Pixel-wise division of two images", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AtanImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AtanImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the one-argument inverse tangent of each pixel.", 22 | "detaileddescription" : "This filter is templated over the pixel type of the input image and the pixel type of the output image.\n\nThe filter walks over all the pixels in the input image, and for each pixel does the following:\n\n\n\\li cast the pixel value to double , \n\n\\li apply the std::atan() function to the double value, \n\n\\li cast the double value resulting from std::atan() to the pixel type of the output image, \n\n\\li store the cast value into the output image.", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MaximumImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MaximumImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "00c5a06c3a1b3be415732bd5073450ef", 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd", 18 | "Input/Ramp-One-Zero-Float.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Implements a pixel-wise operator Max(a,b) between two images.", 23 | "detaileddescription" : "The pixel values of the output image are the maximum between the corresponding pixels of the two input images.\n\nThis class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Pixel wise compare two input images and set the output pixel to their max", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MinimumImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MinimumImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "35088a16227bda50ff5c93baa2199a17", 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd", 18 | "Input/Ramp-One-Zero-Float.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Implements a pixel-wise operator Min(a,b) between two images.", 23 | "detaileddescription" : "The pixel values of the output image are the minimum between the corresponding pixels of the two input images.\n\nThis class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Pixel wise compare two input images and set the output pixel to their min", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/InverseFFTImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "InverseFFTImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "filter_type" : "itk::InverseFFTImageFilter", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test Inverse FFT", 14 | "tolerance" : "0.01", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-FFT-Complex.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Base class for inverse Fast Fourier Transform .", 22 | "detaileddescription" : "This is a base class for the \"inverse\" or \"reverse\" Discrete Fourier Transform . This is an abstract base class: the actual implementation is provided by the best child available on the system when the object is created via the object factory system.\n\nThis class transforms a full complex image with Hermitian symmetry into its real spatial domain representation. If the input does not have Hermitian symmetry, the imaginary component is discarded.\n\n\\see ForwardFFTImageFilter , InverseFFTImageFilter", 23 | "itk_module" : "ITKFFT", 24 | "itk_group" : "FFT" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/VectorMagnitudeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "VectorMagnitudeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "VectorPixelIDTypeList", 8 | "filter_type" : "itk::VectorMagnitudeImageFilter< InputImageType, itk::Image::ValueType, InputImageType::ImageDimension> >", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "3d", 13 | "description" : "3D", 14 | "settings" : [], 15 | "tolerance" : "0.0001", 16 | "inputs" : [ 17 | "Input/RA-Gradient.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Take an image of vectors as input and produce an image with the magnitude of those vectors.", 22 | "detaileddescription" : "The filter expects the input image pixel type to be a vector and the output image pixel type to be a scalar.\n\nThis filter assumes that the PixelType of the input image is a VectorType that provides a GetNorm() method.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the magnitude of each pixel in a vector image to produce a magnitude image", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BoundedReciprocalImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BoundedReciprocalImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 9 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 10 | "members" : [], 11 | "tests" : [ 12 | { 13 | "tag" : "defaults", 14 | "description" : "Simply run with default settings", 15 | "settings" : [], 16 | "tolerance" : 0.01, 17 | "inputs" : [ 18 | "Input/Ramp-Zero-One-Float.nrrd" 19 | ] 20 | }, 21 | { 22 | "tag" : "vector", 23 | "description" : "Simply run with default settings for a vector image", 24 | "settings" : [], 25 | "tolerance" : "0.0001", 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGB.png" 28 | ] 29 | } 30 | ], 31 | "briefdescription" : "Computes 1/(1+x) for each pixel in the image.", 32 | "detaileddescription" : "The filter expect both the input and output images to have the same number of dimensions, and both of a scalar image type.", 33 | "itk_module" : "ITKImageIntensity", 34 | "itk_group" : "ImageIntensity" 35 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AsinImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AsinImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the sine of each pixel.", 22 | "detaileddescription" : "This filter is templated over the pixel type of the input image and the pixel type of the output image.\n\nThe filter walks over all the pixels in the input image, and for each pixel does the following:\n\n\n\\li cast the pixel value to double , \n\n\\li apply the std::asin() function to the double value, \n\n\\li cast the double value resulting from std::asin() to the pixel type of the output image, \n\n\\li store the casted value into the output image.\n\n\nThe filter expects both images to have the same dimension (e.g. both 2D, or both 3D, or both ND)", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/TernaryMagnitudeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "TernaryMagnitudeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 3, 6 | "doc" : "", 7 | "filter_type" : "itk::TernaryMagnitudeImageFilter", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2d", 13 | "description" : "2D", 14 | "inputs" : [ 15 | "Input/STAPLE1.png", 16 | "Input/STAPLE2.png", 17 | "Input/STAPLE1.png" 18 | ], 19 | "settings" : [], 20 | "md5hash" : "eca4bb7103117968b758a3f24f60a01a" 21 | }, 22 | { 23 | "tag" : "3d", 24 | "description" : "3D", 25 | "inputs" : [ 26 | "Input/RA-Float.nrrd", 27 | "Input/RA-Float.nrrd", 28 | "Input/RA-Float.nrrd" 29 | ], 30 | "settings" : [], 31 | "tolerance" : 0.002 32 | } 33 | ], 34 | "briefdescription" : "Compute the pixel-wise magnitude of three images.", 35 | "detaileddescription" : "This class is templated over the types of the three input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.", 36 | "itk_module" : "ITKImageIntensity", 37 | "itk_group" : "ImageIntensity" 38 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AcosImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AcosImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Computes the inverse cosine of each pixel.", 22 | "detaileddescription" : "This filter is templated over the pixel type of the input image and the pixel type of the output image.\n\nThe filter walks over all the pixels in the input image, and for each pixel does do the following:\n\n\n\\li cast the pixel value to double , \n\n\\li apply the std::acos() function to the double value \n\n\\li cast the double value resulting from std::acos() to the pixel type of the output image \n\n\\li store the casted value into the output image.\n\n\nThe filter expects both images to have the same dimension (e.g. both 2D, or both 3D, or both ND).", 23 | "itk_module" : "ITKImageIntensity", 24 | "itk_group" : "ImageIntensity" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/TernaryMagnitudeSquaredImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "TernaryMagnitudeSquaredImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 3, 6 | "doc" : "", 7 | "filter_type" : "itk::TernaryMagnitudeSquaredImageFilter", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2d", 13 | "description" : "2D", 14 | "inputs" : [ 15 | "Input/STAPLE1.png", 16 | "Input/STAPLE2.png", 17 | "Input/STAPLE1.png" 18 | ], 19 | "settings" : [], 20 | "md5hash" : "b095bd511398c8d902bf27566760c6dd" 21 | }, 22 | { 23 | "tag" : "3d", 24 | "description" : "3D", 25 | "inputs" : [ 26 | "Input/RA-Float.nrrd", 27 | "Input/RA-Float.nrrd", 28 | "Input/RA-Float.nrrd" 29 | ], 30 | "settings" : [], 31 | "tolerance" : 100.0 32 | } 33 | ], 34 | "briefdescription" : "Compute the pixel-wise squared magnitude of three images.", 35 | "detaileddescription" : "This class is templated over the types of the three input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.", 36 | "itk_module" : "ITKImageIntensity", 37 | "itk_group" : "ImageIntensity" 38 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NotImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NotImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "defaults", 12 | "description" : "Simply run with default settings", 13 | "settings" : [], 14 | "md5hash" : "2004dccdb2d68b953fd858a5b6a37d35", 15 | "inputs" : [ 16 | "Input/STAPLE1.png" 17 | ] 18 | } 19 | ], 20 | "briefdescription" : "Implements the NOT logical operator pixel-wise on an image.", 21 | "detaileddescription" : "This class is templated over the type of an input image and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nSince the logical NOT operation operates only on boolean types, the input type must be implicitly convertible to bool, which is only defined in C++ for integer types, the images passed to this filter must comply with the requirement of using integer pixel type.\n\nThe total operation over one pixel will be\n\n\\code\n* if( !A )\n\n* {\n\n* return this->m_ForegroundValue;\n\n* }\n\n* return this->m_BackgroundValue;\n\n* \n\n\\endcode\n\nWhere \"!\" is the unary Logical NOT operator in C++.", 22 | "itk_module" : "ITKImageIntensity", 23 | "itk_group" : "ImageIntensity" 24 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/Atan2ImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "Atan2ImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.01, 16 | "inputs" : [ 17 | "Input/Ramp-Zero-One-Float.nrrd", 18 | "Input/Ramp-One-Zero-Float.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Computes two argument inverse tangent.", 23 | "detaileddescription" : "The first argument to the atan function is provided by a pixel in the first input image (SetInput1() ) and the corresponding pixel in the second input image (SetInput2() ) is used as the second argument.\n\nThis class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nBoth pixel input types are cast to double in order to be used as parameters of std::atan2() . The resulting double value is cast to the output pixel type.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the arctangent of each pixel.", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/GradientMagnitudeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "GradientMagnitudeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "float", 9 | "members" : [ 10 | { 11 | "name" : "UseImageSpacing", 12 | "type" : "bool", 13 | "default" : "true", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "default", 23 | "description" : "Simply run with default settings", 24 | "settings" : [], 25 | "tolerance" : 1e-05, 26 | "inputs" : [ 27 | "Input/RA-Float.nrrd" 28 | ] 29 | } 30 | ], 31 | "briefdescription" : "Computes the gradient magnitude of an image region at each pixel.", 32 | "detaileddescription" : "\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the gradient magnitude image", 33 | "itk_module" : "ITKImageGradient", 34 | "itk_group" : "ImageGradient" 35 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AndImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AndImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "int", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "IntegerPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "a216e4eac5235a2c9e4fd473bd9b3947", 16 | "inputs" : [ 17 | "Input/STAPLE1.png", 18 | "Input/STAPLE2.png" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Implements the AND bitwise operator pixel-wise between two images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nSince the bitwise AND operation is only defined in C++ for integer types, the images passed to this filter must comply with the requirement of using integer pixel type.\n\nThe total operation over one pixel will be \\code\n* output_pixel = static_cast( input1_pixel & input2_pixel )\n\n* \n\n\\endcode\n Where \"&\" is the bitwise AND operator in C++.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Binary AND two images", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/OrImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "OrImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "int", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "IntegerPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "5cd4b5af0cdc5935e8ee76a9b5e39669", 16 | "inputs" : [ 17 | "Input/STAPLE1.png", 18 | "Input/STAPLE2.png" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Implements the OR bitwise operator pixel-wise between two images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nSince the bitwise OR operation is only defined in C++ for integer types, the images passed to this filter must comply with the requirement of using integer pixel type.\n\nThe total operation over one pixel will be\n\n\\code\n* output_pixel = static_cast( input1_pixel | input2_pixel )\n\n* \n\n\\endcode\n\nWhere \"|\" is the boolean OR operator in C++.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Binary OR two images", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/XorImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "XorImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "int", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "IntegerPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "md5hash" : "f6b04487e9d8d12d737802e1a8e78c0b", 16 | "inputs" : [ 17 | "Input/STAPLE1.png", 18 | "Input/STAPLE2.png" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Computes the XOR bitwise operator pixel-wise between two images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nSince the bitwise XOR operation is only defined in C++ for integer types, the images passed to this filter must comply with the requirement of using integer pixel type.\n\nThe total operation over one pixel will be\n\n\\code\n* output_pixel = static_cast( input1_pixel ^ input2_pixel )\n\n* \n\n\\endcode\n\nWhere \"^\" is the boolean XOR operator in C++.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Binary XOR (exclusive OR) two images", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BinomialBlurImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BinomialBlurImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Repetitions", 12 | "type" : "unsigned int", 13 | "default" : "1u", 14 | "doc" : "", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Get and set the number of times to repeat the filter.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Get and set the number of times to repeat the filter." 19 | } 20 | ], 21 | "tests" : [ 22 | { 23 | "tag" : "defaults", 24 | "description" : "Test BinomialBlurImageFilter with default parametrs", 25 | "md5hash" : "ccd2e6e83817056f586e37f59e43bfff", 26 | "settings" : [], 27 | "inputs" : [ 28 | "Input/VM1111Shrink-RGBFloat.nrrd" 29 | ] 30 | } 31 | ], 32 | "briefdescription" : "Performs a separable blur on each dimension of an image.", 33 | "detaileddescription" : "The binomial blur consists of a nearest neighbor average along each image dimension. The net result after n-iterations approaches convultion with a gaussian.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Blur an image", 34 | "itk_module" : "ITKSmoothing", 35 | "itk_group" : "Smoothing" 36 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/CosImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "CosImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "float", 13 | "description" : "Cosine of an image", 14 | "tolerance" : 0.01, 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-Slice-Float.nrrd" 18 | ] 19 | }, 20 | { 21 | "tag" : "short", 22 | "description" : "Cosine of an image", 23 | "tolerance" : 0.01, 24 | "settings" : [], 25 | "inputs" : [ 26 | "Input/RA-Slice-Short.nrrd" 27 | ] 28 | } 29 | ], 30 | "briefdescription" : "Computes the cosine of each pixel.", 31 | "detaileddescription" : "This filter is templated over the pixel type of the input image and the pixel type of the output image.\n\nThe filter walks over all of the pixels in the input image, and for each pixel does the following:\n\n\n\\li cast the pixel value to double , \n\n\\li apply the std::cos() function to the double value, \n\n\\li cast the double value resulting from std::cos() to the pixel type of the output image, \n\n\\li store the cast value into the output image.\n\n\nThe filter expects both images to have the same dimension (e.g. both 2D, or both 3D, or both ND)", 32 | "itk_module" : "ITKImageIntensity", 33 | "itk_group" : "ImageIntensity" 34 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/PowImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "PowImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "typelist::Append::Type", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Simply run with default settings", 14 | "settings" : [], 15 | "tolerance" : 0.001, 16 | "inputs" : [ 17 | "Input/RA-Float.nrrd", 18 | "Input/RA-Float.nrrd" 19 | ] 20 | } 21 | ], 22 | "briefdescription" : "Computes the powers of 2 images.", 23 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nThe output of the pow function will be cast to the pixel type of the output image.\n\nThe total operation over one pixel will be \\code\n* output_pixel = static_cast< TOutput >( std::pow(static_cast(A),static_cast(B)) );\n\n* \n\n\\endcode\n\nThe pow function can be applied to two images with the following: \\code\n* SetInput1 ( image1 );\n\n* SetInput2 ( image2 );\n\n* \n\n\\endcode\n\nAdditionally, this filter can be used to raise every pixel of an image to a power of a constant by using \\code\n* SetInput1 ( image1 );\n\n* SetConstant2 ( constant );\n\n* \n\n\\endcode", 24 | "itk_module" : "ITKImageIntensity", 25 | "itk_group" : "ImageIntensity" 26 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ForwardFFTImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ForwardFFTImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "RealPixelIDTypeList", 8 | "filter_type" : "itk::ForwardFFTImageFilter", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test ForwardFFT", 14 | "tolerance" : "0.09", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-Slice-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Base class for forward Fast Fourier Transform .", 22 | "detaileddescription" : "This is a base class for the \"forward\" or \"direct\" discrete Fourier Transform . This is an abstract base class: the actual implementation is provided by the best child class available on the system when the object is created via the object factory system.\n\nThis class transforms a real input image into its full complex Fourier transform. The Fourier transform of a real input image has Hermitian symmetry: \\f$ f(\\mathbf{x}) = f^*(-\\mathbf{x}) \\f$ . That is, when the result of the transform is split in half along the x-dimension, the values in the second half of the transform are the complex conjugates of values in the first half reflected about the center of the image in each dimension.\n\nThis filter works only for real single-component input image types.\n\n\\see InverseFFTImageFilter , FFTComplexToComplexImageFilter", 23 | "itk_module" : "ITKFFT", 24 | "itk_group" : "FFT" 25 | } -------------------------------------------------------------------------------- /Utilities/JSONGenerateWikiDocs.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # JSONGenerateWikiDocs.py 4 | # 5 | # This scripts read in the SimpleITK JSON descriptions of filters, and 6 | # the text output produces if for inclusion in a Wiki for 7 | # documentation. 8 | # 9 | # Usage: Utilities/JSONGenerateWikiDocs.py SimpleFilters/Resources/json/*.json 10 | # 11 | 12 | import json 13 | import sys 14 | try: 15 | from collections import OrderedDict 16 | except ImportError: 17 | import ordereddict as OrderedDict 18 | 19 | # This script takes one argument the name of a json file. 20 | # 21 | 22 | print("""{| border="1" style="border-collapse:collapse;" 23 | |- 24 | ! Filter Name 25 | ! Brief Description 26 | ! ITK Class""") 27 | 28 | entryFormat = "|-\n! {0}\n! {1}\n! [http://www.itk.org/Doxygen/html/classitk_1_1{2}.html {2}]" 29 | for fname in sys.argv[1:]: 30 | 31 | with file( fname, "r" ) as fp: 32 | j = json.load( fp,object_pairs_hook=OrderedDict ) 33 | 34 | 35 | jsonName = j["name"] 36 | 37 | if "briefdescription" in j: 38 | jsonBrief = j["briefdescription"] 39 | else: 40 | jsonBrief = "" 41 | 42 | if "itk_name" in j: 43 | jsonITK = j["itk_name"] 44 | elif "filter_type" in j: 45 | filter_type = j["filter_type"] 46 | if filter_type.startswith("itk::"): 47 | filter_type = filter_type[len("itk::"):] 48 | i=filter_type.find('<') 49 | if (i)!=-1: 50 | filter_type=filter_type[:i] 51 | jsonITK = filter_type 52 | else: 53 | jsonITK = jsonName 54 | 55 | print(entryFormat.format(jsonName, jsonBrief, jsonITK)) 56 | 57 | print("|}") 58 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BitwiseNotImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BitwiseNotImageFilter", 3 | "itk_name" : "UnaryFunctorImageFilter", 4 | "template_code_filename" : "ImageFilter", 5 | "template_test_filename" : "ImageFilter", 6 | "include_files" : [ 7 | "itkBitwiseOpsFunctors.h" 8 | ], 9 | "number_of_inputs" : 1, 10 | "doc" : "Some global documentation", 11 | "pixel_types" : "IntegerPixelIDTypeList", 12 | "filter_type" : "itk::UnaryFunctorImageFilter< InputImageType, InputImageType, Functor::BitwiseNot< typename InputImageType::PixelType,typename OutputImageType::PixelType> >", 13 | "members" : [], 14 | "tests" : [ 15 | { 16 | "tag" : "defaults", 17 | "description" : "Simply run with default settings", 18 | "settings" : [], 19 | "md5hash" : "d63a9f2add11cd86fc3c5cb297222107", 20 | "inputs" : [ 21 | "Input/2th_cthead1.png" 22 | ] 23 | } 24 | ], 25 | "briefdescription" : "Implements pixel-wise generic operation on one image.", 26 | "detaileddescription" : "This class is parameterized over the type of the input image and the type of the output image. It is also parameterized by the operation to be applied, using a Functor style.\n\nUnaryFunctorImageFilter allows the output dimension of the filter to be larger than the input dimension. Thus subclasses of the UnaryFunctorImageFilter (like the CastImageFilter ) can be used to promote a 2D image to a 3D image, etc.\n\n\\see BinaryFunctorImageFilter TernaryFunctorImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Apply a custom operation to each pixel in an image", 27 | "itk_module" : "ITKCommon", 28 | "itk_group" : "Common" 29 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MeanProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MeanProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "\todo this filter should work with VectorImages too.", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "z_projection", 19 | "description" : "project in the 2nd dimension", 20 | "settings" : [ 21 | { 22 | "parameter" : "ProjectionDimension", 23 | "cxx_value" : "2u", 24 | "value" : "2" 25 | } 26 | ], 27 | "tolerance" : "0.0001", 28 | "inputs" : [ 29 | "Input/RA-Float.nrrd" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Mean projection.", 34 | "detaileddescription" : "This class was contributed to the Insight Journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ProjectionImageFilter \n\n\\see MedianProjectionImageFilter \n\n\\see MinimumProjectionImageFilter \n\n\\see StandardDeviationProjectionImageFilter \n\n\\see SumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter \n\n\\see MaximumProjectionImageFilter", 35 | "itk_module" : "ITKImageStatistics", 36 | "itk_group" : "ImageStatistics" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/StandardDeviationProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "StandardDeviationProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "z_projection", 19 | "description" : "project in the 2nd dimension", 20 | "settings" : [ 21 | { 22 | "parameter" : "ProjectionDimension", 23 | "cxx_value" : "2u", 24 | "value" : "2" 25 | } 26 | ], 27 | "tolerance" : "0.0001", 28 | "inputs" : [ 29 | "Input/RA-Float.nrrd" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Mean projection.", 34 | "detaileddescription" : "This class was contributed to the Insight Journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ProjectionImageFilter \n\n\\see MedianProjectionImageFilter \n\n\\see MeanProjectionImageFilter \n\n\\see SumProjectionImageFilter \n\n\\see MeanProjectionImageFilter \n\n\\see MaximumProjectionImageFilter \n\n\\see MinimumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter", 35 | "itk_module" : "ITKImageStatistics", 36 | "itk_group" : "ImageStatistics" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NormalizeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NormalizeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 10 | "members" : [], 11 | "tests" : [ 12 | { 13 | "tag" : "defaults", 14 | "description" : "Simply run with default settings", 15 | "settings" : [], 16 | "tolerance" : "0.0001", 17 | "inputs" : [ 18 | "Input/Ramp-Up-Short.nrrd" 19 | ] 20 | }, 21 | { 22 | "tag" : "vector", 23 | "description" : "Simply run with default settings for a vector image", 24 | "settings" : [], 25 | "tolerance" : "0.0001", 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGB.png" 28 | ] 29 | } 30 | ], 31 | "briefdescription" : "Normalize an image by setting its mean to zero and variance to one.", 32 | "detaileddescription" : "NormalizeImageFilter shifts and scales an image so that the pixels in the image have a zero mean and unit variance. This filter uses StatisticsImageFilter to compute the mean and variance of the input and then applies ShiftScaleImageFilter to shift and scale the pixels.\n\nNB: since this filter normalizes the data to lie within -1 to 1, integral types will produce an image that DOES NOT HAVE a unit variance.\n\n\\see NormalizeToConstantImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Normalize an image", 33 | "itk_module" : "ITKImageIntensity", 34 | "itk_group" : "ImageIntensity" 35 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SumProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SumProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "\todo this filter should work with VectorImages too. \todo output type should be AccumulateType", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "z_projection", 19 | "description" : "project in the 2nd dimension", 20 | "settings" : [ 21 | { 22 | "parameter" : "ProjectionDimension", 23 | "cxx_value" : "2u", 24 | "value" : "2" 25 | } 26 | ], 27 | "tolerance" : "0.0001", 28 | "inputs" : [ 29 | "Input/RA-Float.nrrd" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Sum projection.", 34 | "detaileddescription" : "This class was contributed to the Insight Journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ProjectionImageFilter \n\n\\see MedianProjectionImageFilter \n\n\\see MeanProjectionImageFilter \n\n\\see MeanProjectionImageFilter \n\n\\see MaximumProjectionImageFilter \n\n\\see MinimumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter \n\n\\see StandardDeviationProjectionImageFilter", 35 | "itk_module" : "ITKImageStatistics", 36 | "itk_group" : "ImageStatistics" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/InvertIntensityImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "InvertIntensityImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Maximum", 12 | "type" : "double", 13 | "default" : 255, 14 | "pixeltype" : "Input", 15 | "doc" : "Maximum output", 16 | "briefdescriptionSet" : "", 17 | "detaileddescriptionSet" : "Set/Get the maximum intensity value for the inversion.", 18 | "briefdescriptionGet" : "", 19 | "detaileddescriptionGet" : "Set/Get the maximum intensity value for the inversion." 20 | } 21 | ], 22 | "tests" : [ 23 | { 24 | "tag" : "3d", 25 | "description" : "3D", 26 | "settings" : [], 27 | "md5hash" : "76765a57f26a7979f33efc8ed9801a55", 28 | "inputs" : [ 29 | "Input/RA-Short.nrrd" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Invert the intensity of an image.", 34 | "detaileddescription" : "InvertIntensityImageFilter inverts intensity of pixels by subtracting pixel value to a maximum value. The maximum value can be set with SetMaximum and defaults the maximum of input pixel type. This filter can be used to invert, for example, a binary image, a distance map, etc.\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see IntensityWindowingImageFilter ShiftScaleImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Invert an image", 35 | "itk_module" : "ITKImageIntensity", 36 | "itk_group" : "ImageIntensity" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BinaryThinningImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BinaryThinningImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "\\todo this filter may not work in 3D\n \\note the output of this filter is still the same as the input type eventhought the output is 0 or 1.", 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "members" : [], 9 | "custom_methods" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "BinaryThinning", 13 | "description" : "Test binnary thinning", 14 | "md5hash" : "153ad0b2f3658dee3b14ad93d0cfe550", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/BlackDots.png" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "This filter computes one-pixel-wide edges of the input image.", 22 | "detaileddescription" : "This class is parametrized over the type of the input image and the type of the output image.\n\nThe input is assumed to be a binary image. If the foreground pixels of the input image do not have a value of 1, they are rescaled to 1 internally to simplify the computation.\n\nThe filter will produce a skeleton of the object. The output background values are 0, and the foreground values are 1.\n\nThis filter is a sequential thinning algorithm and known to be computational time dependable on the image size. The algorithm corresponds with the 2D implementation described in:\n\nRafael C. Gonzales and Richard E. Woods. Digital Image Processing. Addison Wesley, 491-494, (1993).\n\nTo do: Make this filter ND.\n\n\\see MorphologyImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Skeletonize/thin an image", 23 | "itk_module" : "ITKBinaryMathematicalMorphology", 24 | "itk_group" : "BinaryMathematicalMorphology" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ValuedRegionalMinimaImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ValuedRegionalMinimaImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "ScalarPixelIDTypeList", 7 | "members" : [ 8 | { 9 | "name" : "FullyConnected", 10 | "type" : "bool", 11 | "default" : "false" 12 | } 13 | ], 14 | "custom_methods" : [], 15 | "measurements" : [ 16 | { 17 | "name" : "Flat", 18 | "type" : "bool", 19 | "default" : "false" 20 | } 21 | ], 22 | "tests" : [ 23 | { 24 | "tag" : "defaults", 25 | "description" : "Simply run with default settings", 26 | "settings" : [], 27 | "md5hash" : "8297d018757b1477e31293ab8a8f0db1", 28 | "inputs" : [ 29 | "Input/cthead1.png" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Transforms the image so that any pixel that is not a regional minima is set to the maximum value for the pixel type. Pixels that are regional minima retain their value.", 34 | "detaileddescription" : "Regional minima are flat zones surrounded by pixels of higher value. A completely flat image will be marked as a regional minima by this filter.\n\nThis code was contributed in the Insight Journal paper: \"Finding regional extrema - methods and performance\" by Beare R., Lehmann G. https://hdl.handle.net/1926/153 http://www.insight-journal.org/browse/publication/65 \n\n\\author Richard Beare. Department of Medicine, Monash University, Melbourne, Australia.\n\n\\see ValuedRegionalMaximaImageFilter , ValuedRegionalExtremaImageFilter , \n\n\\see HMinimaImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li ValuedRegionalMinimaImageFilter", 35 | "itk_module" : "ITKMathematicalMorphology", 36 | "itk_group" : "MathematicalMorphology" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MorphologicalGradientImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MorphologicalGradientImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [], 9 | "custom_methods" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "MorphologicalGradient", 13 | "description" : "Test morhological gradient", 14 | "md5hash" : "57167a1d86b60fbf9e040d9441676876", 15 | "settings" : [ 16 | { 17 | "parameter" : "KernelRadius", 18 | "no_get_method" : 1, 19 | "value" : 1 20 | }, 21 | { 22 | "parameter" : "KernelType", 23 | "value" : "itk::simple::sitkBall", 24 | "lua_value" : "SimpleITK.sitkBall", 25 | "python_value" : "SimpleITK.sitkBall", 26 | "ruby_value" : "Simpleitk::SitkBall", 27 | "java_value" : "KernelEnum.sitkBall", 28 | "tcl_value" : "$$sitkBall", 29 | "csharp_value" : "KernelEnum.sitkBall", 30 | "R_value" : "'sitkBall'" 31 | } 32 | ], 33 | "inputs" : [ 34 | "Input/STAPLE1.png" 35 | ] 36 | } 37 | ], 38 | "briefdescription" : "gray scale dilation of an image", 39 | "detaileddescription" : "Dilate an image using grayscale morphology. Dilation takes the maximum of all the pixels identified by the structuring element.\n\nThe structuring element is assumed to be composed of binary values (zero or one). Only elements of the structuring element having values > 0 are candidates for affecting the center pixel.\n\n\\see MorphologyImageFilter , GrayscaleFunctionDilateImageFilter , BinaryDilateImageFilter", 40 | "itk_module" : "ITKMathematicalMorphology", 41 | "itk_group" : "MathematicalMorphology" 42 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ValuedRegionalMaximaImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ValuedRegionalMaximaImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "ScalarPixelIDTypeList", 7 | "members" : [ 8 | { 9 | "name" : "FullyConnected", 10 | "type" : "bool", 11 | "default" : "false" 12 | } 13 | ], 14 | "custom_methods" : [], 15 | "measurements" : [ 16 | { 17 | "name" : "Flat", 18 | "type" : "bool", 19 | "default" : "false" 20 | } 21 | ], 22 | "tests" : [ 23 | { 24 | "tag" : "defaults", 25 | "description" : "Simply run with default settings", 26 | "settings" : [], 27 | "md5hash" : "c94b3702844c508818e4718a75102472", 28 | "inputs" : [ 29 | "Input/cthead1.png" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Transforms the image so that any pixel that is not a regional maxima is set to the minimum value for the pixel type. Pixels that are regional maxima retain their value.", 34 | "detaileddescription" : "Regional maxima are flat zones surrounded by pixels of lower value. A completely flat image will be marked as a regional maxima by this filter.\n\nThis code was contributed in the Insight Journal paper: \"Finding regional extrema - methods and performance\" by Beare R., Lehmann G. https://hdl.handle.net/1926/153 http://www.insight-journal.org/browse/publication/65 \n\n\\author Richard Beare. Department of Medicine, Monash University, Melbourne, Australia.\n\n\\see ValuedRegionalMinimaImageFilter \n\n\\see ValuedRegionalExtremaImageFilter \n\n\\see HMinimaImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li ValuedRegionalMaximaImageFilter", 35 | "itk_module" : "ITKMathematicalMorphology", 36 | "itk_group" : "MathematicalMorphology" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BinaryMagnitudeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BinaryMagnitudeImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 2, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "2d", 12 | "description" : "2D", 13 | "settings" : [], 14 | "md5hash" : "ac40268d90c25dd631b54024ae84bffe", 15 | "inputs" : [ 16 | "Input/STAPLE1.png", 17 | "Input/STAPLE2.png" 18 | ] 19 | }, 20 | { 21 | "tag" : "3d", 22 | "description" : "3D", 23 | "settings" : [], 24 | "tolerance" : "1e-8", 25 | "inputA_cast" : "sitkUInt32", 26 | "inputB_cast" : "sitkUInt32", 27 | "inputs" : [ 28 | "Input/RA-Short.nrrd", 29 | "Input/RA-Short.nrrd" 30 | ] 31 | } 32 | ], 33 | "briefdescription" : "Computes the square root of the sum of squares of corresponding input pixels.", 34 | "detaileddescription" : "This filter is templated over the types of the two input images and the type of the output image.\n\nNumeric conversions (castings) are done by the C++ defaults.\n\nThe filter walks over all of the pixels in the two input images, and for each pixel does the following:\n\n\n\\li cast the input 1 pixel value to double \n\n\\li cast the input 2 pixel value to double \n\n\\li compute the sum of squares of the two pixel values \n\n\\li compute the square root of the sum \n\n\\li cast the double value resulting from std::sqrt() to the pixel type of the output image \n\n\\li store the cast value into the output image.\n\n\nThe filter expects all images to have the same dimension (e.g. all 2D, or all 3D, or all ND)", 35 | "itk_module" : "ITKImageIntensity", 36 | "itk_group" : "ImageIntensity" 37 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/RealToHalfHermitianForwardFFTImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "RealToHalfHermitianForwardFFTImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "RealPixelIDTypeList", 8 | "filter_type" : "itk::RealToHalfHermitianForwardFFTImageFilter", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "defaults", 13 | "description" : "Test real to half FFT", 14 | "tolerance" : "0.11", 15 | "settings" : [], 16 | "inputs" : [ 17 | "Input/RA-Slice-Float.nrrd" 18 | ] 19 | } 20 | ], 21 | "briefdescription" : "Base class for specialized real-to-complex forward Fast Fourier Transform .", 22 | "detaileddescription" : "This is a base class for the \"forward\" or \"direct\" discrete Fourier Transform . This is an abstract base class: the actual implementation is provided by the best child class available on the system when the object is created via the object factory system.\n\nThis class transforms a real input image into its complex Fourier transform. The Fourier transform of a real input image has Hermitian symmetry: \\f$ f(\\mathbf{x}) = f^*(-\\mathbf{x}) \\f$ . That is, when the result of the transform is split in half along the X-dimension, the values in the second half of the transform are the complex conjugates of values in the first half reflected about the center of the image in each dimension. This filter takes advantage of the Hermitian symmetry property and reduces the size of the output in the first dimension to N/2+1, where N is the size of the input image in that dimension and the division by 2 is rounded down.\n\n\\see HalfHermitianToRealInverseFFTImageFilter \n\n\\see ForwardFFTImageFilter", 23 | "itk_module" : "ITKFFT", 24 | "itk_group" : "FFT" 25 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/RealAndImaginaryToComplexImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "RealAndImaginaryToComplexImageFilter", 3 | "itk_name" : "ComposeImageFilter", 4 | "template_code_filename" : "ImageFilter", 5 | "template_test_filename" : "ImageFilter", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "RealPixelIDTypeList", 9 | "filter_type" : "itk::ComposeImageFilter", 10 | "output_pixel_type" : "std::complex", 11 | "members" : [], 12 | "tests" : [ 13 | { 14 | "tag" : "defaults", 15 | "description" : "Test defaults", 16 | "md5hash" : "1129328e636444d9df8000a1bdebddce", 17 | "settings" : [], 18 | "inputs" : [ 19 | "Input/RA-Slice-Float.nrrd", 20 | "Input/RA-Slice-Float.nrrd" 21 | ] 22 | } 23 | ], 24 | "briefdescription" : "ComposeImageFilter combine several scalar images into a multicomponent image.", 25 | "detaileddescription" : "ComposeImageFilter combine several scalar images into an itk::Image of vector pixel (itk::Vector , itk::RGBPixel , ...), of std::complex pixel, or in an itk::VectorImage .\n\n\\par Inputs and Usage\n\\code\n* filter->SetInput( 0, image0 );\n\n* filter->SetInput( 1, image1 );\n\n* ...\n\n* filter->Update();\n\n* itk::VectorImage< PixelType, dimension >::Pointer = filter->GetOutput();\n\n* \n\n\\endcode\n All input images are expected to have the same template parameters and have the same size and origin.\n\n\\see VectorImage \n\n\\see VectorIndexSelectionCastImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Create a vector image from a collection of scalar images \n\n\\li Compose a vector image (with 3 components) from three scalar images \n\n\\li Convert a real image and an imaginary image to a complex image", 26 | "itk_module" : "ITKImageCompose", 27 | "itk_group" : "ImageCompose" 28 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/GrayscaleErodeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "GrayscaleErodeImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Performs Erode in a grayscale image.", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [], 9 | "custom_methods" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "GrayscaleErode", 13 | "description" : "Test grayscale erode", 14 | "md5hash" : "cb0f49738a99f3467b575bc95a0ace44", 15 | "settings" : [ 16 | { 17 | "parameter" : "KernelRadius", 18 | "no_get_method" : 1, 19 | "value" : 1 20 | }, 21 | { 22 | "parameter" : "KernelType", 23 | "value" : "itk::simple::sitkBall", 24 | "lua_value" : "SimpleITK.sitkBall", 25 | "python_value" : "SimpleITK.sitkBall", 26 | "ruby_value" : "Simpleitk::SitkBall", 27 | "java_value" : "KernelEnum.sitkBall", 28 | "tcl_value" : "$$sitkBall", 29 | "csharp_value" : "KernelEnum.sitkBall", 30 | "R_value" : "'sitkBall'" 31 | } 32 | ], 33 | "inputs" : [ 34 | "Input/STAPLE1.png" 35 | ] 36 | } 37 | ], 38 | "briefdescription" : "Grayscale erosion of an image.", 39 | "detaileddescription" : "Erode an image using grayscale morphology. Erosion takes the maximum of all the pixels identified by the structuring element.\n\nThe structuring element is assumed to be composed of binary values (zero or one). Only elements of the structuring element having values > 0 are candidates for affecting the center pixel.\n\n\\see MorphologyImageFilter , GrayscaleFunctionErodeImageFilter , BinaryErodeImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Erode a grayscale image", 40 | "itk_module" : "ITKMathematicalMorphology", 41 | "itk_group" : "MathematicalMorphology" 42 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/GrayscaleDilateImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "GrayscaleDilateImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Performs Dilation in a grayscale image.", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [], 9 | "custom_methods" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "GrayscaleDilate", 13 | "description" : "Test grayscale dilation", 14 | "settings" : [ 15 | { 16 | "parameter" : "KernelRadius", 17 | "no_get_method" : 1, 18 | "value" : 1 19 | }, 20 | { 21 | "parameter" : "KernelType", 22 | "value" : "itk::simple::sitkBall", 23 | "lua_value" : "SimpleITK.sitkBall", 24 | "python_value" : "SimpleITK.sitkBall", 25 | "ruby_value" : "Simpleitk::SitkBall", 26 | "java_value" : "KernelEnum.sitkBall", 27 | "tcl_value" : "$$sitkBall", 28 | "csharp_value" : "KernelEnum.sitkBall", 29 | "R_value" : "'sitkBall'" 30 | } 31 | ], 32 | "md5hash" : "cb692559f1eb21e4c932f6bbb3850ad3", 33 | "inputs" : [ 34 | "Input/STAPLE1.png" 35 | ] 36 | } 37 | ], 38 | "briefdescription" : "Grayscale dilation of an image.", 39 | "detaileddescription" : "Dilate an image using grayscale morphology. Dilation takes the maximum of all the pixels identified by the structuring element.\n\nThe structuring element is assumed to be composed of binary values (zero or one). Only elements of the structuring element having values > 0 are candidates for affecting the center pixel.\n\n\\see MorphologyImageFilter , GrayscaleFunctionDilateImageFilter , BinaryDilateImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Dilate a grayscale image", 40 | "itk_module" : "ITKMathematicalMorphology", 41 | "itk_group" : "MathematicalMorphology" 42 | } -------------------------------------------------------------------------------- /SimpleFilters/Testing/Python/SimpleFiltersModuleTest.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import qt 3 | import slicer 4 | 5 | class SimpleFiltersTest(unittest.TestCase): 6 | """ 7 | This is the test case for your scripted module. 8 | """ 9 | 10 | def delayDisplay(self,message,msec=1000): 11 | """This utility method displays a small dialog and waits. 12 | This does two things: 1) it lets the event loop catch up 13 | to the state of the test so that rendering and widget updates 14 | have all taken place before the test continues and 2) it 15 | shows the user/developer/tester the state of the test 16 | so that we'll know when it breaks. 17 | """ 18 | print(message) 19 | self.info = qt.QDialog() 20 | self.infoLayout = qt.QVBoxLayout() 21 | self.info.setLayout(self.infoLayout) 22 | self.label = qt.QLabel(message,self.info) 23 | self.infoLayout.addWidget(self.label) 24 | qt.QTimer.singleShot(msec, self.info.close) 25 | self.info.exec_() 26 | 27 | # make sure all events are processed before moving on 28 | qt.QApplication.flush() 29 | 30 | def setUp(self): 31 | """ Do whatever is needed to reset the state - typically a scene clear will be enough. 32 | """ 33 | slicer.mrmlScene.Clear(0) 34 | 35 | def test_SimpleFilters1(self): 36 | 37 | m = slicer.util.mainWindow() 38 | m.moduleSelector().selectModule('SimpleFilters') 39 | 40 | print("testing my test....") 41 | 42 | testWidget = slicer.modules.SimpleFiltersWidget 43 | 44 | # Run through all the loaded filters and get the widget to generate the GUI 45 | for filterIdx in range(testWidget.filterSelector.count): 46 | someJSON=slicer.modules.SimpleFiltersWidget.jsonFilters[filterIdx] 47 | testWidget.filterSelector.setCurrentIndex(filterIdx) 48 | self.delayDisplay("Testing filter \"{}\" ({} of {}).".format(someJSON["name"], filterIdx, testWidget.filterSelector.count),msec=100 ) 49 | 50 | return True 51 | -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MeanImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MeanImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Radius", 12 | "type" : "unsigned int", 13 | "default" : "std::vector(3, 1)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "doc" : "", 17 | "itk_type" : "typename FilterType::RadiusType" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults", 23 | "description" : "Test MeanImageFilter with default parametrs", 24 | "md5hash" : "4abff9cea3d1bfdd10bceb8893a35d3a", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGBFloat.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "by23", 32 | "description" : "Test by 23", 33 | "md5hash" : "4feffebe7656f267b2bc27b966f00a63", 34 | "settings" : [ 35 | { 36 | "parameter" : "Radius", 37 | "type" : "unsigned int", 38 | "dim_vec" : 1, 39 | "value" : [ 40 | 2, 41 | 3 42 | ] 43 | } 44 | ], 45 | "inputs" : [ 46 | "Input/VM1111Shrink-RGB.png" 47 | ] 48 | } 49 | ], 50 | "briefdescription" : "Applies an averaging filter to an image.", 51 | "detaileddescription" : "Computes an image where a given pixel is the mean value of the the pixels in a neighborhood about the corresponding input pixel.\n\nA mean filter is one of the family of linear filters.\n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Mean filter an image", 52 | "itk_module" : "ITKSmoothing", 53 | "itk_group" : "Smoothing" 54 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/VectorConnectedComponentImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "VectorConnectedComponentImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "\todo Add suport for mask image input", 7 | "pixel_types" : "RealVectorPixelIDTypeList", 8 | "filter_type" : "itk::VectorConnectedComponentImageFilter >", 9 | "output_pixel_type" : "uint32_t", 10 | "members" : [ 11 | { 12 | "name" : "DistanceThreshold", 13 | "type" : "double", 14 | "default" : "1.0", 15 | "custom_itk_cast" : "filter->SetDistanceThreshold( static_cast( this->m_DistanceThreshold ) );", 16 | "briefdescriptionSet" : "", 17 | "detaileddescriptionSet" : "", 18 | "briefdescriptionGet" : "", 19 | "detaileddescriptionGet" : "" 20 | }, 21 | { 22 | "name" : "FullyConnected", 23 | "type" : "bool", 24 | "default" : "false", 25 | "doc" : "" 26 | } 27 | ], 28 | "custom_methods" : [], 29 | "tests" : [ 30 | { 31 | "tag" : "wDistance", 32 | "description" : "2D RGB", 33 | "settings" : [ 34 | { 35 | "parameter" : "DistanceThreshold", 36 | "value" : "0.01" 37 | } 38 | ], 39 | "md5hash" : "0dbaaa98c1da2d8e1865c95e53a542de", 40 | "inputs" : [ 41 | "Input/noisy-vector-grid.nrrd" 42 | ] 43 | } 44 | ], 45 | "briefdescription" : "A connected components filter that labels the objects in a vector image. Two vectors are pointing similar directions if one minus their dot product is less than a threshold. Vectors that are 180 degrees out of phase are similar. Assumes that vectors are normalized.", 46 | "detaileddescription" : "", 47 | "itk_module" : "ITKConnectedComponents", 48 | "itk_group" : "ConnectedComponents" 49 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/DivideFloorImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "DivideFloorImageFilter", 3 | "itk_name" : "BinaryFunctorImageFilter", 4 | "template_code_filename" : "BinaryFunctorFilter", 5 | "template_test_filename" : "ImageFilter", 6 | "constant_type" : "double", 7 | "include_files" : [ 8 | "itkArithmeticOpsFunctors.h" 9 | ], 10 | "number_of_inputs" : 2, 11 | "doc" : "Some global documentation", 12 | "pixel_types" : "BasicPixelIDTypeList", 13 | "filter_type" : "itk::BinaryFunctorImageFilter< InputImageType, InputImageType2, InputImageType, Functor::DivFloor< typename InputImageType::PixelType, typename InputImageType2::PixelType, typename OutputImageType::PixelType> >", 14 | "members" : [], 15 | "tests" : [ 16 | { 17 | "tag" : "defaults", 18 | "description" : "Simply run with default settings", 19 | "settings" : [], 20 | "md5hash" : "af2d18b65fdfa4f9cb1e84c777b4a72b", 21 | "inputs" : [ 22 | "Input/Ramp-Up-Short.nrrd", 23 | "Input/Ramp-Down-Short.nrrd" 24 | ] 25 | } 26 | ], 27 | "briefdescription" : "Implements pixel-wise generic operation of two images, or of an image and a constant.", 28 | "detaileddescription" : "This class is parameterized over the types of the two input images and the type of the output image. It is also parameterized by the operation to be applied. A Functor style is used.\n\nThe constant must be of the same type than the pixel type of the corresponding image. It is wrapped in a SimpleDataObjectDecorator so it can be updated through the pipeline. The SetConstant() and GetConstant() methods are provided as shortcuts to set or get the constant value without manipulating the decorator.\n\n\\see UnaryFunctorImageFilter TernaryFunctorImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Apply a predefined operation to corresponding pixels in two images \n\n\\li Apply a custom operation to corresponding pixels in two images", 29 | "itk_module" : "ITKImageFilterBase", 30 | "itk_group" : "ImageFilterBase" 31 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/GradientMagnitudeRecursiveGaussianImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "GradientMagnitudeRecursiveGaussianImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "float", 9 | "members" : [ 10 | { 11 | "name" : "Sigma", 12 | "type" : "double", 13 | "default" : "1.0", 14 | "doc" : "", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Set Sigma value. Sigma is measured in the units of image spacing.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Set Sigma value. Sigma is measured in the units of image spacing." 19 | }, 20 | { 21 | "name" : "NormalizeAcrossScale", 22 | "type" : "bool", 23 | "default" : "false", 24 | "doc" : "", 25 | "briefdescriptionSet" : "", 26 | "detaileddescriptionSet" : "Define which normalization factor will be used for the Gaussian \\see RecursiveGaussianImageFilter::SetNormalizeAcrossScale", 27 | "briefdescriptionGet" : "", 28 | "detaileddescriptionGet" : "Define which normalization factor will be used for the Gaussian \\see RecursiveGaussianImageFilter::SetNormalizeAcrossScale" 29 | } 30 | ], 31 | "tests" : [ 32 | { 33 | "tag" : "default", 34 | "description" : "Simply run with default settings", 35 | "settings" : [], 36 | "tolerance" : 0.0001, 37 | "inputs" : [ 38 | "Input/RA-Float.nrrd" 39 | ] 40 | } 41 | ], 42 | "briefdescription" : "Computes the Magnitude of the Gradient of an image by convolution with the first derivative of a Gaussian.", 43 | "detaileddescription" : "This filter is implemented using the recursive gaussian filters\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Find the gradient magnitude of the image first smoothed with a Gaussian kernel", 44 | "itk_module" : "ITKImageGradient", 45 | "itk_group" : "ImageGradient" 46 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LaplacianRecursiveGaussianImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LaplacianRecursiveGaussianImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "float", 9 | "members" : [ 10 | { 11 | "name" : "Sigma", 12 | "type" : "double", 13 | "default" : "1.0", 14 | "doc" : "", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Set Sigma value. Sigma is measured in the units of image spacing.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Set Sigma value. Sigma is measured in the units of image spacing." 19 | }, 20 | { 21 | "name" : "NormalizeAcrossScale", 22 | "type" : "bool", 23 | "default" : "false", 24 | "doc" : "", 25 | "briefdescriptionSet" : "", 26 | "detaileddescriptionSet" : "Define which normalization factor will be used for the Gaussian \\see RecursiveGaussianImageFilter::SetNormalizeAcrossScale", 27 | "briefdescriptionGet" : "", 28 | "detaileddescriptionGet" : "Define which normalization factor will be used for the Gaussian \\see RecursiveGaussianImageFilter::SetNormalizeAcrossScale" 29 | } 30 | ], 31 | "tests" : [ 32 | { 33 | "tag" : "default", 34 | "description" : "Simply run with default settings", 35 | "settings" : [], 36 | "tolerance" : 0.0001, 37 | "inputs" : [ 38 | "Input/RA-Float.nrrd" 39 | ] 40 | } 41 | ], 42 | "briefdescription" : "Computes the Laplacian of Gaussian (LoG) of an image.", 43 | "detaileddescription" : "Computes the Laplacian of Gaussian (LoG) of an image by convolution with the second derivative of a Gaussian. This filter is implemented using the recursive gaussian filters.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the Laplacian of Gaussian (LoG) of an image", 44 | "itk_module" : "ITKImageFeature", 45 | "itk_group" : "ImageFeature" 46 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/DivideRealImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "DivideRealImageFilter", 3 | "itk_name" : "BinaryFunctorImageFilter", 4 | "template_code_filename" : "BinaryFunctorFilter", 5 | "template_test_filename" : "ImageFilter", 6 | "constant_type" : "double", 7 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 8 | "include_files" : [ 9 | "itkArithmeticOpsFunctors.h" 10 | ], 11 | "number_of_inputs" : 2, 12 | "doc" : "Some global documentation", 13 | "pixel_types" : "BasicPixelIDTypeList", 14 | "filter_type" : "itk::BinaryFunctorImageFilter< InputImageType, InputImageType2, OutputImageType, Functor::DivReal< typename InputImageType::PixelType, typename InputImageType2::PixelType, typename OutputImageType::PixelType> >", 15 | "members" : [], 16 | "tests" : [ 17 | { 18 | "tag" : "defaults", 19 | "description" : "Simply run with default settings", 20 | "settings" : [], 21 | "tolerance" : "1e-8", 22 | "inputs" : [ 23 | "Input/Ramp-Up-Short.nrrd", 24 | "Input/Ramp-Down-Short.nrrd" 25 | ] 26 | } 27 | ], 28 | "briefdescription" : "Implements pixel-wise generic operation of two images, or of an image and a constant.", 29 | "detaileddescription" : "This class is parameterized over the types of the two input images and the type of the output image. It is also parameterized by the operation to be applied. A Functor style is used.\n\nThe constant must be of the same type than the pixel type of the corresponding image. It is wrapped in a SimpleDataObjectDecorator so it can be updated through the pipeline. The SetConstant() and GetConstant() methods are provided as shortcuts to set or get the constant value without manipulating the decorator.\n\n\\see UnaryFunctorImageFilter TernaryFunctorImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Apply a predefined operation to corresponding pixels in two images \n\n\\li Apply a custom operation to corresponding pixels in two images", 30 | "itk_module" : "ITKImageFilterBase", 31 | "itk_group" : "ImageFilterBase" 32 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AbsoluteValueDifferenceImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AbsoluteValueDifferenceImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "default", 13 | "description" : "checker board with default parameters", 14 | "settings" : [], 15 | "md5hash" : "ecb99e6ffea7be1e5419350f725da86b", 16 | "inputs" : [ 17 | "Input/BlackDots.png", 18 | "Input/WhiteDots.png" 19 | ] 20 | }, 21 | { 22 | "tag" : "another", 23 | "description" : "checker board with default parameters", 24 | "settings" : [], 25 | "md5hash" : "ecb99e6ffea7be1e5419350f725da86b", 26 | "inputs" : [ 27 | "Input/WhiteDots.png", 28 | "Input/BlackDots.png" 29 | ] 30 | } 31 | ], 32 | "briefdescription" : "Implements pixel-wise the computation of absolute value difference.", 33 | "detaileddescription" : "This filter is parametrized over the types of the two input images and the type of the output image.\n\nNumeric conversions (castings) are done by the C++ defaults.\n\nThe filter will walk over all the pixels in the two input images, and for each one of them it will do the following:\n\n\n\\li Cast the input 1 pixel value to double . \n\n\\li Cast the input 2 pixel value to double . \n\n\\li Compute the difference of the two pixel values. \n\n\\li Compute the absolute value of the difference. \n\n\\li Cast the double value resulting from the absolute value to the pixel type of the output image. \n\n\\li Store the casted value into the output image.\n\n\nThe filter expects all images to have the same dimension (e.g. all 2D, or all 3D, or all ND).\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the absolute value of the difference of corresponding pixels in two images", 34 | "itk_module" : "ITKImageCompare", 35 | "itk_group" : "ImageCompare" 36 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ComposeImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ComposeImageFilter", 3 | "template_code_filename" : "MultiInputImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "output_image_type" : "itk::VectorImage< typename InputImageType::PixelType, InputImageType::ImageDimension >", 8 | "members" : [], 9 | "tests" : [ 10 | { 11 | "tag" : "default_2D", 12 | "description" : "default composition on 2D", 13 | "settings" : [], 14 | "md5hash" : "c0a5d977f0a9d983831dca858d842087", 15 | "inputs" : [ 16 | "Input/STAPLE1.png", 17 | "Input/STAPLE2.png" 18 | ] 19 | }, 20 | { 21 | "tag" : "default_3D", 22 | "description" : "default composition on 3D", 23 | "settings" : [], 24 | "md5hash" : "b7bce6e5d5f5a65f16e14aed20a664e7", 25 | "inputs" : [ 26 | "Input/Ramp-One-Zero-Float.nrrd", 27 | "Input/Ramp-Zero-One-Float.nrrd", 28 | "Input/Ramp-One-Zero-Float.nrrd" 29 | ] 30 | } 31 | ], 32 | "briefdescription" : "ComposeImageFilter combine several scalar images into a multicomponent image.", 33 | "detaileddescription" : "ComposeImageFilter combine several scalar images into an itk::Image of vector pixel (itk::Vector , itk::RGBPixel , ...), of std::complex pixel, or in an itk::VectorImage .\n\n\\par Inputs and Usage\n\\code\n* filter->SetInput( 0, image0 );\n\n* filter->SetInput( 1, image1 );\n\n* ...\n\n* filter->Update();\n\n* itk::VectorImage< PixelType, dimension >::Pointer = filter->GetOutput();\n\n* \n\n\\endcode\n All input images are expected to have the same template parameters and have the same size and origin.\n\n\\see VectorImage \n\n\\see VectorIndexSelectionCastImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Create a vector image from a collection of scalar images \n\n\\li Compose a vector image (with 3 components) from three scalar images \n\n\\li Convert a real image and an imaginary image to a complex image", 34 | "itk_module" : "ITKImageCompose", 35 | "itk_group" : "ImageCompose" 36 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MedianImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MedianImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Radius", 12 | "type" : "unsigned int", 13 | "default" : "std::vector(3, 1)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "doc" : "", 17 | "itk_type" : "typename FilterType::RadiusType" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults", 23 | "description" : "Test MeanImageFilter with default parametrs", 24 | "md5hash" : "3d91602f6080b45a5431b80d1f78c0a0", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGBFloat.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "by23", 32 | "description" : "Test by 23", 33 | "md5hash" : "03610a1cb421d145fe985478d4eb9c0a", 34 | "settings" : [ 35 | { 36 | "parameter" : "Radius", 37 | "type" : "unsigned int", 38 | "dim_vec" : 1, 39 | "value" : [ 40 | 2, 41 | 3 42 | ] 43 | } 44 | ], 45 | "inputs" : [ 46 | "Input/VM1111Shrink-RGB.png" 47 | ] 48 | } 49 | ], 50 | "briefdescription" : "Applies a median filter to an image.", 51 | "detaileddescription" : "Computes an image where a given pixel is the median value of the the pixels in a neighborhood about the corresponding input pixel.\n\nA median filter is one of the family of nonlinear filters. It is used to smooth an image without being biased by outliers or shot noise.\n\nThis filter requires that the input pixel type provides an operator<() (LessThan Comparable).\n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Median filter an image \n\n\\li Median filter an RGB image", 52 | "itk_module" : "ITKSmoothing", 53 | "itk_group" : "Smoothing" 54 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/WhiteTopHatImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "WhiteTopHatImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "SafeBorder", 11 | "type" : "bool", 12 | "default" : "true", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done" 18 | } 19 | ], 20 | "custom_methods" : [], 21 | "tests" : [ 22 | { 23 | "tag" : "WhiteTopHatErode", 24 | "description" : "Test white top hat", 25 | "md5hash" : "e784daff43d09a18e20556729afc0c9d", 26 | "settings" : [ 27 | { 28 | "parameter" : "KernelRadius", 29 | "no_get_method" : 1, 30 | "value" : 1 31 | }, 32 | { 33 | "parameter" : "KernelType", 34 | "value" : "itk::simple::sitkBall", 35 | "lua_value" : "SimpleITK.sitkBall", 36 | "python_value" : "SimpleITK.sitkBall", 37 | "ruby_value" : "Simpleitk::SitkBall", 38 | "java_value" : "KernelEnum.sitkBall", 39 | "tcl_value" : "$$sitkBall", 40 | "csharp_value" : "KernelEnum.sitkBall", 41 | "R_value" : "'sitkBall'" 42 | } 43 | ], 44 | "inputs" : [ 45 | "Input/STAPLE1.png" 46 | ] 47 | } 48 | ], 49 | "briefdescription" : "White top hat extracts local maxima that are larger than the structuring element.", 50 | "detaileddescription" : "Top-hats are described in Chapter 4.5 of Pierre Soille's book \"Morphological Image Analysis: Principles and Applications\", Second Edition, Springer, 2003.\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.", 51 | "itk_module" : "ITKMathematicalMorphology", 52 | "itk_group" : "MathematicalMorphology" 53 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LaplacianImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LaplacianImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "RealPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "UseImageSpacing", 11 | "type" : "bool", 12 | "default" : "true", 13 | "briefdescriptionSet" : "", 14 | "detaileddescriptionSet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations", 15 | "briefdescriptionGet" : "", 16 | "detaileddescriptionGet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations" 17 | } 18 | ], 19 | "tests" : [ 20 | { 21 | "tag" : "default", 22 | "description" : "Simply run with default settings", 23 | "settings" : [], 24 | "tolerance" : 0.0001, 25 | "inputs" : [ 26 | "Input/RA-Float.nrrd" 27 | ] 28 | } 29 | ], 30 | "briefdescription" : "", 31 | "detaileddescription" : "This filter computes the Laplacian of a scalar-valued image. The Laplacian is an isotropic measure of the 2nd spatial derivative of an image. The Laplacian of an image highlights regions of rapid intensity change and is therefore often used for edge detection. Often, the Laplacian is applied to an image that has first been smoothed with a Gaussian filter in order to reduce its sensitivity to noise.\n\n\\par \nThe Laplacian at each pixel location is computed by convolution with the itk::LaplacianOperator .\n\n\\par Inputs and Outputs\nThe input to this filter is a scalar-valued itk::Image of arbitrary dimension. The output is a scalar-valued itk::Image .\n\n\\warning The pixel type of the input and output images must be of real type (float or double). ConceptChecking is used here to enforce the input pixel type. You will get a compilation error if the pixel type of the input and output images is not float or double.\n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\see LaplacianOperator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the Laplacian of an image", 32 | "itk_module" : "ITKImageFeature", 33 | "itk_group" : "ImageFeature" 34 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MinimumMaximumImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MinimumMaximumImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "filter_type" : "itk::MinimumMaximumImageFilter", 8 | "no_procedure" : true, 9 | "no_return_image" : true, 10 | "members" : [], 11 | "measurements" : [ 12 | { 13 | "name" : "Minimum", 14 | "type" : "double", 15 | "default" : 0.0, 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Return the computed Minimum." 18 | }, 19 | { 20 | "name" : "Maximum", 21 | "type" : "double", 22 | "default" : 0.0, 23 | "briefdescriptionGet" : "", 24 | "detaileddescriptionGet" : "Return the computed Maximum." 25 | } 26 | ], 27 | "tests" : [ 28 | { 29 | "tag" : "2d", 30 | "description" : "2d with unsigned char", 31 | "settings" : [], 32 | "measurements_results" : [ 33 | { 34 | "name" : "Minimum", 35 | "value" : 0, 36 | "tolerance" : 0 37 | }, 38 | { 39 | "name" : "Maximum", 40 | "value" : 255, 41 | "tolerance" : 0 42 | } 43 | ], 44 | "inputs" : [ 45 | "Input/cthead1.png" 46 | ] 47 | }, 48 | { 49 | "tag" : "float", 50 | "description" : "3d float image", 51 | "settings" : [], 52 | "measurements_results" : [ 53 | { 54 | "name" : "Minimum", 55 | "value" : -1146, 56 | "tolerance" : 0 57 | }, 58 | { 59 | "name" : "Maximum", 60 | "value" : 32767, 61 | "tolerance" : 0 62 | } 63 | ], 64 | "inputs" : [ 65 | "Input/RA-Float.nrrd" 66 | ] 67 | } 68 | ], 69 | "briefdescription" : "Computes the minimum and the maximum intensity values of an image.", 70 | "detaileddescription" : "It is templated over input image type only. This filter just copies the input image through this output to be included within the pipeline. The implementation uses the StatisticsImageFilter .\n\n\\see StatisticsImageFilter", 71 | "itk_module" : "ITKImageStatistics", 72 | "itk_group" : "ImageStatistics" 73 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NormalizeToConstantImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NormalizeToConstantImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 10 | "members" : [ 11 | { 12 | "name" : "Constant", 13 | "type" : "double", 14 | "default" : "1.0", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Set/get the normalization constant.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Set/get the normalization constant." 19 | } 20 | ], 21 | "tests" : [ 22 | { 23 | "tag" : "defaults", 24 | "description" : "Simply run with default settings", 25 | "settings" : [], 26 | "tolerance" : "0.0001", 27 | "inputs" : [ 28 | "Input/Ramp-Up-Short.nrrd" 29 | ] 30 | }, 31 | { 32 | "tag" : "vector", 33 | "description" : "Running with vector image to normalize to 0", 34 | "settings" : [ 35 | { 36 | "parameter" : "Constant", 37 | "value" : "0.0" 38 | } 39 | ], 40 | "tolerance" : "0.0001", 41 | "inputs" : [ 42 | "Input/VM1111Shrink-RGB.png" 43 | ] 44 | } 45 | ], 46 | "briefdescription" : "Scales image pixel intensities to make the sum of all pixels equal a user-defined constant.", 47 | "detaileddescription" : "The default value of the constant is 1. It can be changed with SetConstant() .\n\nThis transform is especially useful for normalizing a convolution kernel.\n\nThis code was contributed in the Insight Journal paper: \"FFT based\nconvolution\" by Lehmann G. https://hdl.handle.net/10380/3154 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see NormalizeImageFilter \n\n\\see StatisticsImageFilter \n\n\\see DivideImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Scale all pixels so that their sum is a specified constant", 48 | "itk_module" : "ITKImageIntensity", 49 | "itk_group" : "ImageIntensity" 50 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/VectorIndexSelectionCastImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "VectorIndexSelectionCastImageFilter", 3 | "template_code_filename" : "DualImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "VectorPixelIDTypeList", 8 | "pixel_types2" : "typelist::Append::Type", 9 | "custom_type2" : "const PixelIDValueEnum type2 = (m_OutputPixelType != sitkUnknown) ? m_OutputPixelType : type1;", 10 | "output_pixel_type" : "typename InputImageType2::InternalPixelType", 11 | "members" : [ 12 | { 13 | "name" : "Index", 14 | "type" : "unsigned int", 15 | "default" : "0u", 16 | "doc" : "", 17 | "briefdescriptionSet" : "", 18 | "detaileddescriptionSet" : "Get/Set methods for the index", 19 | "briefdescriptionGet" : "", 20 | "detaileddescriptionGet" : "" 21 | }, 22 | { 23 | "name" : "OutputPixelType", 24 | "type" : "PixelIDValueEnum", 25 | "default" : "itk::simple::sitkUnknown", 26 | "custom_itk_cast" : "", 27 | "briefdescriptionSet" : "Set the output pixel type of the scalar component to extract.", 28 | "briefdescriptionGet" : "Get the ouput pixel type." 29 | } 30 | ], 31 | "tests" : [ 32 | { 33 | "tag" : "blue", 34 | "description" : "Extract blue from VH slice", 35 | "settings" : [ 36 | { 37 | "parameter" : "Index", 38 | "cxx_value" : "2u", 39 | "value" : "2" 40 | } 41 | ], 42 | "md5hash" : "da3f74fce21be8b788da331377f7f361", 43 | "inputs" : [ 44 | "Input/VM1111Shrink-RGBFloat.nrrd" 45 | ] 46 | } 47 | ], 48 | "briefdescription" : "Extracts the selected index of the vector that is the input pixel type.", 49 | "detaileddescription" : "This filter is templated over the input image type and output image type.\n\nThe filter expect the input image pixel type to be a vector and the output image pixel type to be a scalar. The only requirement on the type used for representing the vector is that it must provide an operator[].\n\n\\see ComposeImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Extract a component/channel of a vector image", 50 | "itk_module" : "ITKImageIntensity", 51 | "itk_group" : "ImageIntensity" 52 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/HalfHermitianToRealInverseFFTImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "HalfHermitianToRealInverseFFTImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "ComplexPixelIDTypeList", 8 | "filter_type" : "itk::HalfHermitianToRealInverseFFTImageFilter", 9 | "members" : [ 10 | { 11 | "name" : "ActualXDimensionIsOdd", 12 | "type" : "bool", 13 | "default" : "false", 14 | "doc" : "", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Was the original truncated dimension size odd?", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Was the original truncated dimension size odd?" 19 | } 20 | ], 21 | "tests" : [ 22 | { 23 | "tag" : "defaults", 24 | "description" : "Test half inverse FFT", 25 | "tolerance" : "0.01", 26 | "settings" : [], 27 | "inputs" : [ 28 | "Input/RA-HalfFFT-Complex.nrrd" 29 | ] 30 | } 31 | ], 32 | "briefdescription" : "Base class for specialized complex-to-real inverse Fast Fourier Transform .", 33 | "detaileddescription" : "This is a base class for the \"inverse\" or \"reverse\" Discrete Fourier Transform . This is an abstract base class: the actual implementation is provided by the best child class available on the system when the object is created via the object factory system.\n\nThe input to this filter is assumed to have the same format as the output of the RealToHalfHermitianForwardFFTImageFilter . That is, the input is assumed to consist of roughly half the full complex image resulting from a real-to-complex discrete Fourier transform. This half is expected to be the first half of the image in the X-dimension. Because this filter assumes that the input stores only about half of the non-redundant complex pixels, the output is larger in the X-dimension than it is in the input. To determine the actual size of the output image, this filter needs additional information in the form of a flag indicating whether the output image has an odd size in the X-dimension. Use SetActualXDimensionIsOdd() to set this flag.\n\n\\see ForwardFFTImageFilter , HalfHermitianToRealInverseFFTImageFilter", 34 | "itk_module" : "ITKFFT", 35 | "itk_group" : "FFT" 36 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SubtractImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SubtractImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "NonLabelPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2D", 13 | "description" : "Default parameter settings", 14 | "settings" : [], 15 | "md5hash" : "ce338fe6899778aacfc28414f2d9498b", 16 | "inputs" : [ 17 | "Input/RA-Slice-Float.nrrd", 18 | "Input/RA-Slice-Float.nrrd" 19 | ] 20 | }, 21 | { 22 | "tag" : "3D", 23 | "description" : "Subtract a volume from a volume", 24 | "settings" : [], 25 | "md5hash" : "59071590099d21dd439896592338bf95", 26 | "inputs" : [ 27 | "Input/RA-Short.nrrd", 28 | "Input/RA-Short.nrrd" 29 | ] 30 | }, 31 | { 32 | "tag" : "2d_rgb", 33 | "description" : "2D-RGB", 34 | "settings" : [], 35 | "md5hash" : "30d54bcc6106abcac387cf9da95fe514", 36 | "inputs" : [ 37 | "Input/VM1111Shrink-RGBFloat.nrrd", 38 | "Input/VM1111Shrink-RGBFloat.nrrd" 39 | ] 40 | } 41 | ], 42 | "briefdescription" : "Pixel-wise subtraction of two images.", 43 | "detaileddescription" : "Subtract each pixel from image2 from its corresponding pixel in image1:\n\n\\code\n* Output = Input1 - Input2.\n\n* \n\n\\endcode\n\nThis is done using\n\n\\code\n* SetInput1 ( image1 );\n\n* SetInput2 ( image2 );\n\n* \n\n\\endcode\n\nThis class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nAdditionally, a constant can be subtracted from every pixel in an image using:\n\n\\code\n* SetInput1 ( image1 );\n\n* SetConstant2 ( constant );\n\n* \n\n\\endcode\n\n\\note The result of AddImageFilter with a negative constant is not necessarily the same as SubtractImageFilter . This would be the case when the PixelType defines an operator-() that is not the inverse of operator+() \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Subtract two images \n\n\\li Subtract a constant from every pixel in an image", 44 | "itk_module" : "ITKImageIntensity", 45 | "itk_group" : "ImageIntensity" 46 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BoxMeanImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BoxMeanImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Radius", 12 | "type" : "unsigned int", 13 | "default" : "std::vector(3, 1)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "doc" : "", 17 | "itk_type" : "typename FilterType::RadiusType" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults", 23 | "description" : "Test MeanImageFilter with default parametrs", 24 | "md5hash" : "dc71425a437766b9566cb13bd4139a91", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGBFloat.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "by23", 32 | "description" : "Test by 23", 33 | "md5hash" : "23c2a0d1f7816366aa55b90c0b86f6e6", 34 | "settings" : [ 35 | { 36 | "parameter" : "Radius", 37 | "type" : "unsigned int", 38 | "dim_vec" : 1, 39 | "value" : [ 40 | 2, 41 | 3 42 | ] 43 | } 44 | ], 45 | "inputs" : [ 46 | "Input/VM1111Shrink-RGB.png" 47 | ] 48 | }, 49 | { 50 | "tag" : "by333", 51 | "description" : "Test by 333", 52 | "md5hash" : "c6a8c4774f59ac92eefcaea18bd0f514", 53 | "settings" : [ 54 | { 55 | "parameter" : "Radius", 56 | "type" : "unsigned int", 57 | "dim_vec" : 1, 58 | "value" : [ 59 | 3, 60 | 3, 61 | 3 62 | ] 63 | } 64 | ], 65 | "inputs" : [ 66 | "Input/RA-Short.nrrd" 67 | ] 68 | } 69 | ], 70 | "briefdescription" : "Implements a fast rectangular mean filter using the accumulator approach.", 71 | "detaileddescription" : "This code was contributed in the Insight Journal paper: \"Efficient implementation of kernel filtering\" by Beare R., Lehmann G https://hdl.handle.net/1926/555 http://www.insight-journal.org/browse/publication/160 \n\n\\author Richard Beare", 72 | "itk_module" : "ITKSmoothing", 73 | "itk_group" : "Smoothing" 74 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BoxSigmaImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BoxSigmaImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Radius", 12 | "type" : "unsigned int", 13 | "default" : "std::vector(3, 1)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "doc" : "", 17 | "itk_type" : "typename FilterType::RadiusType" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults", 23 | "description" : "Test MeanImageFilter with default parametrs", 24 | "md5hash" : "500013c78f4508052b63c072e261b329", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGBFloat.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "by23", 32 | "description" : "Test by 23", 33 | "md5hash" : "e0a8cfe245c47b73047c1c5292beb719", 34 | "settings" : [ 35 | { 36 | "parameter" : "Radius", 37 | "type" : "unsigned int", 38 | "dim_vec" : 1, 39 | "value" : [ 40 | 2, 41 | 3 42 | ] 43 | } 44 | ], 45 | "inputs" : [ 46 | "Input/VM1111Shrink-RGB.png" 47 | ] 48 | }, 49 | { 50 | "tag" : "by333", 51 | "description" : "Test by 333", 52 | "md5hash" : "aa7be2354551dd5310c9d75ac026400d", 53 | "settings" : [ 54 | { 55 | "parameter" : "Radius", 56 | "type" : "unsigned int", 57 | "dim_vec" : 1, 58 | "value" : [ 59 | 3, 60 | 3, 61 | 3 62 | ] 63 | } 64 | ], 65 | "inputs" : [ 66 | "Input/RA-Short.nrrd" 67 | ] 68 | } 69 | ], 70 | "briefdescription" : "Implements a fast rectangular sigma filter using the accumulator approach.", 71 | "detaileddescription" : "This code was contributed in the Insight Journal paper: \"Efficient implementation of kernel filtering\" by Beare R., Lehmann G https://hdl.handle.net/1926/555 http://www.insight-journal.org/browse/publication/160 \n\n\\author Gaetan Lehmann", 72 | "itk_module" : "ITKSmoothing", 73 | "itk_group" : "Smoothing" 74 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SquaredDifferenceImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SquaredDifferenceImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "BasicPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2DStapleImages", 13 | "description" : "Default parameter settings", 14 | "settings" : [], 15 | "tolerance" : "1e-8", 16 | "inputA_cast" : "sitkUInt16", 17 | "inputB_cast" : "sitkUInt16", 18 | "inputs" : [ 19 | "Input/STAPLE1.png", 20 | "Input/STAPLE2.png" 21 | ] 22 | }, 23 | { 24 | "tag" : "Ramp_Short1", 25 | "description" : "Ramp", 26 | "settings" : [], 27 | "tolerance" : "1e-8", 28 | "inputs" : [ 29 | "Input/Ramp-Zero-One-Float.nrrd", 30 | "Input/Ramp-One-Zero-Float.nrrd" 31 | ] 32 | }, 33 | { 34 | "tag" : "Ramp_Short2", 35 | "description" : "Ramp", 36 | "settings" : [], 37 | "tolerance" : "1e-8", 38 | "inputA_cast" : "sitkUInt32", 39 | "inputB_cast" : "sitkUInt32", 40 | "inputs" : [ 41 | "Input/Ramp-Up-Short.nrrd", 42 | "Input/Ramp-Down-Short.nrrd" 43 | ] 44 | } 45 | ], 46 | "briefdescription" : "Implements pixel-wise the computation of squared difference.", 47 | "detaileddescription" : "This filter is parametrized over the types of the two input images and the type of the output image.\n\nNumeric conversions (castings) are done by the C++ defaults.\n\nThe filter will walk over all the pixels in the two input images, and for each one of them it will do the following:\n\n\n\\li cast the input 1 pixel value to double \n\n\\li cast the input 2 pixel value to double \n\n\\li compute the difference of the two pixel values\n\n\\li compute the square of the difference\n\n\\li cast the double value resulting from sqr() to the pixel type of the output image\n\n\\li store the casted value into the output image.\n\n\n\nThe filter expect all images to have the same dimension (e.g. all 2D, or all 3D, or all ND)\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the squared difference of corresponding pixels in two images", 48 | "itk_module" : "ITKImageCompare", 49 | "itk_group" : "ImageCompare" 50 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BlackTopHatImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BlackTopHatImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "SafeBorder", 11 | "type" : "bool", 12 | "default" : "true", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done" 18 | } 19 | ], 20 | "custom_methods" : [], 21 | "tests" : [ 22 | { 23 | "tag" : "BlackTopHapErode", 24 | "description" : "Test black top hat", 25 | "md5hash" : "445a5da6221f6d976d169b70c5538614", 26 | "settings" : [ 27 | { 28 | "parameter" : "KernelRadius", 29 | "no_get_method" : 1, 30 | "value" : 1 31 | }, 32 | { 33 | "parameter" : "KernelType", 34 | "value" : "itk::simple::sitkBall", 35 | "lua_value" : "SimpleITK.sitkBall", 36 | "python_value" : "SimpleITK.sitkBall", 37 | "ruby_value" : "Simpleitk::SitkBall", 38 | "java_value" : "KernelEnum.sitkBall", 39 | "tcl_value" : "$$sitkBall", 40 | "csharp_value" : "KernelEnum.sitkBall", 41 | "R_value" : "'sitkBall'" 42 | } 43 | ], 44 | "inputs" : [ 45 | "Input/STAPLE1.png" 46 | ] 47 | } 48 | ], 49 | "briefdescription" : "Black top hat extracts local minima that are smaller than the structuring element.", 50 | "detaileddescription" : "Black top hat extracts local minima that are smaller than the structuring element. It subtracts the background from the input image. The output of the filter transforms the black valleys into white peaks.\n\nTop-hats are described in Chapter 4.5 of Pierre Soille's book \"Morphological Image Analysis: Principles and Applications\", Second Edition, Springer, 2003.\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.", 51 | "itk_module" : "ITKMathematicalMorphology", 52 | "itk_group" : "MathematicalMorphology" 53 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/FFTShiftImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "FFTShiftImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "NonLabelPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Inverse", 11 | "type" : "bool", 12 | "default" : "false", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get whether the filter must invert the transform or not. This option has no effect if none of the size of the input image is even, but is required to restore the original image if at least one of the dimensions has an odd size.", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get whether the filter must invert the transform or not. This option has no effect if none of the size of the input image is even, but is required to restore the original image if at least one of the dimensions has an odd size." 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults_complex", 23 | "description" : "Test FFTShift complex", 24 | "md5hash" : "9b4b0f11dd58a03d94d0e246e14cf63d", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/RA-FFT-Complex.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "defaults_float", 32 | "description" : "Test FFTShift float", 33 | "md5hash" : "94409cf6d85e17a3dba2f2aba214d4ac", 34 | "settings" : [], 35 | "inputs" : [ 36 | "Input/RA-Slice-Float.nrrd" 37 | ] 38 | } 39 | ], 40 | "briefdescription" : "Shift the zero-frequency components of a Fourier transform to the center of the image.", 41 | "detaileddescription" : "The Fourier transform produces an image where the zero frequency components are in the corner of the image, making it difficult to understand. This filter shifts the component to the center of the image.\n\n\\note For images with an odd-sized dimension, applying this filter twice will not produce the same image as the original one without using SetInverse(true) on one (and only one) of the two filters.\n\nhttps://hdl.handle.net/1926/321 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ForwardFFTImageFilter , InverseFFTImageFilter", 42 | "itk_module" : "ITKFFT", 43 | "itk_group" : "FFT" 44 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/GrayscaleMorphologicalClosingImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "GrayscaleMorphologicalClosingImageFilter", 3 | "template_code_filename" : "KernelImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Performs morphological closing in a grayscale image.", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "SafeBorder", 11 | "type" : "bool", 12 | "default" : "true", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "A safe border is added to input image to avoid borders effects and remove it once the closing is done" 18 | } 19 | ], 20 | "custom_methods" : [], 21 | "tests" : [ 22 | { 23 | "tag" : "GrayscaleMorphologicalClosing", 24 | "description" : "Test grayscale morphological closing", 25 | "md5hash" : "103130cc4caf40d9fb252fbabc531e15", 26 | "settings" : [ 27 | { 28 | "parameter" : "KernelRadius", 29 | "no_get_method" : 1, 30 | "value" : 1 31 | }, 32 | { 33 | "parameter" : "KernelType", 34 | "value" : "itk::simple::sitkBall", 35 | "lua_value" : "SimpleITK.sitkBall", 36 | "python_value" : "SimpleITK.sitkBall", 37 | "ruby_value" : "Simpleitk::SitkBall", 38 | "java_value" : "KernelEnum.sitkBall", 39 | "tcl_value" : "$$sitkBall", 40 | "csharp_value" : "KernelEnum.sitkBall", 41 | "R_value" : "'sitkBall'" 42 | } 43 | ], 44 | "inputs" : [ 45 | "Input/STAPLE1.png" 46 | ] 47 | } 48 | ], 49 | "briefdescription" : "gray scale dilation of an image", 50 | "detaileddescription" : "Erode an image using grayscale morphology. Dilation takes the maximum of all the pixels identified by the structuring element.\n\nThe structuring element is assumed to be composed of binary values (zero or one). Only elements of the structuring element having values > 0 are candidates for affecting the center pixel.\n\n\\see MorphologyImageFilter , GrayscaleFunctionErodeImageFilter , BinaryErodeImageFilter", 51 | "itk_module" : "ITKMathematicalMorphology", 52 | "itk_group" : "MathematicalMorphology" 53 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SigmoidImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SigmoidImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Alpha", 11 | "type" : "double", 12 | "default" : 1, 13 | "doc" : "Alpha", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "" 18 | }, 19 | { 20 | "name" : "Beta", 21 | "type" : "double", 22 | "default" : 0, 23 | "doc" : "Alpha", 24 | "briefdescriptionSet" : "", 25 | "detaileddescriptionSet" : "", 26 | "briefdescriptionGet" : "", 27 | "detaileddescriptionGet" : "" 28 | }, 29 | { 30 | "name" : "OutputMaximum", 31 | "type" : "double", 32 | "default" : 255, 33 | "pixeltype" : "Output", 34 | "briefdescriptionSet" : "", 35 | "detaileddescriptionSet" : "", 36 | "briefdescriptionGet" : "", 37 | "detaileddescriptionGet" : "" 38 | }, 39 | { 40 | "name" : "OutputMinimum", 41 | "type" : "double", 42 | "default" : 0, 43 | "pixeltype" : "Input", 44 | "briefdescriptionSet" : "", 45 | "detaileddescriptionSet" : "", 46 | "briefdescriptionGet" : "", 47 | "detaileddescriptionGet" : "" 48 | } 49 | ], 50 | "tests" : [ 51 | { 52 | "tag" : "defaults", 53 | "description" : "Simply run with default settings", 54 | "settings" : [], 55 | "md5hash" : "c9222b9c9150e0d7a07e9de184c10167", 56 | "inputs" : [ 57 | "Input/Ramp-Zero-One-Float.nrrd" 58 | ] 59 | } 60 | ], 61 | "briefdescription" : "Computes the sigmoid function pixel-wise.", 62 | "detaileddescription" : "A linear transformation is applied first on the argument of the sigmoid function. The resulting total transform is given by\n\n \\f[ f(x) = (Max-Min) \\cdot \\frac{1}{\\left(1+e^{- \\frac{ x - \\beta }{\\alpha}}\\right)} + Min \\f] \n\nEvery output pixel is equal to f(x). Where x is the intensity of the homologous input pixel, and alpha and beta are user-provided constants.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Pass image pixels through a sigmoid function", 63 | "itk_module" : "ITKImageIntensity", 64 | "itk_group" : "ImageIntensity" 65 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MinimumProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MinimumProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "defaults", 19 | "description" : "run with some defaults", 20 | "md5hash" : "5591e0307db733396e8cc8143e7f29f7", 21 | "inputs" : [ 22 | "Input/RA-Float.nrrd" 23 | ] 24 | }, 25 | { 26 | "tag" : "another_dimension", 27 | "description" : "project in the 3rd dimension", 28 | "settings" : [ 29 | { 30 | "parameter" : "ProjectionDimension", 31 | "cxx_value" : "2u", 32 | "value" : "2" 33 | } 34 | ], 35 | "md5hash" : "6c16b87a823ca190294ac8b678ba4300", 36 | "inputs" : [ 37 | "Input/RA-Float.nrrd" 38 | ] 39 | }, 40 | { 41 | "tag" : "short_image", 42 | "description" : "project with a short image", 43 | "settings" : [ 44 | { 45 | "parameter" : "ProjectionDimension", 46 | "cxx_value" : "1u", 47 | "value" : "1" 48 | } 49 | ], 50 | "md5hash" : "c4d83f61ffd5cc3a163155bb5d6a0698", 51 | "inputs" : [ 52 | "Input/Ramp-Up-Short.nrrd" 53 | ] 54 | }, 55 | { 56 | "tag" : "rgb_image", 57 | "description" : "project with a rgb image in 2D", 58 | "md5hash" : "344c2d7cf14b5e8b30b266b77a0548c2", 59 | "inputs" : [ 60 | "Input/VM1111Shrink-RGB.png" 61 | ] 62 | } 63 | ], 64 | "briefdescription" : "Minimum projection.", 65 | "detaileddescription" : "This class was contributed to the Insight Journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ProjectionImageFilter \n\n\\see StandardDeviationProjectionImageFilter \n\n\\see SumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter \n\n\\see MaximumProjectionImageFilter \n\n\\see MeanProjectionImageFilter", 66 | "itk_module" : "ITKImageStatistics", 67 | "itk_group" : "ImageStatistics" 68 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LaplacianSharpeningImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LaplacianSharpeningImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "UseImageSpacing", 12 | "type" : "bool", 13 | "default" : "true", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get whether or not the filter will use the spacing of the input image in its calculations" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "default", 23 | "description" : "Simply run with default settings with a floating point image", 24 | "settings" : [], 25 | "tolerance" : 0.0001, 26 | "inputs" : [ 27 | "Input/RA-Float.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "shortdefault", 32 | "description" : "Simply run with default settings on a short image", 33 | "settings" : [], 34 | "md5hash" : "93a629b9dfad6814c5acbabd42f10c4c", 35 | "inputs" : [ 36 | "Input/RA-Short.nrrd" 37 | ] 38 | }, 39 | { 40 | "tag" : "vectordefault", 41 | "description" : "Run with defaults setting on an RGB image", 42 | "settings" : [], 43 | "md5hash" : "f3ad8145d54e583b3e2354b24769df58", 44 | "inputs" : [ 45 | "Input/fruit.png" 46 | ] 47 | } 48 | ], 49 | "briefdescription" : "This filter sharpens an image using a Laplacian. LaplacianSharpening highlights regions of rapid intensity change and therefore highlights or enhances the edges. The result is an image that appears more in focus.", 50 | "detaileddescription" : "\\par The LaplacianSharpening at each pixel location is computed by\nconvolution with the itk::LaplacianOperator .\n\n\\par Inputs and Outputs\nThe input to this filter is a scalar-valued itk::Image of arbitrary dimension. The output is a scalar-valued itk::Image . \n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\see LaplacianOperator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Sharpen an image", 51 | "itk_module" : "ITKImageFeature", 52 | "itk_group" : "ImageFeature" 53 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NormalizedCorrelationImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NormalizedCorrelationImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 0, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "include_files" : [ 8 | "sitkImageToKernel.hxx" 9 | ], 10 | "inputs" : [ 11 | { 12 | "name" : "Image", 13 | "type" : "Image" 14 | }, 15 | { 16 | "name" : "MaskImage", 17 | "type" : "Image" 18 | }, 19 | { 20 | "name" : "TemplateImage", 21 | "type" : "Image", 22 | "no_size_check" : 0, 23 | "custom_itk_cast" : "filter->SetTemplate( *CreateOperatorFromImage( this->CastImageToITK(*inTemplateImage).GetPointer() ).get() );" 24 | } 25 | ], 26 | "output_pixel_type" : "typename itk::NumericTraits::RealType", 27 | "filter_type" : "itk::NormalizedCorrelationImageFilter", 28 | "members" : [], 29 | "tests" : [ 30 | { 31 | "tag" : "defaults", 32 | "description" : "Basic xcorr with and odd kernel", 33 | "settings" : [], 34 | "tolerance" : "0.0001", 35 | "inputs" : [ 36 | "Input/cthead1-Float.mha", 37 | "Input/cthead1-Float.mha", 38 | "Input/Gaussian_1.5.nrrd" 39 | ] 40 | }, 41 | { 42 | "tag" : "EvenKernel", 43 | "description" : "Basic xcorr with an even kernel", 44 | "settings" : [], 45 | "tolerance" : "0.0001", 46 | "inputs" : [ 47 | "Input/cthead1-Float.mha", 48 | "Input/cthead1-Float.mha", 49 | "Input/DeconvolutionKernel.nrrd" 50 | ] 51 | } 52 | ], 53 | "briefdescription" : "Computes the normalized correlation of an image and a template.", 54 | "detaileddescription" : "This filter calculates the normalized correlation between an image and the template. Normalized correlation is frequently use in feature detection because it is invariant to local changes in contrast.\n\nThe filter can be given a mask. When presented with an input image and a mask, the normalized correlation is only calculated at those pixels under the mask.\n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Normalized correlation", 55 | "itk_module" : "ITKConvolution", 56 | "itk_group" : "Convolution" 57 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ShiftScaleImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ShiftScaleImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Shift", 12 | "type" : "double", 13 | "default" : 0, 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get the amount to Shift each Pixel. The shift is followed by a Scale.", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get the amount to Shift each Pixel. The shift is followed by a Scale." 18 | }, 19 | { 20 | "name" : "Scale", 21 | "type" : "double", 22 | "default" : "1.0", 23 | "briefdescriptionSet" : "", 24 | "detaileddescriptionSet" : "Set/Get the amount to Scale each Pixel. The Scale is applied after the Shift.", 25 | "briefdescriptionGet" : "", 26 | "detaileddescriptionGet" : "Set/Get the amount to Scale each Pixel. The Scale is applied after the Shift." 27 | } 28 | ], 29 | "tests" : [ 30 | { 31 | "tag" : "default", 32 | "description" : " default parameters", 33 | "settings" : [], 34 | "md5hash" : "a963bd6a755b853103a2d195e01a50d3", 35 | "inputs" : [ 36 | "Input/RA-Short.nrrd" 37 | ] 38 | }, 39 | { 40 | "tag" : "params", 41 | "description" : " default parameters", 42 | "settings" : [ 43 | { 44 | "parameter" : "Shift", 45 | "type" : "double", 46 | "value" : "100" 47 | }, 48 | { 49 | "parameter" : "Scale", 50 | "type" : "double", 51 | "value" : "0.5" 52 | } 53 | ], 54 | "md5hash" : "e3bee902dc9339d28359ebfb96a70186", 55 | "inputs" : [ 56 | "Input/RA-Short.nrrd" 57 | ] 58 | } 59 | ], 60 | "briefdescription" : "Shift and scale the pixels in an image.", 61 | "detaileddescription" : "ShiftScaleImageFilter shifts the input pixel by Shift (default 0.0) and then scales the pixel by Scale (default 1.0). All computattions are performed in the precision of the input pixel's RealType. Before assigning the computed value to the output pixel, the value is clamped at the NonpositiveMin and max of the pixel type.", 62 | "itk_module" : "ITKImageIntensity", 63 | "itk_group" : "ImageIntensity" 64 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/UnaryMinusImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "UnaryMinusImageFilter", 3 | "itk_name" : "UnaryFunctorImageFilter", 4 | "template_code_filename" : "ImageFilter", 5 | "template_test_filename" : "ImageFilter", 6 | "number_of_inputs" : 1, 7 | "doc" : "", 8 | "pixel_types" : "typelist::Append< SignedPixelIDTypeList, ComplexPixelIDTypeList >::Type", 9 | "filter_type" : "itk::UnaryFunctorImageFilter< InputImageType, OutputImageType, itk::Functor::UnaryMinus >", 10 | "vector_pixel_types_by_component" : "SignedVectorPixelIDTypeList", 11 | "include_files" : [ 12 | "itkArithmeticOpsFunctors.h" 13 | ], 14 | "members" : [], 15 | "tests" : [ 16 | { 17 | "tag" : "short", 18 | "description" : "Run on a short image", 19 | "settings" : [], 20 | "md5hash" : "a3f518ba0be98bf6903f49dcc6937645", 21 | "inputs" : [ 22 | "Input/RA-Slice-Short.nrrd" 23 | ] 24 | }, 25 | { 26 | "tag" : "float", 27 | "description" : "Run on a float image", 28 | "settings" : [], 29 | "md5hash" : "ded119ebd73f6331ee3b29048fba4b6d", 30 | "inputs" : [ 31 | "Input/cthead1-Float.mha" 32 | ] 33 | }, 34 | { 35 | "tag" : "complex", 36 | "description" : "Run on a complex image", 37 | "settings" : [], 38 | "md5hash" : "5e444ac1752722e34aaa9bb77685cad4", 39 | "inputs" : [ 40 | "Input/RA-FFT-Complex.nrrd" 41 | ] 42 | }, 43 | { 44 | "tag" : "RGBFloat", 45 | "description" : "Run on a vector of floats image", 46 | "settings" : [], 47 | "md5hash" : "3f67a4b24d58c878c1768900a897e12b", 48 | "inputs" : [ 49 | "Input/VM1111Shrink-RGBFloat.nrrd" 50 | ] 51 | } 52 | ], 53 | "briefdescription" : "Implements pixel-wise generic operation on one image.", 54 | "detaileddescription" : "This class is parameterized over the type of the input image and the type of the output image. It is also parameterized by the operation to be applied, using a Functor style.\n\nUnaryFunctorImageFilter allows the output dimension of the filter to be larger than the input dimension. Thus subclasses of the UnaryFunctorImageFilter (like the CastImageFilter ) can be used to promote a 2D image to a 3D image, etc.\n\n\\see BinaryFunctorImageFilter TernaryFunctorImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Apply a custom operation to each pixel in an image", 55 | "itk_module" : "ITKCommon" 56 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MaximumProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MaximumProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "defaults", 19 | "description" : "run with some defaults", 20 | "md5hash" : "fb78c55635b17fc9ff38ef0ef14f0948", 21 | "inputs" : [ 22 | "Input/RA-Float.nrrd" 23 | ] 24 | }, 25 | { 26 | "tag" : "another_dimension", 27 | "description" : "project in the 3rd dimension", 28 | "settings" : [ 29 | { 30 | "parameter" : "ProjectionDimension", 31 | "cxx_value" : "2u", 32 | "value" : "2" 33 | } 34 | ], 35 | "md5hash" : "f3f0d97c83c6b0d92df10c28e2481520", 36 | "inputs" : [ 37 | "Input/RA-Float.nrrd" 38 | ] 39 | }, 40 | { 41 | "tag" : "short_image", 42 | "description" : "project with a short image", 43 | "settings" : [ 44 | { 45 | "parameter" : "ProjectionDimension", 46 | "cxx_value" : "1u", 47 | "value" : "1" 48 | } 49 | ], 50 | "md5hash" : "5390344262c91e83bc9208b0991a2fc9", 51 | "inputs" : [ 52 | "Input/Ramp-Up-Short.nrrd" 53 | ] 54 | }, 55 | { 56 | "tag" : "rgb_image", 57 | "description" : "project with a rgb image in 2D", 58 | "md5hash" : "92134e0dd38fccdf054ff23e67a72e75", 59 | "inputs" : [ 60 | "Input/VM1111Shrink-RGB.png" 61 | ] 62 | } 63 | ], 64 | "briefdescription" : "Maximum projection.", 65 | "detaileddescription" : "This class was contributed to the insight journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la reproduction, inra de jouy-en-josas, France.\n\n\\see ProjectionImageFilter \n\n\\see MedianProjectionImageFilter \n\n\\see MeanProjectionImageFilter \n\n\\see MinimumProjectionImageFilter \n\n\\see StandardDeviationProjectionImageFilter \n\n\\see SumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter", 66 | "itk_module" : "ITKImageStatistics", 67 | "itk_group" : "ImageStatistics" 68 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/MedianProjectionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "MedianProjectionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "ProjectionDimension", 12 | "type" : "unsigned int", 13 | "default" : "0u" 14 | } 15 | ], 16 | "tests" : [ 17 | { 18 | "tag" : "defaults", 19 | "description" : "run with some defaults", 20 | "md5hash" : "86de48c070480cb9809e28715f6e70e1", 21 | "inputs" : [ 22 | "Input/RA-Float.nrrd" 23 | ] 24 | }, 25 | { 26 | "tag" : "another_dimension", 27 | "description" : "project in the 3rd dimension", 28 | "settings" : [ 29 | { 30 | "parameter" : "ProjectionDimension", 31 | "cxx_value" : "2u", 32 | "value" : "2" 33 | } 34 | ], 35 | "md5hash" : "0990f0f6c63ea9d63b701ed7c2467de7", 36 | "inputs" : [ 37 | "Input/RA-Float.nrrd" 38 | ] 39 | }, 40 | { 41 | "tag" : "short_image", 42 | "description" : "project with a short image", 43 | "settings" : [ 44 | { 45 | "parameter" : "ProjectionDimension", 46 | "cxx_value" : "1u", 47 | "value" : "1" 48 | } 49 | ], 50 | "md5hash" : "9fcc7164f3294811cbf2d875b0e494d1", 51 | "inputs" : [ 52 | "Input/Ramp-Up-Short.nrrd" 53 | ] 54 | }, 55 | { 56 | "tag" : "rgb_image", 57 | "description" : "project with a rgb image in 2D", 58 | "md5hash" : "b66bc7e92a21a33c46d9a334d2292845", 59 | "inputs" : [ 60 | "Input/VM1111Shrink-RGB.png" 61 | ] 62 | } 63 | ], 64 | "briefdescription" : "Median projection.", 65 | "detaileddescription" : "This class was contributed to the Insight Journal by Gaetan Lehmann. The original paper can be found at https://hdl.handle.net/1926/164 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see ProjectionImageFilter \n\n\\see StandardDeviationProjectionImageFilter \n\n\\see SumProjectionImageFilter \n\n\\see BinaryProjectionImageFilter \n\n\\see MaximumProjectionImageFilter \n\n\\see MinimumProjectionImageFilter \n\n\\see MeanProjectionImageFilter", 66 | "itk_module" : "ITKImageStatistics", 67 | "itk_group" : "ImageStatistics" 68 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/CyclicShiftImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "CyclicShiftImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "NonLabelPixelIDTypeList", 7 | "members" : [ 8 | { 9 | "name" : "Shift", 10 | "type" : "int", 11 | "default" : "std::vector(3, 0)", 12 | "dim_vec" : 1, 13 | "set_as_scalar" : 1, 14 | "itk_type" : "typename FilterType::OffsetType", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Set/get the shift. Shifts may be positive or negative.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Set/get the shift. Shifts may be positive or negative." 19 | } 20 | ], 21 | "tests" : [ 22 | { 23 | "tag" : "defaults", 24 | "description" : "Test CyclicShift with default paramters", 25 | "md5hash" : "a9a0207c759cb8d9e0507414992905d6", 26 | "settings" : [], 27 | "inputs" : [ 28 | "Input/RA-Slice-Short.png" 29 | ] 30 | }, 31 | { 32 | "tag" : "more", 33 | "description" : "Test shift with some numbers", 34 | "md5hash" : "5add8d77a8aec9d1880bcb32f72134fc", 35 | "settings" : [ 36 | { 37 | "parameter" : "Shift", 38 | "type" : "int", 39 | "dim_vec" : 1, 40 | "value" : [ 41 | 5, 42 | -10, 43 | 0 44 | ] 45 | } 46 | ], 47 | "inputs" : [ 48 | "Input/Ramp-Down-Short.nrrd" 49 | ] 50 | } 51 | ], 52 | "briefdescription" : "Perform a cyclic spatial shift of image intensities on the image grid.", 53 | "detaileddescription" : "This filter supports arbitrary cyclic shifts of pixel values on the image grid. If the Shift is set to [xOff, yOff], the value of the pixel at [0, 0] in the input image will be the value of the pixel in the output image at index [xOff modulo xSize, yOff modulo ySize] where xSize and ySize are the sizes of the image in the x and y dimensions, respectively. If a pixel value is moved across a boundary, the pixel value is wrapped around that boundary. For example, if the image is 40-by-40 and the Shift is [13, 47], then the value of the pixel at [0, 0] in the input image will be the value of the pixel in the output image at index [13, 7].\n\nNegative Shifts are supported. This filter also works with images whose largest possible region starts at a non-zero index.", 54 | "itk_module" : "ITKImageGrid", 55 | "itk_group" : "ImageGrid" 56 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SaltAndPepperNoiseImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SaltAndPepperNoiseImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Probability", 11 | "type" : "double", 12 | "default" : "0.01", 13 | "briefdescriptionSet" : "", 14 | "detaileddescriptionSet" : "", 15 | "briefdescriptionGet" : "", 16 | "detaileddescriptionGet" : "" 17 | }, 18 | { 19 | "name" : "Seed", 20 | "type" : "uint32_t", 21 | "default" : "(uint32_t) itk::simple::sitkWallClock", 22 | "custom_itk_cast" : "if (m_Seed) filter->SetSeed(m_Seed);" 23 | } 24 | ], 25 | "tests" : [ 26 | { 27 | "tag" : "2d", 28 | "description" : "2D - baseline as zero noise", 29 | "no_procedure" : 1, 30 | "settings" : [ 31 | { 32 | "parameter" : "Seed", 33 | "cxx_value" : "123u", 34 | "value" : "123" 35 | } 36 | ], 37 | "tolerance" : 20, 38 | "inputs" : [ 39 | "Input/cthead1.png" 40 | ] 41 | }, 42 | { 43 | "tag" : "3d", 44 | "description" : "3D - baseline as zero noise", 45 | "no_procedure" : 1, 46 | "settings" : [ 47 | { 48 | "parameter" : "Seed", 49 | "cxx_value" : "123u", 50 | "value" : "123" 51 | } 52 | ], 53 | "tolerance" : 10000.0, 54 | "inputs" : [ 55 | "Input/RA-Short.nrrd" 56 | ] 57 | }, 58 | { 59 | "tag" : "rgb", 60 | "description" : "vector image - baseline as zero noise", 61 | "no_procedure" : 1, 62 | "settings" : [ 63 | { 64 | "parameter" : "Seed", 65 | "cxx_value" : "123u", 66 | "value" : "123" 67 | } 68 | ], 69 | "tolerance" : 20, 70 | "inputs" : [ 71 | "Input/VM1111Shrink-RGB.png" 72 | ] 73 | } 74 | ], 75 | "briefdescription" : "Alter an image with fixed value impulse noise, often called salt and pepper noise.", 76 | "detaileddescription" : "Pixel alteration occurs at a user defined probability. Salt and pepper pixel are equally distributed.\n\n\\author Gaetan Lehmann\n\nThis code was contributed in the Insight Journal paper \"Noise\nSimulation\". https://hdl.handle.net/10380/3158", 77 | "itk_module" : "ITKImageNoise", 78 | "itk_group" : "ImageNoise" 79 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ReconstructionByDilationImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ReconstructionByDilationImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 2, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "filter_type" : "itk::ReconstructionByDilationImageFilter", 8 | "members" : [ 9 | { 10 | "name" : "FullyConnected", 11 | "type" : "bool", 12 | "default" : "false", 13 | "doc" : "", 14 | "briefdescriptionSet" : "" 15 | }, 16 | { 17 | "name" : "UseInternalCopy", 18 | "type" : "bool", 19 | "default" : "true" 20 | } 21 | ], 22 | "custom_methods" : [], 23 | "tests" : [ 24 | { 25 | "tag" : "basic", 26 | "description" : "Test reconstruction by dilation", 27 | "md5hash" : "14e37b9098df480dfe83775a94fdc2c3", 28 | "settings" : [], 29 | "inputs" : [ 30 | "Input/cthead1-seed.png", 31 | "Input/2th_cthead1.png" 32 | ] 33 | } 34 | ], 35 | "briefdescription" : "grayscale reconstruction by dilation of an image", 36 | "detaileddescription" : "Reconstruction by dilation operates on a \"marker\" image and a \"mask\" image, and is defined as the dilation of the marker image with respect to the mask image iterated until stability.\n\nThe marker image must be less than or equal to the mask image (on a pixel by pixel basis).\n\nGeodesic morphology is described in Chapter 6.2 of Pierre Soille's book \"Morphological Image Analysis: Principles and Applications\", Second Edition, Springer, 2003.\n\nAlgorithm implemented in this filter is based on algorithm described by Kevin Robinson and Paul F. Whelan in \"Efficient Morphological\n Reconstruction: A Downhill Filter\", Pattern Recognition Letters, Volume 25, Issue 15, November 2004, Pages 1759-1767.\n\nThe algorithm, a description of the transform and some applications can be found in \"Morphological Grayscale Reconstruction in Image Analysis:\n Applications and Efficient Algorithms\", Luc Vincent, IEEE Transactions on image processing, Vol. 2, April 1993.\n\n\\author Richard Beare. Department of Medicine, Monash University, Melbourne, Australia.\n\n\\see MorphologyImageFilter , GrayscaleDilateImageFilter , GrayscaleFunctionDilateImageFilter , BinaryDilateImageFilter , ReconstructionByErosionImageFilter , OpeningByReconstructionImageFilter , ClosingByReconstructionImageFilter , ReconstructionImageFilter", 37 | "itk_module" : "ITKMathematicalMorphology", 38 | "itk_group" : "MathematicalMorphology" 39 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ReconstructionByErosionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ReconstructionByErosionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 2, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "filter_type" : "itk::ReconstructionByErosionImageFilter", 8 | "members" : [ 9 | { 10 | "name" : "FullyConnected", 11 | "type" : "bool", 12 | "default" : "false", 13 | "doc" : "", 14 | "briefdescriptionSet" : "" 15 | }, 16 | { 17 | "name" : "UseInternalCopy", 18 | "type" : "bool", 19 | "default" : "true" 20 | } 21 | ], 22 | "custom_methods" : [], 23 | "tests" : [ 24 | { 25 | "tag" : "basic", 26 | "description" : "Test binary reconstruction by erosion", 27 | "md5hash" : "9e52bcf554ad8e9c5391280a18f186f7", 28 | "settings" : [], 29 | "inputs" : [ 30 | "Input/2th_cthead1.png", 31 | "Input/cthead1-seed.png" 32 | ] 33 | } 34 | ], 35 | "briefdescription" : "grayscale reconstruction by erosion of an image", 36 | "detaileddescription" : "Reconstruction by erosion operates on a \"marker\" image and a \"mask\" image, and is defined as the erosion of the marker image with respect to the mask image iterated until stability.\n\nThe marker image must be less than or equal to the mask image (on a pixel by pixel basis).\n\nGeodesic morphology is described in Chapter 6.2 of Pierre Soille's book \"Morphological Image Analysis: Principles and Applications\", Second Edition, Springer, 2003.\n\nAlgorithm implemented in this filter is based on algorithm described by Kevin Robinson and Paul F. Whelan in \"Efficient Morphological\n Reconstruction: A Downhill Filter\", Pattern Recognition Letters, Volume 25, Issue 15, November 2004, Pages 1759-1767.\n\nThe algorithm, a description of the transform and some applications can be found in \"Morphological Grayscale Reconstruction in Image Analysis:\n Applications and Efficient Algorithms\", Luc Vincent, IEEE Transactions on image processing, Vol. 2, April 1993.\n\n\\author Richard Beare. Department of Medicine, Monash University, Melbourne, Australia.\n\n\\see MorphologyImageFilter , GrayscaleDilateImageFilter , GrayscaleFunctionDilateImageFilter , BinaryDilateImageFilter , ReconstructionByErosionImageFilter , OpeningByReconstructionImageFilter , ClosingByReconstructionImageFilter , ReconstructionImageFilter", 37 | "itk_module" : "ITKMathematicalMorphology", 38 | "itk_group" : "MathematicalMorphology" 39 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/SpeckleNoiseImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "SpeckleNoiseImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "StandardDeviation", 11 | "type" : "double", 12 | "default" : "1.0", 13 | "briefdescriptionSet" : "", 14 | "detaileddescriptionSet" : "", 15 | "briefdescriptionGet" : "", 16 | "detaileddescriptionGet" : "" 17 | }, 18 | { 19 | "name" : "Seed", 20 | "type" : "uint32_t", 21 | "default" : "(uint32_t) itk::simple::sitkWallClock", 22 | "custom_itk_cast" : "if (m_Seed) filter->SetSeed(m_Seed);" 23 | } 24 | ], 25 | "tests" : [ 26 | { 27 | "tag" : "2d", 28 | "description" : "2D - baseline as zero noise", 29 | "no_procedure" : 1, 30 | "settings" : [ 31 | { 32 | "parameter" : "Seed", 33 | "cxx_value" : "123u", 34 | "value" : "123" 35 | } 36 | ], 37 | "tolerance" : 100.0, 38 | "inputs" : [ 39 | "Input/cthead1.png" 40 | ] 41 | }, 42 | { 43 | "tag" : "3d", 44 | "description" : "3D - baseline as zero noise", 45 | "no_procedure" : 1, 46 | "settings" : [ 47 | { 48 | "parameter" : "Seed", 49 | "cxx_value" : "123u", 50 | "value" : "123" 51 | } 52 | ], 53 | "tolerance" : 200000.0, 54 | "inputs" : [ 55 | "Input/RA-Short.nrrd" 56 | ] 57 | }, 58 | { 59 | "tag" : "rgb", 60 | "description" : "vector image - baseline as zero noise", 61 | "no_procedure" : 1, 62 | "settings" : [ 63 | { 64 | "parameter" : "Seed", 65 | "cxx_value" : "123u", 66 | "value" : "123" 67 | } 68 | ], 69 | "tolerance" : 100.0, 70 | "inputs" : [ 71 | "Input/VM1111Shrink-RGB.png" 72 | ] 73 | } 74 | ], 75 | "briefdescription" : "Alter an image with speckle (multiplicative) noise.", 76 | "detaileddescription" : "The speckle noise follows a Gamma distribution of mean 1 and standard deviation provided by the user. The noise is proportional to the pixel intensity.\n\n\\author Gaetan Lehmann\n\nThis code was contributed in the Insight Journal paper \"Noise\nSimulation\". https://hdl.handle.net/10380/3158", 77 | "itk_module" : "ITKImageNoise", 78 | "itk_group" : "ImageNoise" 79 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/FastApproximateRankImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "FastApproximateRankImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "BasicPixelIDTypeList", 7 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Rank", 11 | "type" : "double", 12 | "default" : "0.5", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "" 18 | }, 19 | { 20 | "name" : "Radius", 21 | "type" : "unsigned int", 22 | "default" : "std::vector(3, 1)", 23 | "dim_vec" : 1, 24 | "set_as_scalar" : 1, 25 | "doc" : "", 26 | "itk_type" : "typename FilterType::RadiusType" 27 | } 28 | ], 29 | "tests" : [ 30 | { 31 | "tag" : "default", 32 | "description" : "default", 33 | "md5hash" : "8b86ebe8c8eb3ea42c7838f3d66155aa", 34 | "settings" : [], 35 | "inputs" : [ 36 | "Input/cthead1.png" 37 | ] 38 | }, 39 | { 40 | "tag" : "by23", 41 | "description" : "Test by 23", 42 | "md5hash" : "67615832b6f0e0bb877ce03418d3328c", 43 | "settings" : [ 44 | { 45 | "parameter" : "Rank", 46 | "type" : "double", 47 | "value" : "1.0" 48 | }, 49 | { 50 | "parameter" : "Radius", 51 | "type" : "unsigned int", 52 | "dim_vec" : 1, 53 | "value" : [ 54 | 2, 55 | 3 56 | ] 57 | } 58 | ], 59 | "inputs" : [ 60 | "Input/cthead1.png" 61 | ] 62 | }, 63 | { 64 | "tag" : "Vector", 65 | "description" : "Vector image", 66 | "md5hash" : "ab252b5b4214aa0653de26e33ea2c822", 67 | "settings" : [], 68 | "inputs" : [ 69 | "Input/VM1111Shrink-RGBFloat.nrrd" 70 | ] 71 | } 72 | ], 73 | "briefdescription" : "A separable rank filter.", 74 | "detaileddescription" : "Medians aren't separable, but if you want a large robust smoother to be relatively quick then it is worthwhile pretending that they are.\n\nThis code was contributed in the Insight Journal paper: \"Efficient implementation of kernel filtering\" by Beare R., Lehmann G https://hdl.handle.net/1926/555 http://www.insight-journal.org/browse/publication/160 \n\n\\author Richard Beare", 75 | "itk_module" : "ITKReview", 76 | "itk_group" : "Review" 77 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/CheckerBoardImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "CheckerBoardImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "filter_type" : "itk::CheckerBoardImageFilter", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "NonLabelPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "CheckerPattern", 12 | "type" : "uint32_t", 13 | "default" : "std::vector(3, 4)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "itk_type" : "typename FilterType::PatternArrayType", 17 | "briefdescriptionSet" : "", 18 | "detaileddescriptionSet" : "Set/Get the checker pattern array, i.e. the number of checker boxes per image dimension.", 19 | "briefdescriptionGet" : "", 20 | "detaileddescriptionGet" : "Set/Get the checker pattern array, i.e. the number of checker boxes per image dimension." 21 | } 22 | ], 23 | "tests" : [ 24 | { 25 | "tag" : "default", 26 | "description" : "checker board with default parameters", 27 | "settings" : [], 28 | "md5hash" : "f84fcf68e702d715a4de52821cfa0f5e", 29 | "inputs" : [ 30 | "Input/BlackDots.png", 31 | "Input/WhiteDots.png" 32 | ] 33 | }, 34 | { 35 | "tag" : "2d_with_pattern", 36 | "description" : "checker board with pattern", 37 | "settings" : [ 38 | { 39 | "parameter" : "CheckerPattern", 40 | "type" : "uint32_t", 41 | "dim_vec" : 1, 42 | "value" : [ 43 | 20, 44 | 4 45 | ] 46 | } 47 | ], 48 | "md5hash" : "379bd66a18b7ae029c101ebdcb20a8b3", 49 | "inputs" : [ 50 | "Input/BlackDots.png", 51 | "Input/WhiteDots.png" 52 | ] 53 | } 54 | ], 55 | "briefdescription" : "Combines two images in a checkerboard pattern.", 56 | "detaileddescription" : "CheckerBoardImageFilter takes two input images that must have the same dimension, size, origin and spacing and produces an output image of the same size by combinining the pixels from the two input images in a checkerboard pattern. This filter is commonly used for visually comparing two images, in particular for evaluating the results of an image registration process.\n\nThis filter is implemented as a multithreaded filter. It provides a ThreadedGenerateData() method for its implementation.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Combine two images by alternating blocks of a checkerboard pattern", 57 | "itk_module" : "ITKImageCompare", 58 | "itk_group" : "ImageCompare" 59 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/FFTConvolutionImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "FFTConvolutionImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 2, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "include_files" : [ 9 | "sitkBoundaryConditions.hxx" 10 | ], 11 | "custom_set_input" : "filter->SetInput( image1 ); filter->SetKernelImage( image2 );", 12 | "members" : [ 13 | { 14 | "name" : "Normalize", 15 | "type" : "bool", 16 | "default" : "false", 17 | "doc" : "", 18 | "briefdescriptionSet" : "", 19 | "detaileddescriptionSet" : "Normalize the output image by the sum of the kernel components\n", 20 | "briefdescriptionGet" : "", 21 | "detaileddescriptionGet" : "" 22 | }, 23 | { 24 | "name" : "BoundaryCondition", 25 | "enum" : [ 26 | "ZERO_PAD", 27 | "ZERO_FLUX_NEUMANN_PAD", 28 | "PERIODIC_PAD" 29 | ], 30 | "default" : "itk::simple::FFTConvolutionImageFilter::ZERO_FLUX_NEUMANN_PAD", 31 | "custom_itk_cast" : "nsstd::auto_ptr< ImageBoundaryCondition< InputImageType > > bc( CreateNewBoundaryConditionInstance< Self, FilterType >( m_BoundaryCondition ) ); filter->SetBoundaryCondition( bc.get() );\n" 32 | }, 33 | { 34 | "name" : "OutputRegionMode", 35 | "enum" : [ 36 | "SAME", 37 | "VALID" 38 | ], 39 | "default" : "itk::simple::FFTConvolutionImageFilter::SAME", 40 | "itk_type" : "typename FilterType::OutputRegionModeType" 41 | } 42 | ], 43 | "tests" : [ 44 | { 45 | "tag" : "defaults", 46 | "description" : "Basic convolution with gaussian", 47 | "settings" : [], 48 | "tolerance" : "0.0001", 49 | "inputs" : [ 50 | "Input/cthead1-Float.mha", 51 | "Input/Gaussian_1.5.nrrd" 52 | ] 53 | } 54 | ], 55 | "briefdescription" : "Convolve a given image with an arbitrary image kernel using multiplication in the Fourier domain.", 56 | "detaileddescription" : "This filter produces output equivalent to the output of the ConvolutionImageFilter . However, it takes advantage of the convolution theorem to accelerate the convolution computation when the kernel is large.\n\n\\warning This filter ignores the spacing, origin, and orientation of the kernel image and treats them as identical to those in the input image.\n\nThis code was adapted from the Insight Journal contribution:\n\n\"FFT Based Convolution\" by Gaetan Lehmann https://hdl.handle.net/10380/3154 \n\n\\see ConvolutionImageFilter", 57 | "itk_module" : "ITKConvolution", 58 | "itk_group" : "Convolution" 59 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BinShrinkImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BinShrinkImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "NonLabelPixelIDTypeList", 7 | "public_declarations" : "SITK_RETURN_SELF_TYPE_HEADER SetShrinkFactor( unsigned int s ) { this->m_ShrinkFactors = std::vector(3, s ); return *this; }", 8 | "members" : [ 9 | { 10 | "name" : "ShrinkFactors", 11 | "type" : "unsigned int", 12 | "default" : "std::vector(3, 1)", 13 | "dim_vec" : 1, 14 | "doc" : "", 15 | "itk_type" : "typename FilterType::ShrinkFactorsType", 16 | "briefdescriptionSet" : "", 17 | "detaileddescriptionSet" : "Set the shrink factors. Values are clamped to a minimum value of 1. Default is 1 for all dimensions.", 18 | "briefdescriptionGet" : "", 19 | "detaileddescriptionGet" : "Get the shrink factors." 20 | } 21 | ], 22 | "tests" : [ 23 | { 24 | "tag" : "defaults", 25 | "description" : "Test Shirnk with default parameters", 26 | "md5hash" : "45a85203a8972250b0e0226b64312eef", 27 | "settings" : [], 28 | "inputs" : [ 29 | "Input/VM1111Shrink-RGBFloat.nrrd" 30 | ] 31 | }, 32 | { 33 | "tag" : "by4", 34 | "description" : "Test BinShink by 4", 35 | "md5hash" : "31e1303e610e4ab5393c173a91dcc77b", 36 | "settings" : [ 37 | { 38 | "parameter" : "ShrinkFactor", 39 | "type" : "unsigned int", 40 | "no_get_method" : 1, 41 | "value" : "4" 42 | } 43 | ], 44 | "inputs" : [ 45 | "Input/RA-Float.nrrd" 46 | ] 47 | } 48 | ], 49 | "briefdescription" : "Reduce the size of an image by an integer factor in each dimension while performing averaging of an input neighborhood.", 50 | "detaileddescription" : "The output image size in each dimension is given by:\n\noutputSize[j] = max( std::floor(inputSize[j]/shrinkFactor[j]), 1 );\n\nThe algorithm implemented can be describe with the following equation for 2D: \\f[ \\mathsf{I}_{out}(x_o,x_1) = \\frac{\\sum_{i=0}^{f_0}\\sum_{j=0}^{f_1}\\mathsf{I}_{in}(f_0 x_o+i,f_1 x_1+j)}{f_0 f_1} \\f] \n\nThis filter is implemented so that the starting extent of the first pixel of the output matches that of the input.\n\nThe change in image geometry from a 5x5 image binned by a factor of 2x2.\n This code was contributed in the Insight Journal paper: \"BinShrink: A multi-resolution filter with cache efficient averaging\" by Lowekamp B., Chen D. https://hdl.handle.net/10380/3450", 51 | "itk_module" : "ITKImageGrid", 52 | "itk_group" : "ImageGrid" 53 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NoiseImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NoiseImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "Radius", 12 | "type" : "unsigned int", 13 | "default" : "std::vector(3, 1)", 14 | "dim_vec" : 1, 15 | "set_as_scalar" : 1, 16 | "doc" : "", 17 | "itk_type" : "typename FilterType::RadiusType" 18 | } 19 | ], 20 | "tests" : [ 21 | { 22 | "tag" : "defaults", 23 | "description" : "Test MeanImageFilter with default parametrs", 24 | "md5hash" : "76b7e9b810eb9396b7bb636b4f8b5d23", 25 | "settings" : [], 26 | "inputs" : [ 27 | "Input/VM1111Shrink-RGBFloat.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "by23", 32 | "description" : "Test by 23", 33 | "md5hash" : "4d05e86ba6a96eeaf6217e317c85dbfa", 34 | "settings" : [ 35 | { 36 | "parameter" : "Radius", 37 | "type" : "unsigned int", 38 | "dim_vec" : 1, 39 | "value" : [ 40 | 2, 41 | 3 42 | ] 43 | } 44 | ], 45 | "inputs" : [ 46 | "Input/VM1111Shrink-RGB.png" 47 | ] 48 | }, 49 | { 50 | "tag" : "by333", 51 | "description" : "Test by 333", 52 | "md5hash" : "fc4975287b204ba91dd4d85523b91a06", 53 | "settings" : [ 54 | { 55 | "parameter" : "Radius", 56 | "type" : "unsigned int", 57 | "dim_vec" : 1, 58 | "value" : [ 59 | 3, 60 | 3, 61 | 3 62 | ] 63 | } 64 | ], 65 | "inputs" : [ 66 | "Input/RA-Short.nrrd" 67 | ] 68 | } 69 | ], 70 | "briefdescription" : "Calculate the local noise in an image.", 71 | "detaileddescription" : "Computes an image where a given pixel is the standard deviation of the pixels in a neighborhood about the corresponding input pixel. This serves as an estimate of the local noise (or texture) in an image. Currently, this noise estimate assume a piecewise constant image. This filter should be extended to fitting a (hyper) plane to the neighborhood and calculating the standard deviation of the residuals to this (hyper) plane.\n\n\\see Image \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Compute the local noise in an image", 72 | "itk_module" : "ITKImageFilterBase", 73 | "itk_group" : "ImageFilterBase" 74 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/RescaleIntensityImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "RescaleIntensityImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "vector_pixel_types_by_component" : "VectorPixelIDTypeList", 9 | "members" : [ 10 | { 11 | "name" : "OutputMinimum", 12 | "type" : "double", 13 | "pixeltype" : "Output", 14 | "default" : 0, 15 | "doc" : "Output minimum", 16 | "briefdescriptionSet" : "", 17 | "detaileddescriptionSet" : "", 18 | "briefdescriptionGet" : "", 19 | "detaileddescriptionGet" : "" 20 | }, 21 | { 22 | "name" : "OutputMaximum", 23 | "type" : "double", 24 | "pixeltype" : "Output", 25 | "default" : 255, 26 | "doc" : "Output maximum", 27 | "briefdescriptionSet" : "", 28 | "detaileddescriptionSet" : "", 29 | "briefdescriptionGet" : "", 30 | "detaileddescriptionGet" : "" 31 | } 32 | ], 33 | "tests" : [ 34 | { 35 | "tag" : "3d", 36 | "description" : "3D", 37 | "settings" : [], 38 | "tolerance" : "1e-8", 39 | "inputs" : [ 40 | "Input/RA-Float.nrrd" 41 | ] 42 | } 43 | ], 44 | "briefdescription" : "Applies a linear transformation to the intensity levels of the input Image .", 45 | "detaileddescription" : "RescaleIntensityImageFilter applies pixel-wise a linear transformation to the intensity values of input image pixels. The linear transformation is defined by the user in terms of the minimum and maximum values that the output image should have.\n\nThe following equation gives the mapping of the intensity values\n\n\\par \n \\f[ outputPixel = ( inputPixel - inputMin) \\cdot \\frac{(outputMax - outputMin )}{(inputMax - inputMin)} + outputMin \\f] \n\nAll computations are performed in the precision of the input pixel's RealType. Before assigning the computed value to the output pixel.\n\nNOTE: In this filter the minimum and maximum values of the input image are computed internally using the MinimumMaximumImageCalculator . Users are not supposed to set those values in this filter. If you need a filter where you can set the minimum and maximum values of the input, please use the IntensityWindowingImageFilter . If you want a filter that can use a user-defined linear transformation for the intensity, then please use the ShiftScaleImageFilter .\n\n\\see IntensityWindowingImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Rescale the intensity values of an image to a specified range", 46 | "itk_module" : "ITKImageIntensity", 47 | "itk_group" : "ImageIntensity" 48 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/AddImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "AddImageFilter", 3 | "template_code_filename" : "BinaryFunctorFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "constant_type" : "double", 6 | "number_of_inputs" : 2, 7 | "doc" : "Some global documentation", 8 | "pixel_types" : "NonLabelPixelIDTypeList", 9 | "members" : [], 10 | "tests" : [ 11 | { 12 | "tag" : "2d", 13 | "description" : "2D", 14 | "settings" : [], 15 | "md5hash" : "bc458a17e18c79ae767e8be47451d1b4", 16 | "inputs" : [ 17 | "Input/STAPLE1.png", 18 | "Input/STAPLE2.png" 19 | ] 20 | }, 21 | { 22 | "tag" : "3d", 23 | "description" : "3D", 24 | "settings" : [], 25 | "md5hash" : "dfc0af11e8c30a0bd6dedd560486f419", 26 | "inputs" : [ 27 | "Input/RA-Short.nrrd", 28 | "Input/RA-Short.nrrd" 29 | ] 30 | }, 31 | { 32 | "tag" : "2d_rgb", 33 | "description" : "2D-RGB", 34 | "settings" : [], 35 | "md5hash" : "5f00ee8a03437b4e421eb761dc340bc8", 36 | "inputs" : [ 37 | "Input/VM1111Shrink-RGBFloat.nrrd", 38 | "Input/VM1111Shrink-RGBFloat.nrrd" 39 | ] 40 | } 41 | ], 42 | "briefdescription" : "Pixel-wise addition of two images.", 43 | "detaileddescription" : "This class is templated over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nThe pixel type of the input 1 image must have a valid definition of the operator+ with a pixel type of the image 2. This condition is required because internally this filter will perform the operation\n\n\\code\n* pixel_from_image_1 + pixel_from_image_2\n\n* \n\n\\endcode\n\nAdditionally the type resulting from the sum, will be cast to the pixel type of the output image.\n\nThe total operation over one pixel will be \\code\n* output_pixel = static_cast( input1_pixel + input2_pixel )\n\n* \n\n\\endcode\n\nFor example, this filter could be used directly for adding images whose pixels are vectors of the same dimension, and to store the resulting vector in an output image of vector pixels.\n\nThe images to be added are set using the methods: \\code\n* SetInput1 ( image1 );\n\n* SetInput2 ( image2 );\n\n* \n\n\\endcode\n\nAdditionally, this filter can be used to add a constant to every pixel of an image by using \\code\n* SetInput1 ( image1 );\n\n* SetConstant2 ( constant );\n\n* \n\n\\endcode\n\n\\warning No numeric overflow checking is performed in this filter.\n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Add two images together \n\n\\li Add a constant to every pixel in an image", 44 | "itk_module" : "ITKImageIntensity", 45 | "itk_group" : "ImageIntensity" 46 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/IsoContourDistanceImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "IsoContourDistanceImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "Docs", 6 | "number_of_inputs" : 1, 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "output_pixel_type" : "float", 9 | "members" : [ 10 | { 11 | "name" : "LevelSetValue", 12 | "type" : "double", 13 | "default" : "0.0", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get the value of the level set to be located. The default value is 0.", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get the value of the level set to be located. The default value is 0." 18 | }, 19 | { 20 | "name" : "FarValue", 21 | "type" : "double", 22 | "default" : "10", 23 | "pixeltype" : "Output", 24 | "briefdescriptionSet" : "", 25 | "detaileddescriptionSet" : "Set/Get the value of the level set to be located. The default value is 0.", 26 | "briefdescriptionGet" : "", 27 | "detaileddescriptionGet" : "Set/Get the value of the level set to be located. The default value is 0." 28 | } 29 | ], 30 | "tests" : [ 31 | { 32 | "tag" : "default", 33 | "description" : "Default parameter settings", 34 | "tolerance" : "0.0001", 35 | "settings" : [ 36 | { 37 | "parameter" : "LevelSetValue", 38 | "value" : "50.0" 39 | } 40 | ], 41 | "inputs" : [ 42 | "Input/2th_cthead1.png" 43 | ] 44 | } 45 | ], 46 | "briefdescription" : "Compute an approximate distance from an interpolated isocontour to the close grid points.", 47 | "detaileddescription" : "For standard level set algorithms, it is useful to periodically reinitialize the evolving image to prevent numerical accuracy problems in computing derivatives. This reinitialization is done by computing a signed distance map to the current level set. This class provides the first step in this reinitialization by computing an estimate of the distance from the interpolated isocontour to the pixels (or voxels) that are close to it, i.e. for which the isocontour crosses a segment between them and one of their direct neighbors. This class supports narrowbanding. If the input narrowband is provided, the algorithm will only locate the level set within the input narrowband.\n\nImplementation of this class is based on Fast and Accurate Redistancing for Level Set Methods `Krissian K. and Westin C.F.', EUROCAST NeuroImaging Workshop Las Palmas Spain, Ninth International Conference on Computer Aided Systems Theory , pages 48-51, Feb 2003.", 48 | "itk_module" : "ITKDistanceMap", 49 | "itk_group" : "DistanceMap" 50 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LabelContourImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LabelContourImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "FullyConnected", 11 | "type" : "bool", 12 | "default" : "false", 13 | "doc" : "", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get whether the connected components are defined strictly by face connectivity or by face+edge+vertex connectivity. Default is FullyConnectedOff. \\note For objects that are 1 pixel wide, use FullyConnectedOn.", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get whether the connected components are defined strictly by face connectivity or by face+edge+vertex connectivity. Default is FullyConnectedOff. \\note For objects that are 1 pixel wide, use FullyConnectedOn." 18 | }, 19 | { 20 | "name" : "BackgroundValue", 21 | "type" : "double", 22 | "default" : "0", 23 | "pixeltype" : "Input", 24 | "briefdescriptionSet" : "", 25 | "detaileddescriptionSet" : "Set/Get the background value used to identify the objects and mark the pixels not on the border of the objects.", 26 | "briefdescriptionGet" : "", 27 | "detaileddescriptionGet" : "Set/Get the background value used to identify the objects and mark the pixels not on the border of the objects." 28 | } 29 | ], 30 | "tests" : [ 31 | { 32 | "tag" : "default", 33 | "description" : "Simply run with default settings", 34 | "md5hash" : "d742c05a8d8aa9b41f58b8d2aad6b5d0", 35 | "settings" : [], 36 | "inputs" : [ 37 | "Input/2th_cthead1.png" 38 | ] 39 | } 40 | ], 41 | "briefdescription" : "Labels the pixels on the border of the objects in a labeled image.", 42 | "detaileddescription" : "LabelContourImageFilter takes a labeled image as input, where the pixels in the objects are the pixels with a value different of the BackgroundValue. Only the pixels on the contours of the objects are kept. The pixels not on the border are changed to BackgroundValue. The labels of the object are the same in the input and in the output image.\n\nThe connectivity can be changed to minimum or maximum connectivity with SetFullyConnected() . Full connectivity produces thicker contours.\n\nhttps://hdl.handle.net/1926/1352 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see BinaryContourImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Label the contours of connected components", 43 | "itk_module" : "ITKImageLabel", 44 | "itk_group" : "ImageLabel" 45 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/InvertDisplacementFieldImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "InvertDisplacementFieldImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "RealVectorPixelIDTypeList", 7 | "filter_type" : "itk::InvertDisplacementFieldImageFilter< itk::Image< itk::Vector< typename InputImageType::InternalPixelType, InputImageType::ImageDimension>, InputImageType::ImageDimension > >", 8 | "custom_set_input" : "filter->SetDisplacementField( GetImageFromVectorImage(const_cast< InputImageType * >(image1.GetPointer())) );", 9 | "include_files" : [ 10 | "itkVector.h", 11 | "sitkImageConvert.h" 12 | ], 13 | "members" : [ 14 | { 15 | "name" : "MaximumNumberOfIterations", 16 | "type" : "uint32_t", 17 | "default" : "10u", 18 | "doc" : "Number of iterations to run", 19 | "briefdescriptionSet" : "", 20 | "detaileddescriptionSet" : "", 21 | "briefdescriptionGet" : "", 22 | "detaileddescriptionGet" : "" 23 | }, 24 | { 25 | "name" : "MaxErrorToleranceThreshold", 26 | "type" : "double", 27 | "default" : "0.1", 28 | "briefdescriptionSet" : "", 29 | "detaileddescriptionSet" : "", 30 | "briefdescriptionGet" : "", 31 | "detaileddescriptionGet" : "" 32 | }, 33 | { 34 | "name" : "MeanErrorToleranceThreshold", 35 | "type" : "double", 36 | "default" : "0.001", 37 | "briefdescriptionSet" : "", 38 | "detaileddescriptionSet" : "", 39 | "briefdescriptionGet" : "", 40 | "detaileddescriptionGet" : "" 41 | }, 42 | { 43 | "name" : "EnforceBoundaryCondition", 44 | "type" : "bool", 45 | "default" : "true", 46 | "briefdescriptionSet" : "", 47 | "detaileddescriptionSet" : "", 48 | "briefdescriptionGet" : "", 49 | "detaileddescriptionGet" : "" 50 | } 51 | ], 52 | "measurements" : [ 53 | { 54 | "name" : "MaxErrorNorm", 55 | "type" : "double", 56 | "default" : 0.0, 57 | "briefdescriptionGet" : "", 58 | "detaileddescriptionGet" : "" 59 | }, 60 | { 61 | "name" : "MeanErrorNorm", 62 | "type" : "double", 63 | "default" : 0.0, 64 | "briefdescriptionGet" : "", 65 | "detaileddescriptionGet" : "" 66 | } 67 | ], 68 | "tests" : [ 69 | { 70 | "tag" : "2d", 71 | "description" : "2D", 72 | "settings" : [], 73 | "tolerance" : "0.001", 74 | "inputs" : [ 75 | "Input/displacement.mha" 76 | ] 77 | } 78 | ], 79 | "briefdescription" : "Iteratively estimate the inverse field of a displacement field.", 80 | "detaileddescription" : "\\author Nick Tustison \n\nBrian Avants", 81 | "itk_module" : "ITKDisplacementField", 82 | "itk_group" : "DisplacementField" 83 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/HMaximaImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "HMaximaImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "BasicPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Height", 11 | "type" : "double", 12 | "default" : "2.0", 13 | "pixeltype" : "Input", 14 | "briefdescriptionSet" : "", 15 | "detaileddescriptionSet" : "Set/Get the height that a local maximum must be above the local background (local contrast) in order to survive the processing. Local maxima below this value are replaced with an estimate of the local background.", 16 | "briefdescriptionGet" : "", 17 | "detaileddescriptionGet" : "Set/Get the height that a local maximum must be above the local background (local contrast) in order to survive the processing. Local maxima below this value are replaced with an estimate of the local background." 18 | } 19 | ], 20 | "custom_methods" : [], 21 | "tests" : [ 22 | { 23 | "tag" : "HMaxima", 24 | "description" : "Test HMaxima", 25 | "md5hash" : "b30d403fb1c5948abfb17fa9c346cecd", 26 | "settings" : [ 27 | { 28 | "parameter" : "Height", 29 | "value" : 2000 30 | } 31 | ], 32 | "inputs" : [ 33 | "Input/RA-Short.nrrd" 34 | ] 35 | } 36 | ], 37 | "briefdescription" : "Suppress local maxima whose height above the baseline is less than h.", 38 | "detaileddescription" : "HMaximaImageFilter suppresses local maxima that are less than h intensity units above the (local) background. This has the effect of smoothing over the \"high\" parts of the noise in the image without smoothing over large changes in intensity (region boundaries). See the HMinimaImageFilter to suppress the local minima whose depth is less than h intensity units below the (local) background.\n\nIf the output of HMaximaImageFilter is subtracted from the original image, the signicant \"peaks\" in the image can be identified. This is what the HConvexImageFilter provides.\n\nThis filter uses the ReconstructionByDilationImageFilter . It provides its own input as the \"mask\" input to the geodesic dilation. The \"marker\" image for the geodesic dilation is the input image minus the height parameter h.\n\nGeodesic morphology and the H-Maxima algorithm is described in Chapter 6 of Pierre Soille's book \"Morphological Image Analysis:\nPrinciples and Applications\", Second Edition, Springer, 2003.\n\nThe height parameter is set using SetHeight.\n\n\\see ReconstructionByDilationImageFilter , HMinimaImageFilter , HConvexImageFilter \n\n\\see MorphologyImageFilter , GrayscaleDilateImageFilter , GrayscaleFunctionDilateImageFilter , BinaryDilateImageFilter", 39 | "itk_module" : "ITKMathematicalMorphology", 40 | "itk_group" : "MathematicalMorphology" 41 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/IterativeInverseDisplacementFieldImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "IterativeInverseDisplacementFieldImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "RealVectorPixelIDTypeList", 7 | "filter_type" : "itk::IterativeInverseDisplacementFieldImageFilter< itk::Image< itk::Vector, InputImageType::ImageDimension >, itk::Image< itk::Vector< typename InputImageType::InternalPixelType, InputImageType::ImageDimension>, InputImageType::ImageDimension > >", 8 | "custom_set_input" : "filter->SetInput( GetImageFromVectorImage(const_cast< InputImageType * >(image1.GetPointer())) );", 9 | "include_files" : [ 10 | "itkVector.h", 11 | "sitkImageConvert.h" 12 | ], 13 | "members" : [ 14 | { 15 | "name" : "NumberOfIterations", 16 | "type" : "uint32_t", 17 | "default" : "5u", 18 | "doc" : "Number of iterations to run", 19 | "briefdescriptionSet" : "", 20 | "detaileddescriptionSet" : "", 21 | "briefdescriptionGet" : "", 22 | "detaileddescriptionGet" : "" 23 | }, 24 | { 25 | "name" : "StopValue", 26 | "type" : "double", 27 | "default" : "0.0", 28 | "doc" : "", 29 | "briefdescriptionSet" : "", 30 | "detaileddescriptionSet" : "", 31 | "briefdescriptionGet" : "", 32 | "detaileddescriptionGet" : "" 33 | } 34 | ], 35 | "measurements" : [], 36 | "custom_methods" : [], 37 | "tests" : [ 38 | { 39 | "tag" : "2d", 40 | "description" : "2D", 41 | "settings" : [], 42 | "tolerance" : "0.001", 43 | "inputs" : [ 44 | "Input/displacement.mha" 45 | ] 46 | } 47 | ], 48 | "briefdescription" : "Computes the inverse of a displacement field.", 49 | "detaileddescription" : "IterativeInverseDisplacementFieldImageFilter takes a displacement field as input and computes the displacement field that is its inverse. If the input displacement field was mapping coordinates from a space A into a space B, the output of this filter will map coordinates from the space B into the space A.\n\nThe algorithm implemented in this filter uses an iterative method for progresively refining the values of the inverse field. Starting from the direct field, at every pixel the direct mapping of this point is found, and a the nevative of the current displacement is stored in the inverse field at the nearest pixel. Then, subsequent iterations verify if any of the neigbor pixels provide a better return to the current pixel, in which case its value is taken for updating the vector in the inverse field.\n\nThis method was discussed in the users-list during February 2004.\n\n\\author Corinne Mattmann", 50 | "itk_module" : "ITKDisplacementField", 51 | "itk_group" : "DisplacementField" 52 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/PhysicalPointImageSource.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "PhysicalPointImageSource", 3 | "template_code_filename" : "ImageSource", 4 | "template_test_filename" : "ImageFilter", 5 | "doc" : "", 6 | "number_of_inputs" : 0, 7 | "pixel_types" : "VectorPixelIDTypeList", 8 | "output_image_type" : "TImageType", 9 | "filter_type" : "itk::PhysicalPointImageSource", 10 | "members" : [ 11 | { 12 | "name" : "OutputPixelType", 13 | "type" : "PixelIDValueEnum", 14 | "default" : "itk::simple::sitkVectorFloat32", 15 | "custom_itk_cast" : "" 16 | }, 17 | { 18 | "name" : "Size", 19 | "type" : "unsigned int", 20 | "dim_vec" : 1, 21 | "default" : "std::vector(3, 64)", 22 | "itk_type" : "typename FilterType::SizeType" 23 | }, 24 | { 25 | "name" : "Origin", 26 | "type" : "double", 27 | "dim_vec" : 1, 28 | "default" : "std::vector(3, 0.0)", 29 | "itk_type" : "typename FilterType::PointType" 30 | }, 31 | { 32 | "name" : "Spacing", 33 | "type" : "double", 34 | "dim_vec" : 1, 35 | "default" : "std::vector(3, 1.0)", 36 | "itk_type" : "typename FilterType::SpacingType" 37 | }, 38 | { 39 | "name" : "Direction", 40 | "type" : "std::vector", 41 | "default" : "std::vector()", 42 | "doc" : "Passing a zero sized array, defaults to identiy matrix. The size of the array must exactly match the direction matrix for the dimension of the image.", 43 | "custom_itk_cast" : "filter->SetDirection( sitkSTLToITKDirection( this->m_Direction ) );" 44 | } 45 | ], 46 | "custom_methods" : [ 47 | { 48 | "name" : "SetReferenceImage", 49 | "doc" : "This methods sets the size, origin, spacing and direction to that of the provided image", 50 | "return_type" : "void", 51 | "parameters" : [ 52 | { 53 | "type" : "const Image &", 54 | "var_name" : "refImage" 55 | } 56 | ], 57 | "body" : "this->SetSize( refImage.GetSize() ); this->SetOrigin( refImage.GetOrigin() ); this->SetSpacing( refImage.GetSpacing() );this->SetDirection( refImage.GetDirection() );" 58 | } 59 | ], 60 | "tests" : [ 61 | { 62 | "tag" : "default", 63 | "description" : "Simply run with default settings", 64 | "settings" : [], 65 | "md5hash" : "d0857811f2d6f37882341c858000911d", 66 | "inputs" : [] 67 | } 68 | ], 69 | "briefdescription" : "Generate an image of the physical locations of each pixel.", 70 | "detaileddescription" : "This image source supports image which have a multi-component pixel equal to the image dimension, and variable length VectorImages. It is recommended that the component type be a real valued type.", 71 | "itk_module" : "ITKImageSources", 72 | "itk_group" : "ImageSources" 73 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/VotingBinaryHoleFillingImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "VotingBinaryHoleFillingImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "", 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "Radius", 11 | "type" : "unsigned int", 12 | "default" : "std::vector(3, 1)", 13 | "dim_vec" : 1, 14 | "set_as_scalar" : 1, 15 | "doc" : "", 16 | "itk_type" : "typename FilterType::InputSizeType" 17 | }, 18 | { 19 | "name" : "MajorityThreshold", 20 | "type" : "unsigned int", 21 | "default" : "1u", 22 | "briefdescriptionSet" : "", 23 | "detaileddescriptionSet" : "Majority threshold. It is the number of pixels over 50% that will decide whether an OFF pixel will become ON or not. For example, if the neighborhood of a pixel has 124 pixels (excluding itself), the 50% will be 62, and if you set upd a Majority threshold of 5, that means that the filter will require 67 or more neighbor pixels to be ON in order to switch the current OFF pixel to ON. The default value is 1.", 24 | "briefdescriptionGet" : "", 25 | "detaileddescriptionGet" : "Majority threshold. It is the number of pixels over 50% that will decide whether an OFF pixel will become ON or not. For example, if the neighborhood of a pixel has 124 pixels (excluding itself), the 50% will be 62, and if you set upd a Majority threshold of 5, that means that the filter will require 67 or more neighbor pixels to be ON in order to switch the current OFF pixel to ON. The default value is 1." 26 | }, 27 | { 28 | "name" : "ForegroundValue", 29 | "type" : "double", 30 | "default" : "1.0", 31 | "pixeltype" : "Input" 32 | }, 33 | { 34 | "name" : "BackgroundValue", 35 | "type" : "double", 36 | "default" : "0.0", 37 | "pixeltype" : "Input" 38 | } 39 | ], 40 | "tests" : [ 41 | { 42 | "tag" : "VotingBinary", 43 | "description" : "Basic voting hole filling", 44 | "settings" : [ 45 | { 46 | "parameter" : "Radius", 47 | "no_get_method" : 1, 48 | "value" : 5 49 | }, 50 | { 51 | "parameter" : "ForegroundValue", 52 | "value" : "255.0" 53 | } 54 | ], 55 | "md5hash" : "accc574edffef3c6ac37d13e28a524c0", 56 | "inputs" : [ 57 | "Input/STAPLE1.png" 58 | ] 59 | } 60 | ], 61 | "briefdescription" : "Fills in holes and cavities by applying a voting operation on each pixel.", 62 | "detaileddescription" : "\\see Image \n\n\\see VotingBinaryImageFilter \n\n\\see VotingBinaryIterativeHoleFillingImageFilter \n\n\\see Neighborhood \n\n\\see NeighborhoodOperator \n\n\\see NeighborhoodIterator", 63 | "itk_module" : "ITKLabelVoting", 64 | "itk_group" : "LabelVoting" 65 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/WrapPadImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "WrapPadImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "\todo add SetBound member function to set both properties", 7 | "pixel_types" : "NonLabelPixelIDTypeList", 8 | "members" : [ 9 | { 10 | "name" : "PadLowerBound", 11 | "type" : "unsigned int", 12 | "default" : "std::vector(3, 0)", 13 | "doc" : "\todo what does this itk_type attribute do?", 14 | "dim_vec" : 1, 15 | "itk_type" : "typename InputImageType::SizeType" 16 | }, 17 | { 18 | "name" : "PadUpperBound", 19 | "type" : "unsigned int", 20 | "default" : "std::vector(3, 0)", 21 | "doc" : "\todo what does this itk_type attribute do?", 22 | "dim_vec" : 1, 23 | "itk_type" : "typename InputImageType::SizeType" 24 | } 25 | ], 26 | "tests" : [ 27 | { 28 | "tag" : "defaults", 29 | "description" : "Test WrapPad with default parameters", 30 | "md5hash" : "a9a0207c759cb8d9e0507414992905d6", 31 | "settings" : [], 32 | "inputs" : [ 33 | "Input/RA-Slice-Short.png" 34 | ] 35 | }, 36 | { 37 | "tag" : "more", 38 | "description" : "Test WrapPad reasonable padding", 39 | "md5hash" : "78043cec7d50726f00d1ca81a3e2bc9a", 40 | "settings" : [ 41 | { 42 | "parameter" : "PadLowerBound", 43 | "type" : "unsigned int", 44 | "dim_vec" : 1, 45 | "value" : [ 46 | 5, 47 | 10, 48 | 15 49 | ] 50 | }, 51 | { 52 | "parameter" : "PadUpperBound", 53 | "type" : "unsigned int", 54 | "dim_vec" : 1, 55 | "value" : [ 56 | 3, 57 | 6, 58 | 9 59 | ] 60 | } 61 | ], 62 | "inputs" : [ 63 | "Input/Ramp-Down-Short.nrrd" 64 | ] 65 | } 66 | ], 67 | "briefdescription" : "Increase the image size by padding with replicants of the input image value.", 68 | "detaileddescription" : "WrapPadImageFilter changes the image bounds of an image. Added pixels are filled in with a wrapped replica of the input image. For instance, if the output image needs a pixel that is two pixels to the left of the LargestPossibleRegion of the input image, the value assigned will be from the pixel two pixels inside the right boundary of the LargestPossibleRegion. The image bounds of the output must be specified.\n\nVisual explanation of padding regions.\n This filter is implemented as a multithreaded filter. It provides a ThreadedGenerateData() method for its implementation.\n\n\\see MirrorPadImageFilter , ConstantPadImageFilter \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Pad an image by wrapping", 69 | "itk_module" : "ITKImageGrid", 70 | "itk_group" : "ImageGrid" 71 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/ZeroFluxNeumannPadImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "ZeroFluxNeumannPadImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "NonLabelPixelIDTypeList", 7 | "members" : [ 8 | { 9 | "name" : "PadLowerBound", 10 | "type" : "unsigned int", 11 | "default" : "std::vector(3, 0)", 12 | "dim_vec" : 1, 13 | "itk_type" : "typename InputImageType::SizeType" 14 | }, 15 | { 16 | "name" : "PadUpperBound", 17 | "type" : "unsigned int", 18 | "default" : "std::vector(3, 0)", 19 | "dim_vec" : 1, 20 | "itk_type" : "typename InputImageType::SizeType" 21 | } 22 | ], 23 | "tests" : [ 24 | { 25 | "tag" : "defaults", 26 | "description" : "Test Pad with default parameters", 27 | "md5hash" : "a9a0207c759cb8d9e0507414992905d6", 28 | "settings" : [], 29 | "inputs" : [ 30 | "Input/RA-Slice-Short.png" 31 | ] 32 | }, 33 | { 34 | "tag" : "more", 35 | "description" : "Test Pad reasonable padding", 36 | "md5hash" : "e75385e0e2c67ff47a8b2d0a1ee87017", 37 | "settings" : [ 38 | { 39 | "parameter" : "PadLowerBound", 40 | "type" : "unsigned int", 41 | "dim_vec" : 1, 42 | "value" : [ 43 | 5, 44 | 10, 45 | 15 46 | ] 47 | }, 48 | { 49 | "parameter" : "PadUpperBound", 50 | "type" : "unsigned int", 51 | "dim_vec" : 1, 52 | "value" : [ 53 | 3, 54 | 6, 55 | 9 56 | ] 57 | } 58 | ], 59 | "inputs" : [ 60 | "Input/Ramp-Down-Short.nrrd" 61 | ] 62 | } 63 | ], 64 | "briefdescription" : "Increase the image size by padding according to the zero-flux Neumann boundary condition.", 65 | "detaileddescription" : "A filter which extends the image size and fill the missing pixels according to a Neumann boundary condition where first, upwind derivatives on the boundary are zero. This is a useful condition in solving some classes of differential equations.\n\nFor example, invoking this filter on an image with a corner like: \\code\n* * * * * * * *\n\n* * * * * * * *\n\n* * * 1 2 3 4 5 (where * denotes pixels that lie\n\n* * * 3 3 5 5 6 outside of the image boundary)\n\n* * * 4 4 6 7 8\n\n* \n\n\\endcode\n returns the following padded image: \\code\n* 1 1 1 2 3 4 5\n\n* 1 1 1 2 3 4 5\n\n* 1 1 1 2 3 4 5\n\n* 3 3 3 3 5 5 6 (note the corner values)\n\n* 4 4 4 4 6 7 8\n\n* \n\n\\endcode\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\n\\see WrapPadImageFilter , MirrorPadImageFilter , ConstantPadImageFilter , ZeroFluxNeumannBoundaryCondition", 66 | "itk_module" : "ITKImageGrid", 67 | "itk_group" : "ImageGrid" 68 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/BinaryNotImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "BinaryNotImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "doc" : "Some global documentation", 7 | "pixel_types" : "IntegerPixelIDTypeList", 8 | "filter_type" : "itk::BinaryNotImageFilter< InputImageType >", 9 | "members" : [ 10 | { 11 | "name" : "ForegroundValue", 12 | "type" : "double", 13 | "default" : "1.0", 14 | "pixeltype" : "Input", 15 | "briefdescriptionSet" : "", 16 | "detaileddescriptionSet" : "Set/Get the value in the image considered as \"foreground\". Defaults to maximum value of PixelType.", 17 | "briefdescriptionGet" : "", 18 | "detaileddescriptionGet" : "Set/Get the value in the image considered as \"foreground\". Defaults to maximum value of PixelType." 19 | }, 20 | { 21 | "name" : "BackgroundValue", 22 | "type" : "double", 23 | "default" : "0.0", 24 | "pixeltype" : "Input", 25 | "briefdescriptionSet" : "", 26 | "detaileddescriptionSet" : "Set the value used as \"background\". Defaults to NumericTraits::NonpositiveMin() .", 27 | "briefdescriptionGet" : "", 28 | "detaileddescriptionGet" : "Get the value used as \"background\". Defaults to NumericTraits::NonpositiveMin() ." 29 | } 30 | ], 31 | "tests" : [ 32 | { 33 | "tag" : "defaults", 34 | "description" : "Simply run with default settings", 35 | "settings" : [], 36 | "md5hash" : "ae5c932ab2e19291dd20c2c4ac382428", 37 | "inputs" : [ 38 | "Input/2th_cthead1.png" 39 | ] 40 | }, 41 | { 42 | "tag" : "withFG", 43 | "description" : "with foreground value", 44 | "settings" : [ 45 | { 46 | "parameter" : "ForegroundValue", 47 | "value" : "100.0" 48 | } 49 | ], 50 | "md5hash" : "0cea51dbae361d6727688d79f33c27d0", 51 | "inputs" : [ 52 | "Input/2th_cthead1.png" 53 | ] 54 | } 55 | ], 56 | "briefdescription" : "Implements the BinaryNot logical operator pixel-wise between two images.", 57 | "detaileddescription" : "This class is parametrized over the types of the two input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nThe total operation over one pixel will be\n\noutput_pixel = static_cast( input1_pixel != input2_pixel )\n\nWhere \"!=\" is the equality operator in C++.\n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France.\n\nThis implementation was taken from the Insight Journal paper: https://hdl.handle.net/1926/584 or http://www.insight-journal.org/browse/publication/176 \n\n\\par Wiki Examples:\n\n\\li All Examples \n\n\\li Invert an image using the Binary Not operation", 58 | "itk_module" : "ITKLabelMap", 59 | "itk_group" : "LabelMap" 60 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/LabelToRGBImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "LabelToRGBImageFilter", 3 | "template_code_filename" : "ImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "include_files" : [ 6 | "sitkLabelFunctorUtils.hxx" 7 | ], 8 | "number_of_inputs" : 1, 9 | "output_image_type" : "itk::VectorImage< uint8_t, InputImageType::ImageDimension>", 10 | "doc" : "Docs", 11 | "pixel_types" : "IntegerPixelIDTypeList", 12 | "members" : [ 13 | { 14 | "name" : "BackgroundValue", 15 | "type" : "double", 16 | "default" : "0.0", 17 | "pixeltype" : "Input", 18 | "doc" : "", 19 | "briefdescriptionSet" : "", 20 | "detaileddescriptionSet" : "Set/Get the background value", 21 | "briefdescriptionGet" : "", 22 | "detaileddescriptionGet" : "Set/Get the background value" 23 | }, 24 | { 25 | "name" : "Colormap", 26 | "type" : "std::vector", 27 | "default" : "std::vector()", 28 | "custom_itk_cast" : "SetLabelFunctorFromColormap(filter->GetFunctor(),this->m_Colormap);" 29 | } 30 | ], 31 | "tests" : [ 32 | { 33 | "tag" : "default", 34 | "description" : "Simply run with default settings", 35 | "md5hash" : "850e04c66180956c8a19471309fa2391", 36 | "settings" : [], 37 | "inputs" : [ 38 | "Input/2th_cthead1.mha" 39 | ] 40 | }, 41 | { 42 | "tag" : "custom_color", 43 | "description" : "Setting custom color map", 44 | "md5hash" : "af9bc977b86bfdf2e87d989958f6771f", 45 | "settings" : [ 46 | { 47 | "parameter" : "Colormap", 48 | "type" : "uint8_t", 49 | "dim_vec" : 1, 50 | "value" : [ 51 | 255, 52 | 0, 53 | 0, 54 | 255, 55 | 255, 56 | 255, 57 | 0, 58 | 0, 59 | 255 60 | ] 61 | } 62 | ], 63 | "inputs" : [ 64 | "Input/2th_cthead1.mha" 65 | ] 66 | } 67 | ], 68 | "briefdescription" : "Apply a colormap to a label image.", 69 | "detaileddescription" : "Apply a colormap to a label image. The set of colors is a good selection of distinct colors. The user can choose to use a background value. In that case, a gray pixel with the same intensity than the background label is produced.\n\nThis code was contributed in the Insight Journal paper: \"The watershed transform in ITK - discussion and new developments\" by Beare R., Lehmann G. https://hdl.handle.net/1926/202 http://www.insight-journal.org/browse/publication/92 \n\n\\author Gaetan Lehmann. Biologie du Developpement et de la Reproduction, INRA de Jouy-en-Josas, France. \n\nRichard Beare. Department of Medicine, Monash University, Melbourne, Australia.\n\n\\see LabelOverlayImageFilter \n\n\\see LabelMapToRGBImageFilter , LabelToRGBFunctor, ScalarToRGBPixelFunctor", 70 | "itk_module" : "ITKImageFusion", 71 | "itk_group" : "ImageFusion" 72 | } -------------------------------------------------------------------------------- /SimpleFilters/Resources/json/NaryAddImageFilter.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "NaryAddImageFilter", 3 | "template_code_filename" : "MultiInputImageFilter", 4 | "template_test_filename" : "ImageFilter", 5 | "number_of_inputs" : 1, 6 | "pixel_types" : "typelist::Append::Type", 7 | "members" : [], 8 | "tests" : [ 9 | { 10 | "tag" : "default2", 11 | "description" : "adding of 2 images", 12 | "settings" : [], 13 | "md5hash" : "d83255b0121596228f3c23a312d9af69", 14 | "inputs" : [ 15 | "Input/Ramp-One-Zero-Float.nrrd", 16 | "Input/Ramp-Zero-One-Float.nrrd" 17 | ] 18 | }, 19 | { 20 | "tag" : "default3", 21 | "description" : "adding of 3 images", 22 | "settings" : [], 23 | "md5hash" : "4628b3b09af910ac432e2a740b20c742", 24 | "inputs" : [ 25 | "Input/Ramp-One-Zero-Float.nrrd", 26 | "Input/Ramp-Zero-One-Float.nrrd", 27 | "Input/Ramp-One-Zero-Float.nrrd" 28 | ] 29 | }, 30 | { 31 | "tag" : "default4", 32 | "description" : "adding of 4 images", 33 | "settings" : [], 34 | "md5hash" : "64140d8b2b8826dbfa6f3bb1d3fbe3eb", 35 | "inputs" : [ 36 | "Input/Ramp-One-Zero-Float.nrrd", 37 | "Input/Ramp-Zero-One-Float.nrrd", 38 | "Input/Ramp-One-Zero-Float.nrrd", 39 | "Input/Ramp-One-Zero-Float.nrrd" 40 | ] 41 | }, 42 | { 43 | "tag" : "default5", 44 | "description" : "adding of 5 images", 45 | "settings" : [], 46 | "md5hash" : "c0b3778cf51f4311678a2c9e0561daed", 47 | "inputs" : [ 48 | "Input/Ramp-One-Zero-Float.nrrd", 49 | "Input/Ramp-Zero-One-Float.nrrd", 50 | "Input/Ramp-One-Zero-Float.nrrd", 51 | "Input/Ramp-One-Zero-Float.nrrd", 52 | "Input/Ramp-One-Zero-Float.nrrd" 53 | ] 54 | } 55 | ], 56 | "briefdescription" : "Pixel-wise addition of N images.", 57 | "detaileddescription" : "This class is templated over the types of the input images and the type of the output image. Numeric conversions (castings) are done by the C++ defaults.\n\nThe pixel type of the input images must have a valid definition of the operator+ with each other. This condition is required because internally this filter will perform the operation\n\n\\code\n* pixel_from_image_N + pixel_from_image_(N+1)\n\n* \n\n\\endcode\n\nAdditionally the type resulting from the sum, will be cast to the pixel type of the output image.\n\nThe total operation over one pixel will be\n\n\\code\n* output_pixel = static_cast( input_pixel_N + input_pixel_(N+1) )\n\n* \n\n\\endcode\n\nFor example, this filter could be used directly for adding images whose pixels are vectors of the same dimension, and to store the resulting vector in an output image of vector pixels.\n\n\\warning No numeric overflow checking is performed in this filter.", 58 | "itk_module" : "ITKImageIntensity", 59 | "itk_group" : "ImageIntensity" 60 | } --------------------------------------------------------------------------------