Lineal path function#

Theory#

The 2-point cluster function has a first order notion of connectedness. To quantify the true connectedness along a path, the lineal path function is used. The lineal path function quantifies the probability that an entire path of pixels connecting \(\vec{x}_i\) and \(\vec{x}_i + \Delta x\) (denoted: \(\{ \vec{x}_i + \delta\vec{x}_0, \vec{x}_i + \delta\vec{x}_1, ... , \vec{x}_i + \delta\vec{x}_n \}\), where \(\delta\vec{x}_0 \equiv \vec{0}\) and \(\delta\vec{x}_n \equiv \Delta\vec{x}\)) is in the same phase:

\[L ( \Delta x ) = P \big\{ \mathcal{I}(\vec{x}) = 1 , \mathcal{I}(\vec{x}+\delta\vec{x}_1) = 1 , \ldots \mathcal{I}(\vec{x}+\Delta\vec{x}) = 1 \big\}\]

In practice the probability is constructed by starting from each pixel \(\vec{x}_i\) for which \(\mathcal{I} ( \vec{x}_i )=1\) ‘walking’ along a pixel path until the edge of the inclusion is reached at \(\vec{x}_i + \delta x_j\). The value of \(L\) is increased for all the relative positions that have been passed along the path connecting \(\vec{0}\) and \(\delta \vec{x}_j\). This is then repeated for all possible directions (with each their own path).

Two limit values can again be identified. At zero distance, the volume fraction is again found:

\[L (\Delta \vec{x} = \vec{0}) = \varphi\]

Furthermore it is highly unlikely that a path can be found through the inclusion phase to a relative position very far away. I.e.

\[L (\Delta \vec{x} \rightarrow \infty) = 0\]

An important ingredient of the computation of \(L\) is thus the choice of the pixel paths. In GooseEYE the paths are constructed between the centre of the region of interest and each of the points on the end of the region of interest. The paths can be computed using different algorithms, illustrated below:

pixel_path.py

Example#

Note

Like for the 2-point correlation, the average can be extended to that of an ensemble of images.

L.py

import GooseEYE
import numpy as np

# generate image, extract 'volume-fraction' for plotting
img = GooseEYE.dummy_circles((500, 500))
phi = np.mean(img)

# lineal path function
L = GooseEYE.L((101, 101), img)

L.cpp

#include <GooseEYE/GooseEYE.h>
#include <highfive/H5Easy.hpp>

#define MYASSERT(expr) MYASSERT_IMPL(expr, __FILE__, __LINE__)
#define MYASSERT_IMPL(expr, file, line) \
    if (!(expr)) { \
        throw std::runtime_error( \
            std::string(file) + ':' + std::to_string(line) + \
            ": assertion failed (" #expr ") \n\t"); \
    }

int main()
{
    // generate image
    auto I = GooseEYE::dummy_circles({500, 500});

    // lineal path function
    auto L = GooseEYE::L({101, 101}, I);

    // check against previous versions
    H5Easy::File data("L.h5", H5Easy::File::ReadOnly);
    MYASSERT(xt::all(xt::equal(I, H5Easy::load<decltype(I)>(data, "I"))));
    MYASSERT(xt::allclose(L, H5Easy::load<decltype(L)>(data, "L")));

    return 0;
}