# A differentiable 2D digital image correlation framework

Émile Roux

► To cite this version:

Émile Roux. A differentiable 2D digital image correlation framework. SoftwareX, 2026, 34, 10.1016/j.softx.2026.102571. hal-05525287

HAL Id: hal-05525287

https://hal.science/hal-05525287v1

Submitted on 24 Feb 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
<figure><img src="image_2.png" /></figure>

# D²IC: A differentiable 2D digital image correlation framework

Roux Emile

<figure><img src="image_3.png" /></figure>

SYMME, Univ. Savoie Mont Blanc, Annecy, FR-74000, France

## ARTICLE INFO

**Keywords:**

Digital image correlation
Photomechanics
Automatic differentiation
JAX
Finite-element-based DIC

## ABSTRACT

D²IC is an open-source Python package for two-dimensional Digital Image Correlation (DIC) based on differentiable programming. It implements a global finite-element formulation: the displacement field is discretized on a quadrilateral mesh and estimated by minimizing a pixelwise brightness-constancy objective. Spring regularization can be added when needed. The computational core is written in JAX, which provides automatic differentiation, just-in-time compilation, and seamless execution on CPU or accelerator backends. D²IC exposes exact gradients of the correlation objective with respect to nodal displacements and other parameters. This enables rapid development of inverse problems, mechanically constrained extensions, and hybrid learning/optimization workflows without hand-derived Jacobians or finite differences. The package includes utilities for ROI/mesh generation from masks and a coarse translation-only initialization based on ZNCC at element centers with nodal projection. It also provides an optional nodal Gauss-Newton refinement to improve convergence from coarse initial guesses. Post-processing routines compute strains on the mesh. Thanks to end-to-end differentiability, the software also supports uncertainty propagation from image noise to displacement and strain via Jacobian-vector products. Worked examples and Jupyter notebooks reproduce validation on the 2D DIC Challenge datasets and demonstrate heterogeneous strain mapping and uncertainty visualization.

## Metadata

### Code metadata

<table><thead><tr><td>Nr.</td><td>Code metadata description</td><td>Metadata</td></tr></thead><tbody><tr><td>C1</td><td>Current code version</td><td>For example V1.0</td></tr><tr><td>C2</td><td>Permanent link to code/repository used for this code version</td><td>https://github.com/EmileRouxSMB/D2IC</td></tr><tr><td>C3</td><td>Permanent link to Reproducible Capsule</td><td>For example: https://zenodo.org/records/18503528</td></tr><tr><td>C4</td><td>Legal Code License</td><td>GPLv3</td></tr><tr><td>C5</td><td>Code versioning system used</td><td>git</td></tr><tr><td>C6</td><td>Software code languages, tools, and services used</td><td>Python, JAX</td></tr><tr><td>C7</td><td>Compilation requirements, operating environments & dependencies</td><td></td></tr><tr><td>C8</td><td>If available link to developer documentation/manual</td><td>https://github.com/EmileRouxSMB/D2IC/blob/main/doc/01_Simple2D_DIC.ipynb</td></tr><tr><td>C9</td><td>Support email for questions</td><td>emile.roux@univ-smb.fr</td></tr></tbody></table>

## 1. Motivation and significance

Digital Image Correlation (DIC) is a cornerstone technique in photomechanics to measure kinematics from image sequences. It enables non-contact, full-field displacement and strain measurements and is routinely used for material testing and experimental mechanics.

Comprehensive reviews highlight both the maturity of the method and the breadth of practical challenges that drive ongoing developments (e.g., spatial resolution vs. noise, robustness to large deformations and texture changes, computational cost, and user-dependent parameter tuning) [1].
<table><caption>**Table 1**
Overview of common DIC software solutions and qualitative comparison of their main methodological family and GPU usage.</caption><thead><tr><th>Software</th><th>Main approach</th><th>License / implementation</th><th>GPU</th></tr></thead><tbody><tr><td>CORRELI [9]</td><td>Global FE-DIC (mesh-based, continuous displacement field)</td><td>Academic reference implementation</td><td>No</td></tr><tr><td>Pyxel [10]</td><td>Global FE-DIC (mesh-based)</td><td>Open-source; Python</td><td>No</td></tr><tr><td>GPUCorrel [11]</td><td>Local DIC (subset-based) with GPU acceleration</td><td>Open-source; Python</td><td>Yes</td></tr><tr><td>OpenLSA [12]</td><td>Localized Spectrum Analysis (periodic patterns)</td><td>Open-source (GPL)</td><td>No</td></tr><tr><td>Ncorr [13]</td><td>Local DIC (subset-based)</td><td>Open-source; MATLAB</td><td>No</td></tr><tr><td>YADICs [14]</td><td>Local DIC (subset-based)</td><td>Open-source; MATLAB</td><td>No</td></tr><tr><td>DICe [15]</td><td>Local and global DIC; performance-oriented workflows</td><td>Open-source; C++/Python</td><td>Unknown</td></tr><tr><td>MatchID [16]</td><td>Industrial 2D/3D DIC workflows</td><td>Commercial; proprietary</td><td>Unknown</td></tr><tr><td>VIC-3D [17]</td><td>Stereo 3D DIC workflows</td><td>Commercial; proprietary</td><td>Unknown</td></tr><tr><td>D<sup>2</sup>IC (this work)</td><td>Differentiable global FE-DIC (JAX)</td><td>Open-source; Python/JAX</td><td>Optional</td></tr></tbody></table>

Most DIC algorithms rely on gradient-based optimization and sensitivity analysis, historically implemented through analytical derivations or finite-difference approximations [2–4]. Such approaches are difficult to maintain, error-prone, and computationally expensive when extended to complex parameterizations or coupled models [5,6]. Automatic differentiation enables exact and efficient gradient computation while preserving modularity, making DIC naturally compatible with modern machine learning workflows [7,8].

This methodological diversity translates into a broad software ecosystem. It ranges from local subset-based correlation to global mesh-based (FE) formulations and from CPU-oriented implementations to GPU-accelerated workflows. Table 1 summarizes representative solutions and highlights differences in methodological families and GPU usage. This motivates the need for a lightweight, differentiable implementation that can interface seamlessly with modern Python machine-learning tools.

Machine learning is increasingly used to accelerate or complement DIC. Examples include direct CNN-based displacement/strain regression [18], hybrid formulations that enforce DIC consistency through constraints [19], unsupervised/self-supervised approaches that reduce the need for ground-truth labels [20], and dense-matching architectures borrowed from optical flow and transformers [21,22]; see also the overview in [23]. To support these workflows in the Python ML ecosystem, D<sup>2</sup>IC provides a natively differentiable global FE-DIC implementation in JAX, exposing end-to-end gradients of the correlation objective and regularization for hybrid learning/optimization, uncertainty studies, and integration of data-driven priors.

## 2. Software description

### 2.1. DIC method description

This work uses a global, pixelwise Digital Image Correlation (DIC) formulation implemented in the mesh-based pipeline DICMeshBased. In the current API, data preparation is handled by DICMeshBased.prepare (mesh and pixel assets). The per-image solve is triggered by DICMeshBased.run, which delegates the minimization to the injected SolverBase implementation (by default, GlobalCGSolver). Global FE-based DIC formulations enforce kinematic continuity through a mesh representation of the displacement field. They can be extended toward mechanically constrained or integrated approaches [24–26]. Within this well-established family, reference implementations and methodological contributions include CORRELI [9] and Pyxel [10]. They also include algorithmic developments for global DIC (e.g., inverse compositional Gauss–Newton) [27], and enriched global formulations such as X-DIC [28]. D<sup>2</sup>IC is a complementary open-source implementation that follows the same global FE-DIC principles. It targets a lightweight, differentiable core that can be coupled to inverse problems and optimization workflows in Python.

### 2.1.1. Global DIC formulation (DICMeshBased + GlobalCGSolver)

Let $I_1$ be the reference image and $I_2$ the deformed image, defined over a region of interest (ROI) $\Omega$. Under the standard brightness constancy assumption [29,30], the displacement field $\mathbf{u}(\mathbf{x})$ satisfies

$$I_2(\mathbf{x} + \mathbf{u}(\mathbf{x})) \approx I_1(\mathbf{x}) \quad \forall \mathbf{x} \in \Omega. \qquad (1)$$

Finite element parameterization. The unknown displacement is discretized on a quadrilateral (Q4) mesh of the ROI [24]. Let $\mathbf{u}_i \in \mathbb{R}^2$ be the displacement at node $i \in \{1, \dots, N_n\}$ and $\mathbf{U} = \{\mathbf{u}_i\}_{i=1}^{N_n}$ the vector of all nodal unknowns. For each pixel $p$ of reference coordinate $\mathbf{x}_p$, the code stores (i) the four node indices $\{n_{p,a}\}_{a=1}^4$ of the element containing the pixel and (ii) the corresponding shape functions $\{N_{p,a}\}_{a=1}^4$ evaluated at $\mathbf{x}_p$. The pixel displacement is then obtained by interpolation:

$$\mathbf{u}(\mathbf{x}_p; \mathbf{U}) = \sum_{a=1}^{4} N_{p,a} \mathbf{u}_{n_{p,a}}. \qquad (2)$$

The associated warped coordinate is $\mathbf{x}_p^{\text{def}} = \mathbf{x}_p + \mathbf{u}(\mathbf{x}_p; \mathbf{U})$.

Pixelwise residual and objective. Image intensities are evaluated at off-grid positions using differentiable interpolation (linear/bilinear or bicubic, depending on solver settings and available backends). The pixelwise residual reads

$$r_p(\mathbf{U}) = I_2(\mathbf{x}_p^{\text{def}}) - I_1(\mathbf{x}_p), \qquad (3)$$

and the image mismatch energy minimized by the global solver (GlobalCGSolver Solv e) is the mean squared residual:

$$J_{\text{img}}(\mathbf{U}) = \frac{1}{2N_p} \sum_{p=1}^{N_p} r_p(\mathbf{U})^2, \qquad (4)$$

where $N_p$ is the number of pixels in the ROI.

Spring regularization (optional). In the default global solver (GlobalCGSolver), regularization is implemented as a spring-like penalty between neighboring nodes. Denoting by $\mathcal{E}$ the set of mesh edges (or a chosen node-neighborhood graph) and by $w_{ij} \ge 0$ an edge weight (in the code, derived from the nodal distance), the regularization energy is

$$J_{\text{reg}}(\mathbf{U}) = \frac{1}{2} \sum_{(i,j) \in \mathcal{E}} w_{ij} \|\mathbf{u}_i - \mathbf{u}_j\|^2. \qquad (5)$$

The total objective reads [24,31]

$$J(\mathbf{U}) = J_{\text{img}}(\mathbf{U}) + \alpha_{\text{reg}} J_{\text{reg}}(\mathbf{U}), \qquad (6)$$

with $\alpha_{\text{reg}} \ge 0$.
<figure><img src="image_4.png" /><figcaption>**Fig. 1.** Overview of the main $D^2IC$ classes and their dependencies. The central pipeline is DICMeshBased (DIC core), which plugs into solver implementations (SolverBase) and can be driven either directly or through the batch workflow (BatchMeshBased) with displacement propagators.</figcaption></figure>

Minimization strategy (GlobalCGSolver). The minimization of $J(U)$ uses a standard nonlinear conjugate gradient scheme (Polak-Ribière update [32,33]) coupled with an Armijo backtracking line search [34]. The objective and its derivatives are obtained directly from the differentiable JAX implementation of the image-warping and residual kernels. At each iteration, we evaluate both $J(U_k)$ and $g_k = \nabla_U J(U_k)$ using JAX automatic differentiation (in the code, jax.value_andGrad). We rely on JIT compilation to amortize the cost of repeated evaluations during the line search. This avoids hand-derived adjoints while keeping the full pipeline differentiable. When directional sensitivities are needed, Jacobian-vector products can be computed with jax.jvp. Hereafter, JVP stands for Jacobian-Vector Product, as defined in the JAX automatic differentiation framework. Iterations stop when $||g_k|| < tol$. In the reference implementation, we use Polak-Ribière + (with $\beta_k = \max(\beta_k^{PR}, 0)$ and a restart to steepest descent if the search direction is not a descent direction). The Armijo backtracking starts from $\alpha_0 = 1$ with $c = 10^{-4}$, a reduction factor of 1/2, and at most 10 backtracking steps. Unless specified otherwise by the user, the default iteration controls are $max_iters=50$ and $tol=1e-6$.

## 2.2. Software architecture

Fig. 1 summarizes the current $D^2IC$ code organization. The project is a pure-Python package ($D^2IC$/). It provides a high-level DIC API,

accelerated by JAX and able to run on CPU or GPU, on top of a low-level differentiable core implemented with JAX primitives.

From a dependency standpoint, the core requirement is JAX [35]. It provides the composable transformations used throughout $D^2IC$ (NumPy-like tensor operations, automatic differentiation for gradients, and JIT compilation). It also enables running the same kernels on CPU or accelerator backends when available. For differentiable image interpolation in JAX, we optionally rely on im-jax for bicubic sampling [36] (with a linear alternative available through dm_pix). Secondary dependencies are used for I/O and convenience rather than for the differentiable core. These include meshio (mesh read/write), NumPy (glue code and interoperability), scikit-image and OpenCV (image/feature utilities and ROI/mesh workflows), SciPy (interpolation utilities), and Matplotlib (visualization).

High-level API (DIC level, JAX/GPU-accelerated). As shown in Fig. 1, $D^2IC$ is organized as an object-oriented API. Each subsystem is defined by an abstract base class (interface) and implemented by one or more concrete classes. At the top level, DICBase defines the user-facing workflow (prepare, run). It is implemented by the mesh-based pipeline DICMeshBased (dicMesh_based.py). This class owns the ROI mesh/assets, compiles the selected solver, and solves the DIC problem for each deformed image. The optimization strategy is injected through SolverBase
<caption>**Table 2**</caption>

CPU vs GPU benchmark indicators extracted from $D^2IC$ /scripte/benchmark_butterfly_cpu_vs_gpu_autonomous.py (11 frames; WSL2; GPU: NVIDIA RTX 2000 Ada Generation Laptop GPU). On this configuration, GPU is faster per frame but overall slower due to compilation/warmup overhead; longer sequences and/or larger meshes can amortize this overhead.

<table><thead><tr><td>Backend</td><td>Warmup/Prep (s)</td><td>DIC / frame (s)</td><td>Total (s)</td></tr></thead><tbody><tr><td>CPU</td><td>3.72</td><td>0.53</td><td>11.25</td></tr><tr><td>GPU</td><td>5.54</td><td>0.17</td><td>10.03</td></tr></tbody></table>

(compile, solve), with implementations such as GlobalCGSolver, LocalGaussNewtonSolver, and TranslationZNCCSolver. For sequential datasets, BatchBase is specialized by BatchMeshBased to automate per-frame execution. DisplacementPropagatorBase (e.g., PreviousDisplacementPropagator, ConstantVelocityPropagator) provides lightweight prediction of the next initial guess. This separation keeps the high-level API stable while enabling CPU/GPU acceleration through JAX JIT compilation of the solver kernels. It also connects naturally to the data/asset layer that prepares reusable mesh- and pixel-level caches.

**Data, mesh, and pixel asset layer.** To support the high-level objects described above, the ROI is represented by a quadrilateral mesh (Mesh in mesh_assets.py). This mesh defines the FE discretization of the displacement field. Convenience utilities convert a binary mask into a mesh and its precomputed assets (mask2mesh.py, including a Gmsh-based route). For efficiency, $D^2IC$ precomputes geometry/pixel caches packaged as MeshAssets and PixelAssets. These caches include pixel sampling in a mesh bounding box, pixel→element assignment, shape-function weights, and dense gather tables (node→pixel adjacency, neighbor graphs). This preparation is implemented in pixel_assets.py and reused by all image-based solvers.

**Low-level differentiable core (JAX).** Below this API, the DIC objective is implemented as pure JAX computations. Pixel sampling/warping, residual evaluation, and mesh-based regularization operators consume precomputed PixelAssets/MeshAssets. They return a scalar energy together with differentiable intermediates. The solvers assemble optimization steps using these functions and obtain exact derivatives with automatic differentiation (typically jax.value_andGrad; JVP/VJP when directional products are required). Because the full pipeline is expressed in JAX, the same code executes on CPU or GPU backends and remains end-to-end differentiable. This enables gradient-based extensions (e.g., inverse identification, coupled regularization, or uncertainty propagation) without manually derived Jacobians.

**CPU vs GPU benchmark.** To provide a simple runtime comparison between backends, we run an autonomous script on the PlateHole tutorial sequence. We report the resulting indicators in Table 2. On this benchmark, the GPU backend is faster per frame. However, the CPU backend is more efficient end-to-end because the GPU run is dominated by JAX compilation/warmup overhead. In practice, GPU execution can reduce the steady-state cost of the DIC solve, yet still be slower overall for small workloads where compilation dominates. One practical advantage of JAX is that switching between CPU and GPU is transparent at the user level (same code path and API). In $D^2IC$, its main contribution is access to automatic differentiation and composable transformations (jit, grad/value_andGrad, JVP/VJP) rather than raw GPU speedups on every problem. GPU acceleration can nevertheless become beneficial for larger workloads (larger ROIs/meshes, more expensive warps/interpolations, and/or longer sequences), where the compilation cost is amortized and compute becomes dominant.

## 3. Illustrative examples

This section provides an overview of the capabilities of $D^2IC$ through a series of illustrative examples.

### 3.1. Validation on synthetic data

We validate $D^2IC$ on the 2D DIC Challenge dataset [37]. We use the Sample3 sequence, which prescribes a rigid-body translation increment of 0.1 px per frame in both x and y. This provides an analytical ground truth for the mean displacement. $D^2IC$ is run sequentially over the image series, using the previous solution as initialization for the next frame. We report the spatial mean displacement over the ROI together with a $\pm 1\sigma$ uncertainty estimated from the spatial standard deviation of the nodal displacement field. Fig. 2 compares the measured mean displacement to the expected linear trend; the results closely follow the ground truth over the whole sequence, with uncertainties remaining at the subpixel level.

### 3.2. Plate-with-hole: heterogeneous strain field

We illustrate $D^2IC$ on a standard non-homogeneous strain case from the 2D DIC Challenge [37]. The “PlateHole” images (here, the ohtcfrp sequence) exhibit strong strain gradients and a clear strain concentration around the central hole. This dataset is representative of practical photomechanics benchmarks beyond rigid-body motions. After estimating the displacement field with the global FE-DIC solver, strains are computed from the nodal kinematics to visualize the heterogeneous deformation pattern. Fig. 3 reports the in-plane strain components and highlights the localized amplification in the vicinity of the hole.

### 3.3. Differentiable uncertainty propagation

Beyond point estimates, $D^2IC$ can propagate image-level uncertainty to kinematic and strain quantities thanks to end-to-end automatic differentiation in JAX [35]. Following the workflow illustrated in our uncertainty-propagation notebook, we consider the converged DIC solution on the plate-with-hole example [37]. We model the measured deformed image as a noisy observation. Under a small-noise assumption, the mapping from image intensities to nodal displacements (and

<figure><img src="image_5.png" /><figcaption>**Fig. 2.** Sample3 rigid-body translation validation from the 2D DIC Challenge [37]: measured mean displacement components ($U_x, U_y$) over the ROI versus the expected 0.1 px/frame trend. Shaded bands indicate $\pm 1\sigma$ uncertainty estimated from the spatial standard deviation of the nodal displacement field. This figure can be reproduced using the script $D^2IC/doc/00_Validation_ImageSerie.py$ distributed with the GitHub repository / Zenodo capsule (see Metadata).</figcaption></figure>
<figure><img src="image_6.png" /><figcaption>Fig. 3. Plate-with-hole example from the 2D DIC Challenge [37]: heterogeneous in-plane strain components computed from the $D^2IC$ displacement field on the ohtcfrp plate-hole images. This figure can be reproduced with the notebook $D^2IC/doc/11_Advanced_Use_Uncertainty_Propagation.ipynb$ distributed with the GitHub repository / Zenodo capsule (see Metadata).</figcaption></figure>

<figure><img src="image_7.png" /><figcaption>Fig. 4. Uncertainty propagation example (plate-with-hole ROI): spatial distribution of strain standard deviation components estimated by propagating pixel-intensity noise through the $D^2IC$ pipeline using JAX automatic differentiation (JVP-based linearization). This figure can be reproduced with the notebook $D^2IC/doc/11_Advanced_Use_Uncertainty_Propagation.ipynb$ distributed with the GitHub repository / Zenodo capsule (see Metadata).</figcaption></figure>

derived strains) can be locally linearized around the solution. In particular, for the strain (or any derived quantity) viewed as a function of the deformed image $I_2$, a first-order approximation reads

$$ \delta\epsilon \approx \frac{\partial\epsilon}{\partial I_2} \delta I_2. \qquad (7) $$

In practice, we treat the whole DIC pipeline (solve + post-processing) as an end-to-end differentiable mapping that takes the deformed image $I_2$ as input and returns the nodal strain field $\epsilon$, i.e., $\epsilon = f(I_2)$. The linearized sensitivity is governed by the Jacobian

$$ J_{\epsilon,I_2} = \frac{\partial \epsilon}{\partial I_2} = \left[ \frac{\partial \epsilon_i}{\partial I_{2,j}} \right]_{1 \le i \le N_{\epsilon}, 1 \le j \le N_p}, \qquad (8) $$

whose explicit assembly is intractable for realistic ROIs. Instead, we only need its action on a perturbation $\delta I_2$, i.e., $\delta\epsilon \approx J_{\epsilon,I_2} \delta I_2$. This action can be computed in JAX through a single Jacobian-Vector Product (JVP), leveraging automatic differentiation to reuse the forward DIC functional with minimal additional implementation effort and without explicitly

assembling the Jacobian:

$$ (\epsilon, \delta\epsilon) = \text{jax.jvp}(f, (I_2, ), (\delta I_2, )) \qquad (9) $$

By sampling independent pixel-noise realizations $\delta I_2$ (with prescribed intensity standard deviation) and pushing them through the JVP, we obtain per-node empirical standard deviations $\sigma_{E_{xx}}$, $\sigma_{E_{yy}}$ and $\sigma_{E_{xy}}$.

Fig. 4 shows the resulting strain standard deviation maps on the plate-with-hole ROI. Uncertainty increases in regions with weaker image information (e.g., near boundaries, low-texture areas, or around the hole where warping/interpolation effects are more pronounced). This provides a quantitative confidence indicator alongside the strain fields.

## 4. Impact

Most practical DIC implementations still inherit the classical Jacobian-based viewpoint [2,30]. They often rely on hand-derived sensitivities, finite differences, or bespoke adjoints for advanced identification and regularization settings [5,6]. By reframing FE-DIC as a differentiable program in JAX, $D^2IC$ exposes exact gradients as a first-class output. This reduces implementation burden and enables rapid exploration of new parameterizations and coupled objectives. In this
setting, the DIC core can be reused as a differentiable “layer” (a JAX function with well-defined inputs/outputs and gradients) inside larger models. In addition, the same differentiability supports uncertainty propagation and observability analyses that intrinsically depend on sensitivities [38]. It also makes it straightforward to integrate DIC within existing JAX/ML pipelines in Python [7,8]. Beyond its immediate use as a solver, $D^2IC$ can serve as an experimental backbone for developing and benchmarking new methods (e.g., alternative parameterizations, regularizers, coupled objectives, or hybrid learning-based formulations) while retaining a consistent, end-to-end differentiable implementation.

## 5. Conclusion

This paper introduces $D^2IC$, an open-source, differentiable implementation of global finite-element Digital Image Correlation in Python. Its JAX-based core enables automatic differentiation and JIT compilation. By expressing the FE-DIC objective as a differentiable program, $D^2IC$ exposes exact gradients as a first-class output. This facilitates modular extensions toward identification, regularization design, and hybrid learning/optimization workflows.

We demonstrated the approach on standard benchmark datasets from the DIC Challenge. We used a rigid-body translation sequence (Sample3) to validate mean displacement tracking, and a plate-with-hole case to illustrate heterogeneous strain fields. Finally, we showed how differentiability enables uncertainty propagation from image noise to strain quantities through JVP-based linearization. This produces spatial confidence maps alongside strain estimates.

Future work will focus on broader benchmark coverage (e.g., large rotations and out-of-plane effects), improved robustness to illumination changes, richer regularization and multi-physics couplings, and scalable uncertainty quantification relying on implicit Jacobian operators and iterative solvers.

## Declaration of competing interest

The authors declare the following financial interests/personal relationships which may be considered potential competing interests:

Emile Roux reports that financial support was provided by University of Savoie Mont Blanc. Emile Roux reports a relationship with University of Savoie Mont Blanc that includes employment. If there are other authors, they declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

## Data availability

Data will be made available on request.

## References

[1] Pierron F, Grédiac M. Towards material testing 2.0. A review of test design for identification of constitutive parameters from full-field measurements. Strain 2021;57(1):e12370. https://doi.org/10.1111/str.12370. https://onlinelibrary.wiley.com.

[2] Hild F, Roux S. Digital image correlation: from displacement measurement to identification of elastic properties. Strain 2006;42(2):69–80, Foundational paper linking DIC with inverse identification. Emphasizes optimization, sensitivity, and gradient-based methods. Gradients are typically derived analytically or approximated, motivating AD-based approaches.

[3] Leclerc H, Périé J-N, Roux S, Hild F. Integrated digital image correlation for the identification of mechanical properties. Int J Numer Methods Eng 2011;85:152–80, Representative FEMU/IDIC work. Discusses computation of sensitivities, often via finite differences or analytical expressions. Serves as a baseline to argue for automatic differentiation in modern DIC frameworks.

[4] Passieux J-C. Identification de lois de comportement par corrélation d'images numériques intégrée, [Ph.D. thesis], ENS Cachan, PhD thesis underlying the Pixel software. Relies on hand-derived sensitivities and FE-based IDIC. Illustrates the complexity of maintaining derivative-consistent codes, which AD-based DIC aims to simplify. 2010.

[5] Roux S, Hild F, Viot P, Bernard D. Inverse identification from full-field measurements. Int J Solids Struct 2008;45:160–73, Introduces integrated DIC (IDIC). Sensitivities of the cost function are required and often computed using finite differences or manual derivations. Demonstrates the computational burden AD can alleviate.

[6] Claire D, Hild F, Roux S. Finite element-based digital image correlation with mechanical regularization. Exp Mech 2012;52:815–26, Uses mechanically regularized DIC and discusses gradient computation. Highlights the trade-off between finite differences and adjoint-based sensitivity analysis. Relevant to contrast adjoint methods with AD-based approaches.

[7] Liu J, Chen Z, Sun W. Differentiable programming for physics-based inverse problems, Computer Methods in Applied Mechanics and EngineeringNot DIC-specific but establishes the paradigm of differentiable solvers using AD. Useful to position D2IC as an application of differentiable programming to experimental mechanics. 2021.

[8] Bradbury J, et al. Jax: composable transformations of Python + NumPy programs. Technical reference for automatic differentiation and JIT compilation. Serves as a backend enabling fully differentiable DIC implementations such as D2IC. [arXiv preprint] arXiv:1912.10914. 2020.

[9] Hild F, Roux S. CORRELI Q4: a software for “finite-element” displacement field measurements by digital image correlation, Tech. Rep. Internal Report No. 269, LMT-Cachan, ENS de Cachan / CNRS-UMR 8535; 2008. https://www.yumpu.com/en/document/view/28956643/correli-lmt-cachan-ens-cachan.

[10] Passieux J-C. Pyxel v1.0. 2021. https://doi.org/10.5281/zenodo.4654018. https://zenodo.org/records/4654018.

[11] Couty V, Witz J-F, Lecomte-Grosbras P, Berthe J, Deletombe E, Brieu M. Gpucorrel: a GPU accelerated digital image correlation software written in Python. SoftwareX 2021;16:100815. https://doi.org/10.1016/j.softx.2021.100815

[12] Blaysat B, Sur F, Jailin T, Vinel A, Grédiac M. OpenLSA: an open-source toolbox for computing full-field displacements from images of periodic patterns. SoftwareX 2024;27:101826. https://doi.org/10.1016/j.softx.2024.101826. https://github.com/BenoitBlaysat/OpenLSA.

[13] Blaber J, Adair B, Antoniou A. Ncorr: open-source 2d digital image correlation mat-lab software. Exp Mech 2015;55(6):1105–22. https://doi.org/10.1007/s11340-015-0009-1

[14] Seghir R, Witz J-F, Coudert S. YaDICs; 2012. https://yadics.univ-lille1.fr/wordpress/index.html.

[15] Turner DZ. Digital image correlation engine (dice) reference manual, Tech. Rep. SAND2015-10606, Sandia National Laboratories; 2015. https://github.com/dicengine/dice.

[16] Matchid. MatchID; 2024. https://www.matchid.eu.

[17] Correlated Solutions. VIC-3D; 2024. https://www.correlatedsolutions.com/vic-3d.

[18] Yang R, Li Y, Zeng D, Guo P. Deep DIC: deep learning-based digital image correlation for end-to-end displacement and strain measurement. J Mater Process Technol 2022;302:117474. https://doi.org/10.1016/j.jmatprotec.2021.117474

[19] Cheng X, Zhou S, Xing T, Zhu Y, Ma S. Solving digital image correlation with neural networks constrained by strain-displacement relations. Opt Express 2023;31(3):3865–80. https://doi.org/10.1364/OE.475232

[20] Zhu C, Lan S, Ren T, Zhang Q. Nonlinear optimization DIC method inspired by unsupervised learning for high order displacement measurement. Opt Lasers Eng 2024. https://doi.org/10.1016/j.optlaseng.2024.108250

[21] Pan B, Liu Y. User-independent, accurate and pixel-wise DIC measurements with a task-optimized neural network. Exp Mech 2024;64(8):1199–213. https://doi.org/10.1007/s11340-024-01088-4

[22] Zhou Y, Zuo Q, Chen N, Jiang Z. Transformer based deep learning for digital image correlation. Opt Lasers Eng 2025;184:108568. https://doi.org/10.1016/j.optlaseng.2024.108568

[23] Boukhtache S, Abdelouahab K, Berry F, Blaysat B, Grédiac M, Sur F. When deep learning meets digital image correlation. Opt Lasers Eng 2021;136:106308. https://doi.org/10.1016/j.optlaseng.2020.106308

[24] Hild F, Roux S. Digital image correlation: from displacement measurement to identification of constitutive laws. C R Mech 2006;334(8):507–14. https://doi.org/10.1016/j.cme.2006.02.012

[25] Leclerc H, Périé J-N, Roux S, Hild F. Integrated digital image correlation for the identification of mechanical properties. In: Computer vision/computer graphics collaboration techniques, vol.5496 of lecture notes in computer science. Springer; 2009. pp. 161–71. https://doi.org/10.1007/978-3-642-01811-4_15. https://link.springer.com/chapter/10.1007/978-3-642-01811-4_15

[26] Réthoré J, Roux S, Hild F. An extended and integrated digital image correlation technique applied to the analysis of fractured samples. The equilibrium gap method as a mechanical filter. Eur J Comput Mech 2009;18(3):285–306. https://doi.org/10.3166/ejcm.18.285-306. https://www.tandfonline.com/doi/abs/10.3166/ejcm.18.285-306.

[27] Passieux J-C, Bouclier R. Classic and inverse compositional gauss–newton in global DIC. Int J Numer Methods Eng 2019;119(6):453–68. https://doi.org/10.1002/nme.6057. https://onlinelibrary.wiley.com/doi/abs/10.1002/nme.6057.

[28] Réthoré J, Roux S, Hild F. From pictures to extended finite elements: extended digital image correlation (x-DIC). C R Mech 2007. https://doi.org/10.1016/j.cme.2007.02.003. https://comptes-rendus.academie-sciences.fr/mecanique/articles/10.1016/j.cme.2007.02.003/.

[29] Pan B, Qian K, Xie H, Asundi A. Two-dimensional digital image correlation for in-plane displacement and strain measurement: a review. Meas Sci Technol 2009;20(6):062001. https://doi.org/10.1088/0957-0233/20/6/062001

[30] Sutton MA, Orteu J-J, Schreier H. Image correlation for shape, motion and deformation measurements: basic concepts, theory and applications. Springer; 2009. https://doi.org/10.1007/978-0-387-78747-3

[31] Tikhonov AN, Arsenin VY. Solutions of Ill-Posed problems. Winston & Sons; 1977.

[32] Polak E, Ribière G. Note sur LA convergence de méthodes de directions conjuguées. Rev Fr Inform Rech Opér 1969;3(16):35–43.

[33] Nocedal J, Wright SJ. Numerical optimization. 2nd ed. Springer; 2006. https://doi.org/10.1007/978-0-387-40065-5
[34] Armijo L. Minimization of functions having Lipschitz continuous first partial derivatives. Pac J Math 1966;16(1):1-3. https://doi.org/10.2140/pjm.1966.16.1

[35] Bradbury J, Frostig R, Hawkins P, Johnson MJ, Leary C, Maclaurin D, Necula G, Paszke A, VanderPlas J, Wanderman-Milne S, Zhang Q. JAX: composable transformations of Python+NumPy programs; 2018. http://github.com/jax-ml/jax.

[36] Roux E. Im-Jax: differentiable bicubic image interpolation for JAX. https://pypi.org/project/im-jax/.

[37] Reu PL, Toussaint E, Jones E, Bruck HA, Iadicola M, Balcaen R, Turner DZ, Siebert T, Lava P, Simonsen MDIC. DIC challenge: developing images and guidelines for evaluating accuracy and resolution of 2d analyses. Exp Mech 2018;58(7):1067-99.

[38] Reu PL. A study of the influence of noise on the digital image correlation displacement uncertainty. Exp Mech 2015;55:1085-100, Discusses uncertainty propagation in DIC, implicitly relying on Jacobians. Highlights the relevance of exact derivatives for uncertainty quantification, which AD naturally provides.