Measuring the distance between two lines using DipLib (PyDIP)

I think the most precise approach to measure the distance between the two edges of the filament is to:

1. detect the two edges using the Gaussian gradient magnitude,
2. determine the center of gravity of the two edges, which will be a point on each of the edges,
3. determine the angle of the two edges, and
4. use trigonometry to find the distance between the two edges.

This assumes that the two edges are perfectly straight and parallel, which doesn’t seem to be the case though.

Using DIPlib you could do it this way:

import diplib as dip
import numpy as np
import matplotlib.pyplot as pp

# load
img = dip.ImageRead('wDnU6.jpg') 
img = img(1)  # use green channel
img.SetPixelSize(0.042, "mm")

# find edges
edges = dip.GradientMagnitude(img)

# binarize
mask = dip.Threshold(edges)[0]
mask = dip.Dilation(mask, 9)  # we want the mask to include the "tails" of the Gaussian
mask = dip.AreaOpening(mask, filterSize=1000)  # remove small regions

# measure the two edges
mask = dip.Label(mask)
msr = dip.MeasurementTool.Measure(mask, edges, ['Gravity','GreyMajorAxes'])
# msr[n] is the measurements for object with ID n, if we have two objects, n can be 1 or 2.

# get distance between edges
center1 = np.array(msr[1]['Gravity'])
center2 = np.array(msr[2]['Gravity'])

normal1 = np.array(msr[1]['GreyMajorAxes'])[0:2]  # first axis is perpendicular to edge
normal2 = np.array(msr[2]['GreyMajorAxes'])[0:2]
normal = (normal1 + normal2) / 2  # we average the two normals, assuming the edges are parallel

distance = abs((center1 - center2) @ normal)
units = msr['Gravity'].Values()[0].units
print("Distance between lines:", distance, units)

This outputs:

Distance between lines: 21.491425398007312 mm

You can show the two edges with:

mmpp = img.PixelSize()[0].magnitude
center1 = center1 / mmpp  # position in pixels
center2 = center2 / mmpp
L = 1000
v = L * np.array([normal[1], -normal[0]])
img.Show()
pt1 = center1 - v
pt2 = center1 + v
pp.plot([pt1[0], pt2[0]], [pt1[1], pt2[1]])
pt1 = center2 - v
pt2 = center2 + v
pp.plot([pt1[0], pt2[0]], [pt1[1], pt2[1]])

---

Another approach uses the distance transform, which assigns to each object pixel the distance to the nearest background pixel. Because the filament is approximately horizontal, it is easy to use the maximum value for each image column as half the width at one point along the filament. This measurement is a bit noisy, because it computes distances between pixels, and uses a binarized image. But we can average the width for each image column to obtain a more precise measurement, though it is likely biased (the estimated value is likely smaller than the true value):

mask = dip.Threshold(img)[0]
dt = dip.EuclideanDistanceTransform(mask, border='object')
width = 2 * np.amax(dt, axis=0)
width = width[100:-100]  # close to the image edges the distance could be off
print("Distance between lines:", np.mean(width), img.PixelSize()[0].units)

This outputs:

Distance between lines: 21.393684 mm

You could also compute locally averaged widths, if you suspect that the filament is not uniform in width:

width_smooth = dip.Gauss(width, 100)

You could then plot the estimated widths to see your estimates:

pp.plot(width)
pp.plot(width_smooth)
pp.show()

---

Answers to additional questions

How do you know that the output image is contained at index [0], since there is little documentation on PyDIP […]

Indeed, there is too little documentation, we could certainly use some help in that area! Most functions are trivially translated from the C++ function, and so the C++ documentation gives suitable information. But some functions, like dip.Threshold(), deviate a bit from the C++; in this case, the output provides both the thresholded image and the selected threshold value in a tuple. Running out = dip.Threshold(edges) in Python and then examining the out variable, you can see it is a tuple with an image as first value and a float as a second value. You’d need to guess the meaning of the two values from the C++ documentation. The source code would be the best place to find out, but that’s not at all user friendly.

As I understand you are finding the principle axes of the two lines, which are just the eigenvectors. […] What I’m not quite understanding is that the line msr[1]['GreyMajorAxes'])[0:2] only returns two values, which would only define a single point. How does this define a line normal to the detected line, if it is only a single point? […]

A vector in 2D is defined by two numbers, the vector goes from the origin to the point given by those two numbers. msr[1]['GreyMajorAxes']) gives four values (in 2D), the first two are the largest eigenvector of the inertia tensor, the second two are the smallest eigenvector. The largest eigenvector corresponds to the normal in this case.

As you have set this up, if I am understanding correctly, mask[0] contains the top line and mask[1] contains the bottom line.

No, mask is a labelled image, where pixels with a value of 0 are background, pixels with a value of 1 are the first object (edge in this case), and pixels with a value of 2 are the second object. So mask==1 will give a binary image with the pixels for the first edge selected. But mask is not a thin line, it is quite wide. The idea is to cover the full width of the Gaussian profile in edge, which is the gradient magnitude of the image. The computations I do above are all based on this Gaussian profile, providing a more precise result than what you’d get from dealing with a binary image or an individual set of pixels.

Therefore, if I were to want to account for the bend in the filament, I could take those two matrices and get a best fit line for each correct?

One thing you could do is find the sub-pixel location of the maximum for each column in edge, within the mask==1 pixels (e.g. by fitting a Gaussian to the values in each column). That will give you a set of points that you can fit a curved line to. This would be a bit more involved to code, but not hard I think.