Values change with implicit conversion from mode F to L #5465

Activity

1. radarhere

   added

   Conversion

   NumPy

   and removed

   Conversion

   on May 4, 2021
2. radarhere commented on May 4, 2021

   

   radarhere

   on May 4, 2021

   Last edited by radarhere

   Member

   More actions

   Mode for fromarray is the "Mode to use". I think this is the mode to use when reading the numpy data - if so, then it makes sense that the values change when it is told to interpret the input data directly.

   You might be interested in .convert('L') instead of , mode='L',

   import numpy as np
   from PIL import Image
   tgt = np.ones(shape=(2, 2)) # float32
   tgt_im = Image.fromarray(tgt)
   tgt_im_np = np.asarray(tgt_im)
   final_img = Image.fromarray(tgt_im_np).convert('L')
   
   print(np.asarray(final_img))

   gives

   [[1 1]
    [1 1]]
   
3. meyerjo commented on May 4, 2021

   

   meyerjo

   on May 4, 2021

   Author

   More actions

   Okay thanks for the workaround.

   However, is it an expected behavior that random numbers appear in the matrix after doing the implicit conversion?
   I assumed that the fromarray method either

   • calls the conversion script, if the input is np.float32, or,
   • raises an exception if the array.dtype does not match the specified mode.
4. wiredfool commented on May 4, 2021

   

   wiredfool

   on May 4, 2021

   Member

   More actions

   I think that the mode to use parameter is a footgun. It’s not an implicit conversion, it’s a cast. In this case, you’re interpreting an array of 32 bit floats as 8 bit ints.

   I’m not sure if there is a good use case at all for the mode parameter here, as we need to be pretty sure what we’re getting from numpy to interpret the array correctly.
5. dtoniolo commented on Sep 20, 2021

   

   dtoniolo

   on Sep 20, 2021

   More actions

   I had a similar issue in #5723. So, if mode is given to Image.fromarray(), then what happens is:

   1. the image is created interpreting the array in a predefined manner (e.g. F if the dtype is np.float32 and the values all reside in the [0, 1].
   2. The image is then converted to the requested mode, changing the dtype and value range of the data array if necessary.

   Is this correct?
6. radarhere commented on Nov 22, 2021

   

   radarhere

   on Nov 22, 2021

   Last edited by radarhere

   Member

   More actions

   To respond to the previous comment,

   1. fromarray sets the mode according to

      Pillow/src/PIL/Image.py

      Lines 2877 to 2902 in d76fd93

      	_fromarray_typemap = {
      	# (shape, typestr) => mode, rawmode
      	# first two members of shape are set to one
      	((1, 1), "|b1"): ("1", "1;8"),
      	((1, 1), "|u1"): ("L", "L"),
      	((1, 1), "|i1"): ("I", "I;8"),
      	((1, 1), "<u2"): ("I", "I;16"),
      	((1, 1), ">u2"): ("I", "I;16B"),
      	((1, 1), "<i2"): ("I", "I;16S"),
      	((1, 1), ">i2"): ("I", "I;16BS"),
      	((1, 1), "<u4"): ("I", "I;32"),
      	((1, 1), ">u4"): ("I", "I;32B"),
      	((1, 1), "<i4"): ("I", "I;32S"),
      	((1, 1), ">i4"): ("I", "I;32BS"),
      	((1, 1), "<f4"): ("F", "F;32F"),
      	((1, 1), ">f4"): ("F", "F;32BF"),
      	((1, 1), "<f8"): ("F", "F;64F"),
      	((1, 1), ">f8"): ("F", "F;64BF"),
      	((1, 1, 2), "|u1"): ("LA", "LA"),
      	((1, 1, 3), "|u1"): ("RGB", "RGB"),
      	((1, 1, 4), "|u1"): ("RGBA", "RGBA"),
      	}
      	# shortcuts
      	_fromarray_typemap[((1, 1), _ENDIAN + "i4")] = ("I", "I")
      	_fromarray_typemap[((1, 1), _ENDIAN + "f4")] = ("F", "F")

   So F mode is the "typestr" has "f" (if it is float, see https://numpy.org/doc/stable/reference/arrays.interface.html#object.__array_interface__ for more information)

   2. I wouldn't say that it is converted - the data is not changed - rather the same data is interpreted differently. This is not what you might expect.

   Some notes on the original post.

   1. The initial post states that

   tgt = np.ones(shape=(2, 2)) # float32

   This is not correct. tgt.dtype is "float64".

   import numpy as np
   from PIL import Image
   tgt = np.ones(shape=(2, 2))
   tgt_im = Image.fromarray(tgt)
   tgt_im_np = np.asarray(tgt_im)

   gives tgt_im_np of

   [[1. 1.]
    [1. 1.]]
   

   You might assume this is equal to np.ones(shape=(2, 2)), but tgt.dtype is "float64" and tgt_im_np.dtype is "float32". So the dtype changes, but I'm not convinced it's a problem that Pillow doesn't have a different mode for all of numpy's different modes.

   3. So if we remove that roundtrip from the original code, then

   import numpy as np
   from PIL import Image
   tgt = np.ones(shape=(2, 2))
   final_img = Image.fromarray(tgt, mode="L")
   print(np.asarray(final_img))

   gives

   [[0 0]
    [0 0]]
   

   This seems more reasonable than the "random numbers" that were initially described.

   import numpy as np
   from PIL import Image
   tgt = np.ones(shape=(2, 2))
   final_img = Image.fromarray(tgt)
   print(np.asarray(final_img))

   gives

   [[1. 1.]
    [1. 1.]]
   
7. radarhere commented on Nov 23, 2021

   

   radarhere

   on Nov 23, 2021

   Last edited by radarhere

   Member

   More actions

   Closing unless there are further questions. #2856 is also about this situation.
8. radarhere

   closed this as completedon Nov 23, 2021
9. radarhere commented on Nov 23, 2021

   

   radarhere

   on Nov 23, 2021

   Member

   More actions

   I've created PR #5849 to clarify this in the documentation.