Added the ability to redirect logging to a callable. (#6244)

larshg · web-flow · commit da4c40873dfb · 2026-03-12T14:21:17.000+01:00
* Added the ability to redirect logging to a callable.

* Use formatted string instead of temporary stringstream.

* Add includes.

* cleanup

* Test for undefined symbol.

* Fix copy paste error.

* Fix ODR of OctreeKey::maxdepth.

* Remove unnecessary c_str().

* Wrap static member variables in a getter method.

* Add wrapper function for easier setting the callback.

* Address parsing in the string from the LogRecord to reduce copying.

* Revert removal of c_str()

* Revert direct removal of the two static variables, but added deprecrecation notice.

* Added more documentation for usage of the setCallback and how to reset logging to console

* Fix missing field in initializer

* Address suggestions from copilot.

* Added checks if verbosity level is enabled before to_string.

Replaced Logrecorder with stringstream directly and added as a member to Logger, to reuse it fore the entire lifetime of the application.

Added doc strings.

Added constructors to LogRecord.

* For now have a stringstream per PCL_LOG_STREAM.

* Only reset_text_color on L_DEBUG, L_WARN and L_ERROR.
diff --git a/common/include/pcl/console/print.h b/common/include/pcl/console/print.h
diff --git a/common/src/print.cpp b/common/src/print.cpp
diff --git a/examples/segmentation/example_cpc_segmentation.cpp b/examples/segmentation/example_cpc_segmentation.cpp
@@ -211,7 +211,7 @@ CPCSegmentation Parameters: \n\
   pcl::PCLPointCloud2 input_pointcloud2;
   if (pcl::io::loadPCDFile (pcd_filename, input_pointcloud2))
   {
-    PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str ());
+    PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str());
     return (3);
   }
   pcl::fromPCLPointCloud2 (input_pointcloud2, *input_cloud_ptr);
@@ -362,9 +362,8 @@ CPCSegmentation Parameters: \n\
     PCL_INFO ("Refining supervoxels\n");
     super.refineSupervoxels (2, supervoxel_clusters);
   }
-  std::stringstream temp;
-  temp << "  Nr. Supervoxels: " << supervoxel_clusters.size () << "\n";
-  PCL_INFO (temp.str ().c_str ());
+
+  PCL_INFO("  Nr. Supervoxels: %zu\n", supervoxel_clusters.size());
 
   PCL_INFO ("Getting supervoxel adjacency\n");
   std::multimap<std::uint32_t, std::uint32_t>supervoxel_adjacency;
diff --git a/examples/segmentation/example_lccp_segmentation.cpp b/examples/segmentation/example_lccp_segmentation.cpp
@@ -182,7 +182,7 @@ LCCPSegmentation Parameters: \n\
   pcl::PCLPointCloud2 input_pointcloud2;
   if (pcl::io::loadPCDFile (pcd_filename, input_pointcloud2))
   {
-    PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str ());
+    PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str());
     return (3);
   }
   pcl::fromPCLPointCloud2 (input_pointcloud2, *input_cloud_ptr);
@@ -289,9 +289,8 @@ LCCPSegmentation Parameters: \n\
     PCL_INFO ("Refining supervoxels\n");
     super.refineSupervoxels (2, supervoxel_clusters);
   }
-  std::stringstream temp;
-  temp << "  Nr. Supervoxels: " << supervoxel_clusters.size () << "\n";
-  PCL_INFO (temp.str ().c_str ());
+  
+  PCL_INFO("  Nr. Supervoxels: %zu\n", supervoxel_clusters.size());
 
   PCL_INFO ("Getting supervoxel adjacency\n");
   std::multimap<std::uint32_t, std::uint32_t> supervoxel_adjacency;
diff --git a/octree/include/pcl/octree/impl/octree2buf_base.hpp b/octree/include/pcl/octree/impl/octree2buf_base.hpp
@@ -73,7 +73,7 @@ Octree2BufBase<LeafContainerT, BranchContainerT>::setMaxVoxelIndex(
 
   // tree depth == amount of bits of maxVoxels
   treeDepth =
-      std::max<uindex_t>(std::min<uindex_t>(OctreeKey::maxDepth,
+      std::max<uindex_t>(std::min<uindex_t>(OctreeKey::getMaxDepth(),
                                             std::ceil(std::log2(max_voxel_index_arg))),
                          0);
 
diff --git a/octree/include/pcl/octree/impl/octree_base.hpp b/octree/include/pcl/octree/impl/octree_base.hpp
@@ -39,6 +39,9 @@
 #ifndef PCL_OCTREE_BASE_HPP
 #define PCL_OCTREE_BASE_HPP
 
+#include <pcl/octree/octree_base.h>
+#include <pcl/octree/octree_key.h>
+
 #include <vector>
 
 namespace pcl {
@@ -75,7 +78,7 @@ OctreeBase<LeafContainerT, BranchContainerT>::setMaxVoxelIndex(
 
   // tree depth == bitlength of maxVoxels
   tree_depth =
-      std::min(static_cast<uindex_t>(OctreeKey::maxDepth),
+      std::min(static_cast<uindex_t>(OctreeKey::getMaxDepth()),
                static_cast<uindex_t>(std::ceil(std::log2(max_voxel_index_arg))));
 
   setTreeDepth(tree_depth);
@@ -91,11 +94,11 @@ OctreeBase<LeafContainerT, BranchContainerT>::setTreeDepth(uindex_t depth_arg)
               depth_arg);
     return;
   }
-  if (depth_arg > OctreeKey::maxDepth) {
+  if (depth_arg > OctreeKey::getMaxDepth()) {
     PCL_ERROR("[pcl::octree::OctreeBase::setTreeDepth] Tree depth (%lu) must be <= max "
               "depth(%lu)!\n",
               depth_arg,
-              OctreeKey::maxDepth);
+              OctreeKey::getMaxDepth());
     return;
   }
 
diff --git a/octree/include/pcl/octree/impl/octree_pointcloud.hpp b/octree/include/pcl/octree/impl/octree_pointcloud.hpp
@@ -713,7 +713,7 @@ pcl::octree::OctreePointCloud<PointT, LeafContainerT, BranchContainerT, OctreeT>
 
   // tree depth == amount of bits of max_voxels
   this->octree_depth_ = std::max<uindex_t>(
-      std::min<uindex_t>(OctreeKey::maxDepth,
+      std::min<uindex_t>(OctreeKey::getMaxDepth(),
                          std::ceil(std::log2(max_voxels) - minValue)),
       0);
 
diff --git a/octree/include/pcl/octree/octree_impl.h b/octree/include/pcl/octree/octree_impl.h
@@ -43,4 +43,3 @@
 #include <pcl/octree/impl/octree_iterator.hpp>
 #include <pcl/octree/impl/octree_pointcloud.hpp>
 #include <pcl/octree/impl/octree_search.hpp>
-#include <pcl/octree/octree.h>
diff --git a/octree/include/pcl/octree/octree_key.h b/octree/include/pcl/octree/octree_key.h
@@ -138,10 +138,19 @@ class OctreeKey {
                                       (!!(this->z & depthMask)));
   }
 
-  /* \brief maximum depth that can be addressed */
+  PCL_DEPRECATED(1, 18, "Use getMaxDepth() instead.")
   static const unsigned char maxDepth =
       static_cast<unsigned char>(sizeof(uindex_t) * 8);
 
+  static unsigned char
+  getMaxDepth()
+  {
+    /* \brief maximum depth that can be addressed */
+    static const unsigned char maxDepth{
+        static_cast<unsigned char>(sizeof(uindex_t) * 8)};
+    return maxDepth;
+  }
+
   // Indices addressing a voxel at (X, Y, Z)
   // NOLINTBEGIN(modernize-use-default-member-init)
   union {
diff --git a/octree/src/octree_inst.cpp b/octree/src/octree_inst.cpp
@@ -36,6 +36,7 @@
 
 #include <pcl/octree/octree.h>
 #include <pcl/octree/octree_impl.h>
+#include <pcl/octree/octree_key.h>
 
 // Instantiations of specific point types
 
diff --git a/sample_consensus/include/pcl/sample_consensus/sac_model.h b/sample_consensus/include/pcl/sample_consensus/sac_model.h
@@ -174,7 +174,7 @@ namespace pcl
 
         // Get a second point which is different than the first
         samples.resize (getSampleSize ());
-        for (unsigned int iter = 0; iter < max_sample_checks_; ++iter)
+        for (unsigned int iter = 0; iter < getMaxSampleChecks(); ++iter)
         {
           // Choose the random indices
           if (samples_radius_ < std::numeric_limits<double>::epsilon ())
@@ -189,7 +189,10 @@ namespace pcl
             return;
           }
         }
-        PCL_DEBUG ("[pcl::SampleConsensusModel::getSamples] WARNING: Could not select %d sample points in %d iterations!\n", getSampleSize (), max_sample_checks_);
+        PCL_DEBUG("[pcl::SampleConsensusModel::getSamples] WARNING: Could not select "
+                  "%d sample points in %d iterations!\n",
+                  getSampleSize(),
+                  getMaxSampleChecks());
         samples.clear ();
       }
 
@@ -347,6 +350,14 @@ namespace pcl
         return sample_size_;
       }
 
+      static unsigned int
+      getMaxSampleChecks()
+      {
+        /** The maximum number of samples to try until we get a good one */
+        static const unsigned int max_sample_checks_ = 1000;
+        return max_sample_checks_;
+      }
+
       /** \brief Return the number of coefficients in the model. */
       inline unsigned int
       getModelSize () const
@@ -545,6 +556,7 @@ namespace pcl
       IndicesPtr indices_;
 
       /** The maximum number of samples to try until we get a good one */
+      PCL_DEPRECATED(1, 18, "Use getMaxSampleChecks() instead.")
       static const unsigned int max_sample_checks_ = 1000;
 
       /** \brief The minimum and maximum radius limits for the model.
diff --git a/test/common/CMakeLists.txt b/test/common/CMakeLists.txt
@@ -11,6 +11,7 @@ if(NOT build)
 endif()
 
 # Args: name, executable_name
+PCL_ADD_TEST(common_console test_console FILES test_console.cpp LINK_WITH pcl_gtest pcl_common)
 PCL_ADD_TEST(common_test_wrappers test_wrappers FILES test_wrappers.cpp LINK_WITH pcl_gtest pcl_common)
 PCL_ADD_TEST(common_test_macros test_macros FILES test_macros.cpp LINK_WITH pcl_gtest pcl_common)
 PCL_ADD_TEST(common_vector_average test_vector_average FILES test_vector_average.cpp LINK_WITH pcl_gtest pcl_common)
diff --git a/test/common/test_console.cpp b/test/common/test_console.cpp
@@ -0,0 +1,108 @@
+#include <pcl/test/gtest.h>
+
+#include <pcl/console/print.h>
+#include <pcl/point_types.h>
+
+TEST(PCL, printStreamsMacros) {
+  pcl::console::setVerbosityLevel(pcl::console::L_VERBOSE);
+
+  PCL_ALWAYS_STREAM("Always_stream\n")
+  PCL_ERROR_STREAM("Error_stream\n")
+  PCL_WARN_STREAM("Warn_stream\n")
+  PCL_INFO_STREAM("Info_stream: this is a point: " << pcl::PointXYZ(1.0, 2.0, 3.0)
+                                                   << "\n")
+  PCL_DEBUG_STREAM("Debug_stream\n")
+  PCL_VERBOSE_STREAM("Verbose_stream: an Eigen vector: "
+                     << "\n"
+                     << Eigen::Vector3f(1.0, 2.0, 3.0) << "\n")
+}
+
+TEST(PCL, printMacros)
+{
+  pcl::console::setVerbosityLevel(pcl::console::L_VERBOSE);
+
+  PCL_ALWAYS("Always\n");
+  PCL_ERROR("Error\n");
+  PCL_WARN("Warn\n");
+  PCL_INFO("Info\n");
+  PCL_DEBUG("Debug\n");
+  PCL_VERBOSE("Verbose\n");
+  PCL_HIGH("High\n");
+}
+
+TEST(PCL, print)
+{
+  pcl::console::setVerbosityLevel(pcl::console::L_VERBOSE);
+
+  pcl::console::print(pcl::console::L_ALWAYS, "Print always\n");
+  
+  pcl::console::print_error("Error\n");
+  pcl::console::print_warn("Warn\n");
+  pcl::console::print_info("Info\n");
+  pcl::console::print_debug("Debug\n");
+  pcl::console::print(pcl::console::L_VERBOSE, "Print verbose\n");
+
+  pcl::console::print_highlight("Highlight\n");
+  pcl::console::print_value("%g\n", 0.001235);
+}
+
+void
+callPrints()
+{
+  pcl::console::print(pcl::console::L_ALWAYS, "Print always\n");
+  pcl::console::print_error("Error\n");
+  pcl::console::print_warn("Warn\n");
+  pcl::console::print_info("Info\n");
+  pcl::console::print_debug("Debug\n");
+  pcl::console::print(pcl::console::L_VERBOSE, "Print verbose\n");
+}
+
+TEST(PCL, checkLogLevel)
+{
+  int callbackCount = 0;
+  
+  pcl::console::setCallback(
+      [&callbackCount](const pcl::console::LogRecord& rec) {
+        std::cout << "Received logrecord: level:" << rec.level << " with message: " << rec.message;
+        callbackCount++;
+       });
+
+  pcl::console::setVerbosityLevel(pcl::console::L_ALWAYS);
+  callPrints();
+  EXPECT_EQ(callbackCount, 1);
+
+  callbackCount = 0;
+  pcl::console::setVerbosityLevel(pcl::console::L_ERROR);
+  callPrints();
+  EXPECT_EQ(callbackCount, 2);
+
+  callbackCount = 0;
+  pcl::console::setVerbosityLevel(pcl::console::L_WARN);
+  callPrints();
+  EXPECT_EQ(callbackCount, 3);
+
+  callbackCount = 0;
+  pcl::console::setVerbosityLevel(pcl::console::L_INFO);
+  callPrints();
+  EXPECT_EQ(callbackCount, 4);
+
+  callbackCount = 0;
+  pcl::console::setVerbosityLevel(pcl::console::L_DEBUG);
+  callPrints();
+  EXPECT_EQ(callbackCount, 5);
+
+  callbackCount = 0;
+  pcl::console::setVerbosityLevel(pcl::console::L_VERBOSE);
+  callPrints();
+  EXPECT_EQ(callbackCount, 6);
+
+}
+
+/* ---[ */
+int
+main(int argc, char** argv)
+{
+  testing::InitGoogleTest(&argc, argv);
+  return (RUN_ALL_TESTS());
+}
+/* ]--- */
diff --git a/tools/train_linemod_template.cpp b/tools/train_linemod_template.cpp
@@ -85,15 +85,15 @@ bool
 loadCloud (const std::string & filename, PointCloudXYZRGBA & cloud)
 {
   TicToc tt;
-  print_highlight ("Loading "); print_value ("%s ", filename.c_str ());
+  print_highlight ("Loading "); print_value ("%s ", filename);
 
   tt.tic ();
   if (loadPCDFile (filename, cloud) < 0)
     return (false);
 
   printElapsedTimeAndNumberOfPoints (tt.toc (), cloud.width, cloud.height);
 
-  print_info ("Available dimensions: "); print_value ("%s\n", pcl::getFieldsList (cloud).c_str ());
+  print_info ("Available dimensions: "); print_value ("%s\n", pcl::getFieldsList (cloud));
 
   return (true);
 }
@@ -271,15 +271,13 @@ main (int argc, char** argv)
     if (!loadCloud (input_filename, *cloud))
     {
       error_code = -1;
-      std::string warn_msg = "Could not load point cloud from file: " + input_filename + "\n";
-      print_warn (warn_msg.c_str ());
+      print_warn("Could not load point cloud from file: " + input_filename + "\n");
       continue;
     }
 
     if (!cloud->isOrganized())
     {
-      std::string warn_msg = "Unorganized point cloud detected. Skipping file " + input_filename + "\n";
-      print_warn(warn_msg.c_str());
+      print_warn("Unorganized point cloud detected. Skipping file " + input_filename + "\n");
       continue;
     }
     else

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ CPCSegmentation Parameters: \n\`
`211`	`211`	`pcl::PCLPointCloud2 input_pointcloud2;`
`212`	`212`	`if (pcl::io::loadPCDFile (pcd_filename, input_pointcloud2))`
`213`	`213`	`{`
`214`		`- PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str ());`
	`214`	`+ PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str());`
`215`	`215`	`return (3);`
`216`	`216`	`}`
`217`	`217`	`pcl::fromPCLPointCloud2 (input_pointcloud2, *input_cloud_ptr);`
`@@ -362,9 +362,8 @@ CPCSegmentation Parameters: \n\`
`362`	`362`	`PCL_INFO ("Refining supervoxels\n");`
`363`	`363`	`super.refineSupervoxels (2, supervoxel_clusters);`
`364`	`364`	`}`
`365`		`- std::stringstream temp;`
`366`		`- temp << " Nr. Supervoxels: " << supervoxel_clusters.size () << "\n";`
`367`		`- PCL_INFO (temp.str ().c_str ());`
	`365`	`+`
	`366`	`+ PCL_INFO(" Nr. Supervoxels: %zu\n", supervoxel_clusters.size());`
`368`	`367`
`369`	`368`	`PCL_INFO ("Getting supervoxel adjacency\n");`
`370`	`369`	`std::multimap<std::uint32_t, std::uint32_t>supervoxel_adjacency;`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ LCCPSegmentation Parameters: \n\`
`182`	`182`	`pcl::PCLPointCloud2 input_pointcloud2;`
`183`	`183`	`if (pcl::io::loadPCDFile (pcd_filename, input_pointcloud2))`
`184`	`184`	`{`
`185`		`- PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str ());`
	`185`	`+ PCL_ERROR ("ERROR: Could not read input point cloud %s.\n", pcd_filename.c_str());`
`186`	`186`	`return (3);`
`187`	`187`	`}`
`188`	`188`	`pcl::fromPCLPointCloud2 (input_pointcloud2, *input_cloud_ptr);`
`@@ -289,9 +289,8 @@ LCCPSegmentation Parameters: \n\`
`289`	`289`	`PCL_INFO ("Refining supervoxels\n");`
`290`	`290`	`super.refineSupervoxels (2, supervoxel_clusters);`
`291`	`291`	`}`
`292`		`- std::stringstream temp;`
`293`		`- temp << " Nr. Supervoxels: " << supervoxel_clusters.size () << "\n";`
`294`		`- PCL_INFO (temp.str ().c_str ());`
	`292`	`+`
	`293`	`+ PCL_INFO(" Nr. Supervoxels: %zu\n", supervoxel_clusters.size());`
`295`	`294`
`296`	`295`	`PCL_INFO ("Getting supervoxel adjacency\n");`
`297`	`296`	`std::multimap<std::uint32_t, std::uint32_t> supervoxel_adjacency;`