pyvale 2025.7.0__cp311-cp311-musllinux_1_2_aarch64.whl → 2025.7.2__cp311-cp311-musllinux_1_2_aarch64.whl

pyvale/cython/rastercyth.c

@@ -11,7 +11,7 @@
             "-fopenmp"
         ],
         "include_dirs": [
-            "/tmp/pip-build-env-052l3x_t/overlay/lib/python3.11/site-packages/numpy/core/include"
+            "/tmp/pip-build-env-eix67hnr/overlay/lib/python3.11/site-packages/numpy/core/include"
         ],
         "name": "pyvale.cython.rastercyth",
         "sources": [

pyvale/dataset.py

@@ -397,7 +397,7 @@ class DataSet:
             Path to the reference image (*.tiff).
         """
         return Path(files("pyvale.data")
-                    .joinpath("DIC_Challenge_Star_Noise_Ref.tif"))
+                    .joinpath("DIC_Challenge_Star_Noise_Ref.tiff"))
 
     @staticmethod
     def dic_challenge_def() -> Path:
@@ -409,7 +409,7 @@ class DataSet:
             Path to the reference image (*.tiff).
         """
         return Path(files("pyvale.data")
-                    .joinpath("DIC_Challenge_Star_Noise_Def.tif"))
+                    .joinpath("DIC_Challenge_Star_Noise_Def.tiff"))
 
 
 

pyvale/dic/cpp/dicfourier.cpp

@@ -12,11 +12,13 @@
 #include <cmath>
 #include <algorithm>
 #include <omp.h>
+#include <csignal>
 
 // Program Header files
 #include "./defines.hpp"
 #include "./dicutil.hpp"
 #include "./dicfourier.hpp"
+#include "./dicsignalhandler.hpp"
 
 namespace fourier {
 
@@ -134,8 +136,10 @@ namespace fourier {
     }
 
     void mgwd(const std::vector<util::SubsetData> &ssdata, 
-              const double *img_ref, const double *img_def, 
-              const Interpolator &interp_def, const bool fft_mad, 
+              const double *img_ref,
+              const double *img_def,
+              const Interpolator &interp_def,
+              const bool fft_mad, 
               const double fft_mad_scale){
 
         const int px_hori = interp_def.px_hori;
@@ -150,11 +154,21 @@ namespace fourier {
             //util::Timer timer("FFT windowing for subset size: " + std::to_string(ssdata[i].size));
 
             const int ss_size = ssdata[i].size;
+            const int num_ss  = ssdata[i].num;
 
             std::fill(shifts[i].x.begin(), shifts[i].x.end(), 0.0);
             std::fill(shifts[i].y.begin(), shifts[i].y.end(), 0.0);
 
-            #pragma omp parallel
+            indicators::ProgressBar bar;
+            std::atomic<int> current_progress = 0;
+            int prev_pct = 0;
+
+            if (g_debug_level == 1){
+                std::string bar_title = "FFT windowing for size: " + std::to_string(ss_size);
+                util::create_progress_bar(bar, bar_title, ssdata[i].num);
+            }
+
+            #pragma omp parallel shared(stop_request)
             {
 
 
@@ -165,6 +179,11 @@ namespace fourier {
                 #pragma omp for
                 for (int ss = 0; ss < ssdata[i].num; ss++){
 
+                    // exit when ctrl+C
+                    if (stop_request){
+                        continue;
+                    }
+
                     int ss_x = ssdata[i].coords[2*ss];
                     int ss_y = ssdata[i].coords[2*ss+1];
 
@@ -213,6 +232,12 @@ namespace fourier {
                     //util::extract_ss_subpx(fft.ss_def, ss_x+shifts[i].x[ss], ss_y+shifts[i].y[ss], interp_def);
                     //shifts[i].cost[ss] = debugcost(fft.ss_ref,fft.ss_def);
                     shifts[i].max_val[ss] = max_val;
+
+
+                    if (g_debug_level == 1){
+                        int progress = current_progress.fetch_add(1);
+                        if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
+                    }
                 }
             }
 
@@ -222,7 +247,6 @@ namespace fourier {
                 remove_outliers(shifts[i].y, ssdata[i], fft_mad);
             }
 
-
             //smooth_field(shifts[i].x, ssdata[i], 7.0, 5);
             //smooth_field(shifts[i].y, ssdata[i], 7.0, 5);
 
@@ -233,9 +257,17 @@ namespace fourier {
             //    std::cout << shifts[i].cost[ss] << std::endl;
             //}
             //std::cout << std::endl;
+
+            if (g_debug_level == 1){
+                int progress = current_progress;
+                util::update_progress_bar(bar, progress-1, num_ss, prev_pct);
+                bar.mark_as_completed();
+                indicators::show_console_cursor(true);
+            }
         }
 
 
+
     }
 
 

pyvale/dic/cpp/dicinterpolator.cpp

@@ -11,7 +11,9 @@
 
 // Program Header files
 #include "./dicinterpolator.hpp"
-
+#include "./dicutil.hpp"
+#include "defines.hpp"
+#include "./dicsignalhandler.hpp"
 
 
 inline int idx_from_2d(const int x, const int y, const int length){
@@ -49,10 +51,27 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
 
     //interpolator data
     std::vector<double> data(px_hori,0);
+
+
+    indicators::ProgressBar bar;
+    std::atomic<int> current_progress = 0;
+    int prev_pct = 0;
+    int niters = px_vert+px_hori+px_hori;
+
+    if (g_debug_level == 1){
+        std::string bar_title = "Creating Interpolator: ";
+        util::create_progress_bar(bar, bar_title, niters);
+    }
+
     
     //#pragma omp parallel for
     for (int j = 0; j < px_vert; j++){
 
+        // exit if ctrl+C
+        if (stop_request){
+            continue;
+        }
+
         // get 1D data
         for (int i = 0; i < px_hori; i++) {
             data[i] = image[j*px_hori + i];
@@ -62,6 +81,12 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
         for (int i = 0; i < px_hori; i++){
             dx[j*px_hori + i] = cspline_eval_deriv(px_x, data, px_x[i], px_hori);
         }
+
+        // update progress bar if enabled
+        if (g_debug_level == 1){
+            int progress = current_progress.fetch_add(1);
+            util::update_progress_bar(bar, progress, niters, prev_pct);
+        }
     }
 
     data.resize(px_vert,0);
@@ -69,6 +94,11 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
     //#pragma omp parallel for
     for (int i = 0; i < px_hori; ++i) {
 
+        // exit if ctrl+C
+        if (stop_request){
+            continue;
+        }
+
         // get 1D data
         for (int j = 0; j < px_vert; j++){
             data[j] = image[j*px_hori + i];
@@ -78,6 +108,12 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
         for (int j = 0; j < px_vert; j++){
             dy[j*px_hori + i] = cspline_eval_deriv(px_y, data, px_y[j], px_vert);
         }
+
+        // update progress bar if enabled
+        if (g_debug_level == 1){
+            int progress = current_progress.fetch_add(1);
+            util::update_progress_bar(bar, progress, niters, prev_pct);
+        }
     }
 
 
@@ -86,6 +122,11 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
     //#pragma omp parallel for
     for (int j = 0; j < px_vert; j++){
 
+        // exit if ctrl+C
+        if (stop_request){
+            continue;
+        }
+
         // get 1D data
         for (int i = 0; i < px_hori; i++) {
             data[i] = dy[j*px_hori + i];
@@ -95,6 +136,20 @@ Interpolator::Interpolator(double*img, int px_hori, int px_vert){
         for (int i = 0; i < px_hori; i++){
             dxy[j*px_hori + i] = cspline_eval_deriv(px_x, data, px_x[i], px_hori);
         }
+
+        // update progress bar if enabled
+        if (g_debug_level == 1){
+            int progress = current_progress.fetch_add(1);
+            util::update_progress_bar(bar, progress, niters, prev_pct);
+        }
+    }
+
+
+    if (g_debug_level == 1){
+        int progress = current_progress;
+        util::update_progress_bar(bar, progress-1, niters, prev_pct);
+        bar.mark_as_completed();
+        indicators::show_console_cursor(true);
     }
 }
 

pyvale/dic/cpp/dicmain.cpp

@@ -16,6 +16,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
 #include <pybind11/stl.h>
+#include <pybind11/iostream.h>
 
 // Program Header files
 #include "./dicinterpolator.hpp"
@@ -26,6 +27,7 @@
 #include "./dicutil.hpp"
 #include "./dicstrain.hpp"
 #include "./dicfourier.hpp"
+#include "./dicsignalhandler.hpp"
 
 // cuda Header files
 #include "../cuda/malloc.hpp"
@@ -39,6 +41,10 @@ void DICengine(const py::array_t<double>& img_ref_arr,
                util::Config &conf,
                util::SaveConfig &saveconf){
 
+    // Register signal handler for Ctrl+C and set debug_level
+    signal(SIGINT, signalHandler);
+    g_debug_level = conf.debug_level;
+
     // ------------------------------------------------------------------------
     // Initialisation
     // ------------------------------------------------------------------------
@@ -59,28 +65,16 @@ void DICengine(const py::array_t<double>& img_ref_arr,
     INFO_OUT("Subset Size:", conf.ss_size << " [px]");
     INFO_OUT("Subset Step:", conf.ss_step << " [px]" );
     INFO_OUT("Number of OMP threads:", omp_get_max_threads());
+    INFO_OUT("Debug level: ", conf.debug_level);
     if (conf.scan_method=="RG") INFO_OUT("Reliability Guided Seed central px location: ", "(" 
                                          << conf.rg_seed.first+conf.ss_size/2 << ", " << conf.rg_seed.second+conf.ss_size/2 << ") [px] " )
 
-    // Register signal handler for Ctrl+C
-    signal(SIGINT, scanmethod::signalHandler);
 
-       // get raw pointers
+    // get raw pointers
     bool* img_roi = static_cast<bool*>(img_roi_arr.request().ptr);
     double* img_ref = static_cast<double*>(img_ref_arr.request().ptr);
     double* img_def_stack = static_cast<double*>(img_def_stack_arr.request().ptr);
 
-    // debugging
-    //for (int y = 0; y < conf.px_vert; y++){
-    //    for (int x = 0; x < conf.px_hori; x++){
-    //        std::cout << x << " " << y << " ";
-    //        std::cout << img_ref[y*conf.px_hori + x] << " ";
-    //        std::cout << img_def_stack[y*conf.px_hori + x] << " ";
-    //        std::cout << img_roi[y*conf.px_hori+x] << std::endl;
-    //    }
-    //}
-    //exit(0);
-
     // ------------------------------------------------------------------------
     // get a list of ss coordinates within RIO;
     // ------------------------------------------------------------------------
@@ -108,8 +102,8 @@ void DICengine(const py::array_t<double>& img_ref_arr,
     optimizer::init(conf.corr_crit, conf.shape_func);
 
     // initialise the brute force scan
-    std::string brute_method = "EXPANDING_WAVEFRONT";
-    brute::init(conf.corr_crit, brute_method);
+    // std::string brute_method = "EXPANDING_WAVEFRONT";
+    // brute::init(conf.corr_crit, brute_method);
 
 
 
@@ -150,7 +144,6 @@ void DICengine(const py::array_t<double>& img_ref_arr,
 
         if (!saveconf.at_end)
             util::save_to_disk(img_num, saveconf, ssdata.back(), conf.num_def_img, conf.num_params, conf.filenames);
-
     }
 
     if (saveconf.at_end)
@@ -172,8 +165,16 @@ void build_info(){
 }
 
 
+void set_num_threads(int n) {
+    omp_set_num_threads(n);
+}
+
+
 
 PYBIND11_MODULE(dic2dcpp, m) {
+
+    py::add_ostream_redirect(m, "ostream_redirect");
+
     py::class_<util::Config>(m, "Config")
         .def(py::init<>())
         .def_readwrite("ss_step", &util::Config::ss_step)
@@ -194,7 +195,8 @@ PYBIND11_MODULE(dic2dcpp, m) {
         .def_readwrite("num_params", &util::Config::num_params)
         .def_readwrite("fft_mad", &util::Config::fft_mad)
         .def_readwrite("fft_mad_scale", &util::Config::fft_mad_scale)
-        .def_readwrite("filenames", &util::Config::filenames);
+        .def_readwrite("filenames", &util::Config::filenames)
+        .def_readwrite("debug_level", &util::Config::debug_level);
 
     py::class_<util::SaveConfig>(m, "SaveConfig")
         .def(py::init<>())
@@ -202,12 +204,15 @@ PYBIND11_MODULE(dic2dcpp, m) {
         .def_readwrite("binary", &util::SaveConfig::binary)
         .def_readwrite("prefix", &util::SaveConfig::prefix)
         .def_readwrite("delimiter", &util::SaveConfig::delimiter)
-        .def_readwrite("at_end", &util::SaveConfig::at_end);
+        .def_readwrite("at_end", &util::SaveConfig::at_end)
+        .def_readwrite("output_unconverged", &util::SaveConfig::output_unconverged)
+        .def_readwrite("shape_params", &util::SaveConfig::shape_params);
 
     // Bind the engine function
     m.def("build_info", &build_info, "build information");
     m.def("dic_engine", &DICengine, "Run 2D analysis on input images with config");
     m.def("strain_engine", &strain::engine, "Strain C++ calculations");
+    m.def("set_num_threads", &set_num_threads, "Set the number of OpenMP threads");
 }
 
 

pyvale/dic/cpp/dicoptimizer.cpp

@@ -52,7 +52,7 @@ namespace optimizer {
         double ftol = 0;
         double xtol = 0;
         opt.lambda = 0.001;
-        bool converged = false;
+        uint8_t converged = false;
 
 
         // trying relative instead of global coordinates for the optimization
@@ -69,6 +69,9 @@ namespace optimizer {
             optimize_cost(ss_ref, ss_def, interp_def, opt, global_x, global_y);
             update_lambda(opt.costp, opt.costpdp, opt.p, opt.pdp, opt.lambda, opt.num_params);
 
+            // TODO: have a look at removing the two square roots in the below. Can we get away without
+            // it? cache is locally and perform the square root only once?
+
             // relative change of all parameters
             xtol = std::sqrt(std::inner_product(opt.dp.begin(), opt.dp.end(), opt.dp.begin(), 0.0)) / 
                           std::sqrt(std::inner_product( opt.p.begin(),  opt.p.end(),  opt.p.begin(), 0.0));
@@ -78,6 +81,8 @@ namespace optimizer {
             // variation on correlation coefficient
             ftol = std::abs(opt.costpdp - opt.costp);
 
+
+            // TODO: convert ssd if statement into func pointer.
             // convergence criteria
             // - rel change in parameters is less than user precision
             // - change in corr coeff is less than precision

pyvale/dic/cpp/dicscanmethod.cpp

@@ -23,19 +23,11 @@
 #include "./indicators.hpp"
 #include "./cursor_control.hpp"
 #include "./dicfourier.hpp"
+#include "./dicsignalhandler.hpp"
 
 namespace scanmethod {
 
 
-    // for graceful exit
-    std::atomic<bool> stop_request(false);
-
-    void signalHandler(int signal) {
-        if (signal == SIGINT) {
-            stop_request = true;
-        }
-    }
-
     void image(const double *img_ref,
                const Interpolator &interp_def,
                const util::SubsetData &ssdata, 
@@ -47,11 +39,11 @@ namespace scanmethod {
 
         // progress bar
         indicators::ProgressBar bar;
-        util::create_progress_bar(bar, conf.filenames, img_num, 100);
+        util::create_progress_bar(bar, conf.filenames[img_num], num_ss);
         std::atomic<int> current_progress = 0;
-        std::atomic<int> prev_pct = 0;
+        int prev_pct = 0;
 
-               // loop over subsets within the ROI
+        // loop over subsets within the ROI
         #pragma omp parallel shared(stop_request)
         {
 
@@ -103,10 +95,13 @@ namespace scanmethod {
 
                 // update progress bar
                 int progress = current_progress.fetch_add(1);
-                util::update_progress_bar(bar, progress, num_ss, prev_pct);
+                if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
 
             }
         }
+
+        int progress = current_progress;
+        util::update_progress_bar(bar, progress-1, num_ss, prev_pct);
         bar.mark_as_completed();
         indicators::show_console_cursor(true);
 
@@ -126,9 +121,9 @@ namespace scanmethod {
 
         // progress bar
         indicators::ProgressBar bar;
-        util::create_progress_bar(bar, conf.filenames, img_num, num_ss);
+        util::create_progress_bar(bar, conf.filenames[img_num], num_ss);
         std::atomic<int> current_progress = 0;
-        std::atomic<int> prev_pct = 0;
+        int prev_pct = 0;
 
         // initialise subsets
         util::Subset ss_def(ss_size);
@@ -211,9 +206,11 @@ namespace scanmethod {
 
             // update progress bar
             int progress = current_progress.fetch_add(1);
-            util::update_progress_bar(bar, progress, num_ss, prev_pct);
+            if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
 
         }
+        int progress = current_progress;
+        util::update_progress_bar(bar, progress-1, num_ss, prev_pct);
         bar.mark_as_completed();
         indicators::show_console_cursor(true);
     }
@@ -242,15 +239,16 @@ namespace scanmethod {
         const int ss_size = ssdata[last_size].size;
         const int ss_step = ssdata[last_size].step;
 
-
+        //TODO: sort this function name out
         fourier::mgwd(ssdata, img_ref, img_def, interp_def, 
                       conf.fft_mad, conf.fft_mad_scale);
 
         // progress bar
         indicators::ProgressBar bar;
-        util::create_progress_bar(bar, conf.filenames, img_num, num_ss);
+        util::create_progress_bar(bar, conf.filenames[img_num], num_ss);
         std::atomic<int> current_progress(0);
-        std::atomic<int> prev_pct(0);
+        //int prev_pct(0);
+        int prev_pct = 0;
 
         // quick check for the initial seed point
         if (!rg::is_valid_point(seed_x, seed_y, ssdata[last_size])) {
@@ -259,7 +257,7 @@ namespace scanmethod {
 
         // Initialize binary mask for computed points (initialized to 0)
         std::vector<std::atomic<int>> computed_mask(ssdata[last_size].mask.size());
-        for (auto& val : computed_mask) val.store(0);
+        for (auto& val : computed_mask) val.store(0); 
 
         // queue for each thread
         std::vector<std::priority_queue<rg::Point>> local_q(omp_get_max_threads());
@@ -287,7 +285,7 @@ namespace scanmethod {
             if (conf.corr_crit=="SSD")
                 opt.opt_threshold = std::numeric_limits<double>::max();
 
-            brute::Parameters brute(conf.bf_threshold, conf.max_disp);
+            // brute::Parameters brute(conf.bf_threshold, conf.max_disp);
 
             std::vector<std::unique_ptr<fourier::FFT>> fft_windows;
 
@@ -299,6 +297,8 @@ namespace scanmethod {
             // number of iterations to make sure we get a good convergence.
             // this is hardcoded for now. Could do with updating so that 
             // the seed location is checked ahead of the main correlation run.
+
+            // TODO: opt.seed_iter exposed to user.
             opt.max_iter = 200;
 
             // ---------------------------------------------------------------------------------------------------------------------------
@@ -336,9 +336,6 @@ namespace scanmethod {
 
                 computed_mask[idx].store(1);
 
-                // int progress = current_progress.fetch_add(1);
-                // util::update_progress_bar(bar, progress, num_ss, prev_pct);
-
                 // loop over the neighbours for the initial seed point
                 for (size_t n = 0; n < ssdata[last_size].neigh[idx].size(); n++) {
 
@@ -369,7 +366,7 @@ namespace scanmethod {
                     util::append_results(img_num, nidx, nres, num_ss);
 
                     // update mask
-                    computed_mask[idx].store(1);
+                    computed_mask[nidx].store(1);
 
                     // add this point to queue
                     // Protect push with mutex
@@ -390,6 +387,7 @@ namespace scanmethod {
             // ---------------------------------------------------------------------------------------------------------------------------
             #pragma omp barrier
 
+            // TODO: reset seed location using the last computed point
             opt.max_iter = conf.max_iter;
 
             std::vector<rg::Point> temp_neigh;
@@ -494,7 +492,7 @@ namespace scanmethod {
 
                         // update progress bar
                         int progress = current_progress.fetch_add(1);
-                        util::update_progress_bar(bar, progress, num_ss, prev_pct);
+                        if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
 
                     }
                 }
@@ -505,6 +503,8 @@ namespace scanmethod {
                 }
             }
         }
+        int progress = current_progress;
+        util::update_progress_bar(bar, progress-1, num_ss, prev_pct);
         bar.mark_as_completed();
         indicators::show_console_cursor(true);
 
@@ -532,9 +532,9 @@ namespace scanmethod {
 
         // progress bar
         indicators::ProgressBar bar;
-        util::create_progress_bar(bar, conf.filenames, img_num, num_ss);
+        util::create_progress_bar(bar, conf.filenames[img_num], num_ss);
         std::atomic<int> current_progress = 0;
-        std::atomic<int> prev_pct = 0;
+        int prev_pct = 0;
 
         // loop over subsets within the ROI
         #pragma omp parallel shared(stop_request)
@@ -587,7 +587,7 @@ namespace scanmethod {
 
                 // update progress bar
                 int progress = current_progress.fetch_add(1);
-                util::update_progress_bar(bar, progress, num_ss, prev_pct);
+                if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
 
             }
         }
@@ -613,9 +613,9 @@ namespace scanmethod {
 
         // progress bar
         indicators::ProgressBar bar;
-        util::create_progress_bar(bar, conf.filenames, img_num, num_ss);
+        util::create_progress_bar(bar, conf.filenames[img_num], num_ss);
         std::atomic<int> current_progress = 0;
-        std::atomic<int> prev_pct = 0;
+        int prev_pct = 0;
 
         // loop over subsets within the ROI
         #pragma omp parallel shared(stop_request)
@@ -666,7 +666,7 @@ namespace scanmethod {
 
                 // update progress bar
                 int progress = current_progress.fetch_add(1);
-                util::update_progress_bar(bar, progress, num_ss, prev_pct);
+                if (omp_get_thread_num()==0) util::update_progress_bar(bar, progress, num_ss, prev_pct);
 
             }
         }

pyvale/dic/cpp/dicsignalhandler.cpp

@@ -0,0 +1,16 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+#include "./dicsignalhandler.hpp"
+#include <csignal>
+
+std::atomic<bool> stop_request = false;
+
+void signalHandler(int signal) {
+    if (signal == SIGINT) {
+        stop_request = true;
+    }
+}

pyvale/dic/cpp/dicstrain.cpp

@@ -6,6 +6,7 @@
 
 // STD library Header files
 #include <cmath>
+#include <omp.h>
 #include <vector>
 #include <iostream>
 #include <iomanip>
@@ -70,8 +71,8 @@ namespace strain {
         for (int img_num = 0; img_num < nimg; img_num++) {
 
             indicators::ProgressBar bar;
-            util::create_progress_bar(bar, filenames, img_num, nwindows);
-            std::atomic<int> prev_pct = 0;
+            util::create_progress_bar(bar, filenames[img_num], nwindows);
+            int prev_pct = 0;
 
             // loop over strain windows within the image
             for (int sw = 0; sw < nwindows; sw++){
@@ -81,6 +82,9 @@ namespace strain {
                 results.x[sw] = x0;
                 results.y[sw] = y0;
 
+                // TODO: through a warning. NAN out the entire window.
+                // it should be up to the user whether they correct with
+                // outlier removal / smoothing.
                 results.valid_window[sw] = fill_window(ss_x, ss_y, u, v, img_num,
                                                 sw, window, nss_x,
                                                 nss_y, sw_size);
@@ -102,7 +106,7 @@ namespace strain {
                                    deform_grad, eps, nwindows, img_num);
                 }
 
-                util::update_progress_bar(bar, sw, nwindows, prev_pct);
+                if (omp_get_thread_num() == 0) util::update_progress_bar(bar, sw, nwindows, prev_pct);
 
             }