Bump minimum MRPT version to 2.15.4 (and remove now old dead code)

jlblancoc · jlblancoc · commit 5bbf03432967 · 2026-04-09T11:32:02.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -55,7 +55,7 @@ endif()
 add_subdirectory(3rdparty)
 
 # find dependencies:
-find_package(MRPT 2.15.0 REQUIRED COMPONENTS
+find_package(MRPT 2.15.4 REQUIRED COMPONENTS
   containers
   tfest
   maps
diff --git a/agents.md b/agents.md
@@ -9,7 +9,7 @@ Quick-start reference for AI agents and new contributors.
 - **Version**: 2.7.1 (March 2026)
 - **License**: BSD-3-Clause
 - **Maintainer**: Jose Luis Blanco-Claraco
-- **Minimum MRPT**: 2.15.0
+- **Minimum MRPT**: 2.15.4
 
 ---
 
@@ -172,7 +172,7 @@ SIMD-optimized translation units are compiled separately with `-mavx` / `-msse2`
 
 | Dependency | Notes |
 |-----------|-------|
-| MRPT ≥ 2.15.0 | containers, tfest, maps, gui, topography — mandatory |
+| MRPT ≥ 2.15.4 | containers, tfest, maps, gui, topography — mandatory |
 | TBB | Optional; enables parallel ICP iterations |
 | mola_common | CMake scripts; fetched as git submodule |
 | mola_imu_preintegration | Optional; advanced deskew in FilterDeskew |
diff --git a/apps/txt2mm/main.cpp b/apps/txt2mm/main.cpp
@@ -21,20 +21,13 @@
 
 #include <mp2p_icp/metricmap.h>
 #include <mrpt/3rdparty/tclap/CmdLine.h>
+#include <mrpt/maps/CGenericPointsMap.h>
 #include <mrpt/maps/CSimplePointsMap.h>
 #include <mrpt/math/CMatrixDynamic.h>
 #include <mrpt/obs/CObservationPointCloud.h>
 #include <mrpt/system/filesystem.h>
 #include <mrpt/version.h>
 
-#if MRPT_VERSION >= 0x20f00  // 2.15.0
-#include <mrpt/maps/CGenericPointsMap.h>
-#else
-#include <mrpt/maps/CColouredPointsMap.h>
-#include <mrpt/maps/CPointsMapXYZI.h>
-#include <mrpt/maps/CPointsMapXYZIRT.h>
-#endif
-
 const char* VALID_FORMATS = "(xyz|xyzi|xyzirt|xyzrgb|xyzrgb_normalized)";
 
 // Replicated here from CGenericPointsMap until MRPT 2.15.3 is minimum required version:
@@ -214,14 +207,10 @@ int main(int argc, char** argv)
         {
             ASSERT_GE_(nCols, 6U);
             const bool rgb_normalized = (format == "xyzrgb_normalized");
-#if MRPT_VERSION >= 0x20f00  // 2.15.0
-            auto pts = mrpt::maps::CGenericPointsMap::Create();
+            auto       pts            = mrpt::maps::CGenericPointsMap::Create();
             pts->registerField_float("color_r");
             pts->registerField_float("color_g");
             pts->registerField_float("color_b");
-#else
-            auto pts = mrpt::maps::CColouredPointsMap::Create();
-#endif
             pts->reserve(nRows);
             if (nCols > 6)
             {
@@ -250,15 +239,9 @@ int main(int argc, char** argv)
                     b_val = mrpt::u8tof(static_cast<uint8_t>(data(i, idxBlue)));
                 }
 
-#if MRPT_VERSION >= 0x20f00  // 2.15.0
                 pts->insertPointField_float("color_r", r_val);
                 pts->insertPointField_float("color_g", g_val);
                 pts->insertPointField_float("color_b", b_val);
-#else
-                pts->insertPointField_color_R(r_val);
-                pts->insertPointField_color_G(g_val);
-                pts->insertPointField_color_B(b_val);
-#endif
             }
 
             pc = pts;
diff --git a/mp2p_icp_filters/src/FilterAdjustTimestamps.cpp b/mp2p_icp_filters/src/FilterAdjustTimestamps.cpp
@@ -82,11 +82,7 @@ void FilterAdjustTimestamps::filter(mp2p_icp::metric_map_t& inOut) const
         return;
     }
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     auto* TsPtr = pc.getPointsBufferRef_float_field("t");
-#else
-    auto* TsPtr = pc.getPointsBufferRef_timestamp();
-#endif
 
     if (TsPtr == nullptr || (TsPtr->empty() && !pc.empty()))
     {
diff --git a/mp2p_icp_filters/src/FilterBoundingBox.cpp b/mp2p_icp_filters/src/FilterBoundingBox.cpp
@@ -106,7 +106,6 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const
         outsidePc->reserve(outsidePc->size() + pc.size() / 10);
     }
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     mrpt::maps::CPointsMap::InsertCtx ctxOutside, ctxInside;
     if (insidePc)
     {
@@ -118,7 +117,6 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const
         outsidePc->registerPointFieldsFrom(pc);
         ctxOutside = outsidePc->prepareForInsertPointsFrom(pc);
     }
-#endif
 
     const auto& xs = pc.getPointsBufferRef_x();
     const auto& ys = pc.getPointsBufferRef_y();
@@ -129,18 +127,10 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const
         const bool isInside = params.bounding_box.containsPoint({xs[i], ys[i], zs[i]});
 
         auto* targetPc = isInside ? insidePc.get() : outsidePc.get();
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
-        auto* ctx = isInside ? &ctxInside : &ctxOutside;
-#endif
+        auto* ctx      = isInside ? &ctxInside : &ctxOutside;
         if (targetPc)
         {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
             targetPc->insertPointFrom(i, *ctx);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-            targetPc->insertPointFrom(pc, i, *ctx);
-#else
-            targetPc->insertPointFrom(pc, i);
-#endif
         }
     }
 
diff --git a/mp2p_icp_filters/src/FilterByIntensity.cpp b/mp2p_icp_filters/src/FilterByIntensity.cpp
@@ -126,7 +126,6 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const
     ASSERT_EQUAL_(Is.size(), xs.size());
     const size_t N = xs.size();
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     mrpt::maps::CPointsMap::InsertCtx ctxLow, ctxHigh, ctxMid;
     if (outLow)
     {
@@ -143,7 +142,6 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const
         outMid->registerPointFieldsFrom(pc);
         ctxMid = outMid->prepareForInsertPointsFrom(pc);
     }
-#endif
 
     size_t countLow = 0, countMid = 0, countHigh = 0;
 
@@ -153,43 +151,29 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const
 
         mrpt::maps::CPointsMap* trg = nullptr;
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
         mrpt::maps::CPointsMap::InsertCtx* ctx = nullptr;
-#endif
         if (I < params.low_threshold)
         {
             trg = outLow.get();
             ++countLow;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
             ctx = &ctxLow;
-#endif
         }
         else if (I > params.high_threshold)
         {
             trg = outHigh.get();
             ++countHigh;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
             ctx = &ctxHigh;
-#endif
         }
         else
         {
             trg = outMid.get();
             ++countMid;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
             ctx = &ctxMid;
-#endif
         }
 
         if (trg)
         {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
             trg->insertPointFrom(i, *ctx);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-            trg->insertPointFrom(pc, i, *ctx);
-#else
-            trg->insertPointFrom(pc, i);
-#endif
         }
     }
 
diff --git a/mp2p_icp_filters/src/FilterByRange.cpp b/mp2p_icp_filters/src/FilterByRange.cpp
@@ -115,7 +115,6 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const
     const float sqrMin = mrpt::square(params.range_min);
     const float sqrMax = mrpt::square(params.range_max);
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     std::optional<mrpt::maps::CPointsMap::InsertCtx> ctxBetween;
     std::optional<mrpt::maps::CPointsMap::InsertCtx> ctxOutside;
     if (outBetween)
@@ -128,7 +127,6 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const
         outOutside->registerPointFieldsFrom(pc);
         ctxOutside = outOutside->prepareForInsertPointsFrom(pc);
     }
-#endif
 
     for (size_t i = 0; i < xs.size(); i++)
     {
@@ -154,15 +152,8 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const
 
         if (targetPc)
         {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
             const auto& ctx = isInside ? ctxBetween : ctxOutside;
             targetPc->insertPointFrom(i, ctx.value());
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-            const auto& ctx = isInside ? ctxBetween : ctxOutside;
-            targetPc->insertPointFrom(pc, i, ctx.value());
-#else
-            targetPc->insertPointFrom(pc, i);
-#endif
         }
     }
 
