Fix unused-but-set-variable warnings of Clang 15

SunBlack · SunBlack · commit 9f9994726792 · 2022-12-02T16:42:35.000+01:00
diff --git a/common/src/io.cpp b/common/src/io.cpp
@@ -93,9 +93,6 @@ pcl::concatenateFields (const pcl::PCLPointCloud2 &cloud1,
   cloud_out.height = cloud2.height;
   cloud_out.is_bigendian = cloud2.is_bigendian;
 
-  //We need to find how many fields overlap between the two clouds
-  std::size_t total_fields = cloud2.fields.size ();
-
   //for the non-matching fields in cloud1, we need to store the offset
   //from the beginning of the point
   std::vector<const pcl::PCLPointField*> cloud1_unique_fields;
@@ -142,8 +139,6 @@ pcl::concatenateFields (const pcl::PCLPointCloud2 &cloud1,
         size = cloud1.point_step - cloud1_fields_sorted[i]->offset;
 
       field_sizes.push_back (size);
-
-      total_fields++;
     }
   }
 
diff --git a/gpu/people/src/face_detector.cpp b/gpu/people/src/face_detector.cpp
@@ -120,8 +120,6 @@ pcl::gpu::people::FaceDetector::loadFromXML2(const std::string
   haar.bHasStumpsOnly = true;
   haar.bNeedsTiltedII = false;
 
-  Ncv32u cur_max_tree_depth;
-
   std::vector<HaarClassifierNode128> host_temp_classifier_not_root_nodes;
   haar_stages.resize(0);
   haarClassifierNodes.resize(0);
@@ -258,15 +256,13 @@ pcl::gpu::people::FaceDetector::loadFromXML2(const std::string
                     {
                         //root node
                         haarClassifierNodes.push_back(current_node);
-                        cur_max_tree_depth = 1;
                     }
                     else
                     {
                         //other node
                         host_temp_classifier_not_root_nodes.push_back(current_node);
                         // TODO replace with PCL_DEBUG in the future
                         PCL_INFO("[pcl::gpu::people::FaceDetector::loadFromXML2] : (I) : Found non root node number %d", host_temp_classifier_not_root_nodes.size());
-                        cur_max_tree_depth++;
                     }
                     node_identifier++;
                   }
diff --git a/io/src/obj_io.cpp b/io/src/obj_io.cpp
@@ -678,7 +678,6 @@ pcl::OBJReader::read (const std::string &file_name, pcl::TextureMesh &mesh,
   try
   {
     std::size_t vn_idx = 0;
-    std::size_t vt_idx = 0;
 
     while (!fs.eof ())
     {
@@ -747,7 +746,6 @@ pcl::OBJReader::read (const std::string &file_name, pcl::TextureMesh &mesh,
             coordinates.emplace_back(c[0], c[1]);
           else
             coordinates.emplace_back(c[0]/c[2], c[1]/c[2]);
-          ++vt_idx;
         }
         catch (const boost::bad_lexical_cast&)
         {
diff --git a/io/src/ply/ply_parser.cpp b/io/src/ply/ply_parser.cpp
@@ -52,9 +52,6 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)
 
   std::size_t number_of_format_statements = 0;
   std::size_t number_of_element_statements = 0;
-  std::size_t number_of_property_statements = 0;
-  std::size_t number_of_obj_info_statements = 0;
-  std::size_t number_of_comment_statements = 0;
 
   format_type format = pcl::io::ply::unknown;
   std::vector<std::shared_ptr<element>> elements;
@@ -262,7 +259,6 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)
           error_callback_ (line_number_, "parse error: unknown type");
           return false;
         }
-        ++number_of_property_statements;
       }
       else
       {
@@ -418,22 +414,19 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)
           error_callback_ (line_number_, "parse error: unknown list size type");
           return false;
         }
-        ++number_of_property_statements;
       }
     }
 
     // comment
     else if (keyword == "comment")
     {
       comment_callback_ (line);
-      ++number_of_comment_statements;
     }
 
     // obj_info
     else if (keyword == "obj_info")
     {
       obj_info_callback_ (line);
-      ++number_of_obj_info_statements;
     }
 
     // end_header
