Update clang-format style: 100 columns, and forbid one-line braces

Author: jlblancoc

.clang-format

@@ -1,83 +1,22 @@
-Language:        Cpp
+Language: Cpp
 BasedOnStyle: Google
 # ---
-#AccessModifierOffset: -4
 AlignAfterOpenBracket: AlwaysBreak # Values: Align, DontAlign, AlwaysBreak
 AlignConsecutiveAssignments: true
 AlignConsecutiveDeclarations: true
-#AlignEscapedNewlinesLeft: true
-#AlignOperands:   false
 AlignTrailingComments: false # Should be off, causes many dummy problems!!
-#AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: true
-#AllowShortCaseLabelsOnASingleLine: false
-#AllowShortFunctionsOnASingleLine: Empty
-#AllowShortIfStatementsOnASingleLine: false
-#AllowShortLoopsOnASingleLine: false
-#AlwaysBreakAfterDefinitionReturnType: None
-#AlwaysBreakAfterReturnType: None
-#AlwaysBreakBeforeMultilineStrings: true
-#AlwaysBreakTemplateDeclarations: true
-#BinPackArguments: false
-#BinPackParameters: false
-#BraceWrapping:
-  #AfterClass:      false
-  #AfterControlStatement: false
-  #AfterEnum:       false
-  #AfterFunction:   false
-  #AfterNamespace:  false
-  #AfterObjCDeclaration: false
-  #AfterStruct:     false
-  #AfterUnion:      false
-  #BeforeCatch:     false
-  #BeforeElse:      true
-  #IndentBraces:    false
-#BreakBeforeBinaryOperators: None
+AllowShortBlocksOnASingleLine: false
 BreakBeforeBraces: Allman
-#BreakBeforeTernaryOperators: true
-#BreakConstructorInitializersBeforeComma: false
-ColumnLimit: 80
-#CommentPragmas:  ''
-#ConstructorInitializerAllOnOneLineOrOnePerLine: true
-#ConstructorInitializerIndentWidth: 4
-#ContinuationIndentWidth: 4
-#Cpp11BracedListStyle: true
-#DerivePointerAlignment: false
-#DisableFormat:   false
-#ExperimentalAutoDetectBinPacking: false
-##FixNamespaceComments: true # Not applicable in 3.8
-#ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-#IncludeCategories:
-  #- Regex:           '.*'
-    #Priority:        1
+ColumnLimit: 100
 IndentCaseLabels: true
-IndentWidth:     4
+IndentWidth: 4
 IndentWrappedFunctionNames: true
-#KeepEmptyLinesAtTheStartOfBlocks: true
-#MacroBlockBegin: ''
-#MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-#PenaltyBreakBeforeFirstCallParameter: 19
-#PenaltyBreakComment: 300
-#PenaltyBreakFirstLessLess: 120
-#PenaltyBreakString: 1000
-#PenaltyExcessCharacter: 1000000
-#PenaltyReturnTypeOnItsOwnLine: 200
 DerivePointerAlignment: false
-#PointerAlignment: Left
-ReflowComments:  true # Should be true, otherwise clang-format doesn't touch comments
-SortIncludes:    true
-#SpaceAfterCStyleCast: false
+ReflowComments: true # Should be true, otherwise clang-format doesn't touch comments
+SortIncludes: true
 SpaceBeforeAssignmentOperators: true
-#SpaceBeforeParens: ControlStatements
-#SpaceInEmptyParentheses: false
-#SpacesBeforeTrailingComments: 2
-#SpacesInAngles:  false
-#SpacesInContainerLiterals: true
-#SpacesInCStyleCastParentheses: false
-#SpacesInParentheses: false
-#SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        4
-UseTab:          Never # Available options are Never, Always, ForIndentation
+Standard: Cpp11
+TabWidth: 4
+UseTab: Never # Available options are Never, Always, ForIndentation

examples/KDTreeVectorOfVectorsAdaptor.h