diff --git a/mp2p_icp_filters/src/FilterByRing.cpp b/mp2p_icp_filters/src/FilterByRing.cpp
@@ -111,13 +111,7 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const
 
     const auto& xs = pc.getPointsBufferRef_x();
 
-#if MRPT_VERSION >= 0x020f04  // 2.15.4
     const auto* ptrR = pc.getPointsBufferRef_uint16_field("ring");
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-    const auto* ptrR = pc.getPointsBufferRef_uint_field("ring");
-#else
-    const auto* ptrR = pc.getPointsBufferRef_ring();
-#endif
 
     if (!ptrR || ptrR->empty())
     {
@@ -127,7 +121,6 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const
             params.input_pointcloud_layer.c_str());
     }
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     mrpt::maps::CPointsMap::InsertCtx ctxSelected;
     if (outSelected)
     {
@@ -140,7 +133,6 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const
         outNonSel->registerPointFieldsFrom(pc);
         ctxNotSelected = outNonSel->prepareForInsertPointsFrom(pc);
     }
-#endif
 
     const auto& Rs = *ptrR;
     ASSERT_EQUAL_(Rs.size(), xs.size());
@@ -152,37 +144,25 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const
     {
         const auto R = Rs[i];
 
-        mrpt::maps::CPointsMap* trg = nullptr;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
+        mrpt::maps::CPointsMap*            trg = nullptr;
         mrpt::maps::CPointsMap::InsertCtx* ctx = nullptr;
-#endif
 
         if (params.selected_ring_ids.count(R) != 0)
         {
             trg = outSelected.get();
             ++countSel;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
             ctx = &ctxSelected;
-#endif
         }
         else
         {
             trg = outNonSel.get();
             ++countNon;
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
             ctx = &ctxNotSelected;
-#endif
         }
 
         if (trg)
         {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
             trg->insertPointFrom(i, *ctx);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-            trg->insertPointFrom(pc, i, *ctx);
-#else
-            trg->insertPointFrom(pc, i);
-#endif
         }
     }
 
diff --git a/mp2p_icp_filters/src/FilterCurvature.cpp b/mp2p_icp_filters/src/FilterCurvature.cpp
@@ -113,11 +113,7 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
     const auto& ys = pc.getPointsBufferRef_y();
     const auto& zs = pc.getPointsBufferRef_z();
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     const auto* ptrRings = pc.getPointsBufferRef_float_field("ring");
-#else
-    const auto* ptrRings = pc.getPointsBufferRef_ring();
-#endif
     if (!ptrRings || ptrRings->empty())
     {
         THROW_EXCEPTION_FMT(
@@ -131,7 +127,6 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
 
     const size_t N = xs.size();
 
-#if MRPT_VERSION >= 0x020f00  // 2.15.0
     mrpt::maps::CPointsMap::InsertCtx ctxLarger;
     if (outPcLarger)
     {
@@ -150,7 +145,6 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
         outPcOther->registerPointFieldsFrom(pc);
         ctxOther = outPcOther->prepareForInsertPointsFrom(pc);
     }
-#endif
 
     const uint16_t nRings = 1 + *std::max_element(ringPerPt.begin(), ringPerPt.end());
 
@@ -230,13 +224,7 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
                 counterLarger++;
                 if (outPcLarger)
                 {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
                     outPcLarger->insertPointFrom(i, ctxLarger);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-                    outPcLarger->insertPointFrom(pc, i, ctxLarger);
-#else
-                    outPcLarger->insertPointFrom(pc, i);
-#endif
                 }
             }
             continue;
@@ -263,26 +251,14 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
                     counterLarger++;
                     if (outPcLarger)
                     {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
                         outPcLarger->insertPointFrom(i, ctxLarger);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-                        outPcLarger->insertPointFrom(pc, i, ctxLarger);
-#else
-                        outPcLarger->insertPointFrom(pc, i);
-#endif
                     }
                 }
                 else
                 {
                     if (outPcOther)
                     {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
                         outPcOther->insertPointFrom(i, ctxOther);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-                        outPcOther->insertPointFrom(pc, i, ctxOther);
-#else
-                        outPcOther->insertPointFrom(pc, i);
-#endif
                     }
                 }
                 continue;
@@ -300,27 +276,15 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const
                 counterLarger++;
                 if (outPcLarger)
                 {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
                     outPcLarger->insertPointFrom(i, ctxLarger);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-                    outPcLarger->insertPointFrom(pc, i, ctxLarger);
-#else
-                    outPcLarger->insertPointFrom(pc, i);
-#endif
                 }
             }
             else
             {
                 counterLess++;
                 if (outPcSmaller)
                 {
-#if MRPT_VERSION >= 0x020f03  // 2.15.3
                     outPcSmaller->insertPointFrom(i, ctxSmaller);
-#elif MRPT_VERSION >= 0x020f00  // 2.15.0
-                    outPcSmaller->insertPointFrom(pc, i, ctxSmaller);
-#else
-                    outPcSmaller->insertPointFrom(pc, i);
-#endif
                 }
             }
         }
diff --git a/mp2p_icp_filters/src/FilterDeskew.cpp b/mp2p_icp_filters/src/FilterDeskew.cpp
@@ -152,10 +152,6 @@ auto findBeforeAfter(const mola::imu::Trajectory& trajectory, const double t)
 }
 #endif  // MP2P_ICP_HAS_MOLA_IMU_PREINTEGRATION
 
-#if MRPT_VERSION < 0x020f00  // 2.15.0
-#error "MRPT >= 2.15.0 is required to compile FilterDeskew"
-#endif
-
 struct CorrectPointsArguments
 {
     mrpt::aligned_std_vector<float>&       xs;
diff --git a/mp2p_icp_filters/src/FilterFartherPointSampling.cpp b/mp2p_icp_filters/src/FilterFartherPointSampling.cpp
diff --git a/mp2p_icp_filters/src/FilterPoleDetector.cpp b/mp2p_icp_filters/src/FilterPoleDetector.cpp
diff --git a/mp2p_icp_filters/src/FilterRemoveByVoxelOccupancy.cpp b/mp2p_icp_filters/src/FilterRemoveByVoxelOccupancy.cpp
diff --git a/mp2p_icp_filters/src/FilterSOR.cpp b/mp2p_icp_filters/src/FilterSOR.cpp

Original file line number	Diff line number	Diff line change
`@@ -82,11 +82,7 @@ void FilterAdjustTimestamps::filter(mp2p_icp::metric_map_t& inOut) const`
`82`	`82`	`return;`
`83`	`83`	`}`
`84`	`84`
`85`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`86`	`85`	`auto* TsPtr = pc.getPointsBufferRef_float_field("t");`
`87`		`-#else`
`88`		`- auto* TsPtr = pc.getPointsBufferRef_timestamp();`
`89`		`-#endif`
`90`	`86`
`91`	`87`	`if (TsPtr == nullptr \|\| (TsPtr->empty() && !pc.empty()))`
`92`	`88`	`{`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,6 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const`
`106`	`106`	`outsidePc->reserve(outsidePc->size() + pc.size() / 10);`
`107`	`107`	`}`
`108`	`108`
`109`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`110`	`109`	`mrpt::maps::CPointsMap::InsertCtx ctxOutside, ctxInside;`
`111`	`110`	`if (insidePc)`
`112`	`111`	`{`
`@@ -118,7 +117,6 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const`
`118`	`117`	`outsidePc->registerPointFieldsFrom(pc);`
`119`	`118`	`ctxOutside = outsidePc->prepareForInsertPointsFrom(pc);`
`120`	`119`	`}`
`121`		`-#endif`
`122`	`120`
`123`	`121`	`const auto& xs = pc.getPointsBufferRef_x();`
`124`	`122`	`const auto& ys = pc.getPointsBufferRef_y();`
`@@ -129,18 +127,10 @@ void FilterBoundingBox::filter(mp2p_icp::metric_map_t& inOut) const`
`129`	`127`	`const bool isInside = params.bounding_box.containsPoint({xs[i], ys[i], zs[i]});`
`130`	`128`
`131`	`129`	`auto* targetPc = isInside ? insidePc.get() : outsidePc.get();`
`132`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`133`		`- auto* ctx = isInside ? &ctxInside : &ctxOutside;`
`134`		`-#endif`
	`130`	`+ auto* ctx = isInside ? &ctxInside : &ctxOutside;`
`135`	`131`	`if (targetPc)`
`136`	`132`	`{`
`137`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`138`	`133`	`targetPc->insertPointFrom(i, *ctx);`
`139`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`140`		`- targetPc->insertPointFrom(pc, i, *ctx);`
`141`		`-#else`
`142`		`- targetPc->insertPointFrom(pc, i);`
`143`		`-#endif`
`144`	`134`	`}`
`145`	`135`	`}`
`146`	`136`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,6 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const`
`126`	`126`	`ASSERT_EQUAL_(Is.size(), xs.size());`
`127`	`127`	`const size_t N = xs.size();`
`128`	`128`
`129`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`130`	`129`	`mrpt::maps::CPointsMap::InsertCtx ctxLow, ctxHigh, ctxMid;`
`131`	`130`	`if (outLow)`
`132`	`131`	`{`
`@@ -143,7 +142,6 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const`
`143`	`142`	`outMid->registerPointFieldsFrom(pc);`
`144`	`143`	`ctxMid = outMid->prepareForInsertPointsFrom(pc);`
`145`	`144`	`}`
`146`		`-#endif`
`147`	`145`
`148`	`146`	`size_t countLow = 0, countMid = 0, countHigh = 0;`
`149`	`147`
`@@ -153,43 +151,29 @@ void FilterByIntensity::filter(mp2p_icp::metric_map_t& inOut) const`
`153`	`151`
`154`	`152`	`mrpt::maps::CPointsMap* trg = nullptr;`
`155`	`153`
`156`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`157`	`154`	`mrpt::maps::CPointsMap::InsertCtx* ctx = nullptr;`
`158`		`-#endif`
`159`	`155`	`if (I < params.low_threshold)`
`160`	`156`	`{`
`161`	`157`	`trg = outLow.get();`
`162`	`158`	`++countLow;`
`163`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`164`	`159`	`ctx = &ctxLow;`
`165`		`-#endif`
`166`	`160`	`}`
`167`	`161`	`else if (I > params.high_threshold)`
`168`	`162`	`{`
`169`	`163`	`trg = outHigh.get();`
`170`	`164`	`++countHigh;`
`171`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`172`	`165`	`ctx = &ctxHigh;`
`173`		`-#endif`
`174`	`166`	`}`
`175`	`167`	`else`
`176`	`168`	`{`
`177`	`169`	`trg = outMid.get();`
`178`	`170`	`++countMid;`
`179`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`180`	`171`	`ctx = &ctxMid;`
`181`		`-#endif`
`182`	`172`	`}`
`183`	`173`
`184`	`174`	`if (trg)`
`185`	`175`	`{`
`186`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`187`	`176`	`trg->insertPointFrom(i, *ctx);`
`188`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`189`		`- trg->insertPointFrom(pc, i, *ctx);`
`190`		`-#else`
`191`		`- trg->insertPointFrom(pc, i);`
`192`		`-#endif`
`193`	`177`	`}`
`194`	`178`	`}`
`195`	`179`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,6 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const`
`115`	`115`	`const float sqrMin = mrpt::square(params.range_min);`
`116`	`116`	`const float sqrMax = mrpt::square(params.range_max);`
`117`	`117`
`118`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`119`	`118`	`std::optional<mrpt::maps::CPointsMap::InsertCtx> ctxBetween;`
`120`	`119`	`std::optional<mrpt::maps::CPointsMap::InsertCtx> ctxOutside;`
`121`	`120`	`if (outBetween)`
`@@ -128,7 +127,6 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const`
`128`	`127`	`outOutside->registerPointFieldsFrom(pc);`
`129`	`128`	`ctxOutside = outOutside->prepareForInsertPointsFrom(pc);`
`130`	`129`	`}`
`131`		`-#endif`
`132`	`130`
`133`	`131`	`for (size_t i = 0; i < xs.size(); i++)`
`134`	`132`	`{`
`@@ -154,15 +152,8 @@ void FilterByRange::filter(mp2p_icp::metric_map_t& inOut) const`
`154`	`152`
`155`	`153`	`if (targetPc)`
`156`	`154`	`{`
`157`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`158`	`155`	`const auto& ctx = isInside ? ctxBetween : ctxOutside;`
`159`	`156`	`targetPc->insertPointFrom(i, ctx.value());`
`160`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`161`		`- const auto& ctx = isInside ? ctxBetween : ctxOutside;`
`162`		`- targetPc->insertPointFrom(pc, i, ctx.value());`
`163`		`-#else`
`164`		`- targetPc->insertPointFrom(pc, i);`
`165`		`-#endif`
`166`	`157`	`}`
`167`	`158`	`}`
`168`	`159`
Original file line number	Diff line number	Diff line change
`@@ -111,13 +111,7 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const`
`111`	`111`
`112`	`112`	`const auto& xs = pc.getPointsBufferRef_x();`
`113`	`113`
`114`		`-#if MRPT_VERSION >= 0x020f04 // 2.15.4`
`115`	`114`	`const auto* ptrR = pc.getPointsBufferRef_uint16_field("ring");`
`116`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`117`		`- const auto* ptrR = pc.getPointsBufferRef_uint_field("ring");`
`118`		`-#else`
`119`		`- const auto* ptrR = pc.getPointsBufferRef_ring();`
`120`		`-#endif`
`121`	`115`
`122`	`116`	`if (!ptrR \|\| ptrR->empty())`
`123`	`117`	`{`
`@@ -127,7 +121,6 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const`
`127`	`121`	`params.input_pointcloud_layer.c_str());`
`128`	`122`	`}`
`129`	`123`
`130`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`131`	`124`	`mrpt::maps::CPointsMap::InsertCtx ctxSelected;`
`132`	`125`	`if (outSelected)`
`133`	`126`	`{`
`@@ -140,7 +133,6 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const`
`140`	`133`	`outNonSel->registerPointFieldsFrom(pc);`
`141`	`134`	`ctxNotSelected = outNonSel->prepareForInsertPointsFrom(pc);`
`142`	`135`	`}`
`143`		`-#endif`
`144`	`136`
`145`	`137`	`const auto& Rs = *ptrR;`
`146`	`138`	`ASSERT_EQUAL_(Rs.size(), xs.size());`
`@@ -152,37 +144,25 @@ void FilterByRing::filter(mp2p_icp::metric_map_t& inOut) const`
`152`	`144`	`{`
`153`	`145`	`const auto R = Rs[i];`
`154`	`146`
`155`		`- mrpt::maps::CPointsMap* trg = nullptr;`
`156`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
	`147`	`+ mrpt::maps::CPointsMap* trg = nullptr;`
`157`	`148`	`mrpt::maps::CPointsMap::InsertCtx* ctx = nullptr;`
`158`		`-#endif`
`159`	`149`
`160`	`150`	`if (params.selected_ring_ids.count(R) != 0)`
`161`	`151`	`{`
`162`	`152`	`trg = outSelected.get();`
`163`	`153`	`++countSel;`
`164`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`165`	`154`	`ctx = &ctxSelected;`
`166`		`-#endif`
`167`	`155`	`}`
`168`	`156`	`else`
`169`	`157`	`{`
`170`	`158`	`trg = outNonSel.get();`
`171`	`159`	`++countNon;`
`172`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`173`	`160`	`ctx = &ctxNotSelected;`
`174`		`-#endif`
`175`	`161`	`}`
`176`	`162`
`177`	`163`	`if (trg)`
`178`	`164`	`{`
`179`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`180`	`165`	`trg->insertPointFrom(i, *ctx);`
`181`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`182`		`- trg->insertPointFrom(pc, i, *ctx);`
`183`		`-#else`
`184`		`- trg->insertPointFrom(pc, i);`
`185`		`-#endif`
`186`	`166`	`}`
`187`	`167`	`}`
`188`	`168`
Original file line number	Diff line number	Diff line change
`@@ -113,11 +113,7 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`113`	`113`	`const auto& ys = pc.getPointsBufferRef_y();`
`114`	`114`	`const auto& zs = pc.getPointsBufferRef_z();`
`115`	`115`
`116`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`117`	`116`	`const auto* ptrRings = pc.getPointsBufferRef_float_field("ring");`
`118`		`-#else`
`119`		`- const auto* ptrRings = pc.getPointsBufferRef_ring();`
`120`		`-#endif`
`121`	`117`	`if (!ptrRings \|\| ptrRings->empty())`
`122`	`118`	`{`
`123`	`119`	`THROW_EXCEPTION_FMT(`
`@@ -131,7 +127,6 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`131`	`127`
`132`	`128`	`const size_t N = xs.size();`
`133`	`129`
`134`		`-#if MRPT_VERSION >= 0x020f00 // 2.15.0`
`135`	`130`	`mrpt::maps::CPointsMap::InsertCtx ctxLarger;`
`136`	`131`	`if (outPcLarger)`
`137`	`132`	`{`
`@@ -150,7 +145,6 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`150`	`145`	`outPcOther->registerPointFieldsFrom(pc);`
`151`	`146`	`ctxOther = outPcOther->prepareForInsertPointsFrom(pc);`
`152`	`147`	`}`
`153`		`-#endif`
`154`	`148`
`155`	`149`	`const uint16_t nRings = 1 + *std::max_element(ringPerPt.begin(), ringPerPt.end());`
`156`	`150`
`@@ -230,13 +224,7 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`230`	`224`	`counterLarger++;`
`231`	`225`	`if (outPcLarger)`
`232`	`226`	`{`
`233`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`234`	`227`	`outPcLarger->insertPointFrom(i, ctxLarger);`
`235`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`236`		`- outPcLarger->insertPointFrom(pc, i, ctxLarger);`
`237`		`-#else`
`238`		`- outPcLarger->insertPointFrom(pc, i);`
`239`		`-#endif`
`240`	`228`	`}`
`241`	`229`	`}`
`242`	`230`	`continue;`
`@@ -263,26 +251,14 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`263`	`251`	`counterLarger++;`
`264`	`252`	`if (outPcLarger)`
`265`	`253`	`{`
`266`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`267`	`254`	`outPcLarger->insertPointFrom(i, ctxLarger);`
`268`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`269`		`- outPcLarger->insertPointFrom(pc, i, ctxLarger);`
`270`		`-#else`
`271`		`- outPcLarger->insertPointFrom(pc, i);`
`272`		`-#endif`
`273`	`255`	`}`
`274`	`256`	`}`
`275`	`257`	`else`
`276`	`258`	`{`
`277`	`259`	`if (outPcOther)`
`278`	`260`	`{`
`279`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`280`	`261`	`outPcOther->insertPointFrom(i, ctxOther);`
`281`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`282`		`- outPcOther->insertPointFrom(pc, i, ctxOther);`
`283`		`-#else`
`284`		`- outPcOther->insertPointFrom(pc, i);`
`285`		`-#endif`
`286`	`262`	`}`
`287`	`263`	`}`
`288`	`264`	`continue;`
`@@ -300,27 +276,15 @@ void FilterCurvature::filter(mp2p_icp::metric_map_t& inOut) const`
`300`	`276`	`counterLarger++;`
`301`	`277`	`if (outPcLarger)`
`302`	`278`	`{`
`303`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`304`	`279`	`outPcLarger->insertPointFrom(i, ctxLarger);`
`305`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`306`		`- outPcLarger->insertPointFrom(pc, i, ctxLarger);`
`307`		`-#else`
`308`		`- outPcLarger->insertPointFrom(pc, i);`
`309`		`-#endif`
`310`	`280`	`}`
`311`	`281`	`}`
`312`	`282`	`else`
`313`	`283`	`{`
`314`	`284`	`counterLess++;`
`315`	`285`	`if (outPcSmaller)`
`316`	`286`	`{`
`317`		`-#if MRPT_VERSION >= 0x020f03 // 2.15.3`
`318`	`287`	`outPcSmaller->insertPointFrom(i, ctxSmaller);`
`319`		`-#elif MRPT_VERSION >= 0x020f00 // 2.15.0`
`320`		`- outPcSmaller->insertPointFrom(pc, i, ctxSmaller);`
`321`		`-#else`
`322`		`- outPcSmaller->insertPointFrom(pc, i);`
`323`		`-#endif`
`324`	`288`	`}`
`325`	`289`	`}`
`326`	`290`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,10 +152,6 @@ auto findBeforeAfter(const mola::imu::Trajectory& trajectory, const double t)`
`152`	`152`	`}`
`153`	`153`	`#endif // MP2P_ICP_HAS_MOLA_IMU_PREINTEGRATION`
`154`	`154`
`155`		`-#if MRPT_VERSION < 0x020f00 // 2.15.0`
`156`		`-#error "MRPT >= 2.15.0 is required to compile FilterDeskew"`
`157`		`-#endif`
`158`		`-`
`159`	`155`	`struct CorrectPointsArguments`
`160`	`156`	`{`
`161`	`157`	`mrpt::aligned_std_vector<float>& xs;`