Make png from true_color

[MaxDragonheart]

I would make a png from a DataArray maked with true_color from xrspatial.multispectral. Below the function used to build the DataArray:

import xarray as xr
from xrspatial.multispectral import true_color

def tci_from_dataarray(
        input_data: xr.core.dataarray.DataArray,
        red: str,
        blue: str,
        green: str,
        nodata_value: Union[int, float] = None,
        contrast: float = 10,
        brighness: float = 0.125,
) -> xr.core.dataarray.DataArray:
    """Make DataArray with True Color bands.

    Args:
        input_data: xr.core.dataarray.DataArray
        red: str
        blue: str
        green: str
        nodata_value: Union[int, float]
        contrast: float,
        brighness: float,

    Returns:
        xr.core.dataarray.DataArray
    """
    data = input_data.sel(band_name=[red, blue, green])
    sensing_datetime = data.time.to_numpy()[0]

    red_band = data.sel(band_name=[red]).squeeze() * 1000
    green_band = data.sel(band_name=[green]).squeeze() * 1000
    blue_band = data.sel(band_name=[blue]).squeeze() * 1000

    if nodata_value is None:
        nodata = data._FillValue
    else:
        nodata = nodata_value

    tci = true_color(
        r=red_band,
        g=green_band,
        b=blue_band,
        nodata=nodata,
        c=contrast,
        th=brighness,
    )
    tci = tci.assign_coords(time=sensing_datetime)
    tci = tci.expand_dims(dim='time')
    tci = tci.where(tci != 0)
    tci.rio.write_nodata(-9999, inplace=True)
    tci.rio.write_crs(data.rio.crs, inplace=True)
    
    return tci

