Detect Alpha Channel with ImageMagick

Question

Scenario

I would like to save images with alpha transparency as .png and images without alpha transparency as .jpg (even if their original format is .png or .gif). How can I detect whether or not an image has alpha transparency using ImageMagick?

Dominicadominical

Answer 1

The ImageMagik command:

identify -format '%[channels]' foo.png 

will print rgba or rgb if there is or is not an alpha channel, respectively.

There could be an alpha channel present with no data in it which wouldn't actually have any transparency, but that is a bit more complicated.

Halfbeak

Is it common for there to be an alpha channel with no data in it? If so, can I find that out? – Dominicadominical

In my experience, people only create alpha channels when they want them to be non-empty, but there is a difference between what usually happens and what can happen. I wouldn't worry about it unless you find it popping up. I was just trying to be complete by noting the existence of an alpha channel does not necessarily imply the presence of transparency. – Halfbeak

Ah, yes. Never underestimate the user. Thanks! – Dominicadominical

This is a very old question to be sure, but the absence of an alpha channel does not imply the absence of alpha pixels. It's possible to have an indexed RGB png with some of the index entries completely transparent. See tRNS in the png documentation. – Immeasurable

Answer 2

Check if the image has an alpha channel

Use -format %A, as per serhiy.h's answer. From the documentation:

%A    image transparency channel. Values include Undefined (no transparency channel), Blend, Copy, or Update.

Check if the image has no transparent or translucent pixels

Use -format %[opaque]. From the documentation:

%[opaque]    CALCULATED: is image fully-opaque?

---

Example

To demonstrate, lets create an image a.png that has an alpha channel but is fully opaque, and an image b.png that is the same except for one translucent pixel:

$ convert rose: PNG32:a.png
$ convert rose: -fill '#0008' -draw "matte 10,10 point" PNG32:b.png

As expected, the %A escape produces Blend for both images, since both have an alpha channel:

$ identify -format '%A' a.png
Blend
$ identify -format '%A' b.png  
Blend

Whereas the %[opaque] escape produces true in one case, and false in the other due to the one transparent pixel:

$ identify -format '%[opaque]' a.png
true
$ identify -format '%[opaque]' b.png
false

Alake

Thanks! With an output like that it's even tempting to do if $(identify -format '%[opaque]' "$file"); then ...; fi – Fiddlehead

I've spent all day looking for %[opaque], THANK YOU – Jack

Full CLI command magick identify -format '%[opaque]' file.png – Insurance

Answer 3

If you want to check that a picture is actually transparent... (not only an alpha channel which might be unused)

Use this command:

convert some_pic.png -verbose info:

(yes, there is a : at the end of the command)

It is quite verbose. Look for the channels list:

(...)
Channel depth:
  red: 16-bit
  green: 16-bit
  blue: 16-bit
Channel statistics:
(...)

In this example, there are three channels, one for each primary color. But non for alpha. So this image is not transparent.

But you can also get this kind of output:

(...)
Channel depth:
  red: 16-bit
  green: 16-bit
  blue: 16-bit
  alpha: 1-bit
Channel statistics:
(...)

Here, there is an alpha channel. However, this does no prove that the image is transparent. It just says that it might be. In the outputs of the command, look for the information about alpha channel:

(...)
  Alpha:
    min: 255 (1)
    max: 255 (1)
    mean: 255 (1)
    standard deviation: 0 (0)
    kurtosis: 0
    skewness: 0
(...)

In this example, the alpha says that the picture is opaque: min = max = 1 (1 = opaque, 0 = transparent). So even if the image has an alpha channel, the user sees an opaque picture.

You can also get this:

(...)
  Alpha:
    min: 95 (0.372549)
    max: 212 (0.831373)
    mean: 111.187 (0.436028)
    standard deviation: 19.5635 (0.0767196)
    kurtosis: 7.52139
    skewness: -2.80445
(...)

This time, min = 0.372549. This means that some pixels are partly transparent. mean is also low. It seems that a large part of the image uses transparency.

Depending of the type of check you want to achieve (full opacity, "almost opaque", etc.), you should check min, mean and maybe standard deviation if your request is a bit tricky.

Note: you might be tempted to check integer values for min, mean and others, as I did in the first place. After all, it is easier to deal with 95 than 0.372549. If you choose this route, beware the alpha channel depth. If it is 8 bits, then 255 is the maximum and means "opaque". If it is 16 bits, the maximum is now 65535 and 255 means "almost transparent". Better check the floats in parenthesis, which always range from 0 to 1.

If you suspect that a lot of pictures you will process have no alpha channel at all, it might be useful to first run:

identify -format '%[channels]' some_pic.png

If it dumps:

rgba

there is an alpha channel (the a in the output) and convert should be used to check min, etc.. But if there isn't, there is no need to run convert. Although I didn't benchmarked these two commands, identify should be much faster than convert.

Wang

For many users, folks who just want to see if the alpha channel is necessary, grabbing the alpha min line and checking that it ends with "(1)" or not should be sufficient. – Transient

thank you for a detailed answer. this actually provides some deeper insight into accessing image's properties and doesn't simply answer the OP's question, but also expands on it. – Inequity

Answer 4

identify -format %A some_pic.png

Will return True if image contains alpha channel.

Epicanthus

Answer 5

If you want to be sure that alpha transparency is really used, the only solution I see it to iterate all pixels and get the color info to check if it's transparent or not. For large images this will be very slow, so, as an optimization you can first make a thumbnail of the image (let's say 20x20) and then check the thumbnail pixels. This was a good solution for me.

Salientian

Answer 6

Here's a couple of bash functions to check if a png has transparency or not, using ImageMagick.

Fast check, which just checks for the presence of an alpha channel:

checkAlphaFast() {
    test $(identify -format %A "$1") == True
}

Slow check, verifies the pixels themselves (even if alpha channel is present):

checkAlphaSlow() {
    test $(identify -format '%[opaque]' "$1") == false
}

You should only consider using the fast check if you're doing this a whole lot, because it's pretty fast either way. Thanks to the other people who answered, from which I made these functions :)

As a bonus: I did not make any benchmarking, but this may be almost as fast as the fast mode and as accurate as the slow mode:

checkAlpha() {
    checkAlphaFast "$1" && checkAlphaSlow "$1"
}

Use these functions like this:

if checkAlpha "$myPNG"; then
    # is transparent
else
    # is opaque
fi

---

And this will give you the opaqueness of the image, where 0 is fully transparent and 1 is fully opaque:

checkOpaqueness() {
    if checkAlphaFast "$1"; then
        convert "$1" -verbose info: | grep -A3 Alpha: | tail +4 | head -n1 | sed -r 's/.*\(|\)//g'
    else
        echo 1
    fi
}

And this one outputs as a rounded percentage, because integers are so much more natural for bash:

checkPercentage() {
    printf %3.2f $(checkOpaqueness "$1") | tr -d . | sed -r 's/^0?0?//'
}

Fiddlehead

Answer 7

Default identify format + transparency detection:

identify -format '%i %m %wx%h %[opaque]\n' image.png

true at the end - no transparency, false - has transparent pixels.

Other format options here: https://imagemagick.org/script/escape.php

Tribble