using System;

using System.Drawing;

using System.Drawing.Imaging;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        Bitmap bitmapToTest = new Bitmap(800,600);

        using(Graphics g = Graphics.FromImage(bitmapToTest))

        {

            g.FillRectangle(Brushes.White, 0,0,800,600);

            g.FillRectangle(Brushes.Black, 100, 100, 100, 100);

            g.Flush();

        }

        BoundingBoxCalculator boundingBoxCalc = new BoundingBoxCalculator(bitmapToTest, new Point(100,100));

        Rectangle rectangleOfObject = boundingBoxCalc.CalculateBoundingBox();

        Console.WriteLine(rectangleOfObject.X);

        Console.WriteLine(rectangleOfObject.Y);

        Console.WriteLine(rectangleOfObject.Width);

        Console.WriteLine(rectangleOfObject.Height);

    }

}

​

internal 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);

    }

}