diff --git a/ml/src/svm.cpp b/ml/src/svm.cpp
@@ -3365,8 +3365,6 @@ svm_load_model(const char* model_file_name)
       model->sv_coef[k][i] = strtod(p, nullptr);
     }
 
-    int jj = 0;
-
     while (true) {
       char* idx = strtok(nullptr, ":");
       char* val = strtok(nullptr, " \t");
@@ -3378,10 +3376,6 @@ svm_load_model(const char* model_file_name)
 
       x_space[j].value = strtod(val, nullptr);
 
-      //             printf("i=%d, j=%d, %f ,%d e %f\n",i,j,model->sv_coef[0][i],
-      //                    model->SV[i][jj].index, model->SV[i][jj].value);
-      jj++;
-
       ++j;
     }
 
diff --git a/ml/src/svm_wrapper.cpp b/ml/src/svm_wrapper.cpp
@@ -680,8 +680,6 @@ pcl::SVMClassify::classification()
                getClassName().c_str());
   }
 
-  // int correct = 0;
-  int total = 0;
   int svm_type = svm_get_svm_type(&model_);
   int nr_class = svm_get_nr_class(&model_);
 
@@ -724,8 +722,6 @@ pcl::SVMClassify::classification()
       prediction_[ii].push_back(predict_label);
     }
 
-    ++total;
-
     ii++;
   }
 
diff --git a/recognition/include/pcl/recognition/face_detection/rf_face_utils.h b/recognition/include/pcl/recognition/face_detection/rf_face_utils.h
@@ -368,7 +368,6 @@ namespace pcl
             std::vector < std::vector<ExampleIndex> > positive_examples;
             positive_examples.resize (num_of_branches + 1);
 
-            std::size_t pos = 0;
             for (std::size_t example_index = 0; example_index < num_of_examples; ++example_index)
             {
               unsigned char branch_index;
@@ -383,7 +382,6 @@ namespace pcl
 
                 positive_examples[branch_index].push_back (examples[example_index]);
                 positive_examples[num_of_branches].push_back (examples[example_index]);
-                pos++;
               }
             }
 
