How to segmentation object c#

Question

I used this code for segmentation, I'm trying to detect pixels one by one because my object is a binary, not a grayscale. when i run the program, it draws 2 object. The first object is successfully drawn (object still has a black color and a red rectangle), but the second object fails get drawn. Screenshot is here. Please help me, why does this happen?

#region Edge Detection

private void btnSegmentasi_Click(object sender, EventArgs e)
{
    Segments = new List<ImageSegment>();
    Bitmap bmp = (Bitmap)pb2.Image;
    imageArea = new Rectangle(0, 0, pb2.Image.Width - 1, pb2.Image.Height - 1);
    for (int y = 0; y < pb2.Image.Height; y++)
    {
        for (int x = 0; x < pb2.Image.Width; x++)
        {
            bool skip = false;
            foreach (ImageSegment segment in Segments)
            {
                if (pointIsInRect(x, y, segment.Rect))
                {
                    skip = true;
                    break;
                }
            }
            if (skip) continue;
            Color warna = bmp.GetPixel(x, y);
            if (warna.G == 0)
                startEdgeDetection(x, y, ref bmp);
        }
    } 
    DGVProses.DataSource = Segments;

    if (Segments.Count > 0)
    {
        Graphics g = pb2.CreateGraphics();
        Rectangle[] rects = (from theSegment in Segments select theSegment.Rect).ToArray();
        g.DrawRectangles(new Pen(Brushes.Red), rects);
        g.Dispose();
    }
}

private void startEdgeDetection(int x, int y, ref Bitmap bmp)
{
    Point startPoint = new Point(x, y);
    Point currPoint = new Point(x, y);

    int sudut = 180;
    int xMin = x, yMin = y, xMax = x, yMax = y;
    do
    {
        sudut -= 45;
        Point offset = angleToPoint(ref sudut);
        Point trialPoint = new Point(currPoint.X + offset.X, currPoint.Y + offset.Y);
        if (!pointIsInRect(trialPoint.X, trialPoint.Y, imageArea))
            continue;
        Color theColor = bmp.GetPixel(trialPoint.X, trialPoint.Y);
        if (theColor.G == 0)
        {
            currPoint = trialPoint;
            sudut -= 180;
            if (currPoint.X > xMax)
                xMax = currPoint.X;
            else if (currPoint.X < xMin)
                xMin = currPoint.X;
            if (currPoint.Y > yMax)
                yMax = currPoint.Y;
            else if (currPoint.Y < yMin)
                yMin = currPoint.Y;
            if (sudut < 0)
                sudut += 360;
            if (currPoint == startPoint && sudut == 180)
                break;
        }
    }
    while (!(currPoint == startPoint && sudut == 180));
    Rectangle r = new Rectangle(xMin, yMin, xMax - xMin + 1, yMax - yMin + 1);
    Bitmap newImage = new Bitmap(r.Width + 2, r.Height + 2);
    using (Graphics g = Graphics.FromImage(newImage))
    {
        g.FillRectangle(Brushes.White, 0, 0, newImage.Width, newImage.Height);
        g.DrawImage(bmp, new Rectangle(1, 1, r.Width, r.Height), r, GraphicsUnit.Pixel);
        g.Dispose();
    }
    Segments.Add(new ImageSegment(r, newImage));
}

private Point angleToPoint(ref int sudut)
{
    if (sudut < 0)
        sudut += 360;
    switch (sudut)
    {
        case 135: return new Point(-1, -1);
        case 90: return new Point(0, -1);
        case 45: return new Point(1, -1);
        case 0: return new Point(1, 0);
        case 315: return new Point(1, 1);
        case 270: return new Point(0, 1);
        case 225: return new Point(-1, 1);
        default: return new Point(-1, 0);
    }
}

private bool pointIsInRect(int x, int y, Rectangle rect)
{
    if (x < rect.X)
        return false;
    if (x > rect.X + rect.Width)
        return false;
    if (x < rect.Y)
        return false;
    if (x > rect.Y + rect.Height)
        return false;
    return true;

}
#endregion

Pasting heaps of code with little context will not help. Please clarify: What do you want to do? Did I get it right that there is a image with the drawn 2 and 1 on it and you would like to extract the single numbers? What is your algorithm supposed to do? What is the ratio behind the algorithm? How is it supposed to work? — Paul Kertscher, Nov 13 '14 at 08:03

score 1 · Answer 1 · answered Nov 13 '14 at 08:27

Okay, I think I've now got a clue of how your algorithm is supposed to work. I'd guess you are running around in circles within the object. I do not really know why it does not happen for the first object, but this is another story.

When you enter startEdgeDetection you start at some point, check if it's black, move by an angle and repeat the whole procedure. You stop when the current point reaches the starting point. The crux is, that this algorithm does not guarantee to walk the whole object, but may just do the following (I do not know it is exactly like this, but pretty much):

OOOOOO
O####O
O####O
OOOOOO

OOOOOO
O*###O
O####O
OOOOOO

OOOOOO
O**##O
O####O
OOOOOO

OOOOOO
O**##O
O#*##O
OOOOOO

OOOOOO
O**##O
O**##O
OOOOOO

O = pixels filled with white
# = pixels filled with black
* = pixels you stepped through

You've reached your starting point again and the algorithm stops, but the bounding box does not contain the whole object, but just a part. If all of your objects bounding boxes have either a width or a height of 1 you fill up your whole object with bounding boxes, hence it appears red.

You'll have to fix the startEdgeDetection to avoid the described case and make sure that you really detect the edge.

well. thats right, i want to detect an object by edge detection like the result of the first object. but i dont know why the code doesn't work at second object. but thanks for your suggest. — Helvi Risna, Nov 13 '14 at 12:24
I just explained what happened, you should find the error by yourself — Paul Kertscher, Nov 13 '14 at 12:31

score 0 · Answer 2 · answered Nov 13 '14 at 12:36

I made up a simple class that finds the bounding box of an object. It should be easy to apply it to your problem.

public class BoundingBoxCalculator
{
    Bitmap bitmapToCalculateBoundingBoxFor;
    Point startingPoint;
    Point[] neighborOffsets = 
    {new Point(-1,-1),
    new Point(0,-1),
    new Point(1,-1),
    new Point(-1, 0),
    new Point(1, 0),
    new Point(-1,1), 
    new Point(0,1),
    new Point(1,1)};

    public BoundingBoxCalculator(Bitmap bitmapContainingObject, Point borderPoint)
    {
        this.bitmapToCalculateBoundingBoxFor = bitmapContainingObject;
        this.startingPoint = borderPoint;
    }

    public Rectangle CalculateBoundingBox()
    {
        List<Point> edgePoints = CalculateEdge();

        int minX = edgePoints.Min(p => p.X);
        int maxX = edgePoints.Max(p => p.X);
        int minY = edgePoints.Min(p => p.Y);
        int maxY = edgePoints.Max(p => p.Y);

        return new Rectangle(minX, minY, maxX - minX, maxY - minY);
    }

    List<Point> CalculateEdge()
    {
        List<Point> edgePoints = new List<Point>();
        Point currentPoint = startingPoint;


        do
        {
            IEnumerable<Point> neighboringEdgePoints = GetNeighboringEdgePoints(currentPoint);
            IEnumerable<Point> neighboringEdgePointsNotVisited = from p in neighboringEdgePoints where !edgePoints.Contains(p) select p;

            edgePoints.Add(currentPoint);

            if(neighboringEdgePointsNotVisited.Count() == 0
               && neighboringEdgePoints.Contains(startingPoint))
            {
                currentPoint = startingPoint;
            }
            else if(neighboringEdgePointsNotVisited.Count() == 1)
            {
                Point nextPoint = neighboringEdgePointsNotVisited.First();
                currentPoint = nextPoint;
            }
            else if(neighboringEdgePointsNotVisited.Count() > 1)
            {
                Point nextPoint = GetPointWithMinDistance(currentPoint, neighboringEdgePointsNotVisited);
                currentPoint = nextPoint;
            }
            else
            {
                throw new Exception();
            }


        } while(currentPoint != startingPoint);

        return edgePoints;
    }

    Point GetPointWithMinDistance(Point origin, IEnumerable<Point> pointsToTest)
    {
        double minDistance = double.MaxValue;
        Point pointWithMinDistance = new Point(0,0);

        foreach(Point pointToTest in pointsToTest)
        {
            double currentDistance = GetPointsDistance(origin, pointToTest);

            if(currentDistance < minDistance)
            {
                minDistance = currentDistance;
                pointWithMinDistance = pointToTest;
            }
        }

        return pointWithMinDistance;
    }

    double GetPointsDistance(Point p1, Point p2)
    {
        return Math.Sqrt((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y));
    }

    IEnumerable<Point> GetNeighboringEdgePoints(Point currentPoint)
    {
        IEnumerable<Point> neighboringPoints = GetNeighboringPoints(currentPoint);
        List<Point> neighboringEdgePoints = new List<Point>();

        foreach(Point pointToTest in neighboringPoints)
        {
            if(GetNeighboringPoints(pointToTest).Count() < 8)
            {
                neighboringEdgePoints.Add(pointToTest);
            }
        }

        return neighboringEdgePoints;
    }

    IEnumerable<Point> GetNeighboringPoints(Point currentPoint)
    {
        List<Point> neighbors = new List<Point>();

        for(int offsetsCount = 0; offsetsCount < neighborOffsets.Length; offsetsCount++)
        {
            Point currentPointWithOffset = AddPointOffset(currentPoint, neighborOffsets[offsetsCount]);
            if(IsInImage(currentPointWithOffset) &&
              IsInObject(currentPointWithOffset))
            {
                neighbors.Add(currentPointWithOffset);
            }
        }

        return neighbors;
    }

    bool IsInImage(Point pointToTest)
    {
        return pointToTest.X >= 0
            && pointToTest.X < bitmapToCalculateBoundingBoxFor.Width
            && pointToTest.Y >= 0
            && pointToTest.Y < bitmapToCalculateBoundingBoxFor.Height;
    }

    bool IsInObject(Point pointToTest)
    {
        Color colorInPointPosition = bitmapToCalculateBoundingBoxFor.GetPixel(pointToTest.X, pointToTest.Y);

        //assume object is color is not white
        return colorInPointPosition.R != 255
            || colorInPointPosition.G != 255
            || colorInPointPosition.B != 255;
    }

    Point AddPointOffset(Point point, Point offset)
    {
        return new Point(point.X + offset.X, point.Y + offset.Y);
    }
}

Find an example at: https://dotnetfiddle.net/49bnTV

I just tested it with a rectangle, but I guess it should work with any shape. Just give it a try.

it said An unhandled exception of type 'System.Exception' occurred in myapp.exe — Helvi Risna, Nov 13 '14 at 13:19
Did you set the starting point - which is given in the constructor - to an actual border point? — Paul Kertscher, Nov 13 '14 at 13:20
I tested the code and when I construct the class with an actual border point it does what I wanted it to do. Please check your input to the constructor. Anyway, you do not have to apologize for being a newbie in image processing - I am not very experienced either :) — Paul Kertscher, Nov 13 '14 at 13:41
i've set the starting point. but still have same error. anyway thanks for your help. — Helvi Risna, Nov 15 '14 at 06:47

How to segmentation object c#

2 Answers2