Making transparent in Custom Algorithms

[sairahul1526]

I wanted to make some values in a band transparent using Custom Algos

Read it here: #745

Below is the code

from titiler.core.algorithm import BaseAlgorithm
from rio_tiler.models import ImageData
import numpy

class Mask(BaseAlgorithm):
    min: int
    max: int

    def __call__(self, img: ImageData) -> ImageData:
        # Create a mask where values are within the specified range
        valid_mask = (img.data[0] >= self.min) & (img.data[0] <= self.max)

        # Apply the mask: keep data as is where valid, else set to 0
        modified_data = numpy.where(valid_mask, img.data, 0)

        # # Update the transparency mask: 255 (opaque) for valid data, 0 (transparent) otherwise
        modified_mask = numpy.where(valid_mask, 255, 0)

        # Create a new ImageData instance with the modified data and transparency mask
        return ImageData(modified_data, modified_mask, assets=img.assets, crs=img.crs, bounds=img.bounds)

# Add the `Mask` algorithm to the default ones
algorithms: Algorithms = default_algorithms.register({"mask": algo.Mask})

# Create a PostProcessParams dependency
PostProcessParams: Callable = algorithms.dependency
reader = MultiBaseTilerFactory(reader=reader.CustomSTACReader, router_prefix="stac", process_dependency=PostProcessParams)

I was able to make the values as 0 but not able to make them transparent in output.

Any help on this? How to show pixel values transparent?

[vincentsarago]

@sairahul1526 are you using the latest version of titiler?

if yes, the ImageData class now takes a Numpy.Masked.array as input which might be why it's not working for you.

class Mask(BaseAlgorithm):
    min: int
    max: int

    def __call__(self, img: ImageData) -> ImageData:
        # Create a mask where values are within the specified range
        valid_mask = (img.data[0] >= self.min) & (img.data[0] <= self.max)

        # Apply the mask: keep data as is where valid, else set to 0
        data = numpy.where(valid_mask, img.data, 0)

        # # Update the transparency mask: 255 (opaque) for valid data, 0 (transparent) otherwise
        modified_mask = numpy.where(valid_mask, 255, 0)

        arr = numpy.ma.MaskedArray(data, mask=modified_mask)

        # Create a new ImageData instance with the modified data and transparency mask
        return ImageData(arr, assets=img.assets, crs=img.crs, bounds=img.bounds)

[sairahul1526]

Thanks for the swift reply @vincentsarago

Yes, I'm using the latest titiler - 0.17.0

Modified your code a little bit to include the change for multiple bands. But still not working

from rio_tiler.models import ImageData
import numpy
from titiler.core.algorithm import BaseAlgorithm

class Mask(BaseAlgorithm):
    min: int
    max: int

    def __call__(self, img: ImageData) -> ImageData:
        # Create a mask where values in the first band are within the specified range
        valid_mask = (img.data[0] >= self.min) & (img.data[0] <= self.max)

        # Apply the mask to keep data as is where valid, else set to 0
        data = numpy.where(valid_mask, img.data, 0)

        # Update the transparency mask: 255 (opaque) for valid data, 0 (transparent) otherwise
        modified_mask = numpy.where(valid_mask, 255, 0)
        
        # Expand the mask dimensions to match the data dimensions
        if img.data.shape[0] > 1:  # Check if there are multiple bands
            modified_mask = numpy.repeat(modified_mask[None, :, :], img.data.shape[0], axis=0)

        # Create a MaskedArray with the data and the modified mask
        masked_array = numpy.ma.MaskedArray(data, mask=modified_mask)

        # Create a new ImageData instance with the modified data and transparency mask
        return ImageData(masked_array, assets=img.assets, crs=img.crs, bounds=img.bounds)

[vincentsarago]

"""titiler.core.algorithm Mask."""

import numpy
from rio_tiler.models import ImageData

from titiler.core.algorithm.base import BaseAlgorithm


class Mask(BaseAlgorithm):
    """Mask values between bounds."""
    # parameters
    min: float
    max: float

    def __call__(self, img: ImageData) -> ImageData:
        """Normalized difference."""
        # Create a mask where values in the first band are within the specified range
        valid_mask = (img.array >= self.min) & (img.array <= self.max)

        # Apply the mask to keep data as is where valid, else set to 0
        data = numpy.where(~valid_mask, img.data, 0)

        # Update the transparency mask: 255 (opaque) for valid data, 0 (transparent) otherwise
        modified_mask = numpy.where(valid_mask, 255, 0)

        # Expand the mask dimensions to match the data dimensions
        if img.data.shape[0] > 1:  # Check if there are multiple bands
            modified_mask = numpy.repeat(modified_mask[None, :, :], img.data.shape[0], axis=0)


        # Create a MaskedArray with the data and the modified mask
        masked_array = numpy.ma.MaskedArray(data, mask=modified_mask)

        return ImageData(
            masked_array,
            assets=img.assets,
            crs=img.crs,
            bounds=img.bounds,
            band_names=img.band_names,
            metadata=img.metadata,
            cutline_mask=img.cutline_mask,

        )

Try ☝️

http://127.0.0.1:8000/cog/preview?url=src/titiler/core/tests/fixtures/cog.tif&algorithm=mask&algorithm_params={%22min%22:1,%20%22max%22:3000}

[sairahul1526]

Thank you so such @vincentsarago

I missed the negate part in data = numpy.where