pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/dic/cpp/dicoptimizer.hpp

@@ -0,0 +1,279 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+
+#ifndef DICOPTIMIZER_H
+#define DICOPTIMIZER_H
+
+// STD library Header files
+#include <vector>
+
+// Program Header files
+#include "./dicresults.hpp"
+#include "./dicinterpolator.hpp"
+
+
+namespace optimizer {
+
+
+    /**
+     * @brief 
+     * 
+     */
+    struct Parameters {
+        int num_params;
+        double lambda; // damping
+        double costp; // cost function for current P values
+        double costpdp; // cost function for P+deltaP values
+        std::vector<double> g; // gradient
+        std::vector<double> dfdp; // derivative of shape function with respect to parameters
+        std::vector<double> H; // Hessian ( becomes (H + lambda * diag(H)) )
+        std::vector<double> invH; // Used for inverse of (H + lambda * diag(H))
+        std::vector<double> p; // hard coded affine parameters
+        std::vector<double> dp; // deltaP
+        std::vector<double> pdp; // P + deltaP
+        std::vector<double> augmented;
+        int max_iter;
+        double precision;
+        double threshold;
+        int px_vert;
+        int px_hori;
+
+
+        // Constructor to initialize vectors and other parameters
+        Parameters(int num_params_, int max_iter_, double precision_, 
+                   double threshold_, int px_vert_, int px_hori_,
+                   const std::string& corr_crit)
+            :
+            num_params(num_params_),
+            lambda(0.01),
+            costp(0.0),
+            costpdp(0.0),
+            g(num_params, 0.0),
+            dfdp(num_params, 0.0),
+            H(num_params*num_params, 0.0),
+            invH(num_params*num_params, 0.0),
+            p(num_params, 0.0),
+            dp(num_params, 0.0),
+            pdp(num_params, 0.0),
+            augmented(num_params*num_params*2, 0.0),
+            max_iter(max_iter_),
+            precision(precision_),
+            threshold(threshold_),
+            px_vert(px_vert_),
+            px_hori(px_hori_) {
+            }
+    };
+
+    /**
+     * @brief This function gets called before the corrolation optimization starts. Sets the function pointer for the user specified shape function.
+     * 
+     * @param[in] corr_crit string for the correlation criteria, e.g. "SSD", "NSSD", "ZNSSD".
+     */
+    void set_cost_function(const std::string& corr_crit);
+
+    /**
+     * @brief 
+     * 
+     * @param ss_x 
+     * @param ss_y 
+     * @param iter 
+     * @param costp 
+     * @param ftol 
+     * @param xtol 
+     * @param p 
+     */
+    void debug_print(int ss_x, int ss_y, int iter, double costp, double ftol, double xtol, const std::vector<double>& p);
+
+
+    /**
+     * @brief 
+     * 
+     * @param ss_x 
+     * @param ss_y 
+     * @param ss_ref 
+     * @param ss_def 
+     * @param interp_ref 
+     * @param opt 
+     * @return OptResult 
+     */
+    OptResult solve(const double ss_x, const double ss_y, subset::Pixels &ss_ref, subset::Pixels &ss_def, const Interpolator &interp_ref, optimizer::Parameters &opt, const std::string &corr_crit);
+
+    /**
+     * @brief calcutes the Sum of Squared Differences (SSD) between reference and deformed subsets.
+     * 
+     * @param[in] ss_ref reference subset
+     * @param[in,out] ss_def deformed subset
+     * @param[in] interp_def interpolator for deformed image 
+     * @param[in,out] opt Optimization parameters including gradient, Hessian, etc. 
+     */
+    void   ssd(const subset::Pixels &ss_ref, subset::Pixels &ss_def, const Interpolator &interp_def, optimizer::Parameters &opt);
+
+    /**
+     * @brief calcutes the Normalized Sum of Squared Differences (NSSD) between reference and deformed subsets.
+     * 
+     * @param[in] ss_ref reference subset
+     * @param[in,out] ss_def deformed subset
+     * @param[in] interp_def interpolator for deformed image 
+     * @param[in,out] opt Optimization parameters including gradient, Hessian, etc. 
+     */
+    void  nssd(const subset::Pixels &ss_ref, subset::Pixels &ss_def, const Interpolator &interp_def, optimizer::Parameters &opt);
+
+    /**
+     * @brief calcutes the Zero Normalized Sum of Squared Differences (ZNSSD) between reference and deformed subsets.
+     * 
+     * @param[in] ss_ref reference subset
+     * @param[in,out] ss_def deformed subset
+     * @param[in] interp_def interpolator for deformed image 
+     * @param[in,out] opt Optimization parameters including gradient, Hessian, etc. 
+     */
+    void znssd(const subset::Pixels &ss_ref, subset::Pixels &ss_def, const Interpolator &interp_def, optimizer::Parameters &opt);
+
+
+    /**
+     * @brief Inverts square matrix using Gauss-Jordan elimination.
+     * 
+     * @param[in] matrix 
+     * @param[out] inverse 
+     * @param[in] augmented 
+     * @param[in] num_params Number of shape function parameters (2 for rigid, 6 for affine, ...)
+     * @return true Matrix inversion was successful
+     * @return false Matrix inversion failed
+     */
+    bool invertMatrix(const std::vector<double>& matrix, std::vector<double>& inverse, std::vector<double>& augmented, int num_params);
+
+    /**
+     * @brief Updates the shape function parameters based on the current and updated parameters.
+     * 
+     * @param[out] pdp shape function parameters for P+deltaP
+     * @param[in] p current shape function parameters P
+     * @param[out] dp the change in shape function for based on the Hessian and gradient
+     * @param[in] invH inverse of the Hessian matrix
+     * @param[in] g gradient vector
+     * @param[in] num_params Number of shape function parameters (2 for rigid, 6 for affine, ...)
+     */
+    void update_shapefunc_parameters(std::vector<double> &pdp, std::vector<double> &p, std::vector<double> &dp, std::vector<double> &invH, std::vector<double> &g, int num_params);
+
+    /**
+     * @brief 
+     * 
+     * @param[in] costp cost value for current shape function parameters P
+     * @param[in] costpdp cost value for updated shape function parameters P+deltaP
+     * @param[out] p shape function parameters for P
+     * @param[in] pdp shape function parameters for P+deltaP
+     * @param lambda Optimization damping factor
+     * @param[in] num_params Number of shape function parameters (2 for rigid, 6 for affine, ...)
+     */
+    void update_lambda(double costp, double costpdp, std::vector<double> &p, std::vector<double> &pdp, double &lambda, int num_params);
+
+    /**
+     * @brief Populates the lower triangular part of the Hessian matrix, H.
+     * 
+     * @param[in,out] H Hessian matrix
+     * @param[out] lambda Optimization damping factor
+     * @param[in] num_params Number of shape function parameters (2 for rigid, 6 for affine, ...)
+     */
+    void populate_hessian_lower_tri(std::vector<double> &H, double lambda, int num_params);
+
+    /**
+     * @brief 
+     * 
+     * @param[out] x_new 
+     * @param[out] y_new 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] p 
+     */
+    inline void affine(double &x_new, double &y_new, double x, double y, std::vector<double> &p);
+
+    /**
+     * @brief 
+     * 
+     * @param[out] x_new 
+     * @param[out] y_new 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] p 
+     */
+    inline void rigid(double &x_new, double &y_new, double x, double y, std::vector<double> &p);
+
+    /**
+     * @brief 
+     * 
+     * @param[out] x_new 
+     * @param[out] y_new 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] p 
+     */
+    inline void quad(double &x_new, double &y_new, double x, double y, std::vector<double> &p);
+
+    /**
+     * @brief calculates the derivative of the affine function with respect to each parameter
+     * 
+     * @param[out dfdp 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] dfdx 
+     * @param[in] dfdy 
+     */
+    inline void daffine_dp(std::vector<double> &dfdp, double x, double y, double dfdx, double dfdy);
+
+    /**
+     * @brief calculates the derivative of the rigid shape function with respect to each parameter
+     * 
+     * @param[out dfdp 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] dfdx 
+     * @param[in] dfdy 
+     */
+    inline void drigid_dp(std::vector<double> &dfdp, double x, double y, double dfdx, double dfdy);
+
+    /**
+     * @brief calculates the derivative of the quadratic function with respect to each parameter
+     * 
+     * @param[out] x_new 
+     * @param[out] y_new 
+     * @param[in] x 
+     * @param[in] y 
+     * @param[in] p 
+     */
+    inline void dquad_dp(std::vector<double> &dfdp, double x, double y, double dfdy);
+
+    /**
+     * @brief Funcion to convert affine shape function parameters to displacement values
+     * 
+     * @param[out] displacements values (u,v, magnitude) are added to results
+     * @param[in] ss_x subset x coordinate
+     * @param[in] ss_y subset y coordinate
+     * @param[in] p shape function parameters
+     */
+    void quad_parameters_to_displacement(OptResult &results, double ss_x, double ss_y, std::vector<double> &p);
+
+    /**
+     * @brief Funcion to convert affine shape function parameters to displacement values
+     * 
+     * @param[out] displacements values (u,v, magnitude) are added to results
+     * @param[in] ss_x subset x coordinate
+     * @param[in] ss_y subset y coordinate
+     * @param[in] p shape function parameters
+     */
+    void affine_parameters_to_displacement(OptResult &results, double ss_x, double ss_y, std::vector<double> &p);
+
+    /**
+     * @brief Funcion to convert affine shape function parameters to displacement values
+     * 
+     * @param[out] displacements values (u,v, magnitude) are added to results
+     * @param[in] ss_x subset x coordinate
+     * @param[in] ss_y subset y coordinate
+     * @param[in] p shape function parameters
+     */
+    void rigid_parameters_to_displacement(OptResult &results, double ss_x, double ss_y, std::vector<double> &p);
+
+}
+
+#endif //DICOPTIMIZER_H

pyvale/dic/cpp/dicresults.cpp

@@ -0,0 +1,239 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+
+// STD library Header files
+#include <sstream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+// common_cpp header files
+#include "../../common_cpp/util.hpp"
+
+// DIC Header files
+#include "./dicresults.hpp"
+#include "./dicutil.hpp"
+
+
+
+OptResultArrays::OptResultArrays(int num_def_img, int num_ss, int num_params, bool at_end){
+
+    if (g_debug_level>0) common_util::Timer timer("resizing of result arrays:");
+    this->at_end = at_end;
+    this->num_ss = num_ss;
+    this->num_params = num_params;
+
+    if (at_end){
+        niter.resize(num_def_img * num_ss);
+        u.resize(num_def_img * num_ss);
+        v.resize(num_def_img * num_ss);
+        p.resize(num_def_img * num_ss * num_params);
+        ftol.resize(num_def_img * num_ss);
+        xtol.resize(num_def_img * num_ss);
+        cost.resize(num_def_img * num_ss);
+        conv.resize(num_def_img * num_ss);
+        above_thresh.resize(num_def_img * num_ss);
+    }
+    else {
+        niter.resize(num_ss);
+        u.resize(num_ss);
+        v.resize(num_ss);
+        p.resize(num_ss * num_params);
+        ftol.resize(num_ss);
+        xtol.resize(num_ss);
+        cost.resize(num_ss);
+        conv.resize(num_ss);
+        above_thresh.resize(num_def_img * num_ss);
+    }
+}
+
+void OptResultArrays::append(OptResult &res, int results_num, int ss) {
+    int idx = index(ss, results_num);
+
+    int idx_p = num_params*idx;
+    niter[idx] = res.iter;
+    u[idx] = res.u;
+    v[idx] = res.v;
+    ftol[idx] = res.ftol;
+    xtol[idx] = res.xtol;
+    cost[idx] = res.cost;
+    conv[idx] = res.converged;
+    above_thresh[idx] = res.above_threshold;
+    for (size_t i = 0; i < num_params; i++){
+        p[idx_p+i] = res.p[i];
+    }
+}
+
+int OptResultArrays::index(const int subset_idx, const int results_num){
+    int idx = at_end ? (results_num) * num_ss + subset_idx : subset_idx;
+    return idx;
+}
+
+int OptResultArrays::index_parameters(const int subset_idx, const int results_num){
+    int idx = index(subset_idx, results_num) * num_params;
+    return idx;
+}
+
+
+void OptResultArrays::write_to_disk(int img_num, const common_util::SaveConfig &saveconf,
+                    const subset::Grid &ss_grid, const int num_def_img,
+                    const std::vector<std::string> &filenames){
+
+    const std::string delimiter = saveconf.delimiter;
+
+    std::stringstream outfile_str;
+    std::ofstream outfile;
+    int results_num = img_num-1;
+
+    std::string file_ext;
+    if (saveconf.binary) file_ext=".dic2d";
+    else file_ext=".csv";
+
+    std::string full_filename = filenames[img_num];
+    size_t dot_pos = full_filename.find(".");
+    if (dot_pos != std::string::npos) {
+        full_filename = full_filename.substr(0, dot_pos);
+    }
+
+    outfile_str << saveconf.basepath << "/"
+                << saveconf.prefix
+                << full_filename
+                << file_ext;
+
+    // set the img var to 0 after opening file if not saving at end
+    if (!saveconf.at_end) results_num = 0;
+
+    // save in binary format
+    if (saveconf.binary){
+        outfile.open(outfile_str.str(), std::ios::binary);
+
+        for (int i = 0; i < ss_grid.num; ++i) {
+
+            int idx = index(i, results_num);
+            //int idx_p = num_params*idx;
+
+            // if the subset has not met threshold, set values to nan
+            if (!saveconf.output_below_threshold && !above_thresh[idx]) {
+                u[idx] = NAN;
+                v[idx] = NAN;
+                for (int pidx = 0; pidx < num_params; pidx++){
+                    p[num_params*idx+pidx] = NAN;
+                }
+                cost[idx] = NAN;
+                ftol[idx] = NAN;
+                xtol[idx] = NAN;
+            }
+
+
+            double mag = std::sqrt(u[idx]*u[idx]+
+                                    v[idx]*v[idx]);
+
+            // convert from corner to centre subset coords
+            double ss_x = ss_grid.coords[2*i  ] + static_cast<double>(ss_grid.size)/2.0 - 0.5;
+            double ss_y = ss_grid.coords[2*i+1] + static_cast<double>(ss_grid.size)/2.0 - 0.5;
+
+            common_util::write_int(outfile, ss_x);
+            common_util::write_int(outfile, ss_y);
+            common_util::write_dbl(outfile, u[idx]);
+            common_util::write_dbl(outfile, v[idx]);
+            common_util::write_dbl(outfile, mag);
+            common_util::write_uint8t(outfile, conv[idx]);
+            common_util::write_dbl(outfile, cost[idx]);
+            common_util::write_dbl(outfile, ftol[idx]);
+            common_util::write_dbl(outfile, xtol[idx]);
+            common_util::write_int(outfile, niter[idx]);
+
+            if (saveconf.shape_params) {
+                for (int pidx = 0; pidx < num_params; pidx++){
+                    common_util::write_dbl(outfile, p[num_params*idx+pidx]);
+                }
+            }
+
+        }
+
+        outfile.close();
+    }
+    else {
+
+        outfile.open(outfile_str.str());
+
+        // column headers
+        outfile << "subset_x" << delimiter;
+        outfile << "subset_y" << delimiter;
+        outfile << "displacement_u" << delimiter;
+        outfile << "displacement_v" << delimiter;
+        outfile << "displacement_mag" << delimiter;
+        outfile << "converged" << delimiter;
+        outfile << "cost" << delimiter;
+        outfile << "ftol" << delimiter;
+        outfile << "xtol" << delimiter;
+        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 < ss_grid.num; i++) {
+
+            int idx = index(i, results_num);
+            //int idx_p = num_params*idx;
+
+            // convert from corner to centre subset coords
+            double ss_x = ss_grid.coords[2*i  ] + static_cast<double>(ss_grid.size)/2.0 - 0.5;
+            double ss_y = ss_grid.coords[2*i+1] + static_cast<double>(ss_grid.size)/2.0 - 0.5;
+
+            // if the subset has not met threshold, set values to nan
+            if (!saveconf.output_below_threshold && !above_thresh[idx]) {
+                u[idx] = NAN;
+                v[idx] = NAN;
+                for (int pidx = 0; pidx < num_params; pidx++){
+                    p[num_params*idx+pidx] = NAN;
+                }
+                cost[idx] = NAN;
+                ftol[idx] = NAN;
+                xtol[idx] = NAN;
+            }
+
+
+            outfile << ss_x << delimiter;
+            outfile << ss_y << delimiter;
+            outfile << u[idx] << delimiter;
+            outfile << v[idx] << delimiter;
+            outfile << sqrt(u[idx]*u[idx]+
+                            v[idx]*v[idx]) << delimiter;
+            outfile << static_cast<int>(conv[idx]) << delimiter;
+            outfile << cost[idx] << delimiter;
+            outfile << ftol[idx] << delimiter;
+            outfile << xtol[idx] << delimiter;
+            outfile << niter[idx];
+
+            // write shape parameters if requested
+            if (saveconf.shape_params) {
+                for (int pidx = 0; pidx < num_params; pidx++){
+                    outfile << delimiter;
+                    outfile << p[num_params*idx+pidx];
+                }
+            }
+
+            // newline after each subset
+            outfile << "\n";
+
+
+        }
+        outfile.close();
+    }
+}
+
+
+

pyvale/dic/cpp/dicresults.hpp

@@ -0,0 +1,64 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+#ifndef DICRESULTS_H
+#define DICRESULTS_H
+
+// STD library Header files
+#include <vector>
+#include <cstdint>
+
+// common_cpp Header files
+#include "../../common_cpp/util.hpp"
+
+// DIC Header files
+#include "./dicsubset.hpp"
+
+struct OptResult {
+    std::vector<double> p;
+    double u = 0.0;
+    double v = 0.0;
+    double mag = 0.0;
+    double ftol = 0.0;
+    double xtol = 0.0;
+    int iter = 0;
+    double cost = 0.0;
+    uint8_t converged = false;
+    uint8_t above_threshold = false;
+    OptResult(size_t num_params) : p(num_params, 0.0) {}
+};
+
+
+class OptResultArrays {
+
+    private:
+        int num_ss;
+        int num_params;
+        bool at_end;
+
+    public:
+        // result arrays.
+        std::vector<int> niter;
+        std::vector<double> u; 
+        std::vector<double> v;
+        std::vector<double> p;
+        std::vector<double> ftol;
+        std::vector<double> xtol;
+        std::vector<double> cost;
+        std::vector<uint8_t> conv;
+        std::vector<uint8_t> above_thresh;
+
+        OptResultArrays(int num_def_img, int num_ss, int num_params, bool conf_at_end);
+        void append(OptResult &res, int img_num, int ss);
+        int index(const int subset_idx, const int img_num);
+        int index_parameters(const int subset_idx, const int img_num);
+        void write_to_disk(int img, const common_util::SaveConfig &saveconf,
+                           const subset::Grid &ss_grid, const int num_def_img,
+                           const std::vector<std::string> &filenames);
+};
+
+
+#endif // DICRESULTS_H

pyvale/dic/cpp/dicrg.cpp

@@ -0,0 +1,55 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+// STD library Header files
+#include <csignal>
+#include <cstdlib>
+#include <vector>
+#include <iostream>
+#include <omp.h>
+
+
+
+// Program Header files
+#include "./dicsubset.hpp"
+
+
+namespace rg {
+
+    bool is_valid_point(const int ss_x, const int ss_y, const subset::Grid &ss_grid) {
+
+        int x = ss_x / ss_grid.step;
+        int y = ss_y / ss_grid.step;
+
+        int idx = y * ss_grid.num_ss_x + x;
+
+        if ((ss_x % ss_grid.step) || (ss_y % ss_grid.step)){
+            std::cerr << "Subset coordinates (" << ss_x << ", " << ss_y << ") are not a valid subset location." << std::endl;
+            std::cerr << "Subset ss_step size: " << ss_grid.step << std::endl;
+            return false;
+            exit(EXIT_FAILURE);
+        }
+        else if (ss_grid.mask[idx] == -1){
+            std::cerr << "Subset coordinates (" << ss_x << ", " << ss_y << ") are not a valid subset location." << std::endl;
+            std::cerr << "subset mask index: " << idx << std::endl;
+            return false;
+            exit(EXIT_FAILURE);
+        }
+        else return true;
+
+        //auto it = ss_grid.coords_to_idx.find({ss_x, ss_y});
+
+        //// check if coordinates are in the coordinate list
+        //if (it == ss_grid.coords_to_idx.end()) {
+        //   std::cerr << "Error: coordinates not found in the coordinate list." << std::endl;
+        //   std::cerr << "Coordinates: " << ss_x << ", " << ss_y << std::endl;
+        //   exit(EXIT_FAILURE);
+        //}
+        //else return true;
+    }
+}
+
+

pyvale/dic/cpp/dicrg.hpp

@@ -0,0 +1,52 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+
+#ifndef DICRG_H
+#define DICRG_H
+
+// STD library Header files
+
+// Program Header files
+#include "./dicsubset.hpp"
+
+namespace rg {
+
+    /**
+     * @brief 
+     * 
+     */
+    struct Point {
+        int idx;
+        double val;
+
+        // Constructor
+        Point(int _idx, double _val) : 
+            idx(_idx), val(_val) {}
+
+        // Comparison operator for priority queue (higher ZNCC first)
+        bool operator<(const Point& other) const {
+            return val < other.val;  // Note: priority_queue puts largest elements on top
+        }
+    };
+
+    /**
+     * @brief 
+     * 
+     * @param x 
+     * @param y 
+     * @param px_hori 
+     * @param px_vert 
+     * @param ss_size 
+     * @return true 
+     * @return false 
+     */
+     bool is_valid_point(const int ss_x, const int ss_y, const subset::Grid &ss_grid);
+
+}
+
+
+#endif // DICRG_H