pyvale 2025.7.1__cp311-cp311-macosx_14_0_arm64.whl → 2025.8.1__cp311-cp311-macosx_14_0_arm64.whl

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);
 
             }
 

pyvale/dic/cpp/dicutil.cpp

@@ -30,7 +30,7 @@ namespace util {
     std::vector<double> ftol_arr;
     std::vector<double> xtol_arr;
     std::vector<double> cost_arr;
-    std::vector<bool> conv_arr;
+    std::vector<uint8_t> conv_arr;
     bool at_end;
 
 
@@ -189,12 +189,16 @@ namespace util {
                             }
                         } 
 
-                        // When partial count num of px in roi
+                        // When partial count num of px in roi. if its outside
+                        // the image its still not valid
                         else {
-                            if (is_valid_in_dims(px_x, px_y, px_hori, px_vert) &&
-                                is_valid_in_roi(px_x, px_y, px_hori, px_vert, img_roi)) {
+                            if (is_valid_in_roi(px_x, px_y, px_hori, px_vert, img_roi)) {
                                 valid_count++;
                             }
+                            if (!is_valid_in_dims(px_x, px_y, px_hori, px_vert)) {
+                                valid = false;
+                                break;
+                            }
                         }
                     }
 
@@ -202,7 +206,7 @@ namespace util {
                 }
 
                 // TODO: this is hardcoded so that atleast 70% of pixels in subset must be in ROI
-                if (partial) {
+                if (partial && valid) {
                     if (valid_count >= (ss_size*ss_size) * (0.70)) {
                         valid = true;
                     } else {
@@ -394,23 +398,44 @@ namespace util {
                 int idx = img * ssdata.num + i;
                 //int idx_p = num_params*idx;
 
+                // if the subset has not converged, set values to nan
+                if (!saveconf.output_unconverged && !conv_arr[idx]) {
+                    u_arr[idx] = NAN;
+                    v_arr[idx] = NAN;
+                    for (int p = 0; p < num_params; p++){
+                        p_arr[num_params*idx+p] = NAN;
+                    }
+                    cost_arr[idx] = NAN;
+                    ftol_arr[idx] = NAN;
+                    xtol_arr[idx] = NAN;
+                }
+
+
                 double mag = std::sqrt(u_arr[idx]*u_arr[idx]+
                                        v_arr[idx]*v_arr[idx]);
 
                 // convert from corner to centre subset coords
                 double ss_x = ssdata.coords[2*i  ] + static_cast<double>(ssdata.size)/2.0 - 0.5;
                 double ss_y = ssdata.coords[2*i+1] + static_cast<double>(ssdata.size)/2.0 - 0.5;
+                
 
                 write_int(outfile, ss_x);
                 write_int(outfile, ss_y);
                 write_dbl(outfile, u_arr[idx]);
                 write_dbl(outfile, v_arr[idx]);
                 write_dbl(outfile, mag);
-                write_bool(outfile, conv_arr[idx]);
+                write_uint8t(outfile, conv_arr[idx]);
                 write_dbl(outfile, cost_arr[idx]);
                 write_dbl(outfile, ftol_arr[idx]);
                 write_dbl(outfile, xtol_arr[idx]);
                 write_int(outfile, niter_arr[idx]);
+
+                if (saveconf.shape_params) {
+                    for (int p = 0; p < num_params; p++){
+                        write_dbl(outfile, p_arr[num_params*idx+p]);
+                    }
+                }
+
             }
 
             outfile.close();
@@ -429,7 +454,18 @@ namespace util {
             outfile << "cost" << delimiter;
             outfile << "ftol" << delimiter;
             outfile << "xtol" << delimiter;
-            outfile << "num_iterations\n";
+            outfile << "num_iterations";
+
+            // column headers for shape parameters
+            if (saveconf.shape_params) {
+                for (int p = 0; p < num_params; p++){
+                    outfile << delimiter;
+                    outfile << "shape_p" << p;
+                }
+            }
+
+            // newline after headers
+            outfile << "\n";
 
             for (int i = 0; i < ssdata.num; i++) {
 
@@ -440,6 +476,18 @@ namespace util {
                 double ss_x = ssdata.coords[2*i  ] + static_cast<double>(ssdata.size)/2.0 - 0.5;
                 double ss_y = ssdata.coords[2*i+1] + static_cast<double>(ssdata.size)/2.0 - 0.5;
 
+                // if the subset has not converged, set values to nan
+                if (!saveconf.output_unconverged && !conv_arr[idx]) {
+                    u_arr[idx] = NAN;
+                    v_arr[idx] = NAN;
+                    for (int p = 0; p < num_params; p++){
+                        p_arr[num_params*idx+p] = NAN;
+                    }
+                    cost_arr[idx] = NAN;
+                    ftol_arr[idx] = NAN;
+                    xtol_arr[idx] = NAN;
+                }
+
 
                 outfile << ss_x << delimiter;
                 outfile << ss_y << delimiter;
@@ -447,14 +495,24 @@ namespace util {
                 outfile << v_arr[idx] << delimiter;
                 outfile << sqrt(u_arr[idx]*u_arr[idx]+
                                 v_arr[idx]*v_arr[idx]) << delimiter;
-                //for (int p = 0; p < num_params; p++){
-                //    outfile << p_arr[idx_p+p] << delimiter;
-                //}
-                outfile << conv_arr[idx] << delimiter;
+                outfile << static_cast<int>(conv_arr[idx]) << delimiter;
                 outfile << cost_arr[idx] << delimiter;
                 outfile << ftol_arr[idx] << delimiter;
                 outfile << xtol_arr[idx] << delimiter;
-                outfile << niter_arr[idx] << "\n";
+                outfile << niter_arr[idx];
+                
+                // write shape parameters if requested
+                if (saveconf.shape_params) {
+                    for (int p = 0; p < num_params; p++){
+                        outfile << delimiter;
+                        outfile << p_arr[num_params*idx+p];
+                    }
+                }
+
+                // newline after each subset
+                outfile << "\n";
+
+
             }
             outfile.close();
         }
@@ -532,8 +590,8 @@ namespace util {
     }
 
     void create_progress_bar(indicators::ProgressBar &bar,
-                             const std::vector<std::string> &filenames,
-                             const int img_num, const int num_ss){
+                             const std::string &bar_title,
+                             const int num_ss){
         //Hide cursor
         indicators::show_console_cursor(false);
         bar.set_option(indicators::option::BarWidth{50});
@@ -542,22 +600,20 @@ namespace util {
         bar.set_option(indicators::option::Lead{"#"});
         bar.set_option(indicators::option::Remainder{"-"});
         bar.set_option(indicators::option::End{"]"});
-        bar.set_option(indicators::option::PrefixText{filenames[img_num]});
+        bar.set_option(indicators::option::PrefixText{bar_title});
         bar.set_option(indicators::option::ShowPercentage{true});
         bar.set_option(indicators::option::ShowElapsedTime{true});
     }
 
-    void update_progress_bar(indicators::ProgressBar &bar, int i, int num_ss, std::atomic<int> &prev_pct) {
-        int curr_pct = static_cast<float>(i) / static_cast<float>(num_ss) * 100;
-        int expected = prev_pct.load();
+    void update_progress_bar(indicators::ProgressBar &bar, int i, int num_ss, int &prev_pct) {
+        int curr_pct = static_cast<int>((static_cast<float>(i) / num_ss) * 100.0f);
 
-        // Only update bar if we've passed the previous percentage
-        if (curr_pct > expected && prev_pct.compare_exchange_strong(expected, curr_pct)) {
-            #pragma omp critical
-                bar.set_progress(curr_pct);
+        // Only update if we've passed a new percentage
+        if (curr_pct > prev_pct) {
+            prev_pct = curr_pct;
+            bar.set_progress(curr_pct);
         }
     }
 
 
-
 }