diff --git a/segmentation/include/pcl/segmentation/impl/cpc_segmentation.hpp b/segmentation/include/pcl/segmentation/impl/cpc_segmentation.hpp
@@ -199,7 +199,6 @@ pcl::CPCSegmentation<PointT>::applyCuttingPlane (std::uint32_t depth_levels_left
       for (const auto &cluster_index : cluster_indices)
       {
         // get centroids of vertices        
-        int cluster_concave_pts = 0;
         float cluster_score = 0;
 //         std::cout << "Cluster has " << cluster_indices[cc].indices.size () << " points" << std::endl;
         for (const auto &current_index : cluster_index.indices)
@@ -208,8 +207,6 @@ pcl::CPCSegmentation<PointT>::applyCuttingPlane (std::uint32_t depth_levels_left
           if (use_directed_weights_)
             index_score *= 1.414 * (std::abs (plane_normal.dot (edge_cloud_cluster->at (current_index).getNormalVector3fMap ())));
           cluster_score += index_score;
-          if (weights[current_index] > 0)
-            ++cluster_concave_pts;
         }
         // check if the score is below the threshold. If that is the case this segment should not be split
         cluster_score /= cluster_index.indices.size ();
diff --git a/segmentation/include/pcl/segmentation/impl/lccp_segmentation.hpp b/segmentation/include/pcl/segmentation/impl/lccp_segmentation.hpp
@@ -177,7 +177,6 @@ pcl::LCCPSegmentation<PointT>::mergeSmallSegments ()
   while (continue_filtering)
   {
     continue_filtering = false;
-    unsigned int nr_filtered = 0;
 
     VertexIterator sv_itr, sv_itr_end;
     // Iterate through all supervoxels, check if they are in a "small" segment -> change label to largest neighborID
@@ -195,7 +194,6 @@ pcl::LCCPSegmentation<PointT>::mergeSmallSegments ()
       if (seg_label_to_sv_list_map_[current_seg_label].size () <= min_segment_size_)
       {
         continue_filtering = true;
-        nr_filtered++;
 
         // Find largest neighbor
         for (auto neighbors_itr = seg_label_to_neighbor_set_map_[current_seg_label].cbegin (); neighbors_itr != seg_label_to_neighbor_set_map_[current_seg_label].cend (); ++neighbors_itr)
diff --git a/surface/include/pcl/surface/impl/gp3.hpp b/surface/include/pcl/surface/impl/gp3.hpp
@@ -134,7 +134,7 @@ pcl::GreedyProjectionTriangulation<PointInT>::reconstructPolygons (std::vector<p
   }
 
   // Initializing
-  int is_free=0, nr_parts=0, increase_nnn4fn=0, increase_nnn4s=0, increase_dist=0, nr_touched = 0;
+  int is_free=0, nr_parts=0, increase_nnn4fn=0, increase_nnn4s=0, increase_dist=0;
   angles_.resize(nnn_);
   std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> > uvn_nn (nnn_);
   Eigen::Vector2f uvn_s;
@@ -909,10 +909,6 @@ pcl::GreedyProjectionTriangulation<PointInT>::reconstructPolygons (std::vector<p
           prev_is_sfn_ = (sfn_[current_index_] == angles_[*(it-1)].index) && (!gaps[*(it-1)]);
           next_is_ffn_ = (ffn_[current_index_] == angles_[*(it+1)].index) && (!gaps[*it]);
           next_is_sfn_ = (sfn_[current_index_] == angles_[*(it+1)].index) && (!gaps[*it]);
-          if (!prev_is_ffn_ && !next_is_sfn_ && !prev_is_sfn_ && !next_is_ffn_)
-          {
-            nr_touched++;
-          }
         }
                                    
         if (gaps[*it])
diff --git a/surface/include/pcl/surface/impl/grid_projection.hpp b/surface/include/pcl/surface/impl/grid_projection.hpp
@@ -651,7 +651,6 @@ pcl::GridProjection<PointNT>::reconstructPolygons (std::vector<pcl::Vertices> &p
   }
 
   Eigen::Vector3i index;
-  int numOfFilledPad = 0;
 
   for (int i = 0; i < data_size_; ++i)
   {
@@ -665,7 +664,6 @@ pcl::GridProjection<PointNT>::reconstructPolygons (std::vector<pcl::Vertices> &p
         if (occupied_cell_list_[getIndexIn1D (index)])
         {
           fillPad (index);
-          numOfFilledPad++;
         }
       }
     }
diff --git a/surface/src/on_nurbs/sequential_fitter.cpp b/surface/src/on_nurbs/sequential_fitter.cpp
@@ -493,7 +493,6 @@ SequentialFitter::grow (float max_dist, float max_angle, unsigned min_length, un
   }
 
   float angle = std::cos (max_angle);
-  unsigned bnd_moved (0);
 
   for (unsigned i = 0; i < num_bnd; i++)
   {
@@ -584,7 +583,6 @@ SequentialFitter::grow (float max_dist, float max_angle, unsigned min_length, un
       this->m_data.boundary[i] (0) = point.x;
       this->m_data.boundary[i] (1) = point.y;
       this->m_data.boundary[i] (2) = point.z;
-      bnd_moved++;
     }
 
   } // i
diff --git a/tools/virtual_scanner.cpp b/tools/virtual_scanner.cpp
@@ -255,7 +255,6 @@ main (int argc, char** argv)
   if (single_view)
     number_of_points = 1;
 
-  int sid = -1;
   for (int i = 0; i < number_of_points; i++)
   {
     // Clear cloud for next view scan
@@ -334,18 +333,13 @@ main (int argc, char** argv)
     // Sweep vertically
     for (double vert = vert_start; vert <= vert_end; vert += sp.vert_res)
     {
-      sid++;
-
       tr1->Identity ();
       tr1->RotateWXYZ (vert, right);
       tr1->InternalTransformPoint (viewray, temp_beam);
 
       // Sweep horizontally
-      int pid = -1;
       for (double hor = hor_start; hor <= hor_end; hor += sp.hor_res)
       {
-        pid ++;
-
         // Create a beam vector with (lat,long) angles (vert, hor) with the viewray
         tr2->Identity ();
         tr2->RotateWXYZ (hor, up);

Original file line number	Diff line number	Diff line change
`@@ -120,8 +120,6 @@ pcl::gpu::people::FaceDetector::loadFromXML2(const std::string`
`120`	`120`	`haar.bHasStumpsOnly = true;`
`121`	`121`	`haar.bNeedsTiltedII = false;`
`122`	`122`
`123`		`- Ncv32u cur_max_tree_depth;`
`124`		`-`
`125`	`123`	`std::vector<HaarClassifierNode128> host_temp_classifier_not_root_nodes;`
`126`	`124`	`haar_stages.resize(0);`
`127`	`125`	`haarClassifierNodes.resize(0);`
`@@ -258,15 +256,13 @@ pcl::gpu::people::FaceDetector::loadFromXML2(const std::string`
`258`	`256`	`{`
`259`	`257`	`//root node`
`260`	`258`	`haarClassifierNodes.push_back(current_node);`
`261`		`- cur_max_tree_depth = 1;`
`262`	`259`	`}`
`263`	`260`	`else`
`264`	`261`	`{`
`265`	`262`	`//other node`
`266`	`263`	`host_temp_classifier_not_root_nodes.push_back(current_node);`
`267`	`264`	`// TODO replace with PCL_DEBUG in the future`
`268`	`265`	`PCL_INFO("[pcl::gpu::people::FaceDetector::loadFromXML2] : (I) : Found non root node number %d", host_temp_classifier_not_root_nodes.size());`
`269`		`- cur_max_tree_depth++;`
`270`	`266`	`}`
`271`	`267`	`node_identifier++;`
`272`	`268`	`}`
Original file line number	Diff line number	Diff line change
`@@ -678,7 +678,6 @@ pcl::OBJReader::read (const std::string &file_name, pcl::TextureMesh &mesh,`
`678`	`678`	`try`
`679`	`679`	`{`
`680`	`680`	`std::size_t vn_idx = 0;`
`681`		`- std::size_t vt_idx = 0;`
`682`	`681`
`683`	`682`	`while (!fs.eof ())`
`684`	`683`	`{`
`@@ -747,7 +746,6 @@ pcl::OBJReader::read (const std::string &file_name, pcl::TextureMesh &mesh,`
`747`	`746`	`coordinates.emplace_back(c[0], c[1]);`
`748`	`747`	`else`
`749`	`748`	`coordinates.emplace_back(c[0]/c[2], c[1]/c[2]);`
`750`		`- ++vt_idx;`
`751`	`749`	`}`
`752`	`750`	`catch (const boost::bad_lexical_cast&)`
`753`	`751`	`{`
Original file line number	Diff line number	Diff line change
`@@ -52,9 +52,6 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)`
`52`	`52`
`53`	`53`	`std::size_t number_of_format_statements = 0;`
`54`	`54`	`std::size_t number_of_element_statements = 0;`
`55`		`- std::size_t number_of_property_statements = 0;`
`56`		`- std::size_t number_of_obj_info_statements = 0;`
`57`		`- std::size_t number_of_comment_statements = 0;`
`58`	`55`
`59`	`56`	`format_type format = pcl::io::ply::unknown;`
`60`	`57`	`std::vector<std::shared_ptr<element>> elements;`
`@@ -262,7 +259,6 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)`
`262`	`259`	`error_callback_ (line_number_, "parse error: unknown type");`
`263`	`260`	`return false;`
`264`	`261`	`}`
`265`		`- ++number_of_property_statements;`
`266`	`262`	`}`
`267`	`263`	`else`
`268`	`264`	`{`
`@@ -418,22 +414,19 @@ bool pcl::io::ply::ply_parser::parse (const std::string& filename)`
`418`	`414`	`error_callback_ (line_number_, "parse error: unknown list size type");`
`419`	`415`	`return false;`
`420`	`416`	`}`
`421`		`- ++number_of_property_statements;`
`422`	`417`	`}`
`423`	`418`	`}`
`424`	`419`
`425`	`420`	`// comment`
`426`	`421`	`else if (keyword == "comment")`
`427`	`422`	`{`
`428`	`423`	`comment_callback_ (line);`
`429`		`- ++number_of_comment_statements;`
`430`	`424`	`}`
`431`	`425`
`432`	`426`	`// obj_info`
`433`	`427`	`else if (keyword == "obj_info")`
`434`	`428`	`{`
`435`	`429`	`obj_info_callback_ (line);`
`436`		`- ++number_of_obj_info_statements;`
`437`	`430`	`}`
`438`	`431`
`439`	`432`	`// end_header`
Original file line number	Diff line number	Diff line change
`@@ -680,8 +680,6 @@ pcl::SVMClassify::classification()`
`680`	`680`	`getClassName().c_str());`
`681`	`681`	`}`
`682`	`682`
`683`		`- // int correct = 0;`
`684`		`- int total = 0;`
`685`	`683`	`int svm_type = svm_get_svm_type(&model_);`
`686`	`684`	`int nr_class = svm_get_nr_class(&model_);`
`687`	`685`
`@@ -724,8 +722,6 @@ pcl::SVMClassify::classification()`
`724`	`722`	`prediction_[ii].push_back(predict_label);`
`725`	`723`	`}`
`726`	`724`
`727`		`- ++total;`
`728`		`-`
`729`	`725`	`ii++;`
`730`	`726`	`}`
`731`	`727`
Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,6 @@ namespace pcl`
`368`	`368`	`std::vector < std::vector<ExampleIndex> > positive_examples;`
`369`	`369`	`positive_examples.resize (num_of_branches + 1);`
`370`	`370`
`371`		`- std::size_t pos = 0;`
`372`	`371`	`for (std::size_t example_index = 0; example_index < num_of_examples; ++example_index)`
`373`	`372`	`{`
`374`	`373`	`unsigned char branch_index;`
`@@ -383,7 +382,6 @@ namespace pcl`
`383`	`382`
`384`	`383`	`positive_examples[branch_index].push_back (examples[example_index]);`
`385`	`384`	`positive_examples[num_of_branches].push_back (examples[example_index]);`
`386`		`- pos++;`
`387`	`385`	`}`
`388`	`386`	`}`
`389`	`387`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,6 @@ pcl::LCCPSegmentation<PointT>::mergeSmallSegments ()`
`177`	`177`	`while (continue_filtering)`
`178`	`178`	`{`
`179`	`179`	`continue_filtering = false;`
`180`		`- unsigned int nr_filtered = 0;`
`181`	`180`
`182`	`181`	`VertexIterator sv_itr, sv_itr_end;`
`183`	`182`	`// Iterate through all supervoxels, check if they are in a "small" segment -> change label to largest neighborID`
`@@ -195,7 +194,6 @@ pcl::LCCPSegmentation<PointT>::mergeSmallSegments ()`
`195`	`194`	`if (seg_label_to_sv_list_map_[current_seg_label].size () <= min_segment_size_)`
`196`	`195`	`{`
`197`	`196`	`continue_filtering = true;`
`198`		`- nr_filtered++;`
`199`	`197`
`200`	`198`	`// Find largest neighbor`
`201`	`199`	`for (auto neighbors_itr = seg_label_to_neighbor_set_map_[current_seg_label].cbegin (); neighbors_itr != seg_label_to_neighbor_set_map_[current_seg_label].cend (); ++neighbors_itr)`