Issue 1883 - Convert mode P to LA to work around a PIL bug when extracting the alpha channel

imageConversion.py

 # coding: utf-8
 
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import os
 import re
 from StringIO import StringIO
 
 try:
   from PIL import Image
   from PIL import ImageOps
 except ImportError:
   import Image
   import ImageOps
 
 def get_alpha(image):

[kzar, 2015/01/27 14:25:42]

I think there should be a comment here to explain why we need to convert the
image to greyscale + alpha before reading the alpha. (Just to work around a PIL
bug that stops us reading alpha for images with mode P?

[Sebastian Noack, 2015/01/27 14:29:25]

Frankly, converting an image without alpha channel to a mode that has an alpha
channel, in order to extract the alpha channel, would be the obvious way doing
it in the first place. The old code were an optimized (but buggy) implementation
which might have needed a comment.

[Sebastian Noack, 2015/01/27 15:10:05]

It's unneeded to document APIs in the calling code. We have discussed and agreed
on that a while ago. PIL is a well-documented library and we don't need to
duplicate their documentation in our code.

However, maybe it makes sense to mention the initial - even if less obvious -
approach, just to make sure that it's not used again in the future.

Also I realized that the original code returned None if no transparency is
involved. So I also recovered that behavior again.

-  if image.mode not in ('RGBA', 'LA'):
-    image = image.convert('LA')
+  if image.mode in ('RGBA', 'LA'):
+    return image.split()[image.getbands().index('A')]
 
-  return image.split()[image.getbands().index('A')]
+  # In order to generate an alpha channel for images using a palette, we
+  # convert the image to grayscale+alpha. Initially, we created an alpha
+  # channel by replacing opaque pixels with a high mark and transparent
+  # pixels with a low mark. However, it turned out that you can't rely on the
+  # value of Image.info['transparency'] since in some cases it might be an
+  # unparsed string instead an int indicating the value of transparent pixels.
+  if image.mode == 'P' and 'transparency' in image.info:
+    return image.convert('LA').split()[1]
 
 def load_image(path):
   image = Image.open(path)
   # Make sure the image is loaded, some versions of PIL load images lazily.
   image.load()
   return image
 
 def ensure_same_mode(im1, im2):
   # if both images already have the same mode (and palette, in
   # case of mode P), don't convert anything. Images with mode P,
@@ skipping 75 matching lines @@
 
     for step in steps:
       filter, args = re.match(r'([^(]+)(?:\((.*)\))?', step).groups()
       args = re.split(r'\s*,\s*', args) if args else ()
       image = globals()['filter_' + filter](image, baseDir, *args)
 
     f = StringIO()
     f.name = filename
     image.save(f)
     files[filename] = f.getvalue()