Add support for temporal mesh in vtkF3DMemoryMesh and scene API

0xfedcafe · 0xfedcafe · commit ff3de6e2edcc · 2025-11-06T15:51:31.000+01:00
diff --git a/library/private/scene_impl.h b/library/private/scene_impl.h
@@ -34,7 +34,7 @@ class scene_impl : public scene
   scene& add(const std::filesystem::path& filePath) override;
   scene& add(const std::vector<std::filesystem::path>& filePath) override;
   scene& add(const std::vector<std::string>& filePathStrings) override;
-  scene& add(const mesh_t& mesh) override;
+  scene& add(const mesh_t& mesh, const double timeStamp = 0) override;
   scene& clear() override;
   int addLight(const light_state_t& lightState) const override;
   int getLightCount() const override;
diff --git a/library/public/scene.h b/library/public/scene.h
@@ -60,7 +60,7 @@ class F3D_EXPORT scene
   /**
    * Add and load provided mesh into the scene
    */
-  virtual scene& add(const mesh_t& mesh) = 0;
+  virtual scene& add(const mesh_t& mesh, const double timeStamp = 0) = 0;
 
   ///@{
   /**
diff --git a/library/src/scene_impl.cxx b/library/src/scene_impl.cxx
@@ -192,6 +192,9 @@ class scene_impl::internals
   animationManager AnimationManager;
 
   vtkNew<vtkF3DMetaImporter> MetaImporter;
+  vtkNew<vtkF3DMemoryMesh> VtkSource;
+  vtkNew<vtkF3DGenericImporter> MemoryMeshImporter;
+  bool MemoryMeshLoaded;
 };
 
 //----------------------------------------------------------------------------
@@ -296,7 +299,7 @@ scene& scene_impl::add(const std::vector<fs::path>& filePaths)
 }
 
 //----------------------------------------------------------------------------
-scene& scene_impl::add(const mesh_t& mesh)
+scene& scene_impl::add(const mesh_t& mesh, const double timeStamp)
 {
   // sanity checks
   auto [valid, err] = mesh.isValid();
@@ -305,17 +308,32 @@ scene& scene_impl::add(const mesh_t& mesh)
     throw scene::load_failure_exception(err);
   }
 
-  vtkNew<vtkF3DMemoryMesh> vtkSource;
-  vtkSource->SetPoints(mesh.points);
-  vtkSource->SetNormals(mesh.normals);
-  vtkSource->SetTCoords(mesh.texture_coordinates);
-  vtkSource->SetFaces(mesh.face_sides, mesh.face_indices);
-
-  vtkSmartPointer<vtkF3DGenericImporter> importer = vtkSmartPointer<vtkF3DGenericImporter>::New();
-  importer->SetInternalReader(vtkSource);
+  auto& memoryMesh = Internals->VtkSource;
+  auto& importer = this->Internals->MemoryMeshImporter;
 
   log::debug("Loading 3D scene from memory");
-  this->Internals->Load({ importer });
+
+  memoryMesh->SetPoints(mesh.points, timeStamp);
+  memoryMesh->SetNormals(mesh.normals, timeStamp);
+  memoryMesh->SetTCoords(mesh.texture_coordinates, timeStamp);
+  memoryMesh->SetFaces(mesh.face_sides, mesh.face_indices, timeStamp);
+
+  if (!this->Internals->MemoryMeshLoaded)
+  {
+    importer->SetInternalReader(memoryMesh);
+    Internals->Load({ importer });
+    this->Internals->MemoryMeshLoaded = true;
+  }
+  else
+  {
+    memoryMesh->Modified();
+    memoryMesh->Update();
+
+    importer->Modified();
+    importer->Update();
+    this->Internals->AnimationManager.Initialize();
+  }
+
   return *this;
 }
 
@@ -327,7 +345,6 @@ scene& scene_impl::clear()
 
   // Clear the window of all actors
   this->Internals->Window.Initialize();
-
   return *this;
 }
 
diff --git a/library/testing/CMakeLists.txt b/library/testing/CMakeLists.txt
@@ -10,6 +10,7 @@ list(APPEND libf3dSDKTests_list
      TestSDKInteractorDropFullScene.cxx
      TestSDKInteractorCommand.cxx
      TestSDKSceneFromMemory.cxx
+     TestSDKSceneTemporalFromMemory.cxx
      TestSDKScene.cxx
      TestSDKLog.cxx
      TestSDKMultiColoring.cxx
diff --git a/library/testing/TestSDKSceneTemporalFromMemory.cxx b/library/testing/TestSDKSceneTemporalFromMemory.cxx
@@ -0,0 +1,83 @@
+#include "PseudoUnitTest.h"
+
+#include <engine.h>
+#include <image.h>
+#include <log.h>
+#include <scene.h>
+#include <window.h>
+
+#include <cmath>
+#include <sstream>
+#include <string>
+#include <vector>
+
+int TestSDKSceneTemporalFromMemory([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
+{
+  PseudoUnitTest test;
+
+  f3d::log::setVerboseLevel(f3d::log::VerboseLevel::DEBUG);
+  f3d::engine eng = f3d::engine::create(true);
+  f3d::scene& sce = eng.getScene();
+  f3d::window& win = eng.getWindow().setSize(300, 300);
+
+  std::string texturePath = std::string(argv[1]) + "data/world.png";
+  eng.getOptions().model.color.texture = texturePath;
+  const std::string outputPath = std::string(argv[2]);
+  const std::string frame0Path = outputPath + "TestSDKSceneTemporalFromMemory_frame0.png";
+  const std::string frame1Path = outputPath + "TestSDKSceneTemporalFromMemory_frame1.png";
+
+  const std::vector<float> basePoints{ 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 1.f, 0.f, 0.f, 1.f, 1.f, 0.f };
+  const std::vector<float> translatedPoints{ 0.25f, 0.f, 0.f, 0.25f, 1.f, 0.f, 1.25f, 0.f, 0.f,
+    1.25f, 1.f, 0.f };
+  const std::vector<float> normals{ 0.f, 0.f, -1.f, 0.f, 0.f, -1.f, 0.f, 0.f, -1.f, 0.f, 0.f,
+    -1.f };
+  const std::vector<float> tcoords{ 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f };
+  const std::vector<unsigned int> faceSides{ 3, 3 };
+  const std::vector<unsigned int> faceIndices{ 0, 1, 2, 1, 3, 2 };
+
+  f3d::mesh_t meshFrame0{ basePoints, normals, tcoords, faceSides, faceIndices };
+  f3d::mesh_t meshFrame1{ translatedPoints, normals, tcoords, faceSides, faceIndices };
+
+  test("add temporal mesh sequence", [&]() {
+    sce.add(meshFrame0, 0.0);
+    sce.add(meshFrame1, 1.0);
+  });
+
+  test("animation time range", [&]() {
+    auto range = sce.animationTimeRange();
+    return std::abs(range.first - 0.0) < 1e-6 && std::abs(range.second - 1.0) < 1e-6;
+  });
+
+  const std::string baselinePath = std::string(argv[1]) + "baselines/TestSDKSceneFromMemory.png";
+  test("qualitative baseline comparison", [&]() {
+    sce.loadAnimationTime(0.0);
+    f3d::image frame0 = win.renderToImage();
+    frame0.save(frame0Path);
+    f3d::image baseline(baselinePath);
+    double error = frame0.compare(baseline);
+    if (error > 0.05)
+    {
+      std::ostringstream stream;
+      stream << "baseline difference is " << error;
+      throw stream.str();
+    }
+  });
+
+  test("quantitative temporal difference", [&]() {
+    sce.loadAnimationTime(0.0);
+    f3d::image frame0 = win.renderToImage();
+    frame0.save(frame0Path);
+    sce.loadAnimationTime(1.0);
+    f3d::image frame1 = win.renderToImage();
+    frame1.save(frame1Path);
+    double error = frame0.compare(frame1);
+    if (error <= 0.01)
+    {
+      std::ostringstream stream;
+      stream << "frame delta is " << error;
+      throw stream.str();
+    }
+  });
+
+  return test.result();
+}
diff --git a/vtkext/private/module/vtkF3DMemoryMesh.cxx b/vtkext/private/module/vtkF3DMemoryMesh.cxx
@@ -1,14 +1,13 @@
 #include "vtkF3DMemoryMesh.h"
 
-#include "vtkDataArrayRange.h"
 #include "vtkFloatArray.h"
 #include "vtkIdTypeArray.h"
 #include "vtkInformationVector.h"
 #include "vtkObjectFactory.h"
 #include "vtkPointData.h"
 #include "vtkSMPTools.h"
-
-#include <numeric>
+#include <vtkInformation.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
 
 vtkStandardNewMacro(vtkF3DMemoryMesh);
 
@@ -46,30 +45,30 @@ vtkF3DMemoryMesh::vtkF3DMemoryMesh()
 vtkF3DMemoryMesh::~vtkF3DMemoryMesh() = default;
 
 //------------------------------------------------------------------------------
-void vtkF3DMemoryMesh::SetPoints(const std::vector<float>& positions)
+void vtkF3DMemoryMesh::SetPoints(const std::vector<float>& positions, const double timeStamp)
 {
   vtkNew<vtkPoints> points;
   points->SetDataTypeToFloat();
   points->SetData(ConvertToFloatArray<3>(positions));
 
-  this->Mesh->SetPoints(points);
+  this->Meshes[timeStamp]->SetPoints(points);
 }
 
 //------------------------------------------------------------------------------
-void vtkF3DMemoryMesh::SetNormals(const std::vector<float>& normals)
+void vtkF3DMemoryMesh::SetNormals(const std::vector<float>& normals, const double timeStamp)
 {
-  this->Mesh->GetPointData()->SetNormals(ConvertToFloatArray<3>(normals));
+  this->Meshes[timeStamp]->GetPointData()->SetNormals(ConvertToFloatArray<3>(normals));
 }
 
 //------------------------------------------------------------------------------
-void vtkF3DMemoryMesh::SetTCoords(const std::vector<float>& tcoords)
+void vtkF3DMemoryMesh::SetTCoords(const std::vector<float>& tcoords, const double timeStamp)
 {
-  this->Mesh->GetPointData()->SetTCoords(ConvertToFloatArray<2>(tcoords));
+  this->Meshes[timeStamp]->GetPointData()->SetTCoords(ConvertToFloatArray<2>(tcoords));
 }
 
 //------------------------------------------------------------------------------
-void vtkF3DMemoryMesh::SetFaces(
-  const std::vector<unsigned int>& faceSizes, const std::vector<unsigned int>& faceIndices)
+void vtkF3DMemoryMesh::SetFaces(const std::vector<unsigned int>& faceSizes,
+  const std::vector<unsigned int>& faceIndices, const double timeStamp)
 {
   vtkNew<vtkIdTypeArray> offsets;
   vtkNew<vtkIdTypeArray> connectivity;
@@ -97,16 +96,44 @@ void vtkF3DMemoryMesh::SetFaces(
   vtkNew<vtkCellArray> polys;
   polys->SetData(offsets, connectivity);
 
-  this->Mesh->SetPolys(polys);
+  this->Meshes[timeStamp]->SetPolys(polys);
+}
+
+//------------------------------------------------------------------------------
+int vtkF3DMemoryMesh::RequestInformation(vtkInformation* vtkNotUsed(request),
+  vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* outputVector)
+{
+  // timeRange = {map_min, map_max}, map_min always <= map_max
+  const auto timeRange = std::array<double, 2>{ Meshes.begin()->first, Meshes.rbegin()->first };
+
+  vtkInformation* outInfo = outputVector->GetInformationObject(0);
+  outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_RANGE(), timeRange.data(), 2);
+
+  return 1;
 }
 
 //------------------------------------------------------------------------------
 int vtkF3DMemoryMesh::RequestData(vtkInformation* vtkNotUsed(request),
   vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* outputVector)
 {
-  vtkPolyData* output = vtkPolyData::GetData(outputVector->GetInformationObject(0));
+  vtkInformation* outInfo = outputVector->GetInformationObject(0);
+  vtkPolyData* output = vtkPolyData::GetData(outInfo);
 
-  output->ShallowCopy(this->Mesh);
+  if (outInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP()) && !this->Meshes.empty())
+  {
+    const double requestedTimeValue =
+      outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP());
+    auto iter = Meshes.upper_bound(requestedTimeValue);
+    if (iter != Meshes.begin())
+    {
+      iter = std::prev(iter);
+    }
+    output->ShallowCopy(iter->second);
+  }
+  else
+  {
+    output->ShallowCopy(this->Meshes[0.0]);
+  }
 
   return 1;
 }
diff --git a/vtkext/private/module/vtkF3DMemoryMesh.h b/vtkext/private/module/vtkF3DMemoryMesh.h
@@ -18,52 +18,53 @@ class vtkF3DMemoryMesh : public vtkPolyDataAlgorithm
   vtkTypeMacro(vtkF3DMemoryMesh, vtkPolyDataAlgorithm);
 
   /**
-   * Set contiguous list of positions.
+   * Set contiguous list of positions for a given timestamp, 0 by default.
    * Length of the list must be a multiple of 3.
    * The list is copied internally.
    */
-  void SetPoints(const std::vector<float>& positions);
+  void SetPoints(const std::vector<float>& positions, const double timeStamp = 0);
 
   /**
-   * Set contiguous list of normals.
+   * Set contiguous list of normals for a given timestamp, 0 by default.
    * Length of the list must be a multiple of 3 (or left empty).
    * Must match the number of points specified in SetPoints.
    * The list is copied internally.
    * The list can be empty.
    */
-  void SetNormals(const std::vector<float>& normals);
+  void SetNormals(const std::vector<float>& normals, const double timeStamp = 0);
 
   /**
-   * Set contiguous list of texture coordinates.
+   * Set contiguous list of texture coordinates for a given timestamp, 0 by default.
    * Length of the list must be a multiple of 2 (or left empty).
    * Must match the number of points specified in SetPoints.
    * The list is copied internally.
    * The list can be empty.
    */
-  void SetTCoords(const std::vector<float>& tcoords);
+  void SetTCoords(const std::vector<float>& tcoords, const double timeStamp = 0);
 
   /**
-   * Set faces by vertex indices.
+   * Set faces by vertex indices for a given timestamp, 0 by default.
    * faceSizes contains the size of each face (3 is triangle, 4 is quad, etc...)
    * cellIndices is a contiguous array of all face indices
    * The length of faceIndices should be the sum of all values in faceSizes
    * The lists are copied internally.
    * The lists can be empty, resulting in a point cloud.
    */
-  void SetFaces(
-    const std::vector<unsigned int>& faceSizes, const std::vector<unsigned int>& faceIndices);
+  void SetFaces(const std::vector<unsigned int>& faceSizes,
+    const std::vector<unsigned int>& faceIndices, const double timeStamp = 0);
 
 protected:
   vtkF3DMemoryMesh();
   ~vtkF3DMemoryMesh() override;
 
+  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
   int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
 private:
   vtkF3DMemoryMesh(const vtkF3DMemoryMesh&) = delete;
   void operator=(const vtkF3DMemoryMesh&) = delete;
 
-  vtkNew<vtkPolyData> Mesh;
+  std::map<double, vtkNew<vtkPolyData>> Meshes;
 };
 
 #endif
