Merge pull request #1386 from thewtex/support-input-transform-type

feat: add itk::wasm::SupportInputTransformTypes

Author: thewtex

ITKKWStyleOverwrite.txt

@@ -5,5 +5,6 @@ itkSupportInputImageTypesMemoryIOTest\.cxx Namespace Disable
 itkSupportInputMeshTypesTest\.cxx Namespace Disable
 itkSupportInputMeshTypesMemoryIOTest\.cxx Namespace Disable
 itkSupportInputPolyDataTypesTest\.cxx Namespace Disable
+itkSupportInputTransformTypesTest\.cxx Namespace Disable
 itkFloatTypesJSON\.h Namespace Disable
 itkOutputTransformIO\.h Namespace Disable

include/itkSupportInputPolyDataTypes.h

@@ -61,7 +61,7 @@ class PipelineFunctor
 
     using InputPolyDataType = itk::wasm::InputPolyData<PolyDataType>;
     InputPolyDataType inputPolyData;
-    pipeline.add_option("InputPolyData", inputPolyData, "The input polydata")->required();
+    pipeline.add_option("input-polydata", inputPolyData, "The input polydata")->required();
 ```
 [...]
 

include/itkSupportInputTransformTypes.h

@@ -0,0 +1,168 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef itkSupportInputTransformTypes_h
+#define itkSupportInputTransformTypes_h
+#include "itkPipeline.h"
+#include "itkWasmPixelTypeFromIOPixelEnum.h"
+#include "itkWasmComponentTypeFromIOComponentEnum.h"
+#include "itkWasmMapComponentType.h"
+
+#include "itkTransform.h"
+#include "itkTransformIOBase.h"
+#include "itkTransformIOFactory.h"
+#include "WebAssemblyInterfaceExport.h"
+
+#include "itkTransformJSON.h"
+
+namespace itk
+{
+
+WebAssemblyInterface_EXPORT bool
+lexical_cast(const std::string & input, TransformTypeJSON & transformType);
+
+namespace wasm
+{
+
+/** \class SupportInputTransformTypes
+ *
+ * \brief Instantiatiate a Pipeline functor over multiple transform parameter types and dimensions and match to the input transform type.
+ *
+ *  Instantiate the PipelineFunctor (function object) over multiple transform types.
+ *  If the input transform matches these parameter types and dimensions, use the compile-time optimized pipeline for that transform type.
+ *  Otherwise, exit the pipeline with an error identifying the unsupported transform type.
+ *
+ * Example usage:
+ *
+```
+template<typename TTransform>
+class PipelineFunctor
+{
+public:
+  int operator()(itk::wasm::Pipeline & pipeline)
+  {
+    using TransformType = TTransform;
+
+    using InputTransformType = itk::wasm::InputTransform<TransformType>;
+    InputTransformType inputTransform;
+    pipeline.add_option("input-transform", inputTransform, "The input polydata")->required();
+```
+[...]
+
+```
+int
+main(int argc, char * argv[])
+{
+  itk::wasm::Pipeline pipeline("support-multiple", "Test supporting multiple input polydata types", argc, argv);
+
+  // Supports the parameters types float, double, and dimensions 2 and 3
+  return itk::wasm::SupportInputTransformTypes<PipelineFunctor, float, double>
+  ::Dimensions<2U, 3U>("input-transform", pipeline);
+}
+```
+ * It is assumed that the input dimension and output dimension will be the same.
+ *
+ * \ingroup WebAssemblyInterface
+ */
+template <template <typename TTransform> class TPipelineFunctor, typename... TParameterValuesSupported>
+class SupportInputTransformTypes
+{
+public:
+  template <unsigned int... VDimensions>
+  static int
+  Dimensions(const std::string & inputTransformOptionName, Pipeline & pipeline)
+  {
+    TransformTypeJSON transformType;
+
+    const auto iwpArgc = pipeline.get_argc();
+    const auto iwpArgv = pipeline.get_argv();
+    bool       passThrough = false;
+    for (int ii = 0; ii < iwpArgc; ++ii)
+    {
+      const std::string arg(iwpArgv[ii]);
+      if (arg == "-h" || arg == "--help" || arg == "--interface-json" || arg == "--version")
+      {
+        passThrough = true;
+      }
+    }
+    if (passThrough)
+    {
+      return IterateDimensions<VDimensions...>(pipeline, transformType, passThrough);
+    }
+
+    auto tempOption = pipeline.add_option(inputTransformOptionName, transformType, "Read Transform type.");
+
+    ITK_WASM_PRE_PARSE(pipeline);
+
+    pipeline.remove_option(tempOption);
+
+    return IterateDimensions<VDimensions...>(pipeline, transformType);
+  }
+
+private:
+  template <unsigned int VDimension, typename TParameterValues, typename... TParameterValuesRest>
+  static int
+  IterateParameterValueTypes(Pipeline & pipeline, const TransformTypeJSON & transformType, bool passThrough = false)
+  {
+    using ParameterValueType = TParameterValues;
+
+    if (passThrough ||
+        transformType.parametersValueType == MapComponentType<ParameterValueType>::JSONFloatTypeEnum)
+    {
+      using TransformType = Transform<ParameterValueType, VDimension, VDimension>;
+
+      using PipelineType = TPipelineFunctor<TransformType>;
+      return PipelineType()(pipeline);
+    }
+
+    if constexpr (sizeof...(TParameterValuesRest) > 0)
+    {
+      return IterateParameterValueTypes<VDimension, TParameterValuesRest...>(pipeline, transformType);
+    }
+
+    std::ostringstream ostrm;
+    std::string        transformTypeString = glz::write_json(transformType).value_or("error");
+    ostrm << "Unsupported transform type: " << transformTypeString << std::endl;
+    CLI::Error err("Runtime error", ostrm.str(), 1);
+    return pipeline.exit(err);
+  }
+
+  template <unsigned int VDimension, unsigned int... VDimensions>
+  static int
+  IterateDimensions(Pipeline & pipeline, const TransformTypeJSON & transformType, bool passThrough = false)
+  {
+    if (passThrough || VDimension == transformType.inputDimension)
+    {
+      return IterateParameterValueTypes<VDimension, TParameterValuesSupported...>(pipeline, transformType);
+    }
+
+    if constexpr (sizeof...(VDimensions) > 0)
+    {
+      return IterateDimensions<VDimensions...>(pipeline, transformType);
+    }
+
+    std::ostringstream ostrm;
+    ostrm << "Unsupported transform dimension: " << transformType.inputDimension;
+    CLI::Error err("Runtime error", ostrm.str(), 1);
+    return pipeline.exit(err);
+  }
+};
+
+} // end namespace wasm
+} // end namespace itk
+
+#endif

include/itkWasmTransformIO.h

@@ -32,8 +32,8 @@ namespace itk
  *
  * \brief Read and write the an itk::Transform in a format for interfacing in WebAssembly (Wasm).
  *
- * This format is intended to facilitate data exchange in itk-wasm.
- * It reads and writes an itk-wasm Transform object where TypedArrays are
+ * This format is intended to facilitate data exchange in ITK-Wasm.
+ * It reads and writes an ITK-Wasm Transform object where TypedArrays are
  * replaced by binary files on the filesystem or in a CBOR file.
  *
  * The file extensions used are .iwt and .iwt.cbor.

src/CMakeLists.txt

@@ -25,6 +25,7 @@ set(WebAssemblyInterface_SRCS
   itkSupportInputImageTypes.cxx
   itkSupportInputMeshTypes.cxx
   itkSupportInputPolyDataTypes.cxx
+  itkSupportInputTransformTypes.cxx
   itktransformParameterizationString.cxx
   itkioComponentEnumFromJSON.cxx
   itkioPixelEnumFromJSON.cxx

src/itkSupportInputTransformTypes.cxx

@@ -0,0 +1,85 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+#include "itkSupportInputTransformTypes.h"
+#include "itkWasmExports.h"
+
+#include "itkjsonFromIOComponentEnum.h"
+#include "itkjsonFromIOPixelEnum.h"
+#include "itkTransformJSON.h"
+
+namespace itk
+{
+
+bool
+lexical_cast(const std::string & input, TransformTypeJSON & transformType)
+{
+  if (wasm::Pipeline::get_use_memory_io())
+  {
+#ifndef ITK_WASM_NO_MEMORY_IO
+    const unsigned int index = std::stoi(input);
+    auto               json = wasm::getMemoryStoreInputJSON(0, index);
+    std::string        deserialized;
+    auto               deserializedAttempt = glz::read_json<itk::TransformJSON>(json);
+    if (!deserializedAttempt)
+    {
+      const std::string descriptiveError = glz::format_error(deserializedAttempt, json);
+      throw std::runtime_error("Failed to deserialize TransformJSON: " + descriptiveError);
+    }
+    auto transformJSON = deserializedAttempt.value();
+    transformType = transformJSON.transformType;
+#else
+    return false;
+#endif
+  }
+  else
+  {
+#ifndef ITK_WASM_NO_FILESYSTEM_IO
+    using TransformIOFactoryFloatType = itk::TransformIOFactoryTemplate<float>;
+    TransformIOBaseTemplate<float>::Pointer transformIOFloat = TransformIOFactoryFloatType::CreateTransformIO(input.c_str(), CommonEnums::IOFileMode::ReadMode);
+    if (transformIOFloat.IsNull())
+    {
+      std::cerr << "IO not available for: " << input << std::endl;
+      return false;
+    }
+
+    transformIOFloat->SetFileName(input);
+    transformIOFloat->Read();
+
+    const auto transformList = transformIOFloat->GetReadTransformList();
+    const auto firstTransform = transformList.front();
+    const std::string transformName = firstTransform->GetTransformTypeAsString();
+    // if the transformName contains "float", then set the transformType to float
+    if (transformName.find("float") != std::string::npos)
+    {
+      transformType.parametersValueType = JSONFloatTypesEnum::float32;
+    }
+    else
+    {
+      transformType.parametersValueType = JSONFloatTypesEnum::float64;
+    }
+    transformType.inputDimension = firstTransform->GetInputSpaceDimension();
+    transformType.outputDimension = firstTransform->GetOutputSpaceDimension();
+    // transformType.transformParameterization = firstTransform->GetNameOfClass();
+#else
+    return false;
+#endif
+  }
+  return true;
+}
+
+} // end namespace itk

test/CMakeLists.txt

@@ -70,6 +70,7 @@ set(WebAssemblyInterfaceTests
   itkSupportInputMeshTypesTest.cxx
   itkSupportInputMeshTypesMemoryIOTest.cxx
   itkSupportInputPolyDataTypesTest.cxx
+  itkSupportInputTransformTypesTest.cxx
   itkTransformJSONTest.cxx
   itkWasmTransformInterfaceTest.cxx
   itkWasmTransformInterfaceCompositeTest.cxx
@@ -287,6 +288,13 @@ itk_add_test(NAME itkSupportInputPolyDataTypesTest
       ${ITK_TEST_OUTPUT_DIR}/itkSupportInputPolyDataTypesTest.iwm
 )
 
+itk_add_test(NAME itkSupportInputTransformTypesTest
+    COMMAND WebAssemblyInterfaceTestDriver
+    itkSupportInputTransformTypesTest
+      DATA{Input/LinearTransform.iwt.cbor}
+      ${ITK_TEST_OUTPUT_DIR}/itkSupportInputTransformTypesTest.iwt
+)
+
 itk_add_test(NAME itkTransformJSONTest
     COMMAND WebAssemblyInterfaceTestDriver
     itkTransformJSONTest

test/Input/LinearTransform.iwt.cbor.cid

@@ -0,0 +1 @@
+bafkreib3spljpfflhairm3aooy4pwkgcczwm7z6ksnzntg7ui7xbyeqllu

test/itkSupportInputPolyDataTypesTest.cxx

@@ -53,7 +53,7 @@ int
 itkSupportInputPolyDataTypesTest(int argc, char * argv[])
 {
   itk::wasm::Pipeline pipeline(
-    "support-input-polydata-types-test", "Test supporting multiple input mesh types", argc, argv);
+    "support-input-polydata-types-test", "Test supporting multiple input polydata types", argc, argv);
 
   itk::WasmMeshIOFactory::RegisterOneFactory();
 

test/itkSupportInputTransformTypesTest.cxx

@@ -0,0 +1,62 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+
+#include "itkPipeline.h"
+#include "itkInputTransform.h"
+#include "itkOutputTransform.h"
+#include "itkSupportInputTransformTypes.h"
+#include "itkWasmTransformIOFactory.h"
+#include "itkAffineTransform.h"
+
+template <typename TTransform>
+class PipelineFunctor
+{
+public:
+  int
+  operator()(itk::wasm::Pipeline & pipeline)
+  {
+    using TransformType = itk::AffineTransform<typename TTransform::ParametersValueType, TTransform::InputSpaceDimension>;
+
+    using InputTransformType = itk::wasm::InputTransform<TransformType>;
+    InputTransformType inputTransform;
+    pipeline.add_option("input-transform", inputTransform, "The input transform")->required()->type_name("INPUT_TRANSFORM");
+
+    using OutputTransformType = itk::wasm::OutputTransform<TransformType>;
+    OutputTransformType outputTransform;
+    pipeline.add_option("output-transform", outputTransform, "The output transform")
+      ->required()
+      ->type_name("OUTPUT_TRANSFORM");
+
+    ITK_WASM_PARSE(pipeline);
+
+    outputTransform.Set(inputTransform.Get());
+
+    return EXIT_SUCCESS;
+  }
+};
+
+int
+itkSupportInputTransformTypesTest(int argc, char * argv[])
+{
+  itk::wasm::Pipeline pipeline(
+    "support-input-transform-types-test", "Test supporting multiple input transform types", argc, argv);
+
+  itk::WasmTransformIOFactory::RegisterOneFactory();
+
+  return itk::wasm::SupportInputTransformTypes<PipelineFunctor, float, double>::Dimensions<2U, 3U>("input-transform", pipeline);
+}