@@ -54,12 +54,10 @@ template <
     class Distance = nanoflann::metric_L2, typename IndexType = size_t>
 struct KDTreeVectorOfVectorsAdaptor
 {
-    using self_t = KDTreeVectorOfVectorsAdaptor<
-        VectorOfVectorsType, num_t, DIM, Distance, IndexType>;
-    using metric_t =
-        typename Distance::template traits<num_t, self_t>::distance_t;
-    using index_t =
-        nanoflann::KDTreeSingleIndexAdaptor<metric_t, self_t, DIM, IndexType>;
+    using self_t =
+        KDTreeVectorOfVectorsAdaptor<VectorOfVectorsType, num_t, DIM, Distance, IndexType>;
+    using metric_t = typename Distance::template traits<num_t, self_t>::distance_t;
+    using index_t  = nanoflann::KDTreeSingleIndexAdaptor<metric_t, self_t, DIM, IndexType>;
 
     /** The kd-tree index for the user to call its methods as usual with any
      * other FLANN index */
@@ -81,8 +79,7 @@ struct KDTreeVectorOfVectorsAdaptor
         index = new index_t(
             static_cast<int>(dims), *this /* adaptor */,
             nanoflann::KDTreeSingleIndexAdaptorParams(
-                leaf_max_size, nanoflann::KDTreeSingleIndexAdaptorFlags::None,
-                n_thread_build));
+                leaf_max_size, nanoflann::KDTreeSingleIndexAdaptorFlags::None, n_thread_build));
     }
 
     ~KDTreeVectorOfVectorsAdaptor() { delete index; }
@@ -95,8 +92,8 @@ struct KDTreeVectorOfVectorsAdaptor
      *  The user can also call index->... methods as desired.
      */
     inline void query(
-        const num_t* query_point, const size_t num_closest,
-        IndexType* out_indices, num_t* out_distances_sq) const
+        const num_t* query_point, const size_t num_closest, IndexType* out_indices,
+        num_t* out_distances_sq) const
     {
         nanoflann::KNNResultSet<num_t, IndexType> resultSet(num_closest);
         resultSet.init(out_indices, out_distances_sq);

examples/SO2_adaptor_example.cpp

@@ -45,8 +45,8 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexAdaptor<
-        nanoflann::SO2_Adaptor<num_t, PointCloud_Orient<num_t>>,
-        PointCloud_Orient<num_t>, 1 /* dim */
+        nanoflann::SO2_Adaptor<num_t, PointCloud_Orient<num_t>>, PointCloud_Orient<num_t>,
+        1 /* dim */
         >;
 
     dump_mem_usage();
@@ -64,8 +64,7 @@ void kdtree_demo(const size_t N)
         index.findNeighbors(resultSet, &query_pt[0]);
 
         std::cout << "knnSearch(nn=" << num_results << "): \n";
-        std::cout << "ret_index=" << ret_index
-                  << " out_dist_sqr=" << out_dist_sqr << std::endl;
+        std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << std::endl;
     }
 }
 

examples/SO3_adaptor_example.cpp

@@ -45,8 +45,7 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexAdaptor<
-        nanoflann::SO3_Adaptor<num_t, PointCloud_Quat<num_t>>,
-        PointCloud_Quat<num_t>, 4 /* dim */
+        nanoflann::SO3_Adaptor<num_t, PointCloud_Quat<num_t>>, PointCloud_Quat<num_t>, 4 /* dim */
         >;
 
     dump_mem_usage();
@@ -64,8 +63,7 @@ void kdtree_demo(const size_t N)
         index.findNeighbors(resultSet, &query_pt[0]);
 
         std::cout << "knnSearch(nn=" << num_results << "): \n";
-        std::cout << "ret_index=" << ret_index
-                  << " out_dist_sqr=" << out_dist_sqr << std::endl;
+        std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << std::endl;
     }
 }
 

examples/dynamic_pointcloud_example.cpp

@@ -40,8 +40,7 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexDynamicAdaptor<
-        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>,
-        PointCloud<num_t>, 3 /* dim */
+        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>, PointCloud<num_t>, 3 /* dim */
         >;
 
     dump_mem_usage();
@@ -78,19 +77,16 @@ void kdtree_demo(const size_t N)
         index.findNeighbors(resultSet, query_pt, {10});
 
         std::cout << "knnSearch(nn=" << num_results << "): \n";
-        std::cout << "ret_index=" << ret_index
-                  << " out_dist_sqr=" << out_dist_sqr << std::endl;
+        std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << std::endl;
         std::cout << "point: ("
-                  << "point: (" << cloud.pts[ret_index].x << ", "
-                  << cloud.pts[ret_index].y << ", " << cloud.pts[ret_index].z
-                  << ")" << std::endl;
+                  << "point: (" << cloud.pts[ret_index].x << ", " << cloud.pts[ret_index].y << ", "
+                  << cloud.pts[ret_index].z << ")" << std::endl;
         std::cout << std::endl;
     }
     {
         // do a knn search searching for more than one result
         const size_t num_results = 5;
-        std::cout << "Searching for " << num_results << " elements"
-                  << std::endl;
+        std::cout << "Searching for " << num_results << " elements" << std::endl;
         size_t                         ret_index[num_results];
         num_t                          out_dist_sqr[num_results];
         nanoflann::KNNResultSet<num_t> resultSet(num_results);
@@ -105,8 +101,8 @@ void kdtree_demo(const size_t N)
                       << "index: " << ret_index[i] << ",\t"
                       << "dist: " << out_dist_sqr[i] << ",\t"
                       << "point: (" << cloud.pts[ret_index[i]].x << ", "
-                      << cloud.pts[ret_index[i]].y << ", "
-                      << cloud.pts[ret_index[i]].z << ")" << std::endl;
+                      << cloud.pts[ret_index[i]].y << ", " << cloud.pts[ret_index[i]].z << ")"
+                      << std::endl;
         }
         std::cout << std::endl;
     }