Below the output from one scene(I've 111 scenes from Landsat LC2):

<xarray.DataArray 'true_color' (y: 367, x: 727, band: 4)>
array([[[nan, nan, nan, nan],
        [nan, nan, nan, nan],
        [nan, nan, nan, nan],
        ...,
...
        ...,
        [nan, nan, nan, nan],
        [nan, nan, nan, nan],
        [nan, nan, nan, nan]]])
Coordinates:
  * y            (y) float64 4.525e+06 4.525e+06 ... 4.514e+06 4.514e+06
  * x            (x) float64 4.361e+05 4.361e+05 ... 4.579e+05 4.579e+05
  * band         (band) int64 0 1 2 3
    time         datetime64[ns] 2021-09-12
    spatial_ref  int64 0
Attributes:
    _FillValue:  -9999.0

I'm be able to save as GeoTIFF all scenes using the code below:

dataarray.astype('float32').rio.to_raster('tci.tif', driver="GTiff")

Problem comes when I try to save the DataArray as png

tci = tci_from_dataarray(
        input_data=scene,
        red=red_band,
        blue=blue_band,
        green=green_band,
        nodata_value=None,
        contrast=10,
        brightness=0.125,
    )
tci = tci.squeeze(dim='time')
plt.imsave(
    fname=chart_directory.joinpath('tci.png'),
    arr=tci.astype('float32'),
    dpi=80.0
)

From Jupyther Notebook I see the error below:

ValueError Traceback (most recent call
last) Input In [42], in <cell line: 7>()
14 tci = tci_from_dataarray(
15 input_data=scene,
16 red=red_band, (...)
21 brightness=0.125,
22 )
23 tci = tci.squeeze(dim='time')
---> 24 plt.imsave(
25 fname=chart_directory.joinpath(f'{tci_folder}/tci.png'),
26 arr=tci.astype('float32'),
27 dpi=80.0
28 )
29 break

File
~/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/pyplot.py:2165, in imsave(fname, arr, **kwargs) 2163
@_copy_docstring_and_deprecators(matplotlib.image.imsave) 2164 def
imsave(fname, arr, **kwargs):
-> 2165 return matplotlib.image.imsave(fname, arr, **kwargs)

File
~/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/image.py:1641,
in imsave(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata,
pil_kwargs) 1639 rgba = arr 1640 else:
-> 1641 rgba = sm.to_rgba(arr, bytes=True) 1642 if pil_kwargs is None: 1643 pil_kwargs = {}

File
~/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/cm.py:437,
in ScalarMappable.to_rgba(self, x, alpha, bytes, norm)
435 if xx.dtype.kind == 'f':
436 if norm and (xx.max() > 1 or xx.min() < 0):
--> 437 raise ValueError("Floating point image RGB values "
438 "must be in the 0..1 range.")
439 if bytes:
440 xx = (xx * 255).astype(np.uint8)

ValueError: Floating point image RGB values must be in the 0..1 range.

I don't understand why I can save easealy my DataArray as GeoTIFF but I've problem with a simple png.

[solomonsanderson]

If we look at the sample output you have provided:

<xarray.DataArray 'true_color' (y: 367, x: 727, band: 4)>
array([[[nan, nan, nan, nan],
[nan, nan, nan, nan],
[nan, nan, nan, nan],
...,
...
...,
[nan, nan, nan, nan],
[nan, nan, nan, nan],
[nan, nan, nan, nan]]])

You can see that "nan" values are returned.

If we now we consider the error your program has returned we can see that it requires rgb values between 0.0 and 1.0.

"nan" is not between 0 and 1 so will cause an error to be thrown by the program.

That would be my bet guess. Let me know how you get on! 😄

[MaxDragonheart]

I think that this is not the problem. Below the output without nan:

<xarray.DataArray 'true_color' (y: 367, x: 727, band: 4)>
array([[[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        ...,
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]],
        ...,
...
       [[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        ...,
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]]], dtype=uint8)
Coordinates:
  * y            (y) float64 4.525e+06 4.525e+06 ... 4.514e+06 4.514e+06
  * x            (x) float64 4.361e+05 4.361e+05 ... 4.579e+05 4.579e+05
  * band         (band) int64 0 1 2 3
    time         datetime64[ns] 2021-09-12
    spatial_ref  int64 0

And this is the error:

../../core/earthobservation/generic.py:107: in save_tci
    plt.imsave(
/home/max/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/pyplot.py:2165: in imsave
    return matplotlib.image.imsave(fname, arr, **kwargs)
/home/max/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/image.py:1641: in imsave
    rgba = sm.to_rgba(arr, bytes=True)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <matplotlib.cm.ScalarMappable object at 0x7fb355e0b760>
x = <xarray.DataArray 'true_color' (y: 367, x: 727, band: 4)>
array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        ...+05 4.579e+05
  * band         (band) int64 0 1 2 3
    time         datetime64[ns] 2021-09-12
    spatial_ref  int64 0
alpha = None, bytes = True, norm = True

    def to_rgba(self, x, alpha=None, bytes=False, norm=True):
        """
        Return a normalized rgba array corresponding to *x*.
    
        In the normal case, *x* is a 1D or 2D sequence of scalars, and
        the corresponding ndarray of rgba values will be returned,
        based on the norm and colormap set for this ScalarMappable.
    
        There is one special case, for handling images that are already
        rgb or rgba, such as might have been read from an image file.
        If *x* is an ndarray with 3 dimensions,
        and the last dimension is either 3 or 4, then it will be
        treated as an rgb or rgba array, and no mapping will be done.
        The array can be uint8, or it can be floating point with
        values in the 0-1 range; otherwise a ValueError will be raised.
        If it is a masked array, the mask will be ignored.
        If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
        will be used to fill in the transparency.  If the last dimension
        is 4, the *alpha* kwarg is ignored; it does not
        replace the pre-existing alpha.  A ValueError will be raised
        if the third dimension is other than 3 or 4.
    
        In either case, if *bytes* is *False* (default), the rgba
        array will be floats in the 0-1 range; if it is *True*,
        the returned rgba array will be uint8 in the 0 to 255 range.
    
        If norm is False, no normalization of the input data is
        performed, and it is assumed to be in the range (0-1).
    
        """
        # First check for special case, image input:
        try:
            if x.ndim == 3:
                if x.shape[2] == 3:
                    if alpha is None:
                        alpha = 1
                    if x.dtype == np.uint8:
                        alpha = np.uint8(alpha * 255)
                    m, n = x.shape[:2]
                    xx = np.empty(shape=(m, n, 4), dtype=x.dtype)
                    xx[:, :, :3] = x
                    xx[:, :, 3] = alpha
                elif x.shape[2] == 4:
                    xx = x
                else:
                    raise ValueError("Third dimension must be 3 or 4")
                if xx.dtype.kind == 'f':
                    if norm and (xx.max() > 1 or xx.min() < 0):
>                       raise ValueError("Floating point image RGB values "
                                         "must be in the 0..1 range.")
E                                        ValueError: Floating point image RGB values must be in the 0..1 range.

/home/max/.cache/pypoetry/virtualenvs/drakonotebook-i1s4hhkA-py3.8/lib/python3.8/site-packages/matplotlib/cm.py:437: ValueError