mesh filters

include/itkMeshJSON.h

@@ -27,6 +27,7 @@
 #include "itkPixelTypesJSON.h"
 #include "itkWasmMesh.h"
 #include "itkMetaDataDictionaryJSON.h"
+#include "itkQuadEdge.h"
 
 #include "glaze/glaze.hpp"
 
@@ -172,6 +173,100 @@ auto meshToMeshJSON(const TMesh * mesh, const WasmMesh<TMesh> * wasmMesh, bool i
 
   return meshJSON;
 }
+
+template <typename TPixel, unsigned int VDimension>
+auto meshToMeshJSON(const QuadEdgeMesh<TPixel, VDimension> * mesh, const WasmMesh<QuadEdgeMesh<TPixel, VDimension>> * wasmMesh, bool inMemory) -> MeshJSON
+{
+  using MeshType = QuadEdgeMesh<TPixel, VDimension>;
+
+  MeshJSON meshJSON;
+
+  meshJSON.meshType.dimension = MeshType::PointDimension;
+
+  meshJSON.meshType.pointComponentType = wasm::MapComponentType<typename MeshType::CoordRepType>::JSONFloatTypeEnum;
+  using PointPixelType = typename MeshType::PixelType;
+  using ConvertPointPixelTraits = MeshConvertPixelTraits<PointPixelType>;
+  meshJSON.meshType.pointPixelComponentType = wasm::MapComponentType<typename ConvertPointPixelTraits::ComponentType>::JSONComponentEnum;
+  meshJSON.meshType.pointPixelType = wasm::MapPixelType<PointPixelType>::JSONPixelEnum;
+  meshJSON.meshType.pointPixelComponents = ConvertPointPixelTraits::GetNumberOfComponents();
+  meshJSON.meshType.cellComponentType = wasm::MapComponentType<typename MeshType::CellIdentifier>::JSONIntTypeEnum;
+  using CellPixelType = typename MeshType::CellPixelType;
+  using ConvertCellPixelTraits = MeshConvertPixelTraits<CellPixelType>;
+  meshJSON.meshType.cellPixelComponentType = wasm::MapComponentType<typename ConvertPointPixelTraits::ComponentType>::JSONComponentEnum;
+  meshJSON.meshType.cellPixelType = wasm::MapPixelType<CellPixelType>::JSONPixelEnum;
+  meshJSON.meshType.cellPixelComponents = ConvertCellPixelTraits::GetNumberOfComponents();
+
+  meshJSON.name = mesh->GetObjectName();
+  meshJSON.numberOfPoints = mesh->GetNumberOfPoints();
+  if (mesh->GetPointData() == nullptr)
+  {
+    meshJSON.numberOfPointPixels = 0;
+  }
+  else
+  {
+    meshJSON.numberOfPointPixels = mesh->GetPointData()->Size();
+  }
+  meshJSON.numberOfCells = mesh->GetNumberOfCells();
+  if (mesh->GetCellData() == nullptr)
+  {
+    meshJSON.numberOfCellPixels = 0;
+  }
+  else
+  {
+    meshJSON.numberOfCellPixels = mesh->GetCellData()->Size();
+  }
+  if (inMemory)
+  {
+    meshJSON.cellBufferSize = wasmMesh->GetCellBuffer()->Size();
+
+    const auto pointsAddress = reinterpret_cast< size_t >( &(wasmMesh->GetPointsBuffer().at(0)) );
+    std::ostringstream pointsStream;
+    pointsStream << "data:application/vnd.itk.address,0:";
+    pointsStream << pointsAddress;
+    meshJSON.points = pointsStream.str();
+    size_t cellsAddress = 0;
+    if (mesh->GetNumberOfCells() > 0)
+    {
+      cellsAddress = reinterpret_cast< size_t >( &(wasmMesh->GetCellBuffer()->at(0)) );
+    }
+    std::ostringstream cellsStream;
+    cellsStream << "data:application/vnd.itk.address,0:";
+    cellsStream << cellsAddress;
+    meshJSON.cells = cellsStream.str();
+
+    size_t pointDataAddress = 0;
+    if (mesh->GetPointData() != nullptr && mesh->GetPointData()->Size() > 0)
+    {
+      pointDataAddress = reinterpret_cast< size_t >( &(wasmMesh->GetPointDataBuffer().at(0)) );
+    }
+    std::ostringstream pointDataStream;
+    pointDataStream << "data:application/vnd.itk.address,0:";
+    pointDataStream << pointDataAddress;
+    meshJSON.pointData = pointDataStream.str();
+
+    size_t cellDataAddress = 0;
+    if (mesh->GetCellData() != nullptr && mesh->GetCellData()->Size() > 0)
+    {
+      cellDataAddress = reinterpret_cast< size_t >( &(wasmMesh->GetCellDataBuffer().at(0)) );
+    }
+    std::ostringstream cellDataStream;
+    cellDataStream <<  "data:application/vnd.itk.address,0:";
+    cellDataStream << cellDataAddress;
+    meshJSON.cellData = cellDataStream.str();
+  }
+  else
+  {
+    meshJSON.points = "data:application/vnd.itk.path,data/points.raw";
+    meshJSON.cells = "data:application/vnd.itk.path,data/cells.raw";
+    meshJSON.pointData = "data:application/vnd.itk.path,data/point-data.raw";
+    meshJSON.cellData = "data:application/vnd.itk.path,data/cell-data.raw";
+  }
+
+  auto dictionary = mesh->GetMetaDataDictionary();
+  metaDataDictionaryToJSON(dictionary, meshJSON.metadata);
+
+  return meshJSON;
+}
 } // end namespace itk
 
 #endif // itkMeshJSON_h

