How to detect where the image content ends?

Question

I receive images of the same size but with different amounts of information. Examples below (red borders are mine). The background is always white.

I am trying to detect where the information on the image ends - at what pixel height (and crop accordingly). In other words, find the first non-white pixel from the bottom.

Is there a better way to do this other than extract BitmapData out of Image object and loop through all the pixels?

Answer 1

Just to add a suggestion having looked over your images and your solution (below) and your method is fine but you may be able to improve efficiency.

The more you know about your image the better; you're confident the background is always white (according to your post, the code is a more generic utility but the following suggestion can still work); can you be confident on the furthest point in a non-white pixel will be found if the row is not empty?

For example; in your two pictures the furthest in non-white pixel on a row is about 60px in. If this is universally true for your data then you don't need to scan the whole line of the image, which would make your for loop:

   for (int y = bitmap.Height - 1; y >= 0; y--) {
        for (int x = 0; x < 60; x++) {
            Color color = bitmap.GetPixel(x, y);
            if (color.R != backColor.R || color.G != backColor.G || color.B != backColor.B) {
                foundContentOnRow = y;
                break;
            }
        }
    }

(You could make it a parameter on the function so you can easily control it if needed).

Imagine for example that the first non-white row was 80px down. To find it currently you do 640 x 300 = 192,000 checks. If you could confidently say that you would know a row was blank within 100 pixels (an over-estimate based on the data presented) then this would be 100 * 300 = 30,000 checks per image.

If you always knew that the first 10 pixels of the image were always blank you could shave a little bit more off (say 3000 checks).

Musing on a setup where you knew that the first non-white pixel was between 10 and 60 pixels in (range of 50) you could find it at row 80 in 50 x 300 = 15,000 checks which is a good reduction.

Of course the downside about assumptions is that if things change your assumptions may not be valid, but if the data is going to remain fairly constant then it may be worthwhile, especially if you do this for a lot of images.

Answer 2

I've ended up using the following code to trim the image. Hopefully someone finds this useful.

class Program {
    static void Main(string[] args) {
        Image full = Image.FromFile("foo.png");
        Image cropped = full.TrimOnBottom();
    }
}

public static class ImageUtilities {
    public static Image TrimOnBottom(this Image image, Color? backgroundColor = null, int margin = 30) {
        var bitmap = (Bitmap)image;
        int foundContentOnRow = -1;

        // handle empty optional parameter
        var backColor = backgroundColor ?? Color.White;

        // scan the image from the bottom up, left to right
        for (int y = bitmap.Height - 1; y >= 0; y--) {
            for (int x = 0; x < bitmap.Width; x++) {
                Color color = bitmap.GetPixel(x, y);
                if (color.R != backColor.R || color.G != backColor.G || color.B != backColor.B) {
                    foundContentOnRow = y;
                    break;
                }
            }

            // exit loop if content found
            if (foundContentOnRow > -1) {
                break;
            }
        }

        if (foundContentOnRow > -1) {
            int proposedHeight = foundContentOnRow + margin;

            // only trim if proposed height smaller than existing image
            if (proposedHeight < bitmap.Height) {
                return CropImage(image, bitmap.Width, proposedHeight);
            }
        }

        return image;
    }

    private static Image CropImage(Image image, int width, int height) {
        Rectangle cropArea = new Rectangle(0, 0, width, height);
        Bitmap bitmap = new Bitmap(image);
        return bitmap.Clone(cropArea, bitmap.PixelFormat);
    }
}