diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkHuangThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkHuangThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..dfb5b397fac --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkHuangThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +33266a4cb8171925d5c606eec70080d0918ae6077103e37cda499fa5194a865a68ff094fa1ebb127413973838cd6702df7a8d10005ba1283f4bec7a6c9e6b92d diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..3a976d2c6fb --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +9d23f748390540c7f7af23c47ffcb02547620454d755f828fce723fddaa79044b7721ad3fc94b022b5bdac07c8d13ea0c6a9fdb8f6faec89c8f0300f673f8b7a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoInterMode.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoInterMode.png.sha512 new file mode 100644 index 00000000000..3a976d2c6fb --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkIntermodesThresholdImageFilterTestNoInterMode.png.sha512 @@ -0,0 +1 @@ +9d23f748390540c7f7af23c47ffcb02547620454d755f828fce723fddaa79044b7721ad3fc94b022b5bdac07c8d13ea0c6a9fdb8f6faec89c8f0300f673f8b7a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkIsoDataThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkIsoDataThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..035e7a4b61f --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkIsoDataThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +107e34c5ff0d55e8277378dc0d7fe75c14599fc7c191ce4f955aff10ebbd597627e5669fb044267510c200a8bc546ed6a65a3134961e75832476cdfde00f2003 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.md5 b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.md5 index 040d51a92be..069363350d2 100644 --- a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.md5 +++ b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.md5 @@ -1 +1 @@ -f8bca7784b541e48d73fef396c69fc6b +b30b1166f9b42b910e3561df16922778 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.sha512 deleted file mode 100644 index bd34ea61c0e..00000000000 --- a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest01.png.sha512 +++ /dev/null @@ -1 +0,0 @@ -c0a0164e85621d1bb6b24e3b4d897ca257df1adb5a2a71197b5735ee8b223b8c0e9bff97c2a2b4e7256c20a56dc617626a313a6d1745ffc50cb3fbd2fc9b7dc7 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.md5 b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.md5 index 3d21d0c7f01..10650e21715 100644 --- a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.md5 +++ b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.md5 @@ -1 +1 @@ -c97875180340d5c10f328531ffc77b04 +403a1256fdc1a7804bd15d8336073bf0 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.sha512 deleted file mode 100644 index 6cd54bff402..00000000000 --- a/Modules/Filtering/Thresholding/test/Baseline/itkKappaSigmaThresholdImageFilterTest02.png.sha512 +++ /dev/null @@ -1 +0,0 @@ -25632cf052e2b4d7b9282ebe3efa2f7ef54049a8a65a3c7baff78bd21a2dd96e8eae3c6b3ae0d5d72150f9d595f651d6a7eb0b56e05b7b09d9669827f0a89c4a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..e9b703a0ace --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +75a3a4393ec6c81a5186f8d05e00eea6592a4f783f3154cb016cbdbd7d3418f9868b60ba64f7c91d171c2f60b9f9b7ff375ee6155bec165846742ba0754bc30a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkLiThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkLiThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..e9b703a0ace --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkLiThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +75a3a4393ec6c81a5186f8d05e00eea6592a4f783f3154cb016cbdbd7d3418f9868b60ba64f7c91d171c2f60b9f9b7ff375ee6155bec165846742ba0754bc30a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..344e5662ce1 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +d67efb2b404c982c30b72a43c6b92ce0d8f23e4ee174cac1af6f37cdb320e752e47ed0a1281b56af040d2f3150c053ddf2b1474816c0716e8b84571deff72d8d diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkMomentsThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkMomentsThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..344e5662ce1 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkMomentsThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +d67efb2b404c982c30b72a43c6b92ce0d8f23e4ee174cac1af6f37cdb320e752e47ed0a1281b56af040d2f3150c053ddf2b1474816c0716e8b84571deff72d8d diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuMultipleThresholdsImageFilterTest2.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuMultipleThresholdsImageFilterTest2.png.sha512 new file mode 100644 index 00000000000..a6530cd3c55 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuMultipleThresholdsImageFilterTest2.png.sha512 @@ -0,0 +1 @@ +7d3ccf81cb874c81e2dcb1c476fae832fe9664e8095a116cb254dbc5a073d2f481abe3745976fc7ca8089db73b70133cb1d6b7d3cc447284be6ca68b497266ab diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.md5 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.md5 index 6802bc82225..62192c5a872 100644 --- a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.md5 +++ b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.md5 @@ -1 +1 @@ -679279da24b82874797d62965e50270e +f932df866e06bdc783b2617d39011e3a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.sha512 deleted file mode 100644 index 4be252a8890..00000000000 --- a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTest.png.sha512 +++ /dev/null @@ -1 +0,0 @@ -f0004c20e4a33e385132abf1458aa63a73d47e16bb5287e27769c158cea93a3e63d673f932faabe03440bd7bab5258f8a803f0c20be9a560818ca5a82a92ee8e diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestFlipInsideOut.png.md5 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestFlipInsideOut.png.md5 new file mode 100644 index 00000000000..8965dd083ef --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestFlipInsideOut.png.md5 @@ -0,0 +1 @@ +d21c829dcac3e13d264a20d355b02a87 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..344e5662ce1 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +d67efb2b404c982c30b72a43c6b92ce0d8f23e4ee174cac1af6f37cdb320e752e47ed0a1281b56af040d2f3150c053ddf2b1474816c0716e8b84571deff72d8d diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.md5 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.md5 deleted file mode 100644 index b0347a6020d..00000000000 --- a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.md5 +++ /dev/null @@ -1 +0,0 @@ -4b680b630223022cb036a3d425aa8a04 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.sha512 index 6fab9bdee44..ce704571cd9 100644 --- a/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.sha512 +++ b/Modules/Filtering/Thresholding/test/Baseline/itkOtsuThresholdImageFilterTestShort.png.sha512 @@ -1 +1 @@ -eaff57ba1e732e62112bb46ed1ce4a546f5eefc56ad8fc56c1a9cec3a3c1b413d1919231723022dd8e70aefb2af18586b86c19886a13d24029ddd821742ef0a4 +2b3848a33d1407cfc8ffa5d71bd69596b76c2819c8fc14bba8e21a3793e0fefd34910540852425a329483f191a7079c0855928a7607ad178bb50d5f1a9447dd1 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..c4093064d44 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +f3ae5b75b0172f96fc3a9c74ed4dd98934825e2587ee3908d52d034a28288c33d8b08d08012883cc41fc330dbe1542d6f49db8322c0dc5d4f84a23a0a3c27877 diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..344e5662ce1 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +d67efb2b404c982c30b72a43c6b92ce0d8f23e4ee174cac1af6f37cdb320e752e47ed0a1281b56af040d2f3150c053ddf2b1474816c0716e8b84571deff72d8d diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkTriangleThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkTriangleThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..e9b703a0ace --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkTriangleThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +75a3a4393ec6c81a5186f8d05e00eea6592a4f783f3154cb016cbdbd7d3418f9868b60ba64f7c91d171c2f60b9f9b7ff375ee6155bec165846742ba0754bc30a diff --git a/Modules/Filtering/Thresholding/test/Baseline/itkYenThresholdImageFilterTestNoAutoMinMax.png.sha512 b/Modules/Filtering/Thresholding/test/Baseline/itkYenThresholdImageFilterTestNoAutoMinMax.png.sha512 new file mode 100644 index 00000000000..344e5662ce1 --- /dev/null +++ b/Modules/Filtering/Thresholding/test/Baseline/itkYenThresholdImageFilterTestNoAutoMinMax.png.sha512 @@ -0,0 +1 @@ +d67efb2b404c982c30b72a43c6b92ce0d8f23e4ee174cac1af6f37cdb320e752e47ed0a1281b56af040d2f3150c053ddf2b1474816c0716e8b84571deff72d8d diff --git a/Modules/Filtering/Thresholding/test/CMakeLists.txt b/Modules/Filtering/Thresholding/test/CMakeLists.txt index de9c8c48a23..24d3ce2df12 100644 --- a/Modules/Filtering/Thresholding/test/CMakeLists.txt +++ b/Modules/Filtering/Thresholding/test/CMakeLists.txt @@ -14,7 +14,7 @@ itkMomentsThresholdImageFilterTest.cxx itkOtsuMultipleThresholdsCalculatorTest.cxx itkOtsuMultipleThresholdsCalculatorTest2.cxx itkOtsuMultipleThresholdsImageFilterTest.cxx -itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx +#itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx itkOtsuThresholdCalculatorTest.cxx itkOtsuThresholdImageFilterTest.cxx itkRenyiEntropyThresholdImageFilterTest.cxx @@ -56,10 +56,10 @@ itk_add_test(NAME itkBinaryThresholdImageFilterTest COMMAND ITKThresholdingTestDriver itkBinaryThresholdImageFilterTest) itk_add_test(NAME itkThresholdImageFilterTest COMMAND ITKThresholdingTestDriver itkThresholdImageFilterTest) -itk_add_test(NAME itkOtsuMultipleThresholdsCalculatorTest - COMMAND ITKThresholdingTestDriver itkOtsuMultipleThresholdsCalculatorTest) +itk_add_test(NAME itkOtsuMultipleThresholdsCalculatorTest1 + COMMAND ITKThresholdingTestDriver itkOtsuMultipleThresholdsCalculatorTest 0) itk_add_test(NAME itkOtsuMultipleThresholdsCalculatorTest2 - COMMAND ITKThresholdingTestDriver itkOtsuMultipleThresholdsCalculatorTest2) + COMMAND ITKThresholdingTestDriver itkOtsuMultipleThresholdsCalculatorTest 1) itk_add_test(NAME itkBinaryThresholdImageFilterTest2 COMMAND ITKThresholdingTestDriver --compare DATA{${ITK_DATA_ROOT}/Baseline/BasicFilters/BinaryThresholdImageFilterTest2.png} @@ -77,99 +77,149 @@ itk_add_test(NAME itkHuangThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkHuangThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTest.png - itkHuangThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTest.png) + itkHuangThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTest.png 256 1 19) +itk_add_test(NAME itkHuangThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkHuangThresholdImageFilterTestNoAutoMinMax.png} + fdcefb74090f63114d811e92f0f5836b + itkHuangThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) itk_add_test(NAME itkHuangMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkHuangMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangMaskedThresholdImageFilterTest.png - itkHuangMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangMaskedThresholdImageFilterTest.png) + itkHuangMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangMaskedThresholdImageFilterTest.png 1 255 239) itk_add_test(NAME itkIntermodesThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIntermodesThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTest.png - itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTest.png) + itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTest.png 256 1 1000 1 76) +itk_add_test(NAME itkIntermodesThresholdImageFilterTestNoInterMode + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkIntermodesThresholdImageFilterTestNoInterMode.png} + eed45f177050894e50ec1be5bc6bd4fa + itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTestNoInterMode.png 32 1 2000 0 75) +#itk_add_test(NAME itkIntermodesThresholdImageFilterTestNoAutoMinMax +# COMMAND ITKThresholdingTestDriver +# --compare-MD5 DATA{Baseline/itkIntermodesThresholdImageFilterTestNoAutoMinMax.png} +# eed45f177050894e50ec1be5bc6bd4fa +# itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTestNoAutoMinMax.png 32 0 400000 0 19) itk_add_test(NAME itkIntermodesMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIntermodesMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesMaskedThresholdImageFilterTest.png - itkIntermodesMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesMaskedThresholdImageFilterTest.png) + itkIntermodesMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesMaskedThresholdImageFilterTest.png 1 255 1000 1 97) itk_add_test(NAME itkIsoDataThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIsoDataThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTest.png - itkIsoDataThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTest.png) + itkIsoDataThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTest.png 256 1 85) +itk_add_test(NAME itkIsoDataThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkIsoDataThresholdImageFilterTestNoAutoMinMax.png} + 9f844fd120ff49a7812e329a1b0216d8 + itkIsoDataThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTestNoAutoMinMax.png 32 0 1) itk_add_test(NAME itkIsoDataMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIsoDataMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataMaskedThresholdImageFilterTest.png itkIsoDataMaskedThresholdImageFilterTest - DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataMaskedThresholdImageFilterTest.png) + DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataMaskedThresholdImageFilterTest.png 1 255 114) itk_add_test(NAME itkKittlerIllingworthThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkKittlerIllingworthThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTest.png - itkKittlerIllingworthThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTest.png) + itkKittlerIllingworthThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTest.png 256 1 32) +itk_add_test(NAME itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax.png} + ecb99e6ffea7be1e5419350f725da86b + itkKittlerIllingworthThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTestNoAutoMinMax.png 32 0 1023) itk_add_test(NAME itkKittlerIllingworthMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkKittlerIllingworthMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthMaskedThresholdImageFilterTest.png - itkKittlerIllingworthMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthMaskedThresholdImageFilterTest.png) + itkKittlerIllingworthMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthMaskedThresholdImageFilterTest.png 1 255 254) itk_add_test(NAME itkLiThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkLiThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTest.png - itkLiThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTest.png) + itkLiThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTest.png 256 1 54) +itk_add_test(NAME itkLiThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkLiThresholdImageFilterTestNoAutoMinMax.png} + ecb99e6ffea7be1e5419350f725da86b + itkLiThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTestNoAutoMinMax.png 32 0 1023) itk_add_test(NAME itkLiMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkLiMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkLiMaskedThresholdImageFilterTest.png - itkLiMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkLiMaskedThresholdImageFilterTest.png) + itkLiMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkLiMaskedThresholdImageFilterTest.png 1 255 177) itk_add_test(NAME itkMaximumEntropyThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMaximumEntropyThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTest.png - itkMaximumEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTest.png) + itkMaximumEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTest.png 256 1 140) +itk_add_test(NAME itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare DATA{Baseline/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png} + ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png + itkMaximumEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) itk_add_test(NAME itkMaximumEntropyMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMaximumEntropyMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyMaskedThresholdImageFilterTest.png - itkMaximumEntropyMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyMaskedThresholdImageFilterTest.png) + itkMaximumEntropyMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyMaskedThresholdImageFilterTest.png 1 255 118) itk_add_test(NAME itkMomentsThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMomentsThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTest.png - itkMomentsThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTest.png) + itkMomentsThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTest.png 256 1 133) +itk_add_test(NAME itkMomentsThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare DATA{Baseline/itkMomentsThresholdImageFilterTestNoAutoMinMax.png} + ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTestNoAutoMinMax.png + itkMomentsThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) itk_add_test(NAME itkMomentsMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMomentsMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsMaskedThresholdImageFilterTest.png - itkMomentsMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsMaskedThresholdImageFilterTest.png) + itkMomentsMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsMaskedThresholdImageFilterTest.png 1 255 139) itk_add_test(NAME itkOtsuThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkOtsuThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTest.png - itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTest.png 256 1) + itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTest.png 256 1 84 0) +itk_add_test(NAME itkOtsuThresholdImageFilterTestFlipInsideOut + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkOtsuThresholdImageFilterTestFlipInsideOut.png} + 70f6b53f769782d0176c28b206d401d3 + itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestFlipInsideOut.png 256 1 84 1) +itk_add_test(NAME itkOtsuThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare DATA{Baseline/itkOtsuThresholdImageFilterTestNoAutoMinMax.png} + ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestNoAutoMinMax.png + itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestNoAutoMinMax.png 32 0 -30720 0) # With one threshold, the OtsuMultipleThresholdsImageFilter should give the same result as the OtsuThresholdImageFilter. # Therefore, in this test, we compare the output to the output of the OtsuThresholdImageFilter. # We set the number of histogram bins to 256 because that is the default for the OtsuThresholdImageFilter. itk_add_test(NAME itkOtsuMultipleThresholdsImageFilterTest2 COMMAND ITKThresholdingTestDriver - --compare DATA{Baseline/itkOtsuThresholdImageFilterTest.png} + --compare DATA{Baseline/itkOtsuMultipleThresholdsImageFilterTest2.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMultipleThresholdsImageFilterTest2.png itkOtsuMultipleThresholdsImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMultipleThresholdsImageFilterTest2.png 256 1 0) @@ -200,151 +250,174 @@ itk_add_test(NAME itkOtsuMultipleThresholdsImageFilterTest6 itkOtsuMultipleThresholdsImageFilterTest DATA{Input/image_3modes.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMultipleThresholdsImageFilterTest6.png 128 2 0 0 1) set_tests_properties(itkOtsuMultipleThresholdsImageFilterTest6 PROPERTIES WILL_FAIL TRUE) -itk_add_test(NAME itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest - COMMAND ITKThresholdingTestDriver - itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png}) +#itk_add_test(NAME itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest +# COMMAND ITKThresholdingTestDriver +# itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png}) itk_add_test(NAME itkOtsuMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkOtsuMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMaskedThresholdImageFilterTest.png - itkOtsuMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMaskedThresholdImageFilterTest.png) + itkOtsuMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuMaskedThresholdImageFilterTest.png 1 255 184) itk_add_test(NAME itkRenyiEntropyThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkRenyiEntropyThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTest.png - itkRenyiEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTest.png) + itkRenyiEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTest.png 256 1 51) +itk_add_test(NAME itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax.png} + d5caadf6ba3cc5177eaa04e831fd0738 + itkRenyiEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) + itk_add_test(NAME itkRenyiEntropyMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkRenyiEntropyMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyMaskedThresholdImageFilterTest.png - itkRenyiEntropyMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyMaskedThresholdImageFilterTest.png) + itkRenyiEntropyMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyMaskedThresholdImageFilterTest.png 1 255 118) itk_add_test(NAME itkShanbhagThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkShanbhagThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTest.png - itkShanbhagThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTest.png) + itkShanbhagThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTest.png 256 1 133) +itk_add_test(NAME itkShanbhagThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare DATA{Baseline/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png} + ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png + itkShanbhagThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) itk_add_test(NAME itkShanbhagMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkShanbhagMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagMaskedThresholdImageFilterTest.png - itkShanbhagMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagMaskedThresholdImageFilterTest.png) + itkShanbhagMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagMaskedThresholdImageFilterTest.png 1 255 55) itk_add_test(NAME itkTriangleThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkTriangleThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTest.png - itkTriangleThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTest.png) + itkTriangleThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTest.png 256 1 2) +itk_add_test(NAME itkTriangleThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkTriangleThresholdImageFilterTestNoAutoMinMax.png} + ecb99e6ffea7be1e5419350f725da86b + itkTriangleThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTestNoAutoMinMax.png 32 0 3071) itk_add_test(NAME itkTriangleMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkTriangleMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleMaskedThresholdImageFilterTest.png - itkTriangleMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleMaskedThresholdImageFilterTest.png) + itkTriangleMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleMaskedThresholdImageFilterTest.png 1 255 254) itk_add_test(NAME itkYenThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkYenThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTest.png - itkYenThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTest.png) + itkYenThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTest.png 256 1 26) +itk_add_test(NAME itkYenThresholdImageFilterTestNoAutoMinMax + COMMAND ITKThresholdingTestDriver + --compare-MD5 DATA{Baseline/itkYenThresholdImageFilterTestNoAutoMinMax.png} + fcd6bcb56c1689fcef28b57c22475bad + itkYenThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTestNoAutoMinMax.png 32 0 -31744) itk_add_test(NAME itkYenMaskedThresholdImageFilterTest COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkYenMaskedThresholdImageFilterTest.png} ${ITK_TEST_OUTPUT_DIR}/itkYenMaskedThresholdImageFilterTest.png - itkYenMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkYenMaskedThresholdImageFilterTest.png) + itkYenMaskedThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/cthead1.png} DATA{${ITK_DATA_ROOT}/Input/cthead1-threshmask.png} ${ITK_TEST_OUTPUT_DIR}/itkYenMaskedThresholdImageFilterTest.png 1 255 118) itk_add_test(NAME itkHuangThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkHuangThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTestShort.png - itkHuangThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTestShort.png) + itkHuangThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkHuangThresholdImageFilterTestShort.png 256 1 30771) itk_add_test(NAME itkIntermodesThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIntermodesThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTestShort.png - itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTestShort.png) + itkIntermodesThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkIntermodesThresholdImageFilterTestShort.png 256 1 1000 1 14251) itk_add_test(NAME itkIsoDataThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkIsoDataThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTestShort.png - itkIsoDataThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTestShort.png) + itkIsoDataThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkIsoDataThresholdImageFilterTestShort.png 256 1 15044) itk_add_test(NAME itkKittlerIllingworthThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkKittlerIllingworthThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTestShort.png - itkKittlerIllingworthThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTestShort.png) + itkKittlerIllingworthThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkKittlerIllingworthThresholdImageFilterTestShort.png 256 1 31168) itk_add_test(NAME itkLiThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkLiThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTestShort.png - itkLiThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTestShort.png) + itkLiThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkLiThresholdImageFilterTestShort.png 256 1 26939) itk_add_test(NAME itkMaximumEntropyThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMaximumEntropyThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTestShort.png - itkMaximumEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTestShort.png) + itkMaximumEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkMaximumEntropyThresholdImageFilterTestShort.png 256 1 22181) itk_add_test(NAME itkMomentsThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkMomentsThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTestShort.png - itkMomentsThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTestShort.png) + itkMomentsThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkMomentsThresholdImageFilterTestShort.png 256 1 23238) itk_add_test(NAME itkOtsuThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkOtsuThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestShort.png - itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestShort.png 256 0 1) + itkOtsuThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkOtsuThresholdImageFilterTestShort.png 256 1 14516 1) itk_add_test(NAME itkRenyiEntropyThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkRenyiEntropyThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTestShort.png - itkRenyiEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTestShort.png) + itkRenyiEntropyThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkRenyiEntropyThresholdImageFilterTestShort.png 256 1 22181) itk_add_test(NAME itkShanbhagThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkShanbhagThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTestShort.png - itkShanbhagThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTestShort.png) + itkShanbhagThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkShanbhagThresholdImageFilterTestShort.png 256 1 28921) itk_add_test(NAME itkTriangleThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkTriangleThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTestShort.png - itkTriangleThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTestShort.png) + itkTriangleThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkTriangleThresholdImageFilterTestShort.png 256 1 22313) itk_add_test(NAME itkYenThresholdImageFilterTestShort COMMAND ITKThresholdingTestDriver --compare DATA{Baseline/itkYenThresholdImageFilterTestShort.png} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTestShort.png - itkYenThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTestShort.png) + itkYenThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/Input-RA-Short.nrrd} ${ITK_TEST_OUTPUT_DIR}/itkYenThresholdImageFilterTestShort.png 256 1 22181) itk_add_test(NAME itkKappaSigmaThresholdImageCalculatorTest01 COMMAND ITKThresholdingTestDriver itkKappaSigmaThresholdImageCalculatorTest - DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence1.png} 10 3.5 19) + DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence1.png} 255 3.5 10 229) itk_add_test(NAME itkKappaSigmaThresholdImageCalculatorTest02 COMMAND ITKThresholdingTestDriver itkKappaSigmaThresholdImageCalculatorTest - DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence2.png} 10 3.0 19) + DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence2.png} 255 3.0 10 361) itk_add_test(NAME itkKappaSigmaThresholdImageFilterTest01 COMMAND ITKThresholdingTestDriver - --compare DATA{Baseline/itkKappaSigmaThresholdImageFilterTest01.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest01.png - itkKappaSigmaThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence1.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest01.png 2 3.5) + --compare DATA{Baseline/itkKappaSigmaThresholdImageFilterTest01.png} + ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest01.png + itkKappaSigmaThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence1.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest01.png 255 3.5 2 69) itk_add_test(NAME itkKappaSigmaThresholdImageFilterTest02 COMMAND ITKThresholdingTestDriver - --compare DATA{Baseline/itkKappaSigmaThresholdImageFilterTest02.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest02.png - itkKappaSigmaThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence2.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest02.png 2 3.0) + --compare DATA{Baseline/itkKappaSigmaThresholdImageFilterTest02.png} + ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest02.png + itkKappaSigmaThresholdImageFilterTest DATA{${ITK_DATA_ROOT}/Input/CellsFluorescence2.png} ${ITK_TEST_OUTPUT_DIR}/itkKappaSigmaThresholdImageFilterTest02.png 255 3.0 2 92) diff --git a/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest.cxx index f8f13f2c8ce..5c878b3eb47 100644 --- a/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest.cxx @@ -18,21 +18,23 @@ #include "itkRandomImageSource.h" #include "itkBinaryThresholdImageFilter.h" +#include "itkNumericTraits.h" #include "itkMath.h" +#include "itkTestingMacros.h" int itkBinaryThresholdImageFilterTest(int, char *[]) { - // Define the dimension of the images - constexpr unsigned int ImageDimension = 3; + constexpr unsigned int Dimension = 3; + + using InputPixelType = unsigned char; + using OutputPixelType = float; // Declare the types of the images - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - using InputPixelType = InputImageType::PixelType; - using OutputPixelType = OutputImageType::PixelType; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; // Declare iterator type using InputIteratorType = itk::ImageRegionIteratorWithIndex; @@ -43,7 +45,7 @@ itkBinaryThresholdImageFilterTest(int, char *[]) using SourceType = itk::RandomImageSource; SourceType::Pointer source = SourceType::New(); - InputImageType::SizeValueType sizeArray[ImageDimension] = { 3, 3, 3 }; + InputImageType::SizeValueType sizeArray[Dimension] = { 3, 3, 3 }; source->SetMin(itk::NumericTraits::ZeroValue()); source->SetMax(itk::NumericTraits::max()); @@ -52,124 +54,154 @@ itkBinaryThresholdImageFilterTest(int, char *[]) // Declare the type for the binary threshold filter using FilterType = itk::BinaryThresholdImageFilter; - - // Create a filter FilterType::Pointer filter = FilterType::New(); - // Setup ivars + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, BinaryThresholdImageFilter, UnaryFunctorImageFilter); + + // Set up ivars InputPixelType lower = 64; InputPixelType upper = 128; - filter->SetUpperThreshold(upper); - filter->SetLowerThreshold(lower); - OutputPixelType inside = -0.5; - OutputPixelType outside = 0.5; - filter->SetInsideValue(inside); - filter->SetOutsideValue(outside); - filter->Print(std::cout); + // No input set: check that thresholds are created using the input + // pixel type non-positive min value + // - filter->SetFunctor(filter->GetFunctor()); + // Lower threshold + FilterType::InputPixelObjectType::Pointer lowerThreshold1 = filter->GetLowerThresholdInput(); - // exercise Get methods - std::cout << "OutsideValue: " << filter->GetOutsideValue() << std::endl; - std::cout << "InsideValue: " << filter->GetInsideValue() << std::endl; - std::cout << "UpperThreshold: " << itk::NumericTraits::PrintType(filter->GetUpperThreshold()) - << std::endl; - std::cout << "LowerThreshold: " << itk::NumericTraits::PrintType(filter->GetLowerThreshold()) - << std::endl; + if (lowerThreshold1->Get() != itk::NumericTraits::NonpositiveMin()) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetLowerThresholdInput():" << std::endl; + std::cerr << "Expected: " + << static_cast::PrintType>( + itk::NumericTraits::NonpositiveMin()) + << ", but got: " << static_cast::PrintType>(lowerThreshold1->Get()) + << std::endl; + return EXIT_FAILURE; + } - // Connect the input images - filter->SetInput(source->GetOutput()); + FilterType::InputPixelObjectType::Pointer lowerThreshold2 = FilterType::InputPixelObjectType::New(); + filter->SetLowerThresholdInput(lowerThreshold2); - // Get the Smart Pointer to the Filter Output - OutputImageType::Pointer outputImage = filter->GetOutput(); + if (lowerThreshold2->Get() != itk::NumericTraits::NonpositiveMin()) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetLowerThresholdInput():" << std::endl; + std::cerr << "Expected: " + << static_cast::PrintType>( + itk::NumericTraits::NonpositiveMin()) + << ", but got: " << static_cast::PrintType>(lowerThreshold2->Get()) + << std::endl; + return EXIT_FAILURE; + } + + // Upper threshold + FilterType::InputPixelObjectType::Pointer upperThreshold1 = filter->GetUpperThresholdInput(); - // Execute the filter - try + if (lowerThreshold1->Get() != itk::NumericTraits::NonpositiveMin()) { - filter->Update(); - filter->SetFunctor(filter->GetFunctor()); + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetUpperThresholdInput():" << std::endl; + std::cerr << "Expected: " + << static_cast::PrintType>( + itk::NumericTraits::NonpositiveMin()) + << ", but got: " << static_cast::PrintType>(upperThreshold1->Get()) + << std::endl; + return EXIT_FAILURE; } - catch (...) + FilterType::InputPixelObjectType::Pointer upperThreshold2 = FilterType::InputPixelObjectType::New(); + filter->SetUpperThresholdInput(upperThreshold2); + + if (upperThreshold2->Get() != itk::NumericTraits::NonpositiveMin()) { - std::cerr << "Caught an unexpected exception. " << std::endl; - std::cerr << "Test failed. " << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetLowerThresholdInput():" << std::endl; + std::cerr << "Expected: " + << static_cast::PrintType>( + itk::NumericTraits::NonpositiveMin()) + << ", but got: " << static_cast::PrintType>(upperThreshold2->Get()) + << std::endl; return EXIT_FAILURE; } + + // Deliberately cause an exception by setting lower threshold to be + // greater than the upper threshold + filter->SetLowerThreshold(upper); + filter->SetUpperThreshold(lower); + + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + filter->SetLowerThreshold(lower); + ITK_TEST_SET_GET_VALUE(lower, filter->GetLowerThreshold()); + + filter->SetUpperThreshold(upper); + ITK_TEST_SET_GET_VALUE(upper, filter->GetUpperThreshold()); + + OutputPixelType inside = -0.5; + filter->SetInsideValue(inside); + ITK_TEST_SET_GET_VALUE(inside, filter->GetInsideValue()); + + OutputPixelType outside = 0.5; + filter->SetOutsideValue(outside); + ITK_TEST_SET_GET_VALUE(outside, filter->GetOutsideValue()); + + + filter->SetFunctor(filter->GetFunctor()); + + filter->SetInput(source->GetOutput()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Get the filter output + OutputImageType::Pointer outputImage = filter->GetOutput(); + // Create an iterator for going through the image output InputIteratorType it(source->GetOutput(), source->GetOutput()->GetRequestedRegion()); OutputIteratorType ot(outputImage, outputImage->GetRequestedRegion()); - // Check the content of the result image - std::cout << "Verification of the output " << std::endl; + // Check the content of the result image ot.GoToBegin(); it.GoToBegin(); while (!ot.IsAtEnd()) { - const InputPixelType input = it.Get(); const OutputPixelType output = ot.Get(); - std::cout << (double)input << " " << (double)output << std::endl; - bool pass = true; if (lower <= input && input <= upper) { if (itk::Math::NotExactlyEquals(output, inside)) { - pass = false; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error checking the inside value:" << std::endl; + std::cout << "Lower threshold: " << static_cast::PrintType>(lower) + << ", upper threshold: " << static_cast::PrintType>(upper) + << std::endl; + std::cerr << "Expected: " << static_cast::PrintType>(inside) + << ", but got: " << static_cast::PrintType>(output) << std::endl; + return EXIT_FAILURE; } } else if (itk::Math::NotExactlyEquals(output, outside)) { - pass = false; - } - - if (!pass) - { - std::cerr << "Error in itkBinaryThresholdImageFilterTest " << std::endl; - std::cerr << " lower = " << (double)lower; - std::cerr << " upper = " << (double)upper; - std::cerr << " inside = " << (double)inside; - std::cerr << " outside = " << (double)outside; - std::cerr << std::endl; - std::cerr << " input = " << (double)input; - std::cerr << " output = " << (double)output; - std::cerr << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error checkint the outside value:" << std::endl; + std::cout << "Lower threshold: " << static_cast::PrintType>(lower) + << ", upper threshold: " << static_cast::PrintType>(upper) + << std::endl; + std::cerr << "Expected: " << static_cast::PrintType>(outside) + << ", but got: " << static_cast::PrintType>(output) << std::endl; return EXIT_FAILURE; } - ++ot; ++it; } - - // Deliberately cause an exception by setting lower threshold to be - // greater than the upper threshold - filter->SetUpperThreshold(lower); - filter->SetLowerThreshold(upper); - bool pass = false; - try - { - filter->Update(); - } - catch (const itk::ExceptionObject & err) - { - pass = true; - std::cout << "Caught an expected exception. " << std::endl; - std::cout << err << std::endl; - } - - if (pass) - { - std::cout << "Test passsed. " << std::endl; - return EXIT_SUCCESS; - } - else - { - std::cout << "Test failed. " << std::endl; - return EXIT_FAILURE; - } + std::cout << "Test finished" << std::endl; + return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest2.cxx b/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest2.cxx index 87a08b48559..a3a7117278b 100644 --- a/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest2.cxx +++ b/Modules/Filtering/Thresholding/test/itkBinaryThresholdImageFilterTest2.cxx @@ -20,73 +20,78 @@ #include "itkImageFileWriter.h" #include "itkStatisticsImageFilter.h" #include "itkBinaryThresholdImageFilter.h" +#include "itkTestingMacros.h" int -itkBinaryThresholdImageFilterTest2(int ac, char * av[]) +itkBinaryThresholdImageFilterTest2(int argc, char * argv[]) { - if (ac < 4) + if (argc != 4) { - std::cerr << "Usage: " << av[0] << " InputImage1 InputImage2 OutputImage\n"; - return -1; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImage1" + << " inputImage2" + << " outputImage" << std::endl; + return EXIT_FAILURE; } // Threshold one image based on the statistics of another image // - // // Define the dimension of the images - constexpr unsigned int ImageDimension = 2; + constexpr unsigned int Dimension = 2; // Declare the types of the images - using ImageType = itk::Image; - using FloatImageType = itk::Image; + using InputPixelType = double; + using OutputPixelType = unsigned char; + + using InputImageType = itk::Image; + using OutputImageType = itk::Image; - // File reader and writer - using ReaderType = itk::ImageFileReader; + using ReaderType = itk::ImageFileReader; ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(av[1]); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); ReaderType::Pointer reader2 = ReaderType::New(); - reader2->SetFileName(av[2]); + reader2->SetFileName(argv[2]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader2->Update()); - using WriterType = itk::ImageFileWriter; - WriterType::Pointer writer = WriterType::New(); - writer->SetFileName(av[3]); // Declare the filter types - using StatisticsType = itk::StatisticsImageFilter; - using ThresholdType = itk::BinaryThresholdImageFilter; + using StatisticsType = itk::StatisticsImageFilter; + using ThresholdType = itk::BinaryThresholdImageFilter; // Create the filters StatisticsType::Pointer statistics = StatisticsType::New(); ThresholdType::Pointer threshold = ThresholdType::New(); - // connect the standard pipeline connections + ITK_EXERCISE_BASIC_OBJECT_METHODS(threshold, BinaryThresholdImageFilter, UnaryFunctorImageFilter); + + + // Set up the standard pipeline connections statistics->SetInput(reader2->GetOutput()); threshold->SetInput(reader->GetOutput()); - // print before assigning thresholds - threshold->Print(std::cout); - - // now connect the inputs and outputs that are decorated scalars threshold->SetUpperThresholdInput(statistics->GetMeanOutput()); + ITK_TEST_SET_GET_VALUE(statistics->GetMeanOutput(), threshold->GetUpperThresholdInput()); + threshold->SetLowerThresholdInput(statistics->GetMinimumOutput()); + ITK_TEST_SET_GET_VALUE(statistics->GetMinimumOutput(), threshold->GetLowerThresholdInput()); + - // connect the writer + // Write the output + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetFileName(argv[3]); writer->SetInput(threshold->GetOutput()); - // Execute the filter - try - { - writer->Update(); - } - catch (...) - { - std::cerr << "Caught an unexpected exception. " << std::endl; - std::cerr << "Test failed. " << std::endl; - return EXIT_FAILURE; - } + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkBinaryThresholdProjectionImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkBinaryThresholdProjectionImageFilterTest.cxx index fd0bb5fd60a..7778eb9a3c4 100644 --- a/Modules/Filtering/Thresholding/test/itkBinaryThresholdProjectionImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkBinaryThresholdProjectionImageFilterTest.cxx @@ -15,87 +15,75 @@ * limitations under the License. * *=========================================================================*/ + #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" - #include "itkBinaryThresholdProjectionImageFilter.h" #include "itkTestingMacros.h" + int itkBinaryThresholdProjectionImageFilterTest(int argc, char * argv[]) { - if (argc < 6) + if (argc != 6) { - std::cerr << "Missing Parameters " << std::endl; - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " InputImage OutputImage Threshold Foreground Background" << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImage" + << " outputImage" + << " threshold" + << " foreground" + << " background" << std::endl; return EXIT_FAILURE; } - constexpr int dim = 3; + constexpr unsigned int Dimension = 3; using PixelType = unsigned char; - using ImageType = itk::Image; + using ImageType = itk::Image; using ReaderType = itk::ImageFileReader; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using FilterType = itk::BinaryThresholdProjectionImageFilter; FilterType::Pointer filter = FilterType::New(); - filter->SetInput(reader->GetOutput()); - // Exercise Set/Get methods for Threshold Value - filter->SetThresholdValue(255); + itk::SimpleFilterWatcher watcher(filter); - if (filter->GetThresholdValue() != 255) - { - std::cerr << "Set/Get Threshold value problem" << std::endl; - return EXIT_FAILURE; - } + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, BinaryThresholdProjectionImageFilter, ProjectionImageFilter); - filter->SetThresholdValue(std::stoi(argv[3])); - // Exercise Set/Get methods for Foreground Value - filter->SetForegroundValue(255); - - if (filter->GetForegroundValue() != 255) - { - std::cerr << "Set/Get Foreground value problem: " << filter->GetForegroundValue() << std::endl; - return EXIT_FAILURE; - } + FilterType::InputPixelType thresholdValue = std::stoi(argv[3]); + filter->SetThresholdValue(thresholdValue); + ITK_TEST_SET_GET_VALUE(thresholdValue, filter->GetThresholdValue()); - filter->SetForegroundValue(std::stoi(argv[4])); + FilterType::OutputPixelType foregroundValue = std::stoi(argv[4]); + filter->SetForegroundValue(foregroundValue); + ITK_TEST_SET_GET_VALUE(foregroundValue, filter->GetForegroundValue()); - // Exercise Set/Get methods for Background Value - filter->SetBackgroundValue(0); + FilterType::OutputPixelType backgroundValue = std::stoi(argv[5]); + filter->SetBackgroundValue(backgroundValue); + ITK_TEST_SET_GET_VALUE(backgroundValue, filter->GetBackgroundValue()); - if (filter->GetBackgroundValue() != 0) - { - std::cerr << "Set/Get Background value problem" << std::endl; - return EXIT_FAILURE; - } - filter->SetBackgroundValue(std::stoi(argv[5])); + filter->SetInput(reader->GetOutput()); + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); - itk::SimpleFilterWatcher watcher(filter, "filter"); + // Write output image using WriterType = itk::ImageFileWriter; WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - try - { - writer->Update(); - } - catch (const itk::ExceptionObject & excp) - { - std::cerr << excp << std::endl; - return EXIT_FAILURE; - } + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkBinaryThresholdSpatialFunctionTest.cxx b/Modules/Filtering/Thresholding/test/itkBinaryThresholdSpatialFunctionTest.cxx index 6f7a9fb0e2c..8ac9b8df2fe 100644 --- a/Modules/Filtering/Thresholding/test/itkBinaryThresholdSpatialFunctionTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkBinaryThresholdSpatialFunctionTest.cxx @@ -20,6 +20,7 @@ #include "itkSphereSignedDistanceFunction.h" #include "itkFloodFilledSpatialFunctionConditionalConstIterator.h" +#include "itkTestingMacros.h" /** * This module tests the sphereality of the @@ -29,12 +30,13 @@ * connect it to a BinaryThresholdSpatialFunction class. * * The sphere parameters are set at radius of 5 and center of (0,0). - * Memebership (i.e. with user specified threshold) is evaluated at + * Membership (i.e. with user specified threshold) is evaluated at * several point and compared to expected values. * The test fails if the evaluated results is not the same as expected * results. * */ + int itkBinaryThresholdSpatialFunctionTest(int, char *[]) { @@ -48,7 +50,7 @@ itkBinaryThresholdSpatialFunctionTest(int, char *[]) SphereFunctionType::Pointer sphere = SphereFunctionType::New(); - // we must initialize the sphere before use + // We must initialize the sphere before use sphere->Initialize(); ParametersType parameters(sphere->GetNumberOfParameters()); @@ -59,20 +61,22 @@ itkBinaryThresholdSpatialFunctionTest(int, char *[]) std::cout << "SphereParameters: " << sphere->GetParameters() << std::endl; - // create a binary threshold function + // Create a binary threshold function FunctionType::Pointer function = FunctionType::New(); - // connect the sphere function + ITK_EXERCISE_BASIC_OBJECT_METHODS(function, BinaryThresholdSpatialFunction, SpatialFunction); + + + // Connect the sphere function function->SetFunction(sphere); - // set the thresholds + // Set the thresholds double lowerThreshold = -3.0; double upperThreshold = 4.0; function->SetLowerThreshold(lowerThreshold); + ITK_TEST_SET_GET_VALUE(lowerThreshold, function->GetLowerThreshold()); function->SetUpperThreshold(upperThreshold); - - std::cout << "LowerThreshold: " << function->GetLowerThreshold() << std::endl; - std::cout << "UpperThreshold: " << function->GetUpperThreshold() << std::endl; + ITK_TEST_SET_GET_VALUE(upperThreshold, function->GetUpperThreshold()); PointType point; @@ -80,27 +84,30 @@ itkBinaryThresholdSpatialFunctionTest(int, char *[]) { point.Fill(p); FunctionType::OutputType output = function->Evaluate(point); - std::cout << "f( " << point << ") = " << output; - std::cout << " [" << function->GetFunction()->Evaluate(point); + std::cout << "f(" << point << ") = " << output; + std::cerr << " [" << function->GetFunction()->Evaluate(point); std::cout << "] " << std::endl; - // check results + // Check results CoordRep val = p * std::sqrt(2.0) - parameters[0]; bool expected = (lowerThreshold <= val && upperThreshold >= val); if (output != expected) { - std::cout << "But expected value is: " << expected << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error at point: " << point << std::endl; + std::cerr << "Expected function value is: " << expected << ", but got: " << output << std::endl; return EXIT_FAILURE; } } - /** - * In the following, we demsonstrate how BinaryThresholdSpatialFunction - * can be used to iterate over pixels whose signed distance is - * within [lowerThreshold,upperThreshold] of the zero level set defining - * the sphere. - */ - // set up a dummy image + // + // In the following, we demsonstrate how BinaryThresholdSpatialFunction + // can be used to iterate over pixels whose signed distance is + // within [lowerThreshold, upperThreshold] of the zero level set defining + // the sphere. + // + + // Set up a dummy image using ImageType = itk::Image; ImageType::Pointer image = ImageType::New(); ImageType::SizeType size; @@ -109,20 +116,19 @@ itkBinaryThresholdSpatialFunctionTest(int, char *[]) image->Allocate(); image->FillBuffer(255); - // set up the conditional iterator + // Set up the conditional iterator using IteratorType = itk::FloodFilledSpatialFunctionConditionalConstIterator; IteratorType iterator(image, function); iterator.SetOriginInclusionStrategy(); - // add a seed that already inside the region + // Add a seed that already inside the region ImageType::IndexType index; index[0] = 0; index[1] = 3; iterator.AddSeed(index); - // - // get the seeds and display them. + // Get the seeds and display them std::cout << "Iterator seeds"; for (auto seed : iterator.GetSeeds()) { @@ -130,35 +136,27 @@ itkBinaryThresholdSpatialFunctionTest(int, char *[]) } std::cout << std::endl; - unsigned int counter = 0; iterator.GoToBegin(); while (!iterator.IsAtEnd()) { - index = iterator.GetIndex(); image->TransformIndexToPhysicalPoint(index, point); double value = sphere->Evaluate(point); - std::cout << counter++ << ": "; - std::cout << index << " "; - std::cout << value << " "; - std::cout << std::endl; - - // check if value is within range + // Check if value is within range if (value < lowerThreshold || value > upperThreshold) { - std::cout << "Point value is not within thresholds ["; - std::cout << lowerThreshold << "," << upperThreshold << "]" << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error at index: " << index << std::endl; + std::cout << "Point value: " << value << " is not within thresholds [" << lowerThreshold << ", " << upperThreshold + << "]" << std::endl; return EXIT_FAILURE; } ++iterator; } - - function->Print(std::cout); - std::cout << "Test passed." << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkHuangMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkHuangMaskedThresholdImageFilterTest.cxx index 6d9871bbc6b..523e7e5670f 100644 --- a/Modules/Filtering/Thresholding/test/itkHuangMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkHuangMaskedThresholdImageFilterTest.cxx @@ -17,63 +17,102 @@ *=========================================================================*/ #include "itkHuangThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkHuangMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::HuangThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - using WriterType = itk::ImageFileWriter; - ReaderType::Pointer reader = ReaderType::New(); + using FilterType = itk::HuangThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, HuangThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkHuangThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkHuangThresholdImageFilterTest.cxx index 5a777ff2dd4..a41fb430971 100644 --- a/Modules/Filtering/Thresholding/test/itkHuangThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkHuangThresholdImageFilterTest.cxx @@ -17,57 +17,106 @@ *=========================================================================*/ #include "itkHuangThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" +#include "itkNumericTraits.h" #include "itkTestingMacros.h" + int itkHuangThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters" << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::HuangThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::HuangThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, HuangThresholdImageFilter, HistogramThresholdImageFilter); + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkIntermodesMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkIntermodesMaskedThresholdImageFilterTest.cxx index 4c261bc0d1e..a5eb1b0139f 100644 --- a/Modules/Filtering/Thresholding/test/itkIntermodesMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkIntermodesMaskedThresholdImageFilterTest.cxx @@ -17,7 +17,6 @@ *=========================================================================*/ #include "itkIntermodesThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" @@ -26,52 +25,103 @@ int itkIntermodesMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 9) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " maximumSmoothingIterations" + << " useInterMode" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::IntermodesThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::IntermodesThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, IntermodesThresholdImageFilter, HistogramThresholdImageFilter); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); + + unsigned long maximumSmoothingIterations = std::stoi(argv[6]); + filter->SetMaximumSmoothingIterations(maximumSmoothingIterations); + ITK_TEST_SET_GET_VALUE(maximumSmoothingIterations, filter->GetMaximumSmoothingIterations()); + + bool useInterMode = static_cast(std::stoi(argv[7])); + filter->SetUseInterMode(useInterMode); + ITK_TEST_SET_GET_VALUE(useInterMode, filter->GetUseInterMode()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[8]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkIntermodesThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkIntermodesThresholdImageFilterTest.cxx index e991f2cd275..070f203bb21 100644 --- a/Modules/Filtering/Thresholding/test/itkIntermodesThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkIntermodesThresholdImageFilterTest.cxx @@ -23,50 +23,115 @@ #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkIntermodesThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 8) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " maximumSmoothingIterations" + << " useInterMode" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::IntermodesThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::IntermodesThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, IntermodesThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); + + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + // Test exceeding maximum iterations for histogram smoothing exception + filter->SetMaximumSmoothingIterations(10); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + unsigned long maximumSmoothingIterations = std::stoi(argv[5]); + filter->SetMaximumSmoothingIterations(maximumSmoothingIterations); + ITK_TEST_SET_GET_VALUE(maximumSmoothingIterations, filter->GetMaximumSmoothingIterations()); + + bool useInterMode = static_cast(std::stoi(argv[6])); + filter->SetUseInterMode(useInterMode); + ITK_TEST_SET_GET_VALUE(useInterMode, filter->GetUseInterMode()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[7]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkIsoDataMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkIsoDataMaskedThresholdImageFilterTest.cxx index cb9887f66dd..b101d791db6 100644 --- a/Modules/Filtering/Thresholding/test/itkIsoDataMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkIsoDataMaskedThresholdImageFilterTest.cxx @@ -17,62 +17,102 @@ *=========================================================================*/ #include "itkIsoDataThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkIsoDataMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << "inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::IsoDataThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + using FilterType = itk::IsoDataThresholdImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, IsoDataThresholdImageFilter, HistogramThresholdImageFilter); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); + filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkIsoDataThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkIsoDataThresholdImageFilterTest.cxx index f9cbc22acb8..f062fe2a874 100644 --- a/Modules/Filtering/Thresholding/test/itkIsoDataThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkIsoDataThresholdImageFilterTest.cxx @@ -17,57 +17,105 @@ *=========================================================================*/ #include "itkIsoDataThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkIsoDataThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cout << "Missing parameters" << std::endl; + std::cerr << "Usage: " << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::IsoDataThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::IsoDataThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, IsoDataThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageCalculatorTest.cxx b/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageCalculatorTest.cxx index 3910c3489a1..7546b1a0a34 100644 --- a/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageCalculatorTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageCalculatorTest.cxx @@ -24,72 +24,67 @@ int itkKappaSigmaThresholdImageCalculatorTest(int argc, char * argv[]) { - if (argc < 5) + if (argc != 6) { - std::cerr << "Missing arguments" << std::endl; + std::cerr << "Missing parameters." << std::endl; std::cerr << "Usage:" << std::endl; - std::cerr << itkNameOfTestExecutableMacro(argv) << std::endl; - std::cerr << "inputImage numberOfIterations sigmaFactor expectedThreshold" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImage" + << " maskValue" + << " sigmaFactor" + << " numberOfIterations" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } - using PixelType = signed short; constexpr unsigned int Dimension = 2; + using PixelType = signed short; + using ImageType = itk::Image; using MaskType = itk::Image; - using ReaderType = itk::ImageFileReader; + using ReaderType = itk::ImageFileReader; ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(argv[1]); + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + // Create and initialize the calculator using CalculatorType = itk::KappaSigmaThresholdImageCalculator; - - std::cout << "Testing Kappa Sigma Image Calulator:\n"; - - try - { - reader->Update(); - } - catch (const itk::ExceptionObject & excp) - { - std::cerr << excp << std::endl; - return EXIT_FAILURE; - } - - /* Create and initialize the calculator */ CalculatorType::Pointer calculator = CalculatorType::New(); - calculator->SetImage(reader->GetOutput()); - calculator->SetNumberOfIterations(std::stoi(argv[2])); - calculator->SetSigmaFactor(std::stod(argv[3])); - calculator->SetMaskValue(255); - // Exercise Get methods - std::cout << "Number of iterations = " << calculator->GetNumberOfIterations() << std::endl; - std::cout << "Sigma factor = " << calculator->GetSigmaFactor() << std::endl; - std::cout << "Mask value = " << calculator->GetMaskValue() << std::endl; + ITK_EXERCISE_BASIC_OBJECT_METHODS(calculator, KappaSigmaThresholdImageCalculator, Object); - calculator->Compute(); + auto maskValue = static_cast(std::stod(argv[3])); + calculator->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, calculator->GetMaskValue()); + + auto sigmaFactor = static_cast(std::stod(argv[4])); + calculator->SetSigmaFactor(sigmaFactor); + ITK_TEST_SET_GET_VALUE(sigmaFactor, calculator->GetSigmaFactor()); - PixelType threshold = calculator->GetOutput(); + auto numberOfIterations = static_cast(std::stoi(argv[5])); + calculator->SetNumberOfIterations(numberOfIterations); + ITK_TEST_SET_GET_VALUE(numberOfIterations, calculator->GetNumberOfIterations()); - std::cout << "calculator: " << calculator; - std::cout << "Threshold: " << threshold; - std::cout << std::endl; + calculator->SetImage(reader->GetOutput()); - // Note that this notion of "expected" value is only for regression testing of the class. - // In a typical usage of this class, you will simply take the calculator->GetOutput(). - PixelType expectedThreshold = std::stoi(argv[4]); + calculator->Compute(); - if (itk::Math::abs(expectedThreshold - threshold) > 1e-3) + // Regression test: compare computed threshold + CalculatorType::InputPixelType expectedThreshold = std::stod(argv[5]); + CalculatorType::InputPixelType resultThreshold = calculator->GetOutput(); + double tolerance = 1e-3; + if (!itk::Math::FloatAlmostEqual((double)expectedThreshold, (double)resultThreshold, 10, tolerance)) { - std::cerr << "Test failed" << std::endl; - std::cerr << "Expected threshold = " << expectedThreshold << std::endl; - std::cerr << "bu Found threshold = " << threshold << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetOutput()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; return EXIT_FAILURE; } + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageFilterTest.cxx index 3d80a7ed38f..d4696ae6efe 100644 --- a/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkKappaSigmaThresholdImageFilterTest.cxx @@ -17,21 +17,25 @@ *=========================================================================*/ #include "itkKappaSigmaThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkKappaSigmaThresholdImageFilterTest(int argc, char * argv[]) { - - if (argc < 5) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile iterations sigmaFactor"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " maskValue" + << " sigmaFactor" + << " numberOfIterations" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } @@ -45,42 +49,69 @@ itkKappaSigmaThresholdImageFilterTest(int argc, char * argv[]) using MaskImageType = itk::Image; using OutputImageType = itk::Image; - using FilterType = itk::KappaSigmaThresholdImageFilter; - using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::KappaSigmaThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - reader->SetFileName(argv[1]); - filter->SetInput(reader->GetOutput()); - writer->SetInput(filter->GetOutput()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, KappaSigmaThresholdImageFilter, ImageToImageFilter); - filter->SetOutsideValue(0); - filter->SetInsideValue(255); - filter->SetMaskValue(255); - filter->SetSigmaFactor(std::stod(argv[3])); - filter->SetNumberOfIterations(std::stoi(argv[4])); - filter->Print(std::cout); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); - std::cout << " GetOutsideValue() = " << filter->GetOutsideValue() << std::endl; - std::cout << " GetInsideValue() = " << filter->GetInsideValue() << std::endl; - std::cout << " GetMaskValue() = " << filter->GetMaskValue() << std::endl; - std::cout << " GetSigmaFactor() = " << filter->GetSigmaFactor() << std::endl; - std::cout << " GetNumberOfIterations() = " << filter->GetNumberOfIterations() << std::endl; + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); - filter->Update(); + auto maskValue = static_cast(std::stod(argv[3])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - std::cout << "Computed Threshold is: " << filter->GetThreshold() << std::endl; + double sigmaFactor = std::stod(argv[4]); + filter->SetSigmaFactor(sigmaFactor); + ITK_TEST_SET_GET_VALUE(sigmaFactor, filter->GetSigmaFactor()); + auto numberOfIterations = static_cast(std::stoi(argv[5])); + filter->SetNumberOfIterations(numberOfIterations); + ITK_TEST_SET_GET_VALUE(numberOfIterations, filter->GetNumberOfIterations()); + + + filter->SetInput(reader->GetOutput()); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkKittlerIllingworthMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkKittlerIllingworthMaskedThresholdImageFilterTest.cxx index 02bca371e71..0087cccba6d 100644 --- a/Modules/Filtering/Thresholding/test/itkKittlerIllingworthMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkKittlerIllingworthMaskedThresholdImageFilterTest.cxx @@ -17,61 +17,102 @@ *=========================================================================*/ #include "itkKittlerIllingworthThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkKittlerIllingworthMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::KittlerIllingworthThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + using FilterType = itk::KittlerIllingworthThresholdImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, KittlerIllingworthThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkKittlerIllingworthThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkKittlerIllingworthThresholdImageFilterTest.cxx index 0320bf6e929..8eb0e0c2d89 100644 --- a/Modules/Filtering/Thresholding/test/itkKittlerIllingworthThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkKittlerIllingworthThresholdImageFilterTest.cxx @@ -17,57 +17,105 @@ *=========================================================================*/ #include "itkKittlerIllingworthThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkKittlerIllingworthThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::KittlerIllingworthThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::KittlerIllingworthThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, KittlerIllingworthThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkLiMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkLiMaskedThresholdImageFilterTest.cxx index 0e564bd17f2..153947a19a4 100644 --- a/Modules/Filtering/Thresholding/test/itkLiMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkLiMaskedThresholdImageFilterTest.cxx @@ -17,61 +17,102 @@ *=========================================================================*/ #include "itkLiThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkLiMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::LiThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + using FilterType = itk::LiThresholdImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, LiThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkLiThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkLiThresholdImageFilterTest.cxx index 5dc0e02b95a..29fb8528f7f 100644 --- a/Modules/Filtering/Thresholding/test/itkLiThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkLiThresholdImageFilterTest.cxx @@ -17,57 +17,105 @@ *=========================================================================*/ #include "itkLiThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkLiThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::LiThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::LiThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, LiThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkMaximumEntropyMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkMaximumEntropyMaskedThresholdImageFilterTest.cxx index 9719d657b06..a4d88a70466 100644 --- a/Modules/Filtering/Thresholding/test/itkMaximumEntropyMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkMaximumEntropyMaskedThresholdImageFilterTest.cxx @@ -23,57 +23,98 @@ #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkMaximumEntropyMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::MaximumEntropyThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::MaximumEntropyThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, MaximumEntropyThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkMaximumEntropyThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkMaximumEntropyThresholdImageFilterTest.cxx index def7fa8fd84..a1ff4aea472 100644 --- a/Modules/Filtering/Thresholding/test/itkMaximumEntropyThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkMaximumEntropyThresholdImageFilterTest.cxx @@ -17,57 +17,106 @@ *=========================================================================*/ #include "itkMaximumEntropyThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkMaximumEntropyThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::MaximumEntropyThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::MaximumEntropyThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, MaximumEntropyThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkMomentsMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkMomentsMaskedThresholdImageFilterTest.cxx index 61be639d5f3..c344f5acf59 100644 --- a/Modules/Filtering/Thresholding/test/itkMomentsMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkMomentsMaskedThresholdImageFilterTest.cxx @@ -23,58 +23,98 @@ #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkMomentsMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; - using FilterType = itk::MomentsThresholdImageFilter; + using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - using ReaderType = itk::ImageFileReader; using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::MomentsThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, MomentsThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkMomentsThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkMomentsThresholdImageFilterTest.cxx index 38a680a0992..cb32bc4b684 100644 --- a/Modules/Filtering/Thresholding/test/itkMomentsThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkMomentsThresholdImageFilterTest.cxx @@ -17,57 +17,106 @@ *=========================================================================*/ #include "itkMomentsThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkMomentsThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::MomentsThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::MomentsThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, MomentsThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuMaskedThresholdImageFilterTest.cxx index fb891b8effd..5c54419185b 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuMaskedThresholdImageFilterTest.cxx @@ -17,62 +17,103 @@ *=========================================================================*/ #include "itkOtsuThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkOtsuMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::OtsuThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; - using WriterType = itk::ImageFileWriter; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + using FilterType = itk::OtsuThresholdImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, OtsuThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsCalculatorTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsCalculatorTest.cxx index a32b4b5f066..dd99d822fda 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsCalculatorTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsCalculatorTest.cxx @@ -19,14 +19,24 @@ #include "itkOtsuMultipleThresholdsCalculator.h" #include "itkTestingMacros.h" + int -itkOtsuMultipleThresholdsCalculatorTest(int, char *[]) +itkOtsuMultipleThresholdsCalculatorTest(int argc, char * argv[]) { + if (argc != 2) + { + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " valleyEmphasis" << std::endl; + return EXIT_FAILURE; + } + using MeasurementType = float; using HistogramType = itk::Statistics::Histogram; + HistogramType::Pointer histogram = HistogramType::New(); - // initialize histogram + // Initialize histogram HistogramType::SizeType size; HistogramType::MeasurementVectorType lowerBound; HistogramType::MeasurementVectorType upperBound; @@ -40,7 +50,7 @@ itkOtsuMultipleThresholdsCalculatorTest(int, char *[]) histogram->Initialize(size, lowerBound, upperBound); - // create vector of values. + // Create vector of values using ValuesVectorType = std::vector; ValuesVectorType values; values.push_back(8.0); @@ -50,22 +60,22 @@ itkOtsuMultipleThresholdsCalculatorTest(int, char *[]) MeasurementType range = 2.0; - // create histogram with samples at values +- range. + // Create histogram with samples at values +- range for (HistogramType::Iterator iter = histogram->Begin(); iter != histogram->End(); ++iter) { HistogramType::MeasurementType measurement = iter.GetMeasurementVector()[0]; - for (float value : values) + for (ValuesVectorType::const_iterator viter = values.begin(); viter != values.end(); ++viter) { - if (measurement > (value - range) && measurement < (value + range)) + if (measurement > (*viter - range) && measurement < (*viter + range)) { iter.SetFrequency(1); } } } - // Compute numberOfValues - 1 thresholds. - size_t numberOfThresholds = values.size() - 1; + // Compute numberOfValues - 1 thresholds + auto numberOfThresholds = values.size() - 1; using OtsuMultipleThresholdCalculatorType = itk::OtsuMultipleThresholdsCalculator; @@ -80,37 +90,32 @@ itkOtsuMultipleThresholdsCalculatorTest(int, char *[]) otsuThresholdCalculator->SetInputHistogram(histogram); otsuThresholdCalculator->SetNumberOfThresholds(numberOfThresholds); - try - { - otsuThresholdCalculator->Compute(); - } - catch (const itk::ExceptionObject & excp) - { - std::cerr << excp << std::endl; - } - otsuThresholdCalculator->Print(std::cout); + otsuThresholdCalculator->SetInputHistogram(histogram.GetPointer()); + + otsuThresholdCalculator->SetNumberOfThresholds(numberOfThresholds); + ITK_TEST_SET_GET_VALUE(numberOfThresholds, otsuThresholdCalculator->GetNumberOfThresholds()); + + bool valleyEmphasis = std::stoi(argv[1]); + ITK_TEST_SET_GET_BOOLEAN(otsuThresholdCalculator, ValleyEmphasis, valleyEmphasis); + + ITK_TRY_EXPECT_NO_EXCEPTION(otsuThresholdCalculator->Compute()); - OtsuMultipleThresholdCalculatorType::OutputType otsuThresholds = otsuThresholdCalculator->GetOutput(); - bool passed = true; + OtsuMultipleThresholdCalculatorType::OutputType otsuThresholds = otsuThresholdCalculator->GetOutput(); - // Check if thresholds correctly separate values. + // Check if thresholds correctly separate values for (unsigned long j = 0; j < numberOfThresholds; ++j) { if (otsuThresholds[j] < values[j] || otsuThresholds[j] > values[j + 1]) { - passed = false; - break; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetOutput() at threshold: " << j << std::endl; + std::cerr << "Expected value to be between: " << values[j] << " and " << values[j + 1] + << ", but got: " << otsuThresholds[j] << std::endl; + return EXIT_FAILURE; } } - if (!passed) - { - std::cout << "Test failed." << std::endl; - std::cout << otsuThresholdCalculator << std::endl; - return EXIT_FAILURE; - } - - std::cout << "Test passed." << std::endl; + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsImageFilterTest.cxx index 1091f4fbe94..079b36f0b2b 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuMultipleThresholdsImageFilterTest.cxx @@ -22,58 +22,64 @@ #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" +#include "itkTestingMacros.h" + int itkOtsuMultipleThresholdsImageFilterTest(int argc, char * argv[]) { if (argc < 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << " numberOfHistogramBins"; - std::cerr << " numberOfThresholds"; - std::cerr << " labelOffset"; - std::cerr << " [valleyEmphasis]"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " numberOfThresholds" + << " labelOffset" + << " [valleyEmphasis]" + << " [returnBinMidpoint]" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using InternalPixelType = unsigned short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using InternalImageType = itk::Image; - using OutputImageType = itk::Image; + using InputImageType = itk::Image; + using InternalImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; using FilterType = itk::OtsuMultipleThresholdsImageFilter; using RescaleType = itk::RescaleIntensityImageFilter; - using WriterType = itk::ImageFileWriter; + // Set up the reader + using ReaderType = itk::ImageFileReader; ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); + reader->SetFileName(argv[1]); - ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, OtsuMultipleThresholdsImageFilter, ImageToImageFilter); + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - RescaleType::Pointer rescaler = RescaleType::New(); - WriterType::Pointer writer = WriterType::New(); + + using FilterType = itk::OtsuMultipleThresholdsImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - // Set up the reader - reader->SetFileName(argv[1]); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, OtsuMultipleThresholdsImageFilter, ImageToImageFilter); + // Set up the filter parameters #if defined(ITKV4_COMPATIBILITY) ITK_TEST_EXPECT_TRUE(filter->GetReturnBinMidpoint()); #else ITK_TEST_EXPECT_TRUE(!filter->GetReturnBinMidpoint()); #endif - filter->ReturnBinMidpointOff(); - // Set up the filter parameters - filter->SetInput(reader->GetOutput()); + filter->ReturnBinMidpointOff(); auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); filter->SetNumberOfHistogramBins(numberOfHistogramBins); @@ -99,22 +105,39 @@ itkOtsuMultipleThresholdsImageFilterTest(int argc, char * argv[]) ITK_TEST_SET_GET_BOOLEAN(filter, ReturnBinMidpoint, returnBinMidpoint); } + FilterType::ThresholdVectorType thresholds = filter->GetThresholds(); + std::cout << "filter->GetThresholds(): "; + for (unsigned int i = 0; i < thresholds.size(); i++) + { + std::cout << itk::NumericTraits::PrintType(thresholds[i]) << " "; + } + std::cout << std::endl; + + + filter->SetInput(reader->GetOutput()); + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); // Rescale the image so that it can be seen. The output of the // filter contains labels that are numbered sequentially, so the // image looks nearly uniform unless there are a large number of labels. + // + using RescaleType = itk::RescaleIntensityImageFilter; + RescaleType::Pointer rescaler = RescaleType::New(); rescaler->SetInput(filter->GetOutput()); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); // Write out the test image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + std::cout << "Test finished." << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorTest.cxx index 0bf3da5d638..a111b2e2b84 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorTest.cxx @@ -19,53 +19,53 @@ #include "itkOtsuThresholdCalculator.h" #include "itkImageRegionIterator.h" #include "itkImageToHistogramFilter.h" +#include "itkTestingMacros.h" -using SizeType = itk::Size<3>; -using ImageType = itk::Image; -using HistogramGeneratorType = itk::Statistics::ImageToHistogramFilter; -using HistogramType = HistogramGeneratorType::HistogramType; -using CalculatorType = itk::OtsuThresholdCalculator; -namespace -{ - -/* Define the image size and physical coordinates */ -SizeType size = { { 20, 20, 20 } }; -double origin[3] = { 0.0, 0.0, 0.0 }; -double spacing[3] = { 1, 1, 1 }; -} // namespace int itkOtsuThresholdCalculatorTest(int, char *[]) { - using Iterator = itk::ImageRegionIterator; + constexpr unsigned int Dimension = 3; - int flag = 0; /* Did this test program work? */ + using PixelType = short; + using SizeType = itk::Size; - std::cout << "Testing Minimum and Maximum Image Calculator:\n"; + using SizeType = itk::Size; + using ImageType = itk::Image; + using HistogramGeneratorType = itk::Statistics::ImageToHistogramFilter; + using HistogramType = HistogramGeneratorType::HistogramType; + using CalculatorType = itk::OtsuThresholdCalculator; - /* Allocate a simple test image */ + // Allocate a simple test image ImageType::Pointer image = ImageType::New(); ImageType::RegionType region; + + // Define the image size and physical coordinates + SizeType size = { { 20, 20, 20 } }; + region.SetSize(size); image->SetLargestPossibleRegion(region); image->SetRequestedRegion(region); image->SetBufferedRegion(region); image->Allocate(); - /* Set origin and spacing of physical coordinates */ + // Set origin and spacing of physical coordinates + double origin[3] = { 0.0, 0.0, 0.0 }; + double spacing[3] = { 1, 1, 1 }; image->SetOrigin(origin); image->SetSpacing(spacing); unsigned long numPixels = region.GetNumberOfPixels(); - Iterator iter(image, image->GetBufferedRegion()); + using IteratorType = itk::ImageRegionIterator; + IteratorType iter(image, image->GetBufferedRegion()); - short value1 = 10; - short value2 = 50; - short range = 5; - short r2 = range * 2 + 1; + ImageType::PixelType value1 = 10; + ImageType::PixelType value2 = 50; + ImageType::PixelType range = 5; + ImageType::PixelType r2 = range * 2 + 1; - /* Fill one half of with values of Value1 +- 2 */ + // Fill one half of with values of value1 +- 2 unsigned long i; for (i = 0; i < numPixels / 2; i++) @@ -74,14 +74,13 @@ itkOtsuThresholdCalculatorTest(int, char *[]) ++iter; } - /* Fill the other half with values of Value2 +- 2 */ + // Fill the other half with values of value2 +- 2 for (i = numPixels / 2; i < numPixels; i++) { iter.Set((i % r2) + value2 - range); ++iter; } - HistogramGeneratorType::Pointer histGenerator = HistogramGeneratorType::New(); histGenerator->SetInput(image); HistogramGeneratorType::HistogramSizeType hsize(1); @@ -89,36 +88,28 @@ itkOtsuThresholdCalculatorTest(int, char *[]) histGenerator->SetHistogramSize(hsize); histGenerator->SetAutoMinimumMaximum(true); - /* Create and initialize the calculator */ + // Create and initialize the calculator CalculatorType::Pointer calculator = CalculatorType::New(); + + ITK_EXERCISE_BASIC_OBJECT_METHODS(calculator, OtsuThresholdCalculator, HistogramThresholdCalculator); + calculator->SetInput(histGenerator->GetOutput()); calculator->Update(); - std::cout << "calculator: " << calculator; - std::cout << "NumberOfHistogramBins: " << histGenerator->GetOutput()->GetSize(); - std::cout << std::endl; - - /* Return minimum of intensity */ + // Return minimum of intensity double thresholdResult = calculator->GetThreshold(); std::cout << "The threshold intensity value is : " << thresholdResult << std::endl; if (thresholdResult < static_cast(value1) || thresholdResult > static_cast(value2)) { - std::cout << "Threshold Value is wrong : " << thresholdResult << std::endl; - std::cout << "Should be between " << value1 << " and " << value2 << std::endl; - flag = 1; - } - - /* Return results of test */ - if (flag != 0) - { - std::cout << "*** Some tests failed" << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected value to be between: " << value1 << " and " << value2 << ", but got: " << thresholdResult + << std::endl; return EXIT_FAILURE; } - else - { - std::cout << "All tests successfully passed" << std::endl; - return EXIT_SUCCESS; - } + + std::cout << "Test finished" << std::endl; + return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx index 943deb5df20..f70b7780391 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest.cxx @@ -24,14 +24,15 @@ #include "itkOtsuMultipleThresholdsCalculator.h" #include "itkTestingMacros.h" + int itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest(int argc, char * argv[]) { if (argc < 2) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile "; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << itkNameOfTestExecutableMacro(argv) << std::endl; + std::cerr << " inputImageFile" << std::endl; return EXIT_FAILURE; } @@ -40,15 +41,15 @@ itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest(int argc, c // Then test the computed thresholds for the two filters for various numbers of // histogram bins. // The two algorithms should output the same result. - std::string inputImageName = argv[1]; - int numberOfThresholds = 1; constexpr unsigned int ImageDimension = 2; using InputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + int numberOfThresholds = 1; + ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(inputImageName); + reader->SetFileName(argv[1]); reader->Update(); using HistogramGeneratorType = itk::Statistics::ScalarImageToHistogramGenerator; @@ -75,20 +76,20 @@ itkOtsuThresholdCalculatorVersusOtsuMultipleThresholdsCalculatorTest(int argc, c histogramGenerator->Compute(); otsuCalculator->Compute(); - otsuMultipleCalculator->Compute(); - std::cout << "Computed Otsu threshold using " << binsIterator << " bins: " << otsuCalculator->GetThreshold() - << std::endl; - std::cout << "Computed Otsu multiple threshold using " << binsIterator - << " bins: " << otsuMultipleCalculator->GetOutput()[0] << std::endl; if (itk::Math::NotAlmostEquals(otsuCalculator->GetThreshold(), otsuMultipleCalculator->GetOutput()[0])) { - std::cout << "Computed Otsu threshold (" << otsuCalculator->GetThreshold() - << ") is different from computed Otsu multiple threshold (" << otsuMultipleCalculator->GetOutput()[0] - << ")" << std::endl; + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in itk::OtsuThresholdCalculator::GetThreshold() or \ + itk::OtsuMultipleThresholdsCalculator::GetOutput()" + << std::endl; + std::cout << "Computed Otsu threshold: " << otsuCalculator->GetThreshold() + << " is different from computed Otsu multiple threshold: " << otsuMultipleCalculator->GetOutput()[0] + << std::endl; return EXIT_FAILURE; } } + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkOtsuThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkOtsuThresholdImageFilterTest.cxx index 26728b16eff..19a42d3cc2a 100644 --- a/Modules/Filtering/Thresholding/test/itkOtsuThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkOtsuThresholdImageFilterTest.cxx @@ -17,80 +17,121 @@ *=========================================================================*/ #include "itkOtsuThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" +#include "itkTestingMacros.h" + int itkOtsuThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc < 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile [numberOfHistogramBins flipOutputIntensities]"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" + << " [flipOutputIntensities]" + << " [returnBinMidpoint]" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::OtsuThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::OtsuThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, OtsuThresholdImageFilter, HistogramThresholdImageFilter); + + #if defined(ITKV4_COMPATIBILITY) ITK_TEST_EXPECT_TRUE(filter->GetReturnBinMidpoint()); #else ITK_TEST_EXPECT_TRUE(!filter->GetReturnBinMidpoint()); #endif - reader->SetFileName(argv[1]); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + filter->SetInput(reader->GetOutput()); - if (argc > 3) - { - filter->SetNumberOfHistogramBins(std::stoi(argv[3])); - } - if (argc > 4) + + if (argc > 5) { - bool flipOutputIntensities = std::stoi(argv[4]); + bool flipOutputIntensities = std::stoi(argv[6]); if (flipOutputIntensities) { - // Flip the inside and outside values. + // Flip the inside and outside values FilterType::OutputPixelType outsideValue = filter->GetInsideValue(); FilterType::OutputPixelType insideValue = filter->GetOutsideValue(); filter->SetInsideValue(insideValue); filter->SetOutsideValue(outsideValue); } } - if (argc > 5) + if (argc > 6) { - bool returnBinMidpoint = static_cast(std::stoi(argv[5])); + bool returnBinMidpoint = static_cast(std::stoi(argv[6])); ITK_TEST_SET_GET_BOOLEAN(filter, ReturnBinMidpoint, returnBinMidpoint); } - filter->Update(); - // Test GetMacros - unsigned long numberOfHistogramBins = filter->GetNumberOfHistogramBins(); - std::cout << "filter->GetNumberOfHistogramBins(): " << numberOfHistogramBins << std::endl; - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkRenyiEntropyMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkRenyiEntropyMaskedThresholdImageFilterTest.cxx index 4fc25dfa76c..082d32df219 100644 --- a/Modules/Filtering/Thresholding/test/itkRenyiEntropyMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkRenyiEntropyMaskedThresholdImageFilterTest.cxx @@ -23,58 +23,100 @@ #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkRenyiEntropyMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << "expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::RenyiEntropyThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::RenyiEntropyThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, RenyiEntropyThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + filter->SetMaskImage(maskReader->GetOutput()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkRenyiEntropyThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkRenyiEntropyThresholdImageFilterTest.cxx index ca30aa8ccf8..368ee881de3 100644 --- a/Modules/Filtering/Thresholding/test/itkRenyiEntropyThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkRenyiEntropyThresholdImageFilterTest.cxx @@ -17,57 +17,106 @@ *=========================================================================*/ #include "itkRenyiEntropyThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkRenyiEntropyThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::RenyiEntropyThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::RenyiEntropyThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, RenyiEntropyThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkShanbhagMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkShanbhagMaskedThresholdImageFilterTest.cxx index 8f8503e8cdc..73445e2a8e7 100644 --- a/Modules/Filtering/Thresholding/test/itkShanbhagMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkShanbhagMaskedThresholdImageFilterTest.cxx @@ -17,63 +17,103 @@ *=========================================================================*/ #include "itkShanbhagThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkShanbhagMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::ShanbhagThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::ShanbhagThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, ShanbhagThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkShanbhagThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkShanbhagThresholdImageFilterTest.cxx index cbb37e70899..6a168a610e0 100644 --- a/Modules/Filtering/Thresholding/test/itkShanbhagThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkShanbhagThresholdImageFilterTest.cxx @@ -17,57 +17,106 @@ *=========================================================================*/ #include "itkShanbhagThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkShanbhagThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::ShanbhagThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::ShanbhagThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, ShanbhagThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkThresholdLabelerImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkThresholdLabelerImageFilterTest.cxx index 41211410e38..07cf6748242 100644 --- a/Modules/Filtering/Thresholding/test/itkThresholdLabelerImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkThresholdLabelerImageFilterTest.cxx @@ -127,15 +127,12 @@ ThresholdLabelerImageFilterTestHelper(bool useRealTypeThresholds) labelerFilter->SetLabelOffset(offset); ITK_TEST_SET_GET_VALUE(offset, labelerFilter->GetLabelOffset()); - try - { - labelerFilter->Update(); - labelerFilter->SetFunctor(labelerFilter->GetFunctor()); - } - catch (const itk::ExceptionObject & excp) - { - std::cerr << excp << std::endl; - } + + ITK_TRY_EXPECT_NO_EXCEPTION(labelerFilter->SetFunctor(labelerFilter->GetFunctor())); + + + ITK_TRY_EXPECT_NO_EXCEPTION(labelerFilter->Update()); + // Check if labels coincide with expected labels bool passed = true; @@ -162,7 +159,7 @@ ThresholdLabelerImageFilterTestHelper(bool useRealTypeThresholds) if (!passed) { - std::cout << "Test failed." << std::endl; + std::cout << "Test failed!" << std::endl; std::cout << labelerFilter << std::endl; return EXIT_FAILURE; } @@ -185,11 +182,11 @@ itkThresholdLabelerImageFilterTest(int, char *[]) if (testStatusRealTypeThresholds == EXIT_SUCCESS && testStatusNotRealTypeThresholds == EXIT_SUCCESS) { - std::cout << "TEST FINISHED SUCCESSFULLY!" << std::endl; + std::cout << "Test finished." << std::endl; } else { - std::cout << "TEST FAILED!" << std::endl; + std::cerr << "Test failed!" << std::endl; testStatus = EXIT_FAILURE; } diff --git a/Modules/Filtering/Thresholding/test/itkTriangleMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkTriangleMaskedThresholdImageFilterTest.cxx index 9970c086855..ca9d63032a4 100644 --- a/Modules/Filtering/Thresholding/test/itkTriangleMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkTriangleMaskedThresholdImageFilterTest.cxx @@ -17,62 +17,103 @@ *=========================================================================*/ #include "itkTriangleThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkTriangleMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::TriangleThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; - using WriterType = itk::ImageFileWriter; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - ReaderType::Pointer reader = ReaderType::New(); - FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + using FilterType = itk::TriangleThresholdImageFilter; + FilterType::Pointer filter = FilterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, TriangleThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkTriangleThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkTriangleThresholdImageFilterTest.cxx index 97c32187b30..cda450b6cf9 100644 --- a/Modules/Filtering/Thresholding/test/itkTriangleThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkTriangleThresholdImageFilterTest.cxx @@ -17,20 +17,24 @@ *=========================================================================*/ #include "itkTriangleThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkTriangleThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } @@ -40,34 +44,77 @@ itkTriangleThresholdImageFilterTest(int argc, char * argv[]) using InputImageType = itk::Image; using OutputImageType = itk::Image; - using FilterType = itk::TriangleThresholdImageFilter; - using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::TriangleThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, TriangleThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkYenMaskedThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkYenMaskedThresholdImageFilterTest.cxx index 8f5779ed243..30fce462c35 100644 --- a/Modules/Filtering/Thresholding/test/itkYenMaskedThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkYenMaskedThresholdImageFilterTest.cxx @@ -17,63 +17,103 @@ *=========================================================================*/ #include "itkYenThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkYenMaskedThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 4) + if (argc != 7) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile maskImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " maskImageFile" + << " outputImageFile" + << " maskOutput" + << " maskValue" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::YenThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); + + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); + + using MaskReaderType = itk::ImageFileReader; + MaskReaderType::Pointer maskReader = MaskReaderType::New(); + maskReader->SetFileName(argv[2]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(maskReader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::YenThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); - MaskReaderType::Pointer maskreader = MaskReaderType::New(); + itk::SimpleFilterWatcher watcher(filter); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, YenThresholdImageFilter, HistogramThresholdImageFilter); - itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + bool maskOutput = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, MaskOutput, maskOutput); + + auto maskValue = static_cast(std::stod(argv[5])); + filter->SetMaskValue(maskValue); + ITK_TEST_SET_GET_VALUE(maskValue, filter->GetMaskValue()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); - maskreader->SetFileName(argv[2]); filter->SetInput(reader->GetOutput()); - filter->SetMaskImage(maskreader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); + filter->SetMaskImage(maskReader->GetOutput()); + // filter->SetNumberOfHistogramBins(std::stoi(argv[3])); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + FilterType::InputPixelType expectedThreshold = std::stod(argv[6]); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[3]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; } diff --git a/Modules/Filtering/Thresholding/test/itkYenThresholdImageFilterTest.cxx b/Modules/Filtering/Thresholding/test/itkYenThresholdImageFilterTest.cxx index ffc743260dc..9300e61db69 100644 --- a/Modules/Filtering/Thresholding/test/itkYenThresholdImageFilterTest.cxx +++ b/Modules/Filtering/Thresholding/test/itkYenThresholdImageFilterTest.cxx @@ -17,57 +17,105 @@ *=========================================================================*/ #include "itkYenThresholdImageFilter.h" - #include "itkImageFileReader.h" #include "itkImageFileWriter.h" #include "itkSimpleFilterWatcher.h" #include "itkTestingMacros.h" + int itkYenThresholdImageFilterTest(int argc, char * argv[]) { - if (argc < 3) + if (argc != 6) { - std::cerr << "Usage: " << itkNameOfTestExecutableMacro(argv); - std::cerr << " inputImageFile outputImageFile"; - std::cerr << std::endl; + std::cerr << "Missing parameters." << std::endl; + std::cerr << "Usage:" << std::endl; + std::cerr << itkNameOfTestExecutableMacro(argv) << " inputImageFile" + << " outputImageFile" + << " numberOfHistogramBins" + << " autoMinimumMaximum" + << " expectedThreshold" << std::endl; return EXIT_FAILURE; } + constexpr unsigned int Dimension = 2; + using InputPixelType = short; using OutputPixelType = unsigned char; - using InputImageType = itk::Image; - using OutputImageType = itk::Image; - - using FilterType = itk::YenThresholdImageFilter; + using InputImageType = itk::Image; + using OutputImageType = itk::Image; using ReaderType = itk::ImageFileReader; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(argv[1]); - using WriterType = itk::ImageFileWriter; + ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update()); - ReaderType::Pointer reader = ReaderType::New(); + + using FilterType = itk::YenThresholdImageFilter; FilterType::Pointer filter = FilterType::New(); - WriterType::Pointer writer = WriterType::New(); itk::SimpleFilterWatcher watcher(filter); - filter->SetInsideValue(255); - ITK_TEST_SET_GET_VALUE(255, filter->GetInsideValue()); + ITK_EXERCISE_BASIC_OBJECT_METHODS(filter, YenThresholdImageFilter, HistogramThresholdImageFilter); + + + auto insideValue = static_cast(255); + filter->SetInsideValue(insideValue); + ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue()); + + auto outsideValue = static_cast(0); + filter->SetOutsideValue(outsideValue); + ITK_TEST_SET_GET_VALUE(outsideValue, filter->GetOutsideValue()); + + auto numberOfHistogramBins = static_cast(std::stoi(argv[3])); + filter->SetNumberOfHistogramBins(numberOfHistogramBins); + ITK_TEST_SET_GET_VALUE(numberOfHistogramBins, filter->GetNumberOfHistogramBins()); + + auto autoMinimumMaximum = static_cast(std::stoi(argv[4])); + ITK_TEST_SET_GET_BOOLEAN(filter, AutoMinimumMaximum, autoMinimumMaximum); + + // Test no histogram exception (no input set) + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); - filter->SetOutsideValue(0); - ITK_TEST_SET_GET_VALUE(0, filter->GetOutsideValue()); - reader->SetFileName(argv[1]); filter->SetInput(reader->GetOutput()); - // filter->SetNumberOfHistogramBins (std::stoi(argv[3])); - writer->SetInput(filter->GetOutput()); - filter->Update(); - std::cout << "Computed Threshold is: " - << itk::NumericTraits::PrintType(filter->GetThreshold()) << std::endl; + // Test no calculator set exception + filter->SetCalculator(0); + ITK_TRY_EXPECT_EXCEPTION(filter->Update()); + + + FilterType::CalculatorType::Pointer calculator = FilterType::CalculatorType::New(); + filter->SetCalculator(calculator); + ITK_TEST_SET_GET_VALUE(calculator, filter->GetCalculator()); + + + ITK_TRY_EXPECT_NO_EXCEPTION(filter->Update()); + + // Regression test: compare computed threshold + auto expectedThreshold = static_cast(std::stod(argv[5])); + FilterType::InputPixelType resultThreshold = filter->GetThreshold(); + if (itk::Math::NotAlmostEquals(expectedThreshold, resultThreshold)) + { + std::cerr << "Test failed!" << std::endl; + std::cerr << "Error in GetThreshold()" << std::endl; + std::cerr << "Expected: " << itk::NumericTraits::PrintType(expectedThreshold) + << ", but got: " << itk::NumericTraits::PrintType(resultThreshold) + << std::endl; + return EXIT_FAILURE; + } + + // Write output image + using WriterType = itk::ImageFileWriter; + WriterType::Pointer writer = WriterType::New(); + writer->SetInput(filter->GetOutput()); writer->SetFileName(argv[2]); - writer->Update(); + ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update()); + + + std::cout << "Test finished" << std::endl; return EXIT_SUCCESS; }