如何测量绘制在图像上的线的长度？ C＃

Question

I would like to write an application that will measure fragments of a specimen examined under a microscope. I thought that the best way would be to capture the image and draw on selected parts of the specimen then count the value of the drawn line in pixels (and later to convert this value into the appropriate unit).

Is there anything that helps solve such issue already implemented or any tool/package or something that allows such calculations?

I will also willingly learn about solutions in other programming languages if they allow to solve this problem in a easier way or just in some way.

Answer 1

This is a very basic example of measuring a segmented line drawn onto an image in winforms.

It uses a PictureBox to display the image, a Label to display the current result and for good measure I added two Buttons the clear all points and to undo/remove the last one.

I collect to pixel positions in a List<Point> :

List<Point> points = new List<Point>();

The two edit buttons are rather simple:

private void btn_Clear_Click(object sender, EventArgs e)
{
    points.Clear();
    pictureBox1.Invalidate();
    show_Length();
}

private void btn_Undo_Click(object sender, EventArgs e)
{
    if (points.Any())points.Remove(points.Last());
    pictureBox1.Invalidate();
    show_Length();
}

Note how I trigger the Paint event by invalidating the image whenever the points collection changes..

The rest of the code is also simple; I call a function to calculate and display the sum of all segment lengths. Note that I need at least two points before I can do that or display the first line..

private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
{
    points.Add(e.Location);
    pictureBox1.Invalidate();
    show_Length();
}

private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
    if (points.Count > 1) e.Graphics.DrawLines(Pens.Red, points.ToArray());
}

void show_Length()
{
    lbl_len.Text = (pointsF.Count) + " point(s), no segments. " ;

    if (!(points.Count > 1)) return;

    double len = 0;
    for (int i = 1; i < points.Count; i++)
    {
        len += Math.Sqrt((points[i-1].X - points[i].X) * (points[i-1].X - points[i].X) 
                    +  (points[i-1].Y - points[i].Y) * (points[i-1].Y - points[i].Y));
    }
    lbl_len.Text = (points.Count-1) + " segments, " + (int) len + " pixels";
}

A few notes:

• The image is displayed without any zooming. PictureBox has a SizeMode property to make zoomed display simple. In such a case I recommend to store not the direct pixel locations of the mouse but 'unzoomed' values and to use a 'rezoomed' list of values for the display. This way you can zoom in and out and still have the points stick to the right spots.

• For this you ought to use a List<PointF> to keep precision.

• When zooming eg by enlarging the PictureBox , maybe after nesting it in a Panel , make sure to either keep the aspect ratio equal to that of the Image or to do a full calculation to include the extra space left or top; in SizeMode.Normal the image will always sit flush TopLeft but in other modes it will not always do so.

• For the calculation of actual ie physical distances simply divide by the actual dpi value.

Let's see what we have in action:

Update:

To get a chance to create cloers fits and better precision we obviously need to zoom in on the image.

Here are the necessary changes:

We add a list of 'floating points':

List<PointF> pointsF = new List<PointF>();

And use it to store the un-zoomed mouse positions in the mouse down:

pointsF.Add( scaled( e.Location, false));

We replace all other occurances of points with pointsF .

The Paint event always calculates the scaled points to the current zoom level:

if (pointsF.Count > 1)
{
    points = pointsF.Select(x => Point.Round(scaled(x, true))).ToList();
    e.Graphics.DrawLines(Pens.Red, points.ToArray());
}

And the function to do the scaling looks like this:

PointF scaled(PointF p, bool scaled)
{
    float z = scaled ? 1f * zoom : 1f / zoom;
    return new PointF(p.X * z, p.Y * z);
}

It uses a class level variable float zoom = 1f; which gets set along with the picturebox's Clientsize in the Scroll event of a trackbar:

private void trackBar1_Scroll(object sender, EventArgs e)
{
    List<float> zooms = new List<float>()
    { 0.1f, 0.2f, 0.5f, 0.75f, 1f, 2, 3, 4, 6, 8, 10};
    zoom = zooms[trackBar1.Value];

    int w = (int)(pictureBox2.Image.Width * zoom);
    int h = (int)(pictureBox2.Image.Height * zoom);

    pictureBox2.ClientSize = new Size(w, h);
    lbl_zoom.Text = "zoom: " + (zoom*100).ToString("0.0");
}

The picturebox is nested inside a Panel with AutoScroll on. Now we can zoom and scroll while adding segments: