gcc warnings removed

Author: krzysg

examples/Example_apr_iterate.cpp

@@ -246,7 +246,7 @@ int main(int argc, char **argv) {
 
     for (int level = apr_iterator.level_min(); level <= apr_iterator.level_max(); ++level) {
 
-        int z = 0;
+        unsigned int z = 0;
 #ifdef HAVE_OPENMP
 	#pragma omp parallel for schedule(static) private(particle_number,z) firstprivate(apr_iterator) reduction(+:counter)
 #endif

src/algorithm/APRConverter.hpp

@@ -211,8 +211,8 @@ void APRConverter<ImageType>::get_local_particle_cell_set(MeshData<T>& grad_imag
     float min_dim = std::min(this->par.dy,std::min(this->par.dx,this->par.dz));
     float level_factor = pow(2,(*apr).level_max())*min_dim;
 
-    unsigned int l_max = (*apr).level_max() - 1;
-    unsigned int l_min = (*apr).level_min();
+    int l_max = (*apr).level_max() - 1;
+    int l_min = (*apr).level_min();
 
     fine_grained_timer.start_timer("compute_level_second");
     //incorporate other factors and compute the level of the Particle Cell, effectively construct LPC L_n
@@ -308,12 +308,12 @@ void APRConverter<ImageType>::get_local_intensity_scale(const MeshData<T>& input
     std::vector<int> var_win;
     get_window(var_rescale,var_win,this->par);
 
-    int win_y = var_win[0];
-    int win_x = var_win[1];
-    int win_z = var_win[2];
-    int win_y2 = var_win[3];
-    int win_x2 = var_win[4];
-    int win_z2 = var_win[5];
+    size_t win_y = var_win[0];
+    size_t win_x = var_win[1];
+    size_t win_z = var_win[2];
+    size_t win_y2 = var_win[3];
+    size_t win_x2 = var_win[4];
+    size_t win_z2 = var_win[5];
 
     fine_grained_timer.start_timer("calc_sat_mean_y");
     calc_sat_mean_y(local_scale_temp,win_y);
@@ -418,7 +418,7 @@ void APRConverter<ImageType>::auto_parameters(const MeshData<T>& input_img){
     uint64_t min_j = 0;
 
     // set to start at one to ignore potential constant regions thresholded out. (Common in some images)
-    for (int j = 1; j < num_bins; ++j) {
+    for (unsigned int j = 1; j < num_bins; ++j) {
         prop_total += freq[j]/(counter*1.0);
 
         if(prop_total > prop_total_th){
@@ -471,7 +471,7 @@ void APRConverter<ImageType>::auto_parameters(const MeshData<T>& input_img){
 
     patches.resize(std::min(local_max,(uint64_t)10000));
 
-    for (int l = 0; l < patches.size(); ++l) {
+    for (unsigned int l = 0; l < patches.size(); ++l) {
         patches[l].resize(27, 0);
     }
 

src/algorithm/ComputeGradient.hpp

@@ -264,39 +264,39 @@ void ComputeGradient::bspline_filt_rec_z(MeshData<T>& image,float lambda,float t
     //////////////////////////////////////////////////////////////
 
     std::vector<float> impulse_resp_vec_f(k0+3);  //forward
-    for (int64_t k = 0; k < (k0+3);k++){
+    for (size_t k = 0; k < (k0+3);k++){
         impulse_resp_vec_f[k] = impulse_resp(k,rho,omg);
     }
 
     std::vector<float> impulse_resp_vec_b(k0+3);  //backward
-    for (int64_t k = 0; k < (k0+3);k++){
+    for (size_t k = 0; k < (k0+3);k++){
         impulse_resp_vec_b[k] = impulse_resp_back(k,rho,omg,gamma,c0);
     }
 
     std::vector<float> bc1_vec(k0, 0);  //forward
     //y(1) init
     bc1_vec[1] = impulse_resp_vec_f[0];
-    for( int64_t k = 0; k < k0; k++){
+    for(size_t k = 0; k < k0; k++){
         bc1_vec[k] += impulse_resp_vec_f[k+1];
     }
 
     std::vector<float> bc2_vec(k0, 0);  //backward
     //y(0) init
-    for( int64_t k = 0; k < k0; k++){
+    for(size_t k = 0; k < k0; k++){
         bc2_vec[k] = impulse_resp_vec_f[k];
     }
 
     std::vector<float> bc3_vec(k0, 0);  //forward
     //y(N-1) init
     bc3_vec[0] = impulse_resp_vec_b[1];
-    for( int64_t k = 0; k < (k0-1); k++){
+    for(size_t k = 0; k < (k0-1); k++){
         bc3_vec[k+1] += impulse_resp_vec_b[k] + impulse_resp_vec_b[k+2];
     }
 
     std::vector<float> bc4_vec(k0, 0);  //backward
     //y(N) init
     bc4_vec[0] = impulse_resp_vec_b[0];
-    for( int64_t k = 1; k < k0; k++){
+    for(size_t k = 1; k < k0; k++){
         bc4_vec[k] += 2*impulse_resp_vec_b[k];
     }
 
@@ -419,39 +419,39 @@ void ComputeGradient::bspline_filt_rec_x(MeshData<T>& image,float lambda,float t
     //////////////////////////////////////////////////////////////
 
     std::vector<float> impulse_resp_vec_f(k0+3);  //forward
-    for (int64_t k = 0; k < (k0+3);k++){
+    for (size_t k = 0; k < (k0+3);k++){
         impulse_resp_vec_f[k] = impulse_resp(k,rho,omg);
     }
 
     std::vector<float> impulse_resp_vec_b(k0+3);  //backward
-    for (int64_t k = 0; k < (k0+3);k++){
+    for (size_t k = 0; k < (k0+3);k++){
         impulse_resp_vec_b[k] = impulse_resp_back(k,rho,omg,gamma,c0);
     }
 
     std::vector<float> bc1_vec(k0, 0);  //forward
     //y(1) init
     bc1_vec[1] = impulse_resp_vec_f[0];
-    for( int64_t k = 0; k < k0;k++){
+    for(size_t k = 0; k < k0;k++){
         bc1_vec[k] += impulse_resp_vec_f[k+1];
     }
 
     std::vector<float> bc2_vec(k0, 0);  //backward
     //y(0) init
-    for( int64_t k = 0; k < k0;k++){
+    for(size_t k = 0; k < k0;k++){
         bc2_vec[k] = impulse_resp_vec_f[k];
     }
 
     std::vector<float> bc3_vec(k0, 0);  //forward
     //y(N-1) init
     bc3_vec[0] = impulse_resp_vec_b[1];
-    for( int64_t k = 0; k < (k0-1);k++){
+    for(size_t k = 0; k < (k0-1);k++){
         bc3_vec[k+1] += impulse_resp_vec_b[k] + impulse_resp_vec_b[k+2];
     }
 
     std::vector<float> bc4_vec(k0, 0);  //backward
     //y(N) init
     bc4_vec[0] = impulse_resp_vec_b[0];
-    for( int64_t k = 1; k < k0;k++){
+    for(size_t k = 1; k < k0;k++){
         bc4_vec[k] += 2*impulse_resp_vec_b[k];
     }
 

src/algorithm/LocalIntensityScale.hpp

@@ -14,18 +14,17 @@ class LocalIntensityScale {
     void calc_abs_diff(const MeshData<T> &input_image, MeshData<T> &var);
 
     template<typename T>
-    void calc_sat_mean_z(MeshData<T> &input, const int offset);
+    void calc_sat_mean_z(MeshData<T> &input, const size_t offset);
 
     template<typename T>
-    void calc_sat_mean_x(MeshData<T> &input, const int offset);
+    void calc_sat_mean_x(MeshData<T> &input, const size_t offset);
 
     template<typename T>
-    void calc_sat_mean_y(MeshData<T> &input, const int offset);
+    void calc_sat_mean_y(MeshData<T> &input, const size_t offset);
 
     void get_window(float &var_rescale, std::vector<int> &var_win, const APRParameters &par);
     template<typename T>
     void rescale_var_and_threshold(MeshData<T>& var,const float var_rescale, const APRParameters& par);
-
 };
 
 template<typename T>
@@ -104,7 +103,7 @@ void LocalIntensityScale::get_window(float& var_rescale, std::vector<int>& var_w
  * @param offset
  */
 template<typename T>
-void LocalIntensityScale::calc_sat_mean_y(MeshData<T>& input, const int offset){
+void LocalIntensityScale::calc_sat_mean_y(MeshData<T>& input, const size_t offset){
     const size_t z_num = input.z_num;
     const size_t x_num = input.x_num;
     const size_t y_num = input.y_num;
@@ -163,7 +162,7 @@ void LocalIntensityScale::calc_sat_mean_y(MeshData<T>& input, const int offset){
 }
 
 template<typename T>
-void LocalIntensityScale::calc_sat_mean_x(MeshData<T>& input, const int offset) {
+void LocalIntensityScale::calc_sat_mean_x(MeshData<T>& input, const size_t offset) {
     const size_t z_num = input.z_num;
     const size_t x_num = input.x_num;
     const size_t y_num = input.y_num;
@@ -195,7 +194,7 @@ void LocalIntensityScale::calc_sat_mean_x(MeshData<T>& input, const int offset)
 
         // middle
         size_t current_index = offset + 1;
-        size_t index_modulo;
+        size_t index_modulo = 0;
         for(size_t i = offset + 1; i < x_num - offset; i++){
             // the current cumsum
             index_modulo = (current_index + offset) % (2*offset + 1); // current_index - offset - 1
@@ -224,7 +223,7 @@ void LocalIntensityScale::calc_sat_mean_x(MeshData<T>& input, const int offset)
 }
 
 template<typename T>
-void LocalIntensityScale::calc_sat_mean_z(MeshData<T>& input,const int offset) {
+void LocalIntensityScale::calc_sat_mean_z(MeshData<T>& input,const size_t offset) {
     const size_t z_num = input.z_num;
     const size_t x_num = input.x_num;
     const size_t y_num = input.y_num;
@@ -259,7 +258,7 @@ void LocalIntensityScale::calc_sat_mean_z(MeshData<T>& input,const int offset) {
 
         // middle
         size_t current_index = offset + 1;
-        size_t index_modulo;
+        size_t index_modulo = 0;
         for(size_t j = offset + 1; j < z_num - offset; j++){
 
             index_modulo = (current_index + offset) % (2*offset + 1); // current_index - offset - 1

src/algorithm/PullingScheme.hpp

@@ -87,7 +87,7 @@ void PullingScheme::initialize_particle_cell_tree(APR<T>& apr) {
     //make so you can reference the array as l
     particle_cell_tree.resize(l_max + 1);
 
-    for (int l = l_min; l < (l_max + 1) ;l ++){
+    for (unsigned int l = l_min; l < (l_max + 1) ;l ++){
         particle_cell_tree[l].init(ceil((1.0 * apr.apr_access.org_dims[0]) / pow(2.0, 1.0 * l_max - l + 1)),
                                    ceil((1.0 * apr.apr_access.org_dims[1]) / pow(2.0, 1.0 * l_max - l + 1)),
                                    ceil((1.0 * apr.apr_access.org_dims[2]) / pow(2.0, 1.0 * l_max - l + 1)), EMPTY);
@@ -107,8 +107,8 @@ void PullingScheme::pulling_scheme_main() {
 
 
     //loop over all levels from l_max to l_min
-    for (int level = l_max; level >= l_min; --level) {
-        if (level != l_max) {
+    for (int level = l_max; level >= (int)l_min; --level) {
+        if (level != (int)l_max) {
             set_ascendant_neighbours(level); //step 1 and step 2.
             set_filler(level); // step 3.
         }
@@ -197,23 +197,23 @@ void PullingScheme::set_ascendant_neighbours(int level) {
 
 void PullingScheme::set_filler(int level) {
     short children_boundaries[3] = {2,2,2};
-    const size_t x_num = particle_cell_tree[level].x_num;
-    const size_t y_num = particle_cell_tree[level].y_num;
-    const size_t z_num = particle_cell_tree[level].z_num;
+    const int64_t x_num = particle_cell_tree[level].x_num;
+    const int64_t y_num = particle_cell_tree[level].y_num;
+    const int64_t z_num = particle_cell_tree[level].z_num;
 
-    size_t prev_x_num = particle_cell_tree[level + 1].x_num;
-    size_t prev_y_num = particle_cell_tree[level + 1].y_num;
-    size_t prev_z_num = particle_cell_tree[level + 1].z_num;
+    int64_t prev_x_num = particle_cell_tree[level + 1].x_num;
+    int64_t prev_y_num = particle_cell_tree[level + 1].y_num;
+    int64_t prev_z_num = particle_cell_tree[level + 1].z_num;
 
     #ifdef HAVE_OPENMP
 	#pragma omp parallel for default(shared) if (z_num * x_num * y_num > 10000) firstprivate(level, children_boundaries)
     #endif
-    for (size_t j = 0; j < z_num; ++j) {
+    for (int64_t j = 0; j < z_num; ++j) {
         if ( j == z_num - 1 && prev_z_num % 2 ) {
             children_boundaries[0] = 1;
         }
 
-        for (size_t i = 0; i < x_num; ++i) {
+        for (int64_t i = 0; i < x_num; ++i) {
 
             if ( i == x_num - 1 && prev_x_num % 2 ) {
                 children_boundaries[1] = 1;
@@ -224,7 +224,7 @@ void PullingScheme::set_filler(int level) {
 
             size_t index = j*x_num*y_num + i*y_num;
 
-            for (size_t k = 0; k < y_num; ++k) {
+            for (int64_t k = 0; k < y_num; ++k) {
                 if ( k == y_num - 1 && prev_y_num % 2 ) {
                     children_boundaries[2] = 1;
                 }

src/data_structures/APR/APR.hpp

@@ -73,13 +73,13 @@ class APR {
     template< typename S>
     void write_particles_only( std::string save_loc,std::string file_name,ExtraParticleData<S>& parts_extra){
         apr_writer.write_particles_only(save_loc, file_name, parts_extra);
-    };
+    }
 
     //read in ExtraPartCellData
     template<typename T>
     void read_parts_only(std::string file_name,ExtraParticleData<T>& extra_parts){
         apr_writer.read_parts_only(file_name,extra_parts);
-    };
+    }
 
     ////////////////////////
     ///

src/data_structures/APR/APRAccess.hpp

@@ -494,9 +494,6 @@ class APRAccess {
                 const size_t offset_pc_data3 = std::min(x_num_us*(2*z_+1) + (2*x_), x_num_us*z_num_us - 1);
                 const size_t offset_pc_data4 = std::min(x_num_us*(2*z_+1) + (2*x_+1), x_num_us*z_num_us - 1);
 
-                YGap_map gap;
-                gap.global_index_begin = 0;
-
                 size_t size_v = y_begin.data[i+1][offset_pc_data1].size();
 
                 y_begin.data[i+1][offset_pc_data2].resize(size_v);

src/data_structures/APR/APRIterator.hpp

@@ -108,7 +108,7 @@ class APRIterator {
             current_particle_cell.z = (current_particle_cell.pc_offset)/spatial_index_x_max(current_particle_cell.level);
             current_particle_cell.x = (current_particle_cell.pc_offset) - current_particle_cell.z*(spatial_index_x_max(current_particle_cell.level));
 
-            current_gap.iterator = current_gap.iterator= apr_access->gap_map.data[current_particle_cell.level][current_particle_cell.pc_offset][0].map.begin();
+            current_gap.iterator = apr_access->gap_map.data[current_particle_cell.level][current_particle_cell.pc_offset][0].map.begin();
             //then find the gap.
             while((particle_number > apr_access->global_index_end(current_gap))){
                 current_gap.iterator++;
@@ -152,7 +152,6 @@ class APRIterator {
         //  Used for finding the starting particle on a given level
         //
         return apr_access->global_index_by_level_and_z_end[level_][z_]+1l;
-
     }
 
     inline uint64_t particles_zx_begin(const uint16_t& level_,const uint64_t& z_,const uint64_t& x_){

src/data_structures/APR/ExtraPartCellData.hpp

@@ -25,9 +25,9 @@ class ExtraPartCellData {
 
     ExtraPartCellData() {}
     template<typename S>
-    ExtraPartCellData(const ExtraPartCellData<S> &part_data) { initialize_structure_parts(part_data); };
+    ExtraPartCellData(const ExtraPartCellData<S> &part_data) { initialize_structure_parts(part_data); }
     template<typename S>
-    ExtraPartCellData(const APR<S> &apr) { initialize_structure_parts_empty(apr); };
+    ExtraPartCellData(const APR<S> &apr) { initialize_structure_parts_empty(apr); }
 
 
     template<typename S>

src/data_structures/Mesh/MeshData.hpp

@@ -432,7 +432,7 @@ void downsamplePyrmaid(MeshData<T> &original_image, std::vector<MeshData<T>> &do
     // calculate downsampled in range (l_max, l_min]
     auto sum = [](const float x, const float y) -> float { return x + y; };
     auto divide_by_8 = [](const float x) -> float { return x/8.0; };
-    for (int level = l_max; level > l_min; --level) {
+    for (size_t level = l_max; level > l_min; --level) {
         downsample(downsampled[level], downsampled[level - 1], sum, divide_by_8, true);
     }
 }