include/itkMeshToWasmMeshFilter.h

@@ -21,6 +21,7 @@
 #include "itkProcessObject.h"
 #include "itkWasmMesh.h"
 #include "itkMeshJSON.h"
+#include "itkQuadEdgeMesh.h"
 
 namespace itk
 {
@@ -76,6 +77,71 @@ class ITK_TEMPLATE_EXPORT MeshToWasmMeshFilter : public ProcessObject
   WasmMeshType *
   GetOutput(unsigned int idx);
 
+protected:
+  MeshToWasmMeshFilter();
+  ~MeshToWasmMeshFilter() override = default;
+
+  ProcessObject::DataObjectPointer
+  MakeOutput(ProcessObject::DataObjectPointerArraySizeType idx) override;
+  ProcessObject::DataObjectPointer
+  MakeOutput(const ProcessObject::DataObjectIdentifierType &) override;
+
+  void
+  GenerateOutputInformation() override
+  {} // do nothing
+  void
+  GenerateData() override;
+
+  void
+  PrintSelf(std::ostream & os, Indent indent) const override;
+};
+
+template <typename TPixel, unsigned int VDimension>
+class ITK_TEMPLATE_EXPORT MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>> : public ProcessObject
+{
+public:
+  ITK_DISALLOW_COPY_AND_MOVE(MeshToWasmMeshFilter);
+
+  /** Standard class type aliases. */
+  using Self = MeshToWasmMeshFilter;
+  using Superclass = ProcessObject;
+  using Pointer = SmartPointer<Self>;
+  using ConstPointer = SmartPointer<const Self>;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(MeshToWasmMeshFilter, ProcessObject);
+
+  using DataObjectIdentifierType = Superclass::DataObjectIdentifierType;
+  using DataObjectPointerArraySizeType = Superclass::DataObjectPointerArraySizeType;
+
+  using MeshType = QuadEdgeMesh<TPixel, VDimension>;
+  using WasmMeshType = WasmMesh<MeshType>;
+
+  /** Set/Get the path input of this process object.  */
+  using Superclass::SetInput;
+  virtual void
+  SetInput(const MeshType * mesh);
+
+  virtual void
+  SetInput(unsigned int, const MeshType * mesh);
+
+  const MeshType *
+  GetInput();
+
+  const MeshType *
+  GetInput(unsigned int idx);
+
+  WasmMeshType *
+  GetOutput();
+  const WasmMeshType *
+  GetOutput() const;
+
+  WasmMeshType *
+  GetOutput(unsigned int idx);
+
 protected:
   MeshToWasmMeshFilter();
   ~MeshToWasmMeshFilter() override = default;

include/itkMeshToWasmMeshFilter.hxx

@@ -147,6 +147,130 @@ MeshToWasmMeshFilter<TMesh>
 {
   Superclass::PrintSelf(os, indent);
 }
+
+template <typename TPixel, unsigned int VDimension>
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::MeshToWasmMeshFilter()
+{
+  this->SetNumberOfRequiredInputs(1);
+
+  typename WasmMeshType::Pointer output = static_cast<WasmMeshType *>(this->MakeOutput(0).GetPointer());
+  this->ProcessObject::SetNumberOfRequiredOutputs(1);
+  this->ProcessObject::SetNthOutput(0, output.GetPointer());
+}
+
+template <typename TPixel, unsigned int VDimension>
+ProcessObject::DataObjectPointer
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::MakeOutput(ProcessObject::DataObjectPointerArraySizeType)
+{
+  return WasmMeshType::New().GetPointer();
+}
+
+template <typename TPixel, unsigned int VDimension>
+ProcessObject::DataObjectPointer
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::MakeOutput(const ProcessObject::DataObjectIdentifierType &)
+{
+  return WasmMeshType::New().GetPointer();
+}
+
+template <typename TPixel, unsigned int VDimension>
+auto
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GetOutput() -> WasmMeshType *
+{
+  // we assume that the first output is of the templated type
+  return itkDynamicCastInDebugMode<WasmMeshType *>(this->GetPrimaryOutput());
+}
+
+template <typename TPixel, unsigned int VDimension>
+auto
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GetOutput() const -> const WasmMeshType *
+{
+  // we assume that the first output is of the templated type
+  return itkDynamicCastInDebugMode<const WasmMeshType *>(this->GetPrimaryOutput());
+}
+
+template <typename TPixel, unsigned int VDimension>
+auto
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GetOutput(unsigned int idx) -> WasmMeshType *
+{
+  auto * out = dynamic_cast<WasmMeshType *>(this->ProcessObject::GetOutput(idx));
+
+  if (out == nullptr && this->ProcessObject::GetOutput(idx) != nullptr)
+  {
+    itkWarningMacro(<< "Unable to convert output number " << idx << " to type " << typeid(WasmMeshType).name());
+  }
+  return out;
+}
+
+template <typename TPixel, unsigned int VDimension>
+void
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::SetInput(const MeshType * input)
+{
+  // Process object is not const-correct so the const_cast is required here
+  this->ProcessObject::SetNthInput(0, const_cast<MeshType *>(input));
+}
+
+template <typename TPixel, unsigned int VDimension>
+void
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::SetInput(unsigned int index, const MeshType * mesh)
+{
+  // Process object is not const-correct so the const_cast is required here
+  this->ProcessObject::SetNthInput(index, const_cast<MeshType *>(mesh));
+}
+
+template <typename TPixel, unsigned int VDimension>
+const typename MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>::MeshType *
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GetInput()
+{
+  return itkDynamicCastInDebugMode<const MeshType *>(this->GetPrimaryInput());
+}
+
+template <typename TPixel, unsigned int VDimension>
+const typename MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>::MeshType *
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GetInput(unsigned int idx)
+{
+  return itkDynamicCastInDebugMode<const MeshType *>(this->ProcessObject::GetInput(idx));
+}
+
+template <typename TPixel, unsigned int VDimension>
+void
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::GenerateData()
+{
+  // Get the input and output pointers
+  const MeshType * mesh = this->GetInput();
+  WasmMeshType * wasmMesh = this->GetOutput();
+
+  wasmMesh->SetMesh(mesh);
+  constexpr bool inMemory = true;
+  const auto meshJSON = meshToMeshJSON<TPixel, VDimension>(mesh, wasmMesh, inMemory);
+  std::string serialized{};
+  auto ec = glz::write<glz::opts{ .prettify = true }>(meshJSON, serialized);
+  if (ec)
+  {
+    itkExceptionMacro("Failed to serialize MeshJSON");
+  }
+
+  wasmMesh->SetJSON(serialized);
+}
+
+template <typename TPixel, unsigned int VDimension>
+void
+MeshToWasmMeshFilter<QuadEdgeMesh<TPixel, VDimension>>
+::PrintSelf(std::ostream & os, Indent indent) const
+{
+  Superclass::PrintSelf(os, indent);
+}
+
 } // end namespace itk
 
 #endif