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

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

pyvale/dic2d.py

@@ -6,9 +6,14 @@
 
 
 
+import os
+import io
+import sys
 import numpy as np
 from pathlib import Path
 
+import pybind11
+
 # import cython module
 import pyvale.dic2dcpp as dic2dcpp
 import pyvale.dicchecks as dicchecks
@@ -17,7 +22,7 @@ import pyvale.dicchecks as dicchecks
 def dic_2d(reference: np.ndarray | str | Path,
           deformed: np.ndarray | str | Path,
           roi_mask: np.ndarray,
-          seed: list[int],
+          seed: list[int] | list[np.int32] | np.ndarray,
           subset_size: int = 21,
           subset_step: int = 10,
           correlation_criteria: str="ZNSSD",
@@ -27,6 +32,7 @@ def dic_2d(reference: np.ndarray | str | Path,
           opt_precision: float=0.001,
           opt_threshold: float=0.9,
           bf_threshold: float=0.6,
+          num_threads: int | None = None,
           max_displacement: int=128,
           scanning_method: str="RG",
           fft_mad: bool=False,
@@ -35,7 +41,11 @@ def dic_2d(reference: np.ndarray | str | Path,
           output_basepath: Path | str = "./",
           output_binary: bool=False,
           output_prefix: str="dic_results_",
-          output_delimiter: str=",") -> None:
+          output_delimiter: str=",",
+          output_unconverged: bool=False,
+          output_shape_params: bool=False,
+          debug_level: int=0) -> None:
+
     """
     Perform 2D Digital Image Correlation (DIC) between a reference image and one or more deformed images.
 
@@ -51,7 +61,7 @@ def dic_2d(reference: np.ndarray | str | Path,
         The deformed image(s) (3D array for multiple images) or path/pattern to image files.
     roi_mask : np.ndarray
         A binary mask indicating the Region of Interest (ROI) for analysis (same size as image).
-    seed : list of int, optional
+    seed : list[int], list[np.int32] or np.ndarray
         Coordinates `[x, y]` of the seed point for Reliability-Guided (RG) scanning, default is empty.
     subset_size : int, optional
         Size of the square subset window in pixels (default: 21).
@@ -70,6 +80,8 @@ def dic_2d(reference: np.ndarray | str | Path,
         Precision threshold for iterative optimization convergence (default: 0.001).
     opt_threshold : float, optional
         Minimum correlation improvement threshold to continue iterations (default: 0.9).
+    num_threads : int, optional
+        Number of threads to use for parallel computation (default: None, uses all available).
     bf_threshold : float, optional
         Correlation threshold used in rigid bruteforce check for a subset to be considered a
         good match(default: 0.6).
@@ -103,6 +115,12 @@ def dic_2d(reference: np.ndarray | str | Path,
         changed to ".csv" or ".dic2d" depending on whether outputting as a binary.
     output_delimiter : str, optional
         Delimiter used in text output files (default: ",").
+    output_unconverged : bool, optional
+        If True, subset results as they were for the final iteration of the optimization 
+        that did not converge will be saved (default: False).
+    output_shape_params : bool, optional
+        If True, all shape parameters will be saved in the output files (default: False).
+    debug_level:
 
     Returns
     -------
@@ -151,6 +169,7 @@ def dic_2d(reference: np.ndarray | str | Path,
     config.filenames = filenames
     config.fft_mad = fft_mad
     config.fft_mad_scale = fft_mad_scale
+    config.debug_level = debug_level
 
     # assigning c++ struct vals for save config
     saveconf = dic2dcpp.SaveConfig()
@@ -159,6 +178,14 @@ def dic_2d(reference: np.ndarray | str | Path,
     saveconf.prefix = output_prefix
     saveconf.delimiter = output_delimiter
     saveconf.at_end = output_at_end
+    saveconf.output_unconverged = output_unconverged
+    saveconf.shape_params = output_shape_params
+
+
+    #set the number of OMP threads
+    if num_threads is not None:
+        dic2dcpp.set_num_threads(num_threads)
 
     # calling the c++ dic engine
-    dic2dcpp.dic_engine(ref_arr, def_arr, roi_c, config, saveconf)
+    with dic2dcpp.ostream_redirect(stdout=True, stderr=True):
+        dic2dcpp.dic_engine(ref_arr, def_arr, roi_c, config, saveconf)

pyvale/dicchecks.py

@@ -55,16 +55,18 @@ def check_output_directory(output_basepath: str,
 
     if conflicting_files:
         conflicting_files.sort()
-        print("The following output files already exist and may be overwritten:")
+        print("WARNING: The following output files already exist and may be overwritten:")
         for f in conflicting_files:
             print(f"  - {os.path.join(output_basepath, f)}")
         print("")
 
-        user_input = input("Do you want to continue? (y/n): ").strip().lower()
 
-        if user_input not in ("y", "yes", "Y", "YES"):
-            print("Aborting to avoid overwriting data in output directory.")
-            exit(0)
+        ###### TURNING USER INPUT OFF FOR NOW ######
+        # user_input = input("Do you want to continue? (y/n): ").strip().lower()
+
+        # if user_input not in ("y", "yes", "Y", "YES"):
+        #     print("Aborting to avoid overwriting data in output directory.")
+        #     exit(0)
 
 
 def check_correlation_criteria(correlation_criteria: str) -> None:
@@ -247,7 +249,7 @@ def check_subsets(subset_size: int, subset_step: int) -> None:
 
 
 
-def check_and_update_rg_seed(seed: list[int], roi_mask: np.ndarray, scanning_method: str, px_hori: int, px_vert: int, subset_size: int, subset_step: int) -> list[int]:
+def check_and_update_rg_seed(seed: list[int] | list[np.int32] | np.ndarray, roi_mask: np.ndarray, scanning_method: str, px_hori: int, px_vert: int, subset_size: int, subset_step: int) -> list[int]:
     """
     Validate and update the region-growing seed location to align with image bounds and subset spacing.
 
@@ -260,7 +262,7 @@ def check_and_update_rg_seed(seed: list[int], roi_mask: np.ndarray, scanning_met
 
     Parameters
     ----------
-    seed : list of int
+    seed : list[int], list[np.int32] or np.ndarray
         The initial seed coordinates as a list of two integers: [x, y].
     roi_mask : np.ndarray
         A 2D binary mask (same size as the image) indicating the region of interest.
@@ -287,11 +289,19 @@ def check_and_update_rg_seed(seed: list[int], roi_mask: np.ndarray, scanning_met
     if scanning_method != "RG":
         return [0,0]
 
-    if not (isinstance(seed, list) and len(seed) == 2 and all(isinstance(coord, int) for coord in seed)):
-        raise ValueError("Reliability Guided seed is either missing or has been defined incorrectly. must be a list of two integers: seed=[x, y]")
+    if (len(seed) != 2):
+        raise ValueError(f"Reliability Guided seed does not have two elements: " \
+                         f"seed={seed}. Seed " \
+                         f" must be a list of two integers: seed=[x, y]")
+
+    if not isinstance(seed, (list, np.ndarray)) or not all(isinstance(coord, (int, np.int32)) for coord in seed):
+        raise ValueError("Reliability Guided seed must be a list of two integers: seed=[x, y]")
 
     x, y = seed
 
+    if x < 0 or x >= px_hori or y < 0 or y >= px_vert:
+        raise ValueError(f"Seed ({x}, {y}) goes outside the image bounds: ({px_hori}, {px_vert})")
+
     corner_x = x - subset_size//2
     corner_y = y - subset_size//2
 
@@ -302,17 +312,11 @@ def check_and_update_rg_seed(seed: list[int], roi_mask: np.ndarray, scanning_met
     new_x = round_to_step(corner_x, subset_step)
     new_y = round_to_step(corner_y, subset_step)
 
-
-    # Clamp to image bounds
-    new_x = min(max(new_x, 0), px_hori - 1)
-    new_y = min(max(new_y, 0), px_vert - 1)
-
     # check if all pixel values within the seed location are within the ROI
     # seed coordinates are the central pixel to the subset
     max_x = new_x + subset_size//2+1
     max_y = new_y + subset_size//2+1
 
-
     # Check if all pixel values in the ROI are valid
     for i in range(corner_x, max_x):
         for j in range(corner_y, max_y):
@@ -435,9 +439,17 @@ def check_and_get_images(reference: np.ndarray | str | Path,
         ref_arr = reference
         def_arr = deformed
 
-        if (reference.shape != deformed[0].shape or reference.shape != roi.shape):
+        # user might only pass a single deformed image. need to convert to 'stack'
+        if (reference.shape == deformed.shape):
+            def_arr = def_arr.reshape((1,def_arr.shape[0],def_arr.shape[1]))
+
+        elif (reference.shape != deformed[0].shape or reference.shape != roi.shape):
             raise ValueError(f"Shape mismatch: reference {reference.shape}, "
                              f"deformed[0] {deformed[0].shape}, roi {roi.shape}")
+        
+
+        # need to set some dummy filenames in the case that the user passes numpy arrays
+        filenames = [f"deformed image {i}" for i in range(def_arr.shape[0])]
     
     # it might be the case that the roi has been manipulated prior to DIC run
     # and therefore we need to to prevent the roi mask from being a 'view'

pyvale/dicdataimport.py

@@ -23,7 +23,7 @@ calculations.
 def dic_data_import(data: str | Path,
                    binary: bool = False,
                    layout: str = "matrix",
-                   delimiter: str = " ") -> DICResults:
+                   delimiter: str = ",") -> DICResults:
     """
     Import DIC result data from human readable text or binary files.
 
@@ -93,18 +93,67 @@ def dic_data_import(data: str | Path,
             raise ValueError("Mismatch in coordinates across frames.")
         frames.append(f)
 
-    # Stack fields into arrays
-    arrays = [np.stack([frame[i] for frame in frames]) for i in range(8)]
+    # Stack results (except ss_x and ss_y) into arrays
+    arrays = [np.stack([frame[i] for frame in frames]) for i in range(len(fields))]
 
     if layout == "matrix":
+
+        # convert x and y data to meshgrid
         x_unique = np.unique(ss_x_ref)
         y_unique = np.unique(ss_y_ref)
         X, Y = np.meshgrid(x_unique, y_unique)
         shape = (len(files), len(y_unique), len(x_unique))
+
+
         arrays = [to_grid(a,shape,ss_x_ref, ss_y_ref, x_unique,y_unique) for a in arrays]
-        return DICResults(X, Y, *arrays, filenames)
+
+
+        # sorting out shape function parameters if they are present in the files
+        current_shape = arrays[0].shape  # (file,x,y)
+        shape_params = np.zeros(())
+
+        # rigid
+        if len(fields) == 10:
+            shape_params = np.zeros(current_shape+(2,))
+            shape_params[:,:,:,0] = arrays[8]
+            shape_params[:,:,:,1] = arrays[9]
+        if len(fields) == 14:
+            shape_params = np.zeros(current_shape+(6,))
+            shape_params[:,:,:,0] = arrays[8]
+            shape_params[:,:,:,1] = arrays[9]
+            shape_params[:,:,:,2] = arrays[10]
+            shape_params[:,:,:,3] = arrays[11]
+            shape_params[:,:,:,4] = arrays[12]
+            shape_params[:,:,:,5] = arrays[13]
+
+
+
+
+        return DICResults(X, Y, arrays[0], arrays[1], arrays[2], arrays[3],
+                          arrays[4], arrays[5], arrays[6], arrays[7], 
+                          shape_params, filenames)
+    # column layout
     else:
-        return DICResults(ss_x_ref, ss_y_ref, *arrays, filenames)
+
+        shape_params = np.zeros(())
+        current_shape = arrays[0].shape # (file,(x,y))
+        # rigid
+        if len(fields) == 10:
+            shape_params = np.zeros(current_shape+(2,))
+            shape_params[:,:,0] = arrays[8]
+            shape_params[:,:,1] = arrays[9]
+        if len(fields) == 14:
+            shape_params = np.zeros(current_shape+(6,))
+            shape_params[:,:,0] = arrays[8]
+            shape_params[:,:,1] = arrays[9]
+            shape_params[:,:,2] = arrays[10]
+            shape_params[:,:,3] = arrays[11]
+            shape_params[:,:,4] = arrays[12]
+            shape_params[:,:,5] = arrays[13]
+
+        return DICResults(ss_x_ref, ss_y_ref, arrays[0], arrays[1], arrays[2], arrays[3],
+                          arrays[4], arrays[5], arrays[6], arrays[7], 
+                          shape_params, filenames)
 
 
 
@@ -118,6 +167,8 @@ def read_binary(file: str, delimiter: str):
     - 2 × int32 (subset coordinates)
     - 6 × float64 (u, v, match quality, cost, ftol, xtol)
     - 1 × int32 (number of iterations)
+    - 1 × uint8 (convergence flag) 
+    - 2 or 6 × float64 (shape parameters)
 
     Parameters
     ----------
@@ -138,26 +189,74 @@ def read_binary(file: str, delimiter: str):
     ValueError
         If the binary file size does not align with expected row size.
     """
-
-    row_size = (3 * 4 + 6 * 8)
+    
+    # row size can either be 3×4 + 6×8 + 1 = 61 bytes (without shape params)
+    # or 3×4 + 6×8 + 1 + 6×8 = 109 bytes (with shape params)
     with open(file, "rb") as f:
         raw = f.read()
-    if len(raw) % row_size != 0:
-        raise ValueError("Binary file has incomplete rows.")
+
+    has_shape_params = False
+    has_rigid_params = False
+    has_affine_params = False
+
+    row_size_basic = 3 * 4 + 6 * 8 + 1           # 61 bytes
+    row_size_with_rigid = row_size_basic + 2 * 8 # 77 bytes
+    row_size_with_affine = row_size_basic + 6 * 8 # 109 bytes
+
+    if len(raw) % row_size_basic == 0:
+        row_size = row_size_basic
+        has_shape_params = False
+    elif len(raw) % row_size_with_rigid == 0:
+        has_shape_params = True
+        row_size = row_size_with_rigid
+        has_rigid_params = True
+        has_affine_params = False
+    elif len(raw) % row_size_with_affine == 0:
+        has_shape_params = True
+        row_size = row_size_with_affine
+        has_affine_params = True
+        has_rigid_params = False
+    else:
+        raise ValueError(
+            f"Binary file has incomplete rows: {file}. "
+            f"Expected row size: 65 ((without shape params), "
+            f"81 (with rigid shape params) bytes, "
+            f"109 (with affine shape params). "
+            f"Actual size: {len(raw)} bytes."
+        )
+
     rows = len(raw) // row_size
     arr = np.frombuffer(raw, dtype=np.uint8).reshape(rows, row_size)
-    def extract(col, dtype, start): return np.frombuffer(arr[:, start:start+col], dtype=dtype)
-    ss_x = extract(4, np.int32, 0)
-    ss_y = extract(4, np.int32, 4)
-    u    = extract(8, np.float64, 8)
-    v    = extract(8, np.float64, 16)
-    m    = extract(8, np.float64, 24)
-    conv = extract(1, np.bool_, 25)
-    cost = extract(8, np.float64, 33)
-    ftol = extract(8, np.float64, 41)
-    xtol = extract(8, np.float64, 49)
+
+    def extract(col, dtype, start):
+        return np.frombuffer(arr[:, start:start+col].copy(), dtype=dtype)
+
+    ss_x  = extract(4, np.int32, 0)
+    ss_y  = extract(4, np.int32, 4)
+    u     = extract(8, np.float64, 8)
+    v     = extract(8, np.float64, 16)
+    m     = extract(8, np.float64, 24)
+    conv  = extract(1, np.uint8, 32).astype(bool)
+    cost  = extract(8, np.float64, 33)
+    ftol  = extract(8, np.float64, 41)
+    xtol  = extract(8, np.float64, 49)
     niter = extract(4, np.int32, 57)
-    return ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter
+
+    if has_shape_params:
+        if has_rigid_params:
+            p0 = extract(8, np.float64, 61)
+            p1 = extract(8, np.float64, 69)
+            return ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter, p0,p1
+        if has_affine_params:
+            p0 = extract(8, np.float64, 61)
+            p1 = extract(8, np.float64, 69)
+            p2 = extract(8, np.float64, 77)
+            p3 = extract(8, np.float64, 85)
+            p4 = extract(8, np.float64, 93)
+            p5 = extract(8, np.float64, 101)
+            return ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter, p0,p1,p2,p3,p4,p5
+    else:
+        return ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter
 
 
 
@@ -168,6 +267,7 @@ def read_text(file: str, delimiter: str):
 
     Expects at least 9 columns:
     [ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter]
+    Could also include shape parameters if present.
 
     Parameters
     ----------
@@ -181,7 +281,7 @@ def read_text(file: str, delimiter: str):
     -------
     tuple of np.ndarray
         Arrays corresponding to:
-        (ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter)
+        (ss_x, ss_y, u, v, m, conv, cost, ftol, xtol, niter, shape_params)
 
     Raises
     ------
@@ -190,18 +290,41 @@ def read_text(file: str, delimiter: str):
     """
 
     data = np.loadtxt(file, delimiter=delimiter, skiprows=1)
+    
     if data.shape[1] < 9:
         raise ValueError("Text data must have at least 9 columns.")
-    return (
-        data[:, 0].astype(np.int32),  # ss_x
-        data[:, 1].astype(np.int32),  # ss_y
-        data[:, 2], data[:, 3], data[:, 4], # u, v, mag
-        data[:, 5].astype(np.bool_), # convergence
-        data[:, 6], data[:, 7], data[:,8], # cost, ftol, xtol
-        data[:, 9].astype(np.int32) #niter
-    )
-
-
+    
+    if data.shape[1] == 10:
+        return (
+            data[:, 0].astype(np.int32),  # ss_x
+            data[:, 1].astype(np.int32),  # ss_y
+            data[:, 2], data[:, 3], data[:, 4], # u, v, mag
+            data[:, 5].astype(np.bool_), # convergence
+            data[:, 6], data[:, 7], data[:,8], # cost, ftol, xtol
+            data[:, 9].astype(np.int32) #niter
+        )
+    #rigid
+    elif data.shape[1]==12:
+        return (
+            data[:, 0].astype(np.int32),  # ss_x
+            data[:, 1].astype(np.int32),  # ss_y
+            data[:, 2], data[:, 3], data[:, 4], # u, v, mag
+            data[:, 5].astype(np.bool_), # convergence
+            data[:, 6], data[:, 7], data[:,8], # cost, ftol, xtol
+            data[:, 9].astype(np.int32), #niter
+            data[:,10], data[:,11] # shape params (rigid)
+        )
+    #affine
+    elif data.shape[1]==16:
+        return (
+            data[:, 0].astype(np.int32),  # ss_x
+            data[:, 1].astype(np.int32),  # ss_y
+            data[:, 2], data[:, 3], data[:, 4], # u, v, mag
+            data[:, 5].astype(np.bool_), # convergence
+            data[:, 6], data[:, 7], data[:,8], # cost, ftol, xtol
+            data[:, 9].astype(np.int32), #niter
+            data[:,10], data[:,11], data[:,12], data[:,13], data[:,14], data[:,15] # shape params (affine)
+        )