Gtsam 4.3 (#219)

koide3 · web-flow · commit 405a2e80033d · 2025-06-15T12:08:30.000+09:00
* prevent crash on saving empty map

* GTSAM 4.3a0

* require GTSAM 4.3 and gtsam_points 1.2

* fixing minor errors

* update README
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -19,12 +19,12 @@ jobs:
     strategy:
       matrix:
         DISTRO: [
-          { "ubuntu": "noble_gtsam4.2a9", "suffix": "gcc" },
-          { "ubuntu": "noble_gtsam4.2a9", "suffix": "llvm" },
-          { "ubuntu": "jammy_gtsam4.2a9", "suffix": "gcc" },
-          { "ubuntu": "jammy_gtsam4.2a9", "suffix": "llvm" },
-          { "ubuntu": "jammy_cuda12.2_gtsam4.2a9", "suffix": "gcc.cuda" },
-          { "ubuntu": "jammy_cuda12.2_gtsam4.2a9", "suffix": "llvm.cuda" }
+          { "ubuntu": "noble_gtsam4.3a0", "suffix": "gcc" },
+          { "ubuntu": "noble_gtsam4.3a0", "suffix": "llvm" },
+          { "ubuntu": "jammy_gtsam4.3a0", "suffix": "gcc" },
+          { "ubuntu": "jammy_gtsam4.3a0", "suffix": "llvm" },
+          { "ubuntu": "jammy_cuda12.2_gtsam4.3a0", "suffix": "gcc.cuda" },
+          { "ubuntu": "jammy_cuda12.2_gtsam4.3a0", "suffix": "llvm.cuda" }
         ]
 
     steps:
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -24,8 +24,8 @@ endif()
 
 find_package(Boost REQUIRED serialization)
 find_package(Eigen3 REQUIRED)
-find_package(GTSAM REQUIRED)
-find_package(gtsam_points REQUIRED)
+find_package(GTSAM 4.3 REQUIRED)
+find_package(gtsam_points 1.2.0 REQUIRED)
 find_package(OpenMP REQUIRED)
 find_package(spdlog REQUIRED)
 
diff --git a/README.md b/README.md
@@ -26,6 +26,10 @@ If you find this package useful for your project, please consider leaving a comm
 [![ROS2](https://github.com/koide3/glim_ros2/actions/workflows/build.yml/badge.svg)](https://github.com/koide3/glim_ros2/actions/workflows/build.yml)
 [![EXT](https://github.com/koide3/glim_ext/actions/workflows/build.yml/badge.svg)](https://github.com/koide3/glim_ext/actions/workflows/build.yml)
 
+## Updates
+
+- 2025/06/15 : The base GTSAM version has been changed. Make sure you have rebuilt and installed **GTSAM 4.3a0** and **gtsam_points 1.2.0**.
+
 ## Dependencies
 ### Mandatory
 - [Eigen](https://eigen.tuxfamily.org/index.php)
diff --git a/docs/installation.md b/docs/installation.md
@@ -13,7 +13,7 @@ sudo apt install libomp-dev libboost-all-dev libmetis-dev \
 
 # Install GTSAM
 git clone https://github.com/borglab/gtsam
-cd gtsam && git checkout 4.2a9
+cd gtsam && git checkout 4.3a0
 mkdir build && cd build
 cmake .. -DGTSAM_BUILD_EXAMPLES_ALWAYS=OFF \
          -DGTSAM_BUILD_TESTS=OFF \
diff --git a/include/glim/mapping/global_mapping.hpp b/include/glim/mapping/global_mapping.hpp
@@ -3,7 +3,6 @@
 #include <any>
 #include <memory>
 #include <random>
-#include <boost/shared_ptr.hpp>
 #include <glim/mapping/global_mapping_base.hpp>
 
 namespace gtsam {
@@ -81,8 +80,8 @@ class GlobalMapping : public GlobalMappingBase {
 private:
   void insert_submap(int current, const SubMap::Ptr& submap);
 
-  boost::shared_ptr<gtsam::NonlinearFactorGraph> create_between_factors(int current) const;
-  boost::shared_ptr<gtsam::NonlinearFactorGraph> create_matching_cost_factors(int current) const;
+  std::shared_ptr<gtsam::NonlinearFactorGraph> create_between_factors(int current) const;
+  std::shared_ptr<gtsam::NonlinearFactorGraph> create_matching_cost_factors(int current) const;
 
   void update_submaps();
   gtsam_points::ISAM2ResultExt update_isam2(const gtsam::NonlinearFactorGraph& new_factors, const gtsam::Values& new_values);
diff --git a/include/glim/mapping/global_mapping_pose_graph.hpp b/include/glim/mapping/global_mapping_pose_graph.hpp
@@ -5,7 +5,6 @@
 #include <memory>
 #include <random>
 #include <thread>
-#include <boost/shared_ptr.hpp>
 #include <glim/util/concurrent_vector.hpp>
 #include <glim/mapping/global_mapping_base.hpp>
 
@@ -103,9 +102,9 @@ class GlobalMappingPoseGraph : public GlobalMappingBase {
 private:
   void insert_submap(int current, const SubMap::Ptr& submap);
 
-  boost::shared_ptr<gtsam::NonlinearFactorGraph> create_odometry_factors(int current) const;
+  std::shared_ptr<gtsam::NonlinearFactorGraph> create_odometry_factors(int current) const;
   void find_loop_candidates(int current);
-  boost::shared_ptr<gtsam::NonlinearFactorGraph> collect_detected_loops();
+  std::shared_ptr<gtsam::NonlinearFactorGraph> collect_detected_loops();
 
   void update_submaps();
 
@@ -120,7 +119,7 @@ class GlobalMappingPoseGraph : public GlobalMappingBase {
   std::atomic_bool kill_switch;
   std::thread loop_detection_thread;
   ConcurrentVector<LoopCandidate> loop_candidates;
-  ConcurrentVector<boost::shared_ptr<gtsam::NonlinearFactor>> detected_loops;
+  ConcurrentVector<std::shared_ptr<gtsam::NonlinearFactor>> detected_loops;
 
   std::vector<SubMap::Ptr> submaps;
   std::vector<SubMapTarget::Ptr> submap_targets;
diff --git a/include/glim/odometry/odometry_estimation_cpu.hpp b/include/glim/odometry/odometry_estimation_cpu.hpp
@@ -49,7 +49,7 @@ class OdometryEstimationCPU : public OdometryEstimationIMU {
   virtual ~OdometryEstimationCPU() override;
 
 private:
-  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const boost::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) override;
+  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const std::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) override;
 
   virtual void fallback_smoother() override;
 
diff --git a/include/glim/odometry/odometry_estimation_ct.hpp b/include/glim/odometry/odometry_estimation_ct.hpp
@@ -4,7 +4,6 @@
 #include <memory>
 #include <future>
 
-#include <boost/shared_ptr.hpp>
 #include <glim/odometry/odometry_estimation_base.hpp>
 
 namespace gtsam {
diff --git a/include/glim/odometry/odometry_estimation_gpu.hpp b/include/glim/odometry/odometry_estimation_gpu.hpp
@@ -56,7 +56,7 @@ class OdometryEstimationGPU : public OdometryEstimationIMU {
 
 private:
   virtual void create_frame(EstimationFrame::Ptr& frame) override;
-  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const boost::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) override;
+  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const std::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) override;
   virtual void update_frames(const int current, const gtsam::NonlinearFactorGraph& new_factors) override;
 
   void update_keyframes_overlap(int current);
diff --git a/include/glim/odometry/odometry_estimation_imu.hpp b/include/glim/odometry/odometry_estimation_imu.hpp
@@ -4,7 +4,6 @@
 #include <memory>
 #include <random>
 
-#include <boost/shared_ptr.hpp>
 #include <glim/odometry/odometry_estimation_base.hpp>
 
 namespace gtsam {
@@ -79,7 +78,7 @@ class OdometryEstimationIMU : public OdometryEstimationBase {
 
 protected:
   virtual void create_frame(EstimationFrame::Ptr& frame) {}
-  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const boost::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) = 0;
+  virtual gtsam::NonlinearFactorGraph create_factors(const int current, const std::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) = 0;
 
   virtual void fallback_smoother() {}
   virtual void update_frames(const int current, const gtsam::NonlinearFactorGraph& new_factors);
diff --git a/include/glim/util/extension_module_ros.hpp b/include/glim/util/extension_module_ros.hpp
@@ -62,7 +62,7 @@ class TopicSubscription : public GenericTopicSubscription {
     callback(msg);
   }
 
-  const std::function<void(const boost::shared_ptr<const Msg>&)> callback;
+  const std::function<void(const std::shared_ptr<const Msg>&)> callback;
   ros::Subscriber sub;
 };
 
diff --git a/include/glim/viewer/interactive_viewer.hpp b/include/glim/viewer/interactive_viewer.hpp
@@ -4,7 +4,6 @@
 #include <memory>
 #include <thread>
 #include <vector>
-#include <boost/shared_ptr.hpp>
 
 #include <Eigen/Core>
 #include <Eigen/Geometry>
@@ -129,7 +128,7 @@ class InteractiveViewer : public ExtensionModule {
   std::vector<std::tuple<FactorType, std::uint64_t, std::uint64_t>> global_factors;
 
   // Factors to be inserted into the global mapping graph
-  ConcurrentVector<boost::shared_ptr<gtsam::NonlinearFactor>> new_factors;
+  ConcurrentVector<std::shared_ptr<gtsam::NonlinearFactor>> new_factors;
 
   // Logging
   std::shared_ptr<spdlog::logger> logger;
diff --git a/include/glim/viewer/standard_viewer.hpp b/include/glim/viewer/standard_viewer.hpp
@@ -82,7 +82,7 @@ class StandardViewer : public ExtensionModule {
 
   using FactorLine = std::tuple<Eigen::Vector3f, Eigen::Vector3f, Eigen::Vector4f, Eigen::Vector4f>;
   using FactorLineGetter = std::function<std::optional<FactorLine>(const gtsam::NonlinearFactor*)>;
-  std::vector<std::pair<boost::weak_ptr<gtsam::NonlinearFactor>, FactorLineGetter>> odometry_factor_lines;
+  std::vector<std::pair<std::weak_ptr<gtsam::NonlinearFactor>, FactorLineGetter>> odometry_factor_lines;
   std::unordered_map<std::uint64_t, Eigen::Isometry3f> odometry_poses;
 
   bool show_mapping_tools;
diff --git a/src/glim/mapping/global_mapping.cpp b/src/glim/mapping/global_mapping.cpp
@@ -376,7 +376,7 @@ void GlobalMapping::optimize() {
   Callbacks::on_update_submaps(submaps);
 }
 
-boost::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMapping::create_between_factors(int current) const {
+std::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMapping::create_between_factors(int current) const {
   auto factors = gtsam::make_shared<gtsam::NonlinearFactorGraph>();
   if (current == 0 || !params.enable_between_factors) {
     return factors;
@@ -427,7 +427,7 @@ boost::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMapping::create_between_fac
   return factors;
 }
 
-boost::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMapping::create_matching_cost_factors(int current) const {
+std::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMapping::create_matching_cost_factors(int current) const {
   auto factors = gtsam::make_shared<gtsam::NonlinearFactorGraph>();
   if (current == 0) {
     return factors;
@@ -552,9 +552,9 @@ void GlobalMapping::save(const std::string& path) {
   std::unordered_map<std::string, gtsam::NonlinearFactor::shared_ptr> matching_cost_factors;
 
   for (const auto& factor : isam2->getFactorsUnsafe()) {
-    bool serializable = !boost::dynamic_pointer_cast<gtsam_points::IntegratedMatchingCostFactor>(factor)
+    bool serializable = !dynamic_cast<gtsam_points::IntegratedMatchingCostFactor*>(factor.get())
 #ifdef GTSAM_POINTS_USE_CUDA
-                        && !boost::dynamic_pointer_cast<gtsam_points::IntegratedVGICPFactorGPU>(factor)
+                        && !dynamic_cast<gtsam_points::IntegratedVGICPFactorGPU*>(factor.get())
 #endif
       ;
 
@@ -581,13 +581,13 @@ void GlobalMapping::save(const std::string& path) {
   for (const auto& factor : matching_cost_factors) {
     std::string type;
 
-    if (boost::dynamic_pointer_cast<gtsam_points::IntegratedGICPFactor>(factor.second)) {
+    if (dynamic_cast<gtsam_points::IntegratedGICPFactor*>(factor.second.get())) {
       type = "gicp";
-    } else if (boost::dynamic_pointer_cast<gtsam_points::IntegratedVGICPFactor>(factor.second)) {
+    } else if (dynamic_cast<gtsam_points::IntegratedVGICPFactor*>(factor.second.get())) {
       type = "vgicp";
     }
 #ifdef GTSAM_POINTS_USE_CUDA
-    else if (boost::dynamic_pointer_cast<gtsam_points::IntegratedVGICPFactorGPU>(factor.second)) {
+    else if (dynamic_cast<gtsam_points::IntegratedVGICPFactorGPU*>(factor.second.get())) {
       type = "vgicp_gpu";
     }
 #endif
@@ -771,21 +771,20 @@ bool GlobalMapping::load(const std::string& path) {
 
     logger->info("removing translation prior factors");
     auto remove_loc = std::remove_if(loaded_graph.begin(), loaded_graph.end(), [](const auto& factor) {
-      return boost::dynamic_pointer_cast<gtsam::PoseTranslationPrior<gtsam::Pose3>>(factor) != nullptr;
+      return dynamic_cast<gtsam::PoseTranslationPrior<gtsam::Pose3>*>(factor.get()) != nullptr;
     });
     logger->info("removed {} prior factors", std::distance(remove_loc, loaded_graph.end()));
     loaded_graph.erase(remove_loc, loaded_graph.end());
 
     logger->info("removing damping factors");
-    remove_loc = std::remove_if(loaded_graph.begin(), loaded_graph.end(), [](const auto& factor) {
-      return boost::dynamic_pointer_cast<gtsam_points::LinearDampingFactor>(factor) != nullptr;
-    });
+    remove_loc =
+      std::remove_if(loaded_graph.begin(), loaded_graph.end(), [](const auto& factor) { return dynamic_cast<gtsam_points::LinearDampingFactor*>(factor.get()) != nullptr; });
     logger->info("removed {} prior factors", std::distance(remove_loc, loaded_graph.end()));
     loaded_graph.erase(remove_loc, loaded_graph.end());
 
     logger->info("removing prior factors");
     remove_loc =
-      std::remove_if(loaded_graph.begin(), loaded_graph.end(), [](const auto& factor) { return boost::dynamic_pointer_cast<gtsam::PriorFactor<gtsam::Pose3>>(factor) != nullptr; });
+      std::remove_if(loaded_graph.begin(), loaded_graph.end(), [](const auto& factor) { return dynamic_cast<gtsam::PriorFactor<gtsam::Pose3>*>(factor.get()) != nullptr; });
     logger->info("removed {} prior factors", std::distance(remove_loc, loaded_graph.end()));
     loaded_graph.erase(remove_loc, loaded_graph.end());
 
@@ -890,7 +889,7 @@ std::pair<gtsam::NonlinearFactorGraph, gtsam::Values> GlobalMapping::recover_gra
     enable_imu |= (chr == 'e' || chr == 'v' || chr == 'b');
   }
   for (const auto& factor : graph) {
-    enable_imu |= boost::dynamic_pointer_cast<gtsam::ImuFactor>(factor) != nullptr;
+    enable_imu |= dynamic_cast<gtsam::ImuFactor*>(factor.get()) != nullptr;
   }
 
   logger->info("enable_imu={}", enable_imu);
@@ -910,7 +909,7 @@ std::pair<gtsam::NonlinearFactorGraph, gtsam::Values> GlobalMapping::recover_gra
     }
 
     if (factor->keys().size() == 1 && factor->keys()[0] == X(0)) {
-      prior_exists |= boost::dynamic_pointer_cast<gtsam_points::LinearDampingFactor>(factor) != nullptr;
+      prior_exists |= dynamic_cast<gtsam_points::LinearDampingFactor*>(factor.get()) != nullptr;
     }
   }
 
diff --git a/src/glim/mapping/global_mapping_pose_graph.cpp b/src/glim/mapping/global_mapping_pose_graph.cpp
@@ -288,7 +288,7 @@ void GlobalMappingPoseGraph::insert_submap(int current, const SubMap::Ptr& subma
   submap_targets.push_back(target);
 }
 
-boost::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMappingPoseGraph::create_odometry_factors(int current) const {
+std::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMappingPoseGraph::create_odometry_factors(int current) const {
   auto factors = gtsam::make_shared<gtsam::NonlinearFactorGraph>();
   if (current == 0) {
     return factors;
@@ -334,7 +334,7 @@ void GlobalMappingPoseGraph::find_loop_candidates(int current) {
   loop_candidates.insert(new_candidates);
 }
 
-boost::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMappingPoseGraph::collect_detected_loops() {
+std::shared_ptr<gtsam::NonlinearFactorGraph> GlobalMappingPoseGraph::collect_detected_loops() {
   auto factors = gtsam::make_shared<gtsam::NonlinearFactorGraph>();
 
   factors->add(detected_loops.get_all_and_clear());
diff --git a/src/glim/odometry/odometry_estimation_cpu.cpp b/src/glim/odometry/odometry_estimation_cpu.cpp
@@ -74,7 +74,7 @@ OdometryEstimationCPU::OdometryEstimationCPU(const OdometryEstimationCPUParams&
 
 OdometryEstimationCPU::~OdometryEstimationCPU() {}
 
-gtsam::NonlinearFactorGraph OdometryEstimationCPU::create_factors(const int current, const boost::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) {
+gtsam::NonlinearFactorGraph OdometryEstimationCPU::create_factors(const int current, const std::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) {
   const auto params = static_cast<const OdometryEstimationCPUParams*>(this->params.get());
   const int last = current - 1;
 
diff --git a/src/glim/odometry/odometry_estimation_gpu.cpp b/src/glim/odometry/odometry_estimation_gpu.cpp
@@ -125,7 +125,7 @@ void OdometryEstimationGPU::update_frames(const int current, const gtsam::Nonlin
   Callbacks::on_update_keyframes(keyframes);
 }
 
-gtsam::NonlinearFactorGraph OdometryEstimationGPU::create_factors(const int current, const boost::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) {
+gtsam::NonlinearFactorGraph OdometryEstimationGPU::create_factors(const int current, const std::shared_ptr<gtsam::ImuFactor>& imu_factor, gtsam::Values& new_values) {
   if (current == 0 || !frames[current]->frame->size()) {
     return gtsam::NonlinearFactorGraph();
   }
diff --git a/src/glim/util/debug.cpp b/src/glim/util/debug.cpp
@@ -63,7 +63,11 @@ void print_system_info(std::shared_ptr<spdlog::logger> logger) {
   PRINT_IF_DEFINED(logger, GTSAM_ALLOCATOR_TBB);
   PRINT_IF_DEFINED(logger, GTSAM_USE_SYSTEM_EIGEN);
   PRINT_IF_DEFINED(logger, GTSAM_USE_SYSTEM_METIS);
+#ifdef GTSAM_EIGEN_VERSION_WORLD
   logger->debug("GTSAM_EIGEN_VERSION={}.{}", GTSAM_EIGEN_VERSION_WORLD, GTSAM_EIGEN_VERSION_MAJOR);
+#else
+  logger->debug("GTSAM_EIGEN_VERSION is not defined");
+#endif
 
   logger->debug("*** GTSAM_POINTS ***");
   logger->debug("GTSAM_POINTS_VERSION={}.{}.{} ({})", GTSAM_POINTS_VERSION_MAJOR, GTSAM_POINTS_VERSION_MINOR, GTSAM_POINTS_VERSION_PATCH, GTSAM_POINTS_VERSION_STRING);
diff --git a/src/glim/viewer/interactive_viewer.cpp b/src/glim/viewer/interactive_viewer.cpp
@@ -605,7 +605,7 @@ void InteractiveViewer::globalmap_on_smoother_update(gtsam_points::ISAM2Ext& isa
 
   // Explicitly move the poses of merged submaps to the coordinate system of the origin of the first session
   for (const auto& factor : factors) {
-    auto between = boost::dynamic_pointer_cast<const gtsam::BetweenFactor<gtsam::Pose3>>(factor);
+    auto between = dynamic_cast<const gtsam::BetweenFactor<gtsam::Pose3>*>(factor.get());
     if (!between) {
       continue;
     }
@@ -650,18 +650,18 @@ void InteractiveViewer::globalmap_on_smoother_update(gtsam_points::ISAM2Ext& isa
   std::vector<std::tuple<FactorType, gtsam::Key, gtsam::Key>> inserted_factors;
 
   for (const auto& factor : new_factors) {
-    if (boost::dynamic_pointer_cast<gtsam::BetweenFactor<gtsam::Pose3>>(factor)) {
+    if (dynamic_cast<gtsam::BetweenFactor<gtsam::Pose3>*>(factor.get())) {
       inserted_factors.push_back(std::make_tuple(FactorType::BETWEEN, factor->keys()[0], factor->keys()[1]));
     }
-    if (boost::dynamic_pointer_cast<gtsam_points::IntegratedMatchingCostFactor>(factor)) {
+    if (dynamic_cast<gtsam_points::IntegratedMatchingCostFactor*>(factor.get())) {
       inserted_factors.push_back(std::make_tuple(FactorType::MATCHING_COST, factor->keys()[0], factor->keys()[1]));
     }
 #ifdef GTSAM_POINTS_USE_CUDA
-    if (boost::dynamic_pointer_cast<gtsam_points::IntegratedVGICPFactorGPU>(factor)) {
+    if (dynamic_cast<gtsam_points::IntegratedVGICPFactorGPU*>(factor.get())) {
       inserted_factors.push_back(std::make_tuple(FactorType::MATCHING_COST, factor->keys()[0], factor->keys()[1]));
     }
 #endif
-    if (boost::dynamic_pointer_cast<gtsam::ImuFactor>(factor)) {
+    if (dynamic_cast<gtsam::ImuFactor*>(factor.get())) {
       inserted_factors.push_back(std::make_tuple(FactorType::IMU, factor->keys()[0], factor->keys()[2]));
     }
   }
diff --git a/src/glim/viewer/standard_viewer.cpp b/src/glim/viewer/standard_viewer.cpp
@@ -283,7 +283,7 @@ void StandardViewer::set_callbacks() {
                                                         gtsam::Values& new_values,
                                                         std::map<std::uint64_t, double>& new_stamps) {
     //
-    std::vector<std::pair<boost::weak_ptr<gtsam::NonlinearFactor>, FactorLineGetter>> new_factor_lines;
+    std::vector<std::pair<std::weak_ptr<gtsam::NonlinearFactor>, FactorLineGetter>> new_factor_lines;
     new_factor_lines.reserve(new_factors.size());
 
     for (const auto& factor : new_factors) {
@@ -298,7 +298,7 @@ void StandardViewer::set_callbacks() {
         }
         const int idx0 = symbol0.index();
 
-        const auto matching_factor = boost::dynamic_pointer_cast<gtsam_points::IntegratedMatchingCostFactor>(factor);
+        const auto matching_factor = dynamic_cast<gtsam_points::IntegratedMatchingCostFactor*>(factor.get());
         if (matching_factor) {
           const auto l = [this, idx0](const gtsam::NonlinearFactor* factor) -> std::optional<FactorLine> {
             const auto found0 = odometry_poses.find(idx0);
@@ -319,7 +319,7 @@ void StandardViewer::set_callbacks() {
         }
 
 #ifdef GTSAM_POINTS_USE_CUDA
-        const auto gpu_factor = boost::dynamic_pointer_cast<gtsam_points::IntegratedVGICPFactorGPU>(factor);
+        const auto gpu_factor = dynamic_cast<gtsam_points::IntegratedVGICPFactorGPU*>(factor.get());
         if (gpu_factor) {
           const auto l = [this, idx0](const gtsam::NonlinearFactor* factor) -> std::optional<FactorLine> {
             const auto found0 = odometry_poses.find(idx0);
