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

Answer 1

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.

Answer 2

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.