diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMaximumProjectionImageFilter.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMaximumProjectionImageFilter.cpp index bcf0716df5..fd12b0fd66 100644 --- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMaximumProjectionImageFilter.cpp +++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMaximumProjectionImageFilter.cpp @@ -2,6 +2,8 @@ #include "ITKImageProcessing/Common/ITKArrayHelper.hpp" +#include "simplnx/Common/TypesUtility.hpp" +#include "simplnx/DataStructure/IDataArray.hpp" #include "simplnx/Filter/Actions/CreateImageGeometryAction.hpp" #include "simplnx/Parameters/ArraySelectionParameter.hpp" #include "simplnx/Parameters/BoolParameter.hpp" @@ -18,8 +20,15 @@ namespace cxITKMaximumProjectionImageFilter { using ArrayOptionsType = ITK::ScalarPixelIdTypeList; // VectorPixelIDTypeList; + +template +using FilterOutputTypeUI8 = uint8; + template -using FilterOutputType = float; +using FilterOutputTypeUI16 = uint16; + +template +using FilterOutputTypeF32 = float32; struct ITKMaximumProjectionImageFilterFunctor { @@ -132,8 +141,49 @@ IFilter::PreflightResult ITKMaximumProjectionImageFilter::preflightImpl(const Da outputArrayPath = outputGeomPath.createChildPath(originalGeometry.getCellDataPath().getTargetName()).createChildPath(outputArrayName); } - Result helperOutputActions = - ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + Result helperOutputActions = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::uint16: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::float32: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakePreflightErrorResult(-76600, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } + if(helperOutputActions.invalid()) + { + return {std::move(helperOutputActions)}; + } // Consolidate actions resultOutputActions.value().actions.insert(resultOutputActions.value().actions.end(), helperOutputActions.value().actions.begin(), helperOutputActions.value().actions.end()); @@ -164,8 +214,45 @@ Result<> ITKMaximumProjectionImageFilter::executeImpl(DataStructure& dataStructu const cxITKMaximumProjectionImageFilter::ITKMaximumProjectionImageFilterFunctor itkFunctor = {projectionDimension}; - auto result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + Result<> result = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::uint16: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::float32: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakeErrorResult(-76601, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } if(result.invalid()) { return result; diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMedianProjectionImageFilter.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMedianProjectionImageFilter.cpp index 9e7d0fbe7d..c7818264cc 100644 --- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMedianProjectionImageFilter.cpp +++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMedianProjectionImageFilter.cpp @@ -2,6 +2,8 @@ #include "ITKImageProcessing/Common/ITKArrayHelper.hpp" +#include "simplnx/Common/TypesUtility.hpp" +#include "simplnx/DataStructure/IDataArray.hpp" #include "simplnx/Filter/Actions/CreateImageGeometryAction.hpp" #include "simplnx/Parameters/ArraySelectionParameter.hpp" #include "simplnx/Parameters/BoolParameter.hpp" @@ -17,9 +19,19 @@ using namespace nx::core; namespace cxITKMedianProjectionImageFilter { using ArrayOptionsType = ITK::ScalarPixelIdTypeList; + +// Uncommenting below line enables RGB/ARGB images that are currently unsupported +// using ArrayOptionsType = ITK::ArrayOptions, ITK::ArrayUseAllTypes>; // VectorPixelIDTypeList; + +template +using FilterOutputTypeUI8 = uint8; + template -using FilterOutputType = float; +using FilterOutputTypeUI16 = uint16; + +template +using FilterOutputTypeF32 = float32; struct ITKMedianProjectionImageFilterFunctor { @@ -132,8 +144,50 @@ IFilter::PreflightResult ITKMedianProjectionImageFilter::preflightImpl(const Dat outputArrayPath = outputGeomPath.createChildPath(originalGeometry.getCellDataPath().getTargetName()).createChildPath(outputArrayName); } - Result helperOutputActions = - ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + Result helperOutputActions = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::uint16: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::float32: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakePreflightErrorResult(-76590, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } + + if(helperOutputActions.invalid()) + { + return {std::move(helperOutputActions)}; + } // Consolidate actions resultOutputActions.value().actions.insert(resultOutputActions.value().actions.end(), helperOutputActions.value().actions.begin(), helperOutputActions.value().actions.end()); @@ -164,8 +218,45 @@ Result<> ITKMedianProjectionImageFilter::executeImpl(DataStructure& dataStructur const cxITKMedianProjectionImageFilter::ITKMedianProjectionImageFilterFunctor itkFunctor = {projectionDimension}; - auto result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, + Result<> result = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::uint16: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, + itkFunctor, shouldCancel); + break; + } + case DataType::float32: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, + itkFunctor, shouldCancel); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakeErrorResult(-76591, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } if(result.invalid()) { return result; diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMinimumProjectionImageFilter.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMinimumProjectionImageFilter.cpp index aaf3ce7afa..635830c13a 100644 --- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMinimumProjectionImageFilter.cpp +++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKMinimumProjectionImageFilter.cpp @@ -2,6 +2,8 @@ #include "ITKImageProcessing/Common/ITKArrayHelper.hpp" +#include "simplnx/Common/TypesUtility.hpp" +#include "simplnx/DataStructure/IDataArray.hpp" #include "simplnx/Filter/Actions/CreateImageGeometryAction.hpp" #include "simplnx/Parameters/ArraySelectionParameter.hpp" #include "simplnx/Parameters/BoolParameter.hpp" @@ -18,8 +20,15 @@ namespace cxITKMinimumProjectionImageFilter { using ArrayOptionsType = ITK::ScalarPixelIdTypeList; // VectorPixelIDTypeList; + +template +using FilterOutputTypeUI8 = uint8; + template -using FilterOutputType = float; +using FilterOutputTypeUI16 = uint16; + +template +using FilterOutputTypeF32 = float32; struct ITKMinimumProjectionImageFilterFunctor { @@ -132,8 +141,49 @@ IFilter::PreflightResult ITKMinimumProjectionImageFilter::preflightImpl(const Da outputArrayPath = outputGeomPath.createChildPath(originalGeometry.getCellDataPath().getTargetName()).createChildPath(outputArrayName); } - Result helperOutputActions = - ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + Result helperOutputActions = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::uint16: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::float32: { + helperOutputActions = + ITK::DataCheck(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakePreflightErrorResult(-76610, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } + if(helperOutputActions.invalid()) + { + return {std::move(helperOutputActions)}; + } // Consolidate actions resultOutputActions.value().actions.insert(resultOutputActions.value().actions.end(), helperOutputActions.value().actions.begin(), helperOutputActions.value().actions.end()); @@ -164,8 +214,45 @@ Result<> ITKMinimumProjectionImageFilter::executeImpl(DataStructure& dataStructu const cxITKMinimumProjectionImageFilter::ITKMinimumProjectionImageFilterFunctor itkFunctor = {projectionDimension}; - auto result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + Result<> result = {}; + DataType type = dataStructure.getDataAs(selectedInputArray)->getDataType(); + switch(type) + { + case DataType::uint8: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::uint16: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, + outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::float32: { + result = ITK::Execute(dataStructure, selectedInputArray, imageGeomPath, outputArrayPath, itkFunctor, shouldCancel); + break; + } + case DataType::int8: + [[fallthrough]]; + case DataType::int16: + [[fallthrough]]; + case DataType::int32: + [[fallthrough]]; + case DataType::uint32: + [[fallthrough]]; + case DataType::int64: + [[fallthrough]]; + case DataType::uint64: { + [[fallthrough]]; + } + case DataType::float64: { + [[fallthrough]]; + } + case DataType::boolean: { + return MakeErrorResult(-76601, fmt::format("Input {} type is not currently supported. Please reach out to devs if you have a use case.", DataTypeToString(type))); + } + } if(result.invalid()) { return result; diff --git a/src/Plugins/ITKImageProcessing/test/ITKMaximumProjectionImageTest.cpp b/src/Plugins/ITKImageProcessing/test/ITKMaximumProjectionImageTest.cpp index e05bef1ce1..ef274d5fd2 100644 --- a/src/Plugins/ITKImageProcessing/test/ITKMaximumProjectionImageTest.cpp +++ b/src/Plugins/ITKImageProcessing/test/ITKMaximumProjectionImageTest.cpp @@ -151,35 +151,42 @@ TEST_CASE("ITKImageProcessing::ITKMaximumProjectionImageFilter: Image Short Test REQUIRE(md5Hash == "5390344262c91e83bc9208b0991a2fc9"); } -TEST_CASE("ITKImageProcessing::ITKMaximumProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMaximumProjectionImage][defaults]") -{ - DataStructure dataStructure; - const ITKMaximumProjectionImageFilter filter; - - const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); - const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); - const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); - const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; - - { // Start Image Comparison Scope - const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; - Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); - SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) - } // End Image Comparison Scope - - Arguments args; - args.insertOrAssign(ITKMaximumProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); - args.insertOrAssign(ITKMaximumProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); - args.insertOrAssign(ITKMaximumProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); - args.insertOrAssign(ITKMaximumProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); - args.insertOrAssign(ITKMaximumProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); - - auto preflightResult = filter.preflight(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) - - auto executeResult = filter.execute(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) - - const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); - REQUIRE(md5Hash == "92134e0dd38fccdf054ff23e67a72e75"); -} +/** + * TODO: Review RGB/ARGB Image Functionality with Filter + * In the current implementation RGB/ARGB has been disabled due to the inability to validate test case. The below test + * case is an adaptation from SIMPL, however, the MD5 doesn't match. In old SIMPL, when you attempt to replicate pipeline + * an error states it doesn't allow RGB images, however the old test case is passing. For the time being the functionality + * has been disabled. + */ +// TEST_CASE("ITKImageProcessing::ITKMaximumProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMaximumProjectionImage][defaults]") +//{ +// DataStructure dataStructure; +// const ITKMaximumProjectionImageFilter filter; +// +// const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); +// const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); +// const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); +// const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; +// +// { // Start Image Comparison Scope +// const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; +// Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); +// SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) +// } // End Image Comparison Scope +// +// Arguments args; +// args.insertOrAssign(ITKMaximumProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); +// args.insertOrAssign(ITKMaximumProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); +// args.insertOrAssign(ITKMaximumProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); +// args.insertOrAssign(ITKMaximumProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); +// args.insertOrAssign(ITKMaximumProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); +// +// auto preflightResult = filter.preflight(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) +// +// auto executeResult = filter.execute(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) +// +// const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); +// REQUIRE(md5Hash == "92134e0dd38fccdf054ff23e67a72e75"); +// } diff --git a/src/Plugins/ITKImageProcessing/test/ITKMedianProjectionImageTest.cpp b/src/Plugins/ITKImageProcessing/test/ITKMedianProjectionImageTest.cpp index 9f2d5fb3e8..76398a183b 100644 --- a/src/Plugins/ITKImageProcessing/test/ITKMedianProjectionImageTest.cpp +++ b/src/Plugins/ITKImageProcessing/test/ITKMedianProjectionImageTest.cpp @@ -89,7 +89,7 @@ TEST_CASE("ITKImageProcessing::ITKMedianProjectionImageFilter: Dimensional Test" { DataStructure dataStructure; const ITKMedianProjectionImageFilter filter; - + const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); @@ -151,35 +151,42 @@ TEST_CASE("ITKImageProcessing::ITKMedianProjectionImageFilter: Image Short Test" REQUIRE(md5Hash == "9fcc7164f3294811cbf2d875b0e494d1"); } -TEST_CASE("ITKImageProcessing::ITKMedianProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMedianProjectionImage][defaults]") -{ - DataStructure dataStructure; - const ITKMedianProjectionImageFilter filter; - - const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); - const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); - const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); - const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; - - { // Start Image Comparison Scope - const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; - Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); - SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) - } // End Image Comparison Scope - - Arguments args; - args.insertOrAssign(ITKMedianProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); - args.insertOrAssign(ITKMedianProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); - args.insertOrAssign(ITKMedianProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); - args.insertOrAssign(ITKMedianProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); - args.insertOrAssign(ITKMedianProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); - - auto preflightResult = filter.preflight(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) - - auto executeResult = filter.execute(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) - - const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); - REQUIRE(md5Hash == "b66bc7e92a21a33c46d9a334d2292845"); -} +/** + * TODO: Review RGB/ARGB Image Functionality with Filter + * In the current implementation RGB/ARGB has been disabled due to the inability to validate test case. The below test + * case is an adaptation from SIMPL, however, the MD5 doesn't match. In old SIMPL, when you attempt to replicate pipeline + * an error states it doesn't allow RGB images, however the old test case is passing. For the time being the functionality + * has been disabled. + */ +// TEST_CASE("ITKImageProcessing::ITKMedianProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMedianProjectionImage][defaults]") +//{ +// DataStructure dataStructure; +// const ITKMedianProjectionImageFilter filter; +// +// const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); +// const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); +// const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); +// const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; +// +// { // Start Image Comparison Scope +// const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; +// Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); +// SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) +// } // End Image Comparison Scope +// +// Arguments args; +// args.insertOrAssign(ITKMedianProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); +// args.insertOrAssign(ITKMedianProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); +// args.insertOrAssign(ITKMedianProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); +// args.insertOrAssign(ITKMedianProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); +// args.insertOrAssign(ITKMedianProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); +// +// auto preflightResult = filter.preflight(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) +// +// auto executeResult = filter.execute(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) +// +// const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); +// REQUIRE(md5Hash == "b66bc7e92a21a33c46d9a334d2292845"); +// } diff --git a/src/Plugins/ITKImageProcessing/test/ITKMinimumProjectionImageTest.cpp b/src/Plugins/ITKImageProcessing/test/ITKMinimumProjectionImageTest.cpp index 418f943304..f16e3789d2 100644 --- a/src/Plugins/ITKImageProcessing/test/ITKMinimumProjectionImageTest.cpp +++ b/src/Plugins/ITKImageProcessing/test/ITKMinimumProjectionImageTest.cpp @@ -151,35 +151,42 @@ TEST_CASE("ITKImageProcessing::ITKMinimumProjectionImageFilter: Image Short Test REQUIRE(md5Hash == "c4d83f61ffd5cc3a163155bb5d6a0698"); } -TEST_CASE("ITKImageProcessing::ITKMinimumProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMinimumProjectionImage][defaults]") -{ - DataStructure dataStructure; - const ITKMinimumProjectionImageFilter filter; - - const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); - const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); - const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); - const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; - - { // Start Image Comparison Scope - const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; - Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); - SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) - } // End Image Comparison Scope - - Arguments args; - args.insertOrAssign(ITKMinimumProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); - args.insertOrAssign(ITKMinimumProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); - args.insertOrAssign(ITKMinimumProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); - args.insertOrAssign(ITKMinimumProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); - args.insertOrAssign(ITKMinimumProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); - - auto preflightResult = filter.preflight(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) - - auto executeResult = filter.execute(dataStructure, args); - SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) - - const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); - REQUIRE(md5Hash == "344c2d7cf14b5e8b30b266b77a0548c2"); -} +/** + * TODO: Review RGB/ARGB Image Functionality with Filter + * In the current implementation RGB/ARGB has been disabled due to the inability to validate test case. The below test + * case is an adaptation from SIMPL, however, the MD5 doesn't match. In old SIMPL, when you attempt to replicate pipeline + * an error states it doesn't allow RGB images, however the old test case is passing. For the time being the functionality + * has been disabled. + */ +// TEST_CASE("ITKImageProcessing::ITKMinimumProjectionImageFilter: Image RGB Test", "[ITKImageProcessing][ITKMinimumProjectionImage][defaults]") +//{ +// DataStructure dataStructure; +// const ITKMinimumProjectionImageFilter filter; +// +// const DataPath inputGeometryPath({ITKTestBase::k_ImageGeometryPath}); +// const DataPath cellDataPath = inputGeometryPath.createChildPath(ITKTestBase::k_ImageCellDataName); +// const DataPath inputDataPath = cellDataPath.createChildPath(ITKTestBase::k_InputDataName); +// const DataObjectNameParameter::ValueType outputArrayName = ITKTestBase::k_OutputDataPath; +// +// { // Start Image Comparison Scope +// const fs::path inputFilePath = fs::path(unit_test::k_SourceDir.view()) / unit_test::k_DataDir.view() / "JSONFilters" / "Input/VM1111Shrink-RGB.png"; +// Result<> imageReadResult = ITKTestBase::ReadImage(dataStructure, inputFilePath, inputGeometryPath, ITKTestBase::k_ImageCellDataName, ITKTestBase::k_InputDataName); +// SIMPLNX_RESULT_REQUIRE_VALID(imageReadResult) +// } // End Image Comparison Scope +// +// Arguments args; +// args.insertOrAssign(ITKMinimumProjectionImageFilter::k_RemoveOriginalGeometry_Key, std::make_any(true)); +// args.insertOrAssign(ITKMinimumProjectionImageFilter::k_InputImageGeomPath_Key, std::make_any(inputGeometryPath)); +// args.insertOrAssign(ITKMinimumProjectionImageFilter::k_InputImageDataPath_Key, std::make_any(inputDataPath)); +// args.insertOrAssign(ITKMinimumProjectionImageFilter::k_OutputImageArrayName_Key, std::make_any(outputArrayName)); +// args.insertOrAssign(ITKMinimumProjectionImageFilter::k_ProjectionDimension_Key, std::make_any(1)); +// +// auto preflightResult = filter.preflight(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions) +// +// auto executeResult = filter.execute(dataStructure, args); +// SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result) +// +// const std::string md5Hash = ITKTestBase::ComputeMd5Hash(dataStructure, cellDataPath.createChildPath(outputArrayName)); +// REQUIRE(md5Hash == "344c2d7cf14b5e8b30b266b77a0548c2"); +// }