Merge pull request #558 from hpcflow/pyvale_dic

Add tasks for running DIC

Author: mikesmic

.gitignore

@@ -139,3 +139,4 @@ docs/source/reference/ts_*.html
 docs/source/reference/api.rst
 
 problems/
+.DS_Store

matflow/data/scripts/pyvale/__init__.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pyvale.dic as dic
+import numpy as np
+from PIL import Image
+
+
+def create_dic_roi_from_rect_boundary(
+    reference_image_path: str, crop_dists: dict[str, int] | None = None
+):
+    ref_image = np.array(Image.open(Path(reference_image_path)))
+
+    crop_dists_default = {
+        "left": 0,
+        "right": 0,
+        "top": 0,
+        "bottom": 0,
+    }
+    if crop_dists is not None:
+        crop_dists_default.update(crop_dists)
+    crop_dists = crop_dists_default
+
+    roi = dic.RegionOfInterest(ref_image=ref_image)
+    roi.rect_boundary(**crop_dists)
+
+    return {"DIC_mask": roi.mask}

matflow/data/scripts/pyvale/create_dic_roi_from_rect_boundary.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from natsort import natsorted
+import pyvale.dic as dic
+
+
+def extract_dic_result(pyvale_dic_result_files: list[Path]):
+    dicdata = dic.import_2d(
+        natsorted(pyvale_dic_result_files), binary=True, layout="matrix"
+    )
+    return {
+        k: getattr(dicdata, k)
+        for k in [
+            "ss_x",
+            "ss_y",
+            "u",
+            "v",
+            "mag",
+            "converged",
+            "cost",
+            "ftol",
+            "xtol",
+            "niter",
+        ]
+    }

matflow/data/scripts/pyvale/extract_dic_result.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+from natsort import natsorted
+import pyvale.dic as dic
+import numpy as np
+from PIL import Image
+
+Image.MAX_IMAGE_PIXELS = None
+
+
+def run_dic(
+    reference_image_path: str,
+    deformed_image_path: str,
+    DIC_mask: np.ndarray | None = None,
+    DIC_seed: list[int] | None = None,
+    **kwargs
+):
+    reference_image_path = Path(reference_image_path)
+    ref_image = np.array(Image.open(reference_image_path))
+
+    deformed_image_path = Path(deformed_image_path)
+    deformed_image_paths = natsorted(
+        deformed_image_path.parent.glob(deformed_image_path.name)
+    )
+    def_images = []
+    for deformed_image_path in deformed_image_paths:
+        if deformed_image_path == reference_image_path:
+            continue
+        def_images.append(np.array(Image.open(deformed_image_path)))
+    def_images = np.array(def_images)
+
+    if DIC_seed is None:
+        DIC_seed = [ref_image.shape[1] // 2, ref_image.shape[0] // 2]
+
+    if DIC_mask is None:
+        roi = dic.RegionOfInterest(ref_image=ref_image)
+        roi.rect_boundary(left=0, right=0, top=0, bottom=0)
+        DIC_mask = roi.mask
+
+    dic_args = {k: v for k, v in kwargs.items() if v is not None}
+    dic.calculate_2d(
+        reference=ref_image,
+        deformed=def_images,
+        roi_mask=DIC_mask,
+        seed=DIC_seed,
+        output_at_end=True,
+        output_binary=True,
+        output_below_threshold=True,
+        **dic_args
+    )

matflow/data/scripts/pyvale/run_dic.py

@@ -108,3 +108,8 @@
     name: (.*\.e)
     is_regex: true
   doc: Moose output file in the Exodus (NetCDF) format.
+
+- label: pyvale_dic_result_files
+  name:
+    name: (.*\.dic2d)
+    is_regex: true

matflow/data/template_components/command_files.yaml

@@ -649,6 +649,145 @@
         description: The Gmsh-generated mesh, as a string.
       condition: { value.is_instance: [str] }
 
+- type: reference_image_path
+  _validation:
+    - path: []
+      doc: 
+      condition: { value.is_instance: [str, path] }
+- type: deformed_image_path
+  _validation:
+    - path: []
+      doc: 
+      condition: { value.is_instance: [str, path] }
+- type: subset_size
+  _validation: 
+    - path: []
+      doc: "Size of the square subset window in pixels (default: 21)."
+      condition: { value.is_instance: [int] }
+- type: subset_step
+  _validation:
+    - path: []
+      doc: "Step size between subset centers in pixels (default: 10)."
+      condition: { value.is_instance: [int] }
+- type: correlation_criteria
+  _validation:
+    - path: []
+      doc: "Metric for matching subsets: `ZNSSD`, `NSSD` or `SSD` (default: `ZNSSD`)."
+      condition:
+        and:
+          - value.is_instance: [str]
+          - value.in: [ZNSSD, NSSD, SSD]
+- type: shape_function
+  _validation:
+    - path: []
+      doc: "Deformation model: e.g., `AFFINE`, `RIGID` (default: `AFFINE`)."
+      condition:
+        and:
+          - value.is_instance: [str]
+          - value.in: [AFFINE, RIGID]
+- type: interpolation_routine
+  _validation:
+    - path: []
+      doc: >
+        Interpolation method used on image intensity. `BICUBIC` is currently the 
+        only supported option.
+      condition:
+        and:
+          - value.is_instance: [str]
+          - value.in: [BICUBIC]
+- type: max_iterations
+  _validation:
+    - path: []
+      doc: "Maximum number of iterations allowed for subset optimization (default: 40)."
+      condition: { value.is_instance: [int] }
+- type: precision
+  _validation:
+    - path: []
+      doc: "Precision threshold for iterative optimization convergence (default: 0.001)."
+      condition: { value.is_instance: [float] }
+- type: threshold
+  _validation:
+    - path: []
+      doc: "Minimum correlation/cost coefficient value to be considered a matching subset (default: 0.9)."
+      condition: { value.is_instance: [float] }
+- type: bf_threshold
+  _validation:
+    - path: []
+      doc: >
+        Correlation threshold used in rigid bruteforce check for a subset to be 
+        considered a good match(default: 0.6).
+      condition: { value.is_instance: [float] }
+- type: max_displacement
+  _validation:
+    - path: []
+      doc: "Estimate for the Maximum displacement in any direction (in pixels) (default: 128)."
+      condition: { value.is_instance: [int] }
+- type: method
+  _validation:
+    - path: []
+      doc: >
+        Subset scanning method: `RG` for Reliability-Guided (best overall approach), 
+        `IMAGE_SCAN` for a standard scan across the image with no seeding (best 
+        performance with for subpixel displacements with high quality images), `FFT` 
+        for a multi-window FFT based approach (Good for large displacements)
+      condition:
+        and:
+          - value.is_instance: [str]
+          - value.in: [RG, IMAGE_SCAN, FFT]
+- type: fft_mad
+  _validation:
+    - path: []
+      doc: >
+        The option to smooth FFT windowing data by identifying and replacing outliers 
+        using a robust statistical method. For each subset, the function collects 
+        values from its neighboring subsets (within a 5x5 window, i.e., radius = 2), 
+        computes the median and Median Absolute Deviation (MAD), and determines whether 
+        the value at the current subset is an outlier. If it is, the value is replaced 
+        with the median of its neighbors. (default: False)
+      condition: { value.is_instance: [bool] }
+- type: fft_mad_scale
+  _validation:
+    - path: []
+      doc: >
+        An outlier is defined as a value whose deviation from the local median exceeds 
+        fft_mad_scale times the MAD. This value choses the scaling factor that determines 
+        the threshold for detecting outliers relative to the MAD.
+      condition: { value.is_instance: [bool] }
+- type: output_delimiter
+  _validation:
+    - path: []
+      doc: "Delimiter used in text output files (default: `,`)."
+      condition: { value.is_instance: [str] }
+- type: output_below_threshold
+  _validation:
+    - path: []
+      doc: >
+        If True, subset results with cost values that did not exceed the cost threshold 
+        will still be present in output (default: False).
+      condition: { value.is_instance: [bool] }
+- type: dic_seed
+  _validation:
+    - path: []
+      doc: >
+        Coordinates `[x, y]` of the seed point for Reliability-Guided (RG) scanning, 
+        default is centre of image.
+      condition:
+        and:
+          - value.is_instance: [list]
+          - value.length.equal_to: 2
+    - path: [{ "type": "list_value" }]
+      condition: { value.is_instance: [int] }
+- type: crop_dists
+  _validation:
+    - path: []
+      doc: Number of px to exclude from each edge of image (`left`, `right`, `top`, `bottom`).
+      condition:
+        and:
+          - value.is_instance: [dict]
+          - key.in: ["left", "right", "top", "bottom"]
+    - path: [{ "type": "map_value" }]
+      condition: { value.is_instance: [int] }
+
 # Types only used to transfer values between tasks
 - type: damask_post_processing_result
 - type: damask_viz_result

matflow/data/template_components/parameters.yaml

@@ -2787,3 +2787,80 @@
       script_pass_workflow: true
       environments:
         any: python_env
+
+- objective: create_DIC_ROI
+  implementation: pyvale
+  method: from_rect_boundary
+  inputs:
+    - parameter: reference_image_path
+    - parameter: crop_dists
+      default_value: null
+  outputs:
+    - parameter: DIC_mask
+  actions:
+    - script: <<script:pyvale/create_dic_roi_from_rect_boundary.py>>
+      script_data_in: direct
+      script_data_out: direct
+      script_exe: python_script
+      environments:
+        - scope:
+            type: any
+          environment: pyvale_env
+
+- objective: run_DIC
+  doc: Run digital image correlation on two images
+  implementation: pyvale
+  inputs:
+    - parameter: reference_image_path
+    - parameter: deformed_image_path
+    - parameter: DIC_mask
+      default_value: null
+    - parameter: DIC_seed
+      default_value: null
+    - parameter: subset_size
+      default_value: null
+    - parameter: subset_step
+      default_value: null
+    - parameter: correlation_criteria
+      default_value: null
+    - parameter: shape_function
+      default_value: null
+    - parameter: interpolation_routine
+      default_value: null
+    - parameter: max_iterations
+      default_value: null
+    - parameter: precision
+      default_value: null
+    - parameter: threshold
+      default_value: null
+    - parameter: bf_threshold
+      default_value: null
+    - parameter: max_displacement
+      default_value: null
+    - parameter: method
+      default_value: null
+    - parameter: fft_mad
+      default_value: null
+    - parameter: fft_mad_scale
+      default_value: null
+    - parameter: output_delimiter
+      default_value: null
+    - parameter: output_below_threshold
+      default_value: null
+    - parameter: debug_level
+      default_value: 0
+  outputs:
+    - parameter: DIC_results
+  actions:
+    - script: <<script:pyvale/run_dic.py>>
+      script_data_in: direct
+      script_exe: python_script
+      environments:
+        - scope:
+            type: any
+          environment: pyvale_env
+      output_file_parsers:
+        DIC_results:
+          from_files: [pyvale_dic_result_files]
+          save_files: [pyvale_dic_result_files]
+          script: <<script:pyvale/extract_dic_result.py>>

matflow/data/template_components/task_schemas.yaml

@@ -0,0 +1,24 @@
+tasks:
+  - schema: create_DIC_ROI_from_rect_boundary_pyvale
+    inputs:
+      reference_image_path: path/to/dic/images/0.bmp
+      crop_dists:
+        left: 100
+        right: 100
+
+  - schema: run_DIC_pyvale
+    inputs:
+      deformed_image_path: path/to/dic/images/*.bmp
+      max_displacement: 2000
+      fft_mad: true
+      fft_mad_scale: 5.0
+      correlation_criteria: ZNSSD
+      shape_function: AFFINE
+      threshold: 0.8
+      method: MULTIWINDOW
+    sequences:
+      - path: inputs.subset_size
+        values:
+          - 15
+          - 31
+          - 45