Single Point Motion

Let origin $O$ be located at the top, left of the image. We attach reference frame $\mathcal{F}$ to the origin, with the $x$-axis running left-to-right and the $y$-axis running top-to-bottom — the same pixel reference frame used throughout this guide (see Subimage Generation).

Consider a single point $P$, fixed to a physical location on the object being imaged. In the reference image $i_0$, this point is at a known pixel location ${\mathbf{r}}_{OP/\mathcal{F}}=(100,75)$ pixels — we use the shorthand ${\mathbf{p}}_0$ for this reference configuration. Between the reference image and a later current image $i_1$, the object (and therefore $P$) may move. Finding $P$'s new location ${\mathbf{p}}_1$ — its current configuration — in $i_1$, given only ${\mathbf{p}}_0$, is the problem this page works through, using dictk.translation.locate.

Reference Configuration

The examples below reuse astronaut0, the speckle pattern combined with the astronaut photo introduced in Image Generation and used again in Subimage Generation — here called reference_image, matching locate's own parameter name:

import dictk
from dictk.image import combine, PixelCoordinate, point_plot, ArrowAnnotation

speckle = dictk.rosta(width=300, height=300, density=0.5)
photo = dictk.astronaut(width=300, height=300)
reference_image = combine(a=speckle, b=photo)

p0 = PixelCoordinate(x=100, y=75)
point_plot(
    image=reference_image,
    arrows=[
        ArrowAnnotation(
            tail=PixelCoordinate(x=0, y=0), head=p0, color="gold", label="p0"
        )
    ],
    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 — one of the simplest deformation categories (see Image Transformation for the full set). Because the whole image moves together, point $P$'s new location follows directly:

from dictk.image import translate

current_image = translate(arr=reference_image, dx=-6, dy=8)
p1 = PixelCoordinate(x=p0.x - 6, y=p0.y + 8)  # 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=p1, color="cyan", label="p1"
        ),
        ArrowAnnotation(tail=p0, head=p1, color="magenta", label="displacement"),
    ],
    path="single_point_motion_p1_displacement.png",
)

Saved: single_point_motion_p1_displacement.png

Of course, p1 above was only known in advance because we generated current_image ourselves with a known translate. In practice — a real pair of DIC images — ${\mathbf{p}}_1$ is exactly what's unknown and needs to be found. The rest of this page finds it using only reference_image, current_image, and ${\mathbf{p}}_0$, the same information available in the real case, to demonstrate that locate recovers it correctly.

Cross-Correlation

We use cross-correlation to find where point $P$ moved to. Let the kernel — also called a subset, filter, or convolution matrix — be a rectangular region of reference_image centered on ${\mathbf{p}}_0$. The kernel is a small, distinctive patch of image content that we want to locate within a subsequent image.

In the needle in a haystack idiom, the kernel is the needle, and the haystack is current_image. To keep the search tractable, we don't search the entire haystack — we constrain it to a search area (also called a search window, scanning zone, or area of interest (AOI)), a larger rectangular region of current_image centered on a search_center — a guess of roughly where $P$ ended up, not the answer itself. Here, with no better guess available, we reuse ${\mathbf{p}}_0$ itself as search_center.

Kernel

From reference_image, extract the kernel surrounding ${\mathbf{p}}_0$, with a 25-pixel margin on every side (50x50 total):

from dictk.image import subimage_comparison_plot

kernel_margin = 25
kernel_origin = PixelCoordinate(x=p0.x - kernel_margin, y=p0.y - kernel_margin)
subimage_comparison_plot(
    image=reference_image,
    origin=kernel_origin,
    width=2 * kernel_margin,
    height=2 * kernel_margin,
    path="single_point_motion_kernel.png",
)

Saved: single_point_motion_kernel.png

The kernel has its own local coordinate system $\mathcal{K}$, with origin $K$ at its top-left corner. Point $P$'s position is the same in both frames, just expressed relative to a different origin:

$${\mathbf{r}}_{OP/\mathcal{F}}={\mathbf{r}}_{OK/\mathcal{F}}+{\mathbf{r}}_{KP/\mathcal{K}}$$

Since the kernel is centered on ${\mathbf{p}}_0$ with a 25-pixel margin, ${\mathbf{r}}_{KP/\mathcal{K}}=(25,25)$ pixels — point $P$ always sits at (kernel_margin_width, kernel_margin_height) within the kernel's own frame, regardless of where the kernel came from in reference_image.

Search Area

From current_image, extract the search area surrounding search_center (here, ${\mathbf{p}}_0$ again), with a 50-pixel margin on every side (100x100 total):

search_margin = 50
search_center = p0
search_origin = PixelCoordinate(
    x=search_center.x - search_margin, y=search_center.y - search_margin
)
subimage_comparison_plot(
    image=current_image,
    origin=search_origin,
    width=2 * search_margin,
    height=2 * search_margin,
    path="single_point_motion_search.png",
)

Saved: single_point_motion_search.png

The search area likewise has its own local frame $\mathcal{S}$, origin $S$ at its top-left corner:

$${\mathbf{r}}_{O{P}^{\prime }/\mathcal{F}}={\mathbf{r}}_{OS/\mathcal{F}}+{\mathbf{r}}_{S{P}^{\prime }/\mathcal{S}}$$

where $P^{\prime }$ is point $P$'s current position — what we're trying to find. ${\mathbf{r}}_{S{P}^{\prime }/\mathcal{S}}$, its position within the search area's local frame, is still unknown at this point.

Solution

Cross-correlation fixes the search area and finds where the kernel's content best aligns within it — the kernel's own origin $K$, located relative to the search area's origin $S$: ${\mathbf{r}}_{SK/\mathcal{S}}$. Once $K$ is located, $P$'s position within the search area follows from the same kernel-local offset found above:

$${\mathbf{r}}_{S{P}^{\prime }/\mathcal{S}}={\mathbf{r}}_{SK/\mathcal{S}}+{\mathbf{r}}_{KP/\mathcal{K}}$$

Substituting into the search area's equation gives the full chain from the shared origin $O$ to $P^{\prime }$:

$$\boxed{{\mathbf{r}}_{O{P}^{\prime }/\mathcal{F}}={\mathbf{r}}_{OS/\mathcal{F}}+{\mathbf{r}}_{SK/\mathcal{S}}+{\mathbf{r}}_{KP/\mathcal{K}}}$$

This is exactly what dictk.translation.locate computes internally — via skimage.registration.phase_cross_correlation for ${\mathbf{r}}_{SK/\mathcal{S}}$ — so as a caller, you don't assemble this chain by hand; locate returns ${\mathbf{p}}_1$ directly.

Locating the Point

from dictk.translation import locate

found = locate(
    reference_image=reference_image,
    current_image=current_image,
    reference_point=p0,
    search_center=search_center,
    kernel_margin_width=kernel_margin,
    kernel_margin_height=kernel_margin,
    search_margin_width=search_margin,
    search_margin_height=search_margin,
)
print(f"found = {found}")
print(f"displacement = ({found.x - p0.x}, {found.y - p0.y})")

found = PixelCoordinate(x=94, y=83)
displacement = (-6, 8)

found matches the ground-truth ${\mathbf{p}}_1=(94,83)$ pixels from earlier, recovering the known displacement $\delta \mathbf{p}=(-6,8)$ pixels using only the two images and ${\mathbf{p}}_0$ — exactly the information available for a real (not synthetically generated) image pair.

Visualizing the Solution

For illustration, we can back out ${\mathbf{r}}_{SK/\mathcal{S}}$ — the one quantity locate finds via cross-correlation, everything else here being known geometry — from found and the boxed equation above, and draw the full chain ${\mathbf{r}}_{OS/\mathcal{F}}+{\mathbf{r}}_{SK/\mathcal{S}}+{\mathbf{r}}_{KP/\mathcal{K}}$ on current_image:

r_sk = PixelCoordinate(
    x=found.x - search_origin.x - kernel_margin,
    y=found.y - search_origin.y - kernel_margin,
)
point_plot(
    image=current_image,
    arrows=[
        ArrowAnnotation(
            tail=PixelCoordinate(x=0, y=0),
            head=search_origin,
            color="blue",
            label="r_OS: search area origin",
        ),
        ArrowAnnotation(
            tail=search_origin,
            head=PixelCoordinate(x=search_origin.x + r_sk.x, y=search_origin.y + r_sk.y),
            color="orange",
            label="r_SK: kernel found in search area",
        ),
        ArrowAnnotation(
            tail=PixelCoordinate(x=search_origin.x + r_sk.x, y=search_origin.y + r_sk.y),
            head=found,
            color="black",
            label="r_KP: point within kernel",
        ),
    ],
    path="single_point_motion_solution_vectors.png",
)

Saved: single_point_motion_solution_vectors.png