Isolating figures from a background

Question

Sorry, I don't have the right terminology to ask this question, but in simple terms, I have several images like this one. The white areas are not always the same size but are mostly rectangular. The colors are always the same. It's one image and I need to isolate the figures from the white background, or explained in a different way, I need to change the black background to white...

and make it look like this.

Note some of the figures are touching the edges where white meets the black.

The tool, library, or programming language doesn't matter as long as it gets it done.

Answer 1

Here's another way that may work for your other images... clone, then dilate (enlarge) the little white windows by 7 pixels, then erode them again, invert and choose the lightest pixels:

convert image.png \( +clone -morphology dilate square:7x7 -morphology erode square:7x7 -negate \) -evaluate-sequence max  result.png

Answer 2

Here is one method that works for this image using Imagemagick. You trim the black area first, then divide the image into 3 equal sections, then trim those, then flatten onto white. The trim and crop keep track of the original offsets since I do not use +repage to remove the virtual canvas.

magick original.png -fuzz 5% -trim -crop 3x1@ -trim -background white -flatten result.png

See https://www.imagemagick.org/Usage/crop/#crop_equal https://www.imagemagick.org/Usage/crop/#trim

Answer 3

Interesting question! I assume you realise your little white windows into your symbols are not horizontally aligned? We'll come to that later. I have a fun method based on a "squeezebox", or accordion...

There are 3 parts, so I'll do a horizontal rule under each to divide them up.

---

Part 1

Squeeze your image in together from the left and right sides (like the squeezebox) till it is only a single pixel wide column but the same height as the original:

Now threshold the column so that only horizontal lines that were fully black stay black. Anywhere there was a window or any white pixels on a horizontal line it becomes white. Then invert it.

Now, stretch the column (extend that squeezebox) back to its original size using nearest neighbour sampling:

---

Part 2

Now do the same thing again, but after rotating the squeezebox through 90 degrees. Basically, we are going to squash the image till it is 1 pixel high, threshold and negate it, then stretch (extend that vertically rotated squeezebox) till it is back to the original height:

---

Part 3

Now take the original image and put in a stack with the two black and white stripey ones above and, at each pixel location, choose the lightest pixel:

The code looks like this:

#!/bin/bash

# Get width and height
read w h < <(identify -format "%w %h" image.png)
echo $w $h

magick image.png -threshold 50% \
   \( -clone 0 -resize 1x\! -threshold 1% -negate -scale ${w}x${h}\! \) \
   \( -clone 0 -resize x1\! -threshold 1% -negate -scale ${w}x${h}\! \) \
   -evaluate-sequence max result.png

---

Ok, that's not bad and it doesn't rely on there being exactly 3 windows. But, as I said at the start, the little white windows are not aligned across their tops and so you get artefacts around the windows - only in the horizontal direction because there is only one image in the vertical direction so nothing to align. Basically, I suggest to do a little morphology to make your windows all 3 pixels smaller in height top and bottom, the code then looks like this:

#!/bin/bash

# Get width and height
read w h < <(identify -format "%w %h" image.png)
echo $w $h

magick image.png -threshold 50% \
   \( -clone 0 -resize 1x\! -threshold 1% -negate -scale ${w}x${h}\! -morphology dilate rectangle:7x7 \) \
   \( -clone 0 -resize x1\! -threshold 1% -negate -scale ${w}x${h}\!                                  \) \
   -evaluate-sequence max result.png

Change the rectangle:7x7 to larger numbers to trim more pixels around your window edges. Basically it will trim half the number of pixels off the top and bottom. So rectangle:7x7 will make your window 3 pixels smaller at the top and bottom, whereas rectangle:15x15 will make them 7 pixels smaller. Here's a link to Anthony Thyssen's excellent pages on how to use ImageMagick - and morphology in particular.

Answer 4

Here's another idea...

convert image.png -threshold 50% \
   \( +clone -morphology edgeout square:3x3 -write step1.png \
      -fill red -draw 'color 0,0 floodfill' -write step2.png \
      -fill black +opaque red -fill black   -write step3.png \
      -opaque red                           -write step4.png \
      -morphology dilate square:3x3         -write step5.png \
   \) -evaluate-sequence max result.png

And here are the steps 1-5 and the result. You can remove all the -write stepX.png parts from the code, they are just so you can see what I am doing:

Step1 - "show me all the pixels around the edges of the white areas"

Step 2 - "flood fill with red from the top-left corner now we have proper edges to our windows so that the flood doesn't "leak" into the windows"

Step 3 - "make everything that is not red into black"

Step 4 - "make everything that is red into white"

Step 5 - "make the white shapes a fraction larger"

Result - "at every pixel location, pick the pixel that is lightest out of the current and original image"

Answer 5

Mark's morphology method is a little simpler than this. So I suggest going with it as the best method so far. But here is a similar method (kind of a hybrid of his last two methods) that may be of interest. I have include +write tmpX.png to show the steps. Those can be removed. (Unix Syntax using Imagemagick 6.9.9.33)

convert original.png \
\( -clone 0 -morphology edgeout square:3 -negate +write tmp1.png \) \
\( -clone 0 -morphology dilate square:3 \
-morphology edge square:3 +write tmp2.png \) \
-delete 0 \
-evaluate-sequence max \
result.png

Line 1: reads the input

Line 2 - tmp1.png: uses morphology edgeout to convert the image to black curves with black box around them on a white background (as in Mark's other example).

Line 3 and 4 - tmp2.png: uses morphology dilate (to remove the curves) and edge to just create a white outline box around the white areas on a black background.

Line 6 and 7: result.png removes the black box in the tmp1.png using tmp2.png by taking the maximum between the two images pixel-by-pixel.

For comparison, here is Mark's elegant method that I have simplified a little:

convert original.png \
\( +clone -morphology close square:3 -negate +write tmp1.png \) \
-evaluate-sequence max \
result.png

Line 1: read the input

Line 2: - tmp1.png: use morphology close (same as dilate and erode) to create a black box to replace the white area including the black curve in the original. The square size can be as low as 3, but not lower for this to work. The smaller the less is removed from the curve ends.

Line 3: remove all the black in the original other than the curves by computing the maximum between the two image pixel-by-pixel.

Answer 6

@Mack wrote:

This method of trimming works on this particular image, but what happens when spacing is uneven? Is there a better way to do this without the trimming and cropping?

One way would be to separate each white square from the background into individual images. I have a bash unix shell script, multicrop2, that will do that. But for this image, it will produce one extra large image. For example:

magick original.png tmp.png
multicrop2 -b white tmp.png result.png

You can discard the last one shown here.

See my script, multicrop2, at http://www.fmwconcepts.com/imagemagick/index.html

As is currently, the script loses the virtual canvas of each output image. But I might be able to add an argument to keep it, so that the 3 good images could be flattened onto white such that the separate images would be merged back into a white background at there proper locations.

Answer 7

If by this you mean replace the white by transparency (a.k.a. color-to-alpha in image editors), the magical formula is:

convert original.png ( -clone 0 -fill "#a0132e" -colorize 100 ) ( -clone 0,1 -compose difference -composite -separate +channel -evaluate-sequence max -auto-level ) -delete 1 -alpha off -compose over -compose copy_opacity -composite output.png

Explanations here

Answer 8

Here's a slightly different solution using gaussian blur as a morphological operator. I used pyvips, but it would be easy to redo in magick.

The idea is that if you gaussblur with a fairly large sigma and then threshold > 0, you'll expand all the white by the gaussian radius and thereby fill in the lines.

The neat bit is that this can be used a second time with the threshold flipped to erode by exactly the amount you dilated by. Just blur a second time by the same amount, but now do != 255 and you'll have the shape of the background! Bitwise OR that with your original image for a solution.

import sys
import pyvips

im = pyvips.Image.new_from_file(sys.argv[1], access="sequential")

bg = im.gaussblur(2) > 0
bg = bg.gaussblur(2) != 255

im |= bg

im = im.write_to_file(sys.argv[2])

Then:

python characters.py ~/pics/characters.png x.png

Makes:

One nice feature of this is that there's no flooding, so you can stream the image. It'll work on images of any size and need very little memory.

Answer 9

Here is another rather simple morphology method (bottomhat) using Imagemagick. The kernel size needs to be at least 4 in this case. See https://www.imagemagick.org/Usage/morphology/#bottom-hat

Input:

convert source.png -morphology bottomhat octagon:4 -negate result.png