@@ -115,18 +111,16 @@ void kdtree_demo(const size_t N)
         std::cout << "Unsorted radius search" << std::endl;
         const num_t                                       radiusSqr = 1;
         std::vector<nanoflann::ResultItem<size_t, num_t>> indices_dists;
-        nanoflann::RadiusResultSet<num_t, size_t>         resultSet(
-                    radiusSqr, indices_dists);
+        nanoflann::RadiusResultSet<num_t, size_t>         resultSet(radiusSqr, indices_dists);
 
         index.findNeighbors(resultSet, query_pt);
 
-        nanoflann::ResultItem<size_t, num_t> worst_pair =
-            resultSet.worst_item();
-        std::cout << "Worst pair: idx=" << worst_pair.first
-                  << " dist=" << worst_pair.second << std::endl;
+        nanoflann::ResultItem<size_t, num_t> worst_pair = resultSet.worst_item();
+        std::cout << "Worst pair: idx=" << worst_pair.first << " dist=" << worst_pair.second
+                  << std::endl;
         std::cout << "point: (" << cloud.pts[worst_pair.first].x << ", "
-                  << cloud.pts[worst_pair.first].y << ", "
-                  << cloud.pts[worst_pair.first].z << ")" << std::endl;
+                  << cloud.pts[worst_pair.first].y << ", " << cloud.pts[worst_pair.first].z << ")"
+                  << std::endl;
         std::cout << std::endl;
     }
 }

examples/example_with_cmake/pointcloud_example.cpp

@@ -45,8 +45,7 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexAdaptor<
-        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>,
-        PointCloud<num_t>, 3 /* dim */
+        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>, PointCloud<num_t>, 3 /* dim */
         >;
 
     dump_mem_usage();
@@ -61,26 +60,23 @@ void kdtree_demo(const size_t N)
         num_t                          out_dist_sqr;
         nanoflann::KNNResultSet<num_t> resultSet(num_results);
         resultSet.init(&ret_index, &out_dist_sqr);
-        index.findNeighbors(
-            resultSet, &query_pt[0], nanoflann::SearchParams(10));
+        index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
 
         std::cout << "knnSearch(nn=" << num_results << "): \n";
-        std::cout << "ret_index=" << ret_index
-                  << " out_dist_sqr=" << out_dist_sqr << std::endl;
+        std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << std::endl;
     }
     {
         // Unsorted radius search:
         const num_t                               radius = 1;
         std::vector<std::pair<size_t, num_t>>     indices_dists;
-        nanoflann::RadiusResultSet<num_t, size_t> resultSet(
-            radius, indices_dists);
+        nanoflann::RadiusResultSet<num_t, size_t> resultSet(radius, indices_dists);
 
         index.findNeighbors(resultSet, query_pt, nanoflann::SearchParams());
 
         // Get worst (furthest) point, without sorting:
         std::pair<size_t, num_t> worst_pair = resultSet.worst_item();
-        std::cout << "Worst pair: idx=" << worst_pair.first
-                  << " dist=" << worst_pair.second << std::endl;
+        std::cout << "Worst pair: idx=" << worst_pair.first << " dist=" << worst_pair.second
+                  << std::endl;
     }
 }
 

examples/example_with_pkgconfig/pointcloud_example.cpp

@@ -45,8 +45,7 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexAdaptor<
-        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>,
-        PointCloud<num_t>, 3 /* dim */
+        nanoflann::L2_Simple_Adaptor<num_t, PointCloud<num_t>>, PointCloud<num_t>, 3 /* dim */
         >;
 
     dump_mem_usage();
@@ -61,26 +60,23 @@ void kdtree_demo(const size_t N)
         num_t                          out_dist_sqr;
         nanoflann::KNNResultSet<num_t> resultSet(num_results);
         resultSet.init(&ret_index, &out_dist_sqr);
-        index.findNeighbors(
-            resultSet, &query_pt[0], nanoflann::SearchParams(10));
+        index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
 
         std::cout << "knnSearch(nn=" << num_results << "): \n";
-        std::cout << "ret_index=" << ret_index
-                  << " out_dist_sqr=" << out_dist_sqr << std::endl;
+        std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << std::endl;
     }
     {
         // Unsorted radius search:
         const num_t                               radius = 1;
         std::vector<std::pair<size_t, num_t>>     indices_dists;
-        nanoflann::RadiusResultSet<num_t, size_t> resultSet(
-            radius, indices_dists);
+        nanoflann::RadiusResultSet<num_t, size_t> resultSet(radius, indices_dists);
 
         index.findNeighbors(resultSet, query_pt, nanoflann::SearchParams());
 
         // Get worst (furthest) point, without sorting:
         std::pair<size_t, num_t> worst_pair = resultSet.worst_item();
-        std::cout << "Worst pair: idx=" << worst_pair.first
-                  << " dist=" << worst_pair.second << std::endl;
+        std::cout << "Worst pair: idx=" << worst_pair.first << " dist=" << worst_pair.second
+                  << std::endl;
     }
 }
 

examples/examples_gui/nanoflann_gui_example_R3/nanoflann_gui_example_R3.cpp

@@ -44,7 +44,10 @@
 mrpt::opengl::CPointCloud::Ptr pc_to_viz(const PointCloud<double>& pc)
 {
     auto gl = mrpt::opengl::CPointCloud::Create();
-    for (const auto pt : pc.pts) { gl->insertPoint(pt.x, pt.y, pt.z); }
+    for (const auto pt : pc.pts)
+    {
+        gl->insertPoint(pt.x, pt.y, pt.z);
+    }
     gl->setPointSize(3.0f);
     return gl;
 }
@@ -91,8 +94,7 @@ void kdtree_demo(const size_t N)
 
     // construct a kd-tree index:
     using my_kd_tree_t = nanoflann::KDTreeSingleIndexAdaptor<
-        nanoflann::L2_Simple_Adaptor<double, PointCloud<double>>,
-        PointCloud<double>, 3 /* dim */
+        nanoflann::L2_Simple_Adaptor<double, PointCloud<double>>, PointCloud<double>, 3 /* dim */
         >;
 
     mrpt::system::CTimeLogger profiler;
@@ -127,22 +129,19 @@ void kdtree_demo(const size_t N)
         const size_t nnToSearch = (rng.drawUniform32bit() % 10) + 1;
 #endif
         const double queryPt[3] = {
-            rng.drawUniform(-0.3, maxRangeXY + 0.3),
-            rng.drawUniform(-0.3, maxRangeXY + 0.3),
+            rng.drawUniform(-0.3, maxRangeXY + 0.3), rng.drawUniform(-0.3, maxRangeXY + 0.3),
             rng.drawUniform(-0.3, maxRangeZ + 0.3)};
 
         mrpt::system::CTimeLoggerEntry tle2(profiler, "query");
 
 #if defined(USE_RADIUS_SEARCH)
         indicesDists.clear();
-        nanoflann::RadiusResultSet<double, size_t> resultSet(
-            sqRadius, indicesDists);
+        nanoflann::RadiusResultSet<double, size_t> resultSet(sqRadius, indicesDists);
         index.findNeighbors(resultSet, queryPt);
 #else
 
 #if defined(USE_RKNN_SEARCH)
-        nanoflann::RKNNResultSet<double, size_t> resultSet(
-            nnToSearch, sqRadius);
+        nanoflann::RKNNResultSet<double, size_t> resultSet(nnToSearch, sqRadius);
 #elif defined(USE_KNN_SEARCH)
         nanoflann::KNNResultSet<double, size_t> resultSet(nnToSearch);
 #else
@@ -162,20 +161,17 @@ void kdtree_demo(const size_t N)
 #endif
         tle2.stop();
 
-        std::cout << "\nQuery point: (" << queryPt[0] << "," << queryPt[1]
-                  << "," << queryPt[2] << ") => " << resultSet.size()
-                  << " results.\n";
+        std::cout << "\nQuery point: (" << queryPt[0] << "," << queryPt[1] << "," << queryPt[2]
+                  << ") => " << resultSet.size() << " results.\n";
 
         if (!resultSet.empty())
         {
 #if defined(USE_RADIUS_SEARCH)
-            nanoflann::ResultItem<size_t, double> worstPair =
-                resultSet.worst_item();
+            nanoflann::ResultItem<size_t, double> worstPair = resultSet.worst_item();
             std::cout << "Worst pair: idx=" << worstPair.first
                       << " dist=" << std::sqrt(worstPair.second) << std::endl;
 #else
-            std::cout << "nnToSearch=" << nnToSearch
-                      << " actual found=" << indices.size()
+            std::cout << "nnToSearch=" << nnToSearch << " actual found=" << indices.size()
                       << " Worst found dist=" << worstDist << std::endl;
 #endif
         }