Single Point Motion

Consider a single point $P$, fixed to a physical location on the object being imaged. In the reference image $i_0$, this point $P$ is located at a known pixel location, for example ${\mathbf{r}}_{OP/\mathcal{F}}=(100,75)$ pixels. This vector, from the origin $O$ of the reference image frame $\mathcal{F}$ to the pixel point $P$, locates the reference configuration. For brevity, we will use ${\mathbf{p}}_0$ to denote the fully explicit vector ${\mathbf{r}}_{OP/\mathcal{F}}$.

Next, the object is moved (e.g., translated, rotated, stretched, or deformed — see Image Transformation). A second image $i_1$, called the current image, is taken. Where is point $P$ from $i_0$ located in $i_1$? We label point $P$'s found location in $i_1$ as $P^{\prime }$. For brevity, we will use ${\mathbf{p}}_1$ to denote the fully explicit vector ${\mathbf{r}}_{O{P}^{\prime }/\mathcal{F}}$.

Note that the camera itself has not moved, only the object and any point of interest on the object have moved. The origin $O$ and the reference frame $\mathcal{F}$ are the same across the two images $i_0$ and $i_1$.

The canonical problem solved by digital image correlation (DIC) is as follows:

• Given a point $P$ in image $i_0$, find the location of that same point $P^{\prime }$ in image $i_1$.

Below, we motivate this canonical problem with a simple example of a single point translation. We first develop a manual solution to serve as the known ground truth. Then, we illustrate how dictk.translation.locate solves this problem numerically via DIC.

Reference Configuration

The examples below reuse checkerboard0, the speckle pattern combined with the checkerboard introduced in Image Generation. This will be the reference_image, matching locate's own parameter name:

from dictk.image import read, PixelCoordinate
from dictk.plot import point_plot, ArrowAnnotation

reference_image = read(path="checkerboard0.png")

p0 = PixelCoordinate(x=100, y=75)
point_plot(
    image=reference_image,
    arrows=[
        ArrowAnnotation(
            tail=PixelCoordinate(x=0, y=0), head=p0, color="orange", label=r"$\boldsymbol{p}_0$"
        )
    ],
    figsize=(6.4, 4.8),
    path="single_point_motion_p0.png",
)

Saved: single_point_motion_p0.png

Current Configuration and Displacement

For this page, the current image $i_1$ is generated with dictk.image.translate (see Image Transformation): every pixel of reference_image shifts by the same (dx, dy), a rigid-body translation. Because the whole image moves together, point $P$'s new location follows directly:

from dictk.image import translate

dx, dy = -6, 8
current_image = translate(arr=reference_image, dx=dx, dy=dy)
p1 = PixelCoordinate(x=p0.x + dx, y=p0.y + dy)  # ground truth, known here by construction

We define the displacement of the point $\delta \mathbf{p}$ as the relative motion between the reference configuration ${\mathbf{p}}_0$ and the current configuration ${\mathbf{p}}_1$, such that

$${\mathbf{p}}_0+\delta \mathbf{p}:={\mathbf{p}}_1⟹\delta \mathbf{p}={\mathbf{p}}_1-{\mathbf{p}}_0$$

so with ${\mathbf{p}}_1=(94,83)$ and ${\mathbf{p}}_0=(100,75)$,

$$\delta \mathbf{p}=(94,83)-(100,75)=(-6,8)\text{pixels}$$

point_plot(
    image=current_image,
    arrows=[
        ArrowAnnotation(
            tail=PixelCoordinate(x=0, y=0), head=p0, color="orange", label=r"$\boldsymbol{p}_0$"
        ),
        ArrowAnnotation(
            tail=PixelCoordinate(x=0, y=0), head=p1, color="cyan", label=r"$\boldsymbol{p}_1$"
        ),
        ArrowAnnotation(
            tail=p0, head=p1, color="magenta", label=r"$\delta \boldsymbol{p}$"
        ),
    ],
    figsize=(6.4, 4.8),
    path="single_point_motion_p1_displacement.png",
)

Saved: single_point_motion_p1_displacement.png

In the example above, p1 was only known in advance because we generated current_image ourselves with a known translate. In practice, the location $\mathbf{p}$ is unknown and found via DIC of a pair of images.

Below, we illustrate the canonical DIC process:

• Given a ${\mathbf{p}}_0$ in the reference_image, find ${\mathbf{p}}_1$ in the current_image.

The next page, Cross Correlation (CC), shows how the locate function calculates ${\mathbf{p}}_1$ directly, using the technique its name describes.