indices

The spectral indices transform classes.

kelp.core.indices.AppendAFRI1600

Bases: AppendIndex

Aerosol free vegetation index 1600

References

Index DataBase

Source code in kelp/core/indices.py

class AppendAFRI1600(AppendIndex):
    """
    Aerosol free vegetation index 1600

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_swir: int,
        index_nir: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_swir=index_swir,
            index_nir=index_nir,
        )

    def _compute_index(self, swir: Tensor, nir: Tensor) -> Tensor:
        return nir - 0.66 * (swir / (nir + 0.66 * swir + consts.data.EPS))

kelp.core.indices.AppendARVI

Bases: AppendIndex

Atmospherically Resistant Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendARVI(AppendIndex):
    """
    Atmospherically Resistant Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return -0.18 + 1.17 * ((nir - red) / (nir + red + consts.data.EPS))

kelp.core.indices.AppendATSAVI

Bases: AppendIndex

Adjusted transformed soil-adjusted VI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendATSAVI(AppendIndex):
    """
    Adjusted transformed soil-adjusted VI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return (
            1.22
            * (nir - 1.22 * red - 0.03)
            / (1.22 * nir + red - 1.22 * 0.03 + 0.08 * (1 + 1.22**2) + consts.data.EPS)
        )

kelp.core.indices.AppendAVI

Bases: AppendIndex

Ashburn Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendAVI(AppendIndex):
    """
    Ashburn Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return 2 * nir - red

kelp.core.indices.AppendBWDRVI

Bases: AppendIndex

Blue-wide dynamic range vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendBWDRVI(AppendIndex):
    """
    Blue-wide dynamic range vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, blue: Tensor) -> Tensor:
        return (0.1 * nir - blue) / (0.1 * nir + blue + consts.data.EPS)

kelp.core.indices.AppendCDOM

Bases: AppendIndex

Colored Dissolved Organic Matter

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendCDOM(AppendIndex):
    """
    Colored Dissolved Organic Matter

    References:
       [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, red: Tensor, green: Tensor) -> Tensor:
        return 537 * torch.exp(-2.93 * green / (red + consts.data.EPS))

kelp.core.indices.AppendCHLA

Bases: AppendIndex

Chlorophyll-a

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendCHLA(AppendIndex):
    """
    Chlorophyll-a

    References:
        [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, blue: Tensor, green: Tensor) -> Tensor:
        # Yes, I know we should use coastal band here instead of blue, but we don't get to have coastal band
        blue = blue / 65_535
        green = green / 65_535
        return 4.23 * torch.pow((green / (blue + consts.data.EPS)), 3.94)

kelp.core.indices.AppendCI

Bases: AppendIndex

Coloration Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendCI(AppendIndex):
    """
    Coloration Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, blue: Tensor) -> Tensor:
        return (red - blue) / (red + consts.data.EPS)

kelp.core.indices.AppendCVI

Bases: AppendIndex

Chlorophyll vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendCVI(AppendIndex):
    """
    Chlorophyll vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return nir * (red / (green**2 + consts.data.EPS))

kelp.core.indices.AppendCYA

Bases: AppendIndex

Cyanobacteria density

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendCYA(AppendIndex):
    """
    Cyanobacteria density

    References:
       [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        red = red / 65_535
        green = green / 65_535
        blue = blue / 65_535
        return torch.pow(((green * red + consts.data.EPS) / (blue + consts.data.EPS)), 2.38)  # * 115_530.31

kelp.core.indices.AppendClGreen

Bases: AppendIndex

Chlorophyll Index Green

References

Index DataBase

Source code in kelp/core/indices.py

class AppendClGreen(AppendIndex):
    """
    Chlorophyll Index Green

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return nir / (green + consts.data.EPS) - 1

kelp.core.indices.AppendDEMWM

Bases: AppendIndex

DEM Water Mask

References

Index DataBase

Source code in kelp/core/indices.py

class AppendDEMWM(AppendIndex):
    """
    DEM Water Mask

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_dem: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_dem=index_dem,
        )

    def _compute_index(self, dem: Tensor) -> Tensor:
        return torch.maximum(dem, torch.zeros_like(dem))

kelp.core.indices.AppendDOC

Bases: AppendIndex

Dissolved Organic Carbon index

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendDOC(AppendIndex):
    """
    Dissolved Organic Carbon index

    References:
       [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, red: Tensor, green: Tensor) -> Tensor:
        return 432 * torch.exp(-2.24 * green / (red + consts.data.EPS))

kelp.core.indices.AppendDVIMSS

Bases: AppendIndex

Differenced Vegetation Index MSS

References

Index DataBase

Source code in kelp/core/indices.py

class AppendDVIMSS(AppendIndex):
    """
    Differenced Vegetation Index MSS

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return 2.4 * nir - red

kelp.core.indices.AppendEVI

Bases: AppendIndex

Enhanced Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendEVI(AppendIndex):
    """
    Enhanced Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, blue: Tensor) -> Tensor:
        return torch.clamp(
            2.5 * ((nir - red) / (nir + 6 * red - 7.5 * blue + 1 + consts.data.EPS)),
            min=-20_000,
            max=20_000,
        )

kelp.core.indices.AppendEVI2

Bases: AppendIndex

Enhanced Vegetation Index 2

References

Index DataBase

Source code in kelp/core/indices.py

class AppendEVI2(AppendIndex):
    """
    Enhanced Vegetation Index 2

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return 2.4 * (nir - red) / (nir + red + 1 + consts.data.EPS)

kelp.core.indices.AppendEVI22

Bases: AppendIndex

Enhanced Vegetation Index 2 -2

References

Index DataBase

Source code in kelp/core/indices.py

class AppendEVI22(AppendIndex):
    """
    Enhanced Vegetation Index 2 -2

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return 2.5 * (nir - red) / (nir + 2.4 * red + 1 + consts.data.EPS)

kelp.core.indices.AppendGARI

Bases: AppendIndex

Green atmospherically resistant vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGARI(AppendIndex):
    """
    Green atmospherically resistant vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (nir - (green - (blue - red))) / (nir - (green + (blue - red)) + consts.data.EPS)

kelp.core.indices.AppendGBNDVI

Bases: AppendIndex

Green-Blue NDVI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGBNDVI(AppendIndex):
    """
    Green-Blue NDVI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (nir - (green + blue)) / (nir + green + blue + consts.data.EPS)

kelp.core.indices.AppendGDVI

Bases: AppendIndex

Difference NIR/Green Green Difference Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGDVI(AppendIndex):
    """
    Difference NIR/Green Green Difference Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return nir - green

kelp.core.indices.AppendGNDVI

Bases: AppendIndex

Green Normalized Difference Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGNDVI(AppendIndex):
    """
    Green Normalized Difference Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return (nir - green) / (nir + green + consts.data.EPS)

kelp.core.indices.AppendGRNDVI

Bases: AppendIndex

Green-Red NDVI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGRNDVI(AppendIndex):
    """
    Green-Red NDVI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return (nir - (red + green)) / (nir + red + green + consts.data.EPS)

kelp.core.indices.AppendGVMI

Bases: AppendIndex

Global Vegetation Moisture Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendGVMI(AppendIndex):
    """
    Global Vegetation Moisture Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_swir: int,
        index_nir: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_swir=index_swir,
            index_nir=index_nir,
        )

    def _compute_index(self, swir: Tensor, nir: Tensor) -> Tensor:
        return ((nir + 0.1) - (swir + 0.02)) / ((nir + 0.1) + (swir + 0.02) + consts.data.EPS)

kelp.core.indices.AppendH

Bases: AppendIndex

Hue

References

Index DataBase

Source code in kelp/core/indices.py

class AppendH(AppendIndex):
    """
    Hue

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return torch.arctan(((2 * red - green - blue) / 30.5) * (green - blue))

kelp.core.indices.AppendI

Bases: AppendIndex

Intensity

References

Index DataBase

Source code in kelp/core/indices.py

class AppendI(AppendIndex):
    """
    Intensity

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (1 / 30.5) * (red + green + blue + consts.data.EPS)

kelp.core.indices.AppendIPVI

Bases: AppendIndex

Infrared percentage vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendIPVI(AppendIndex):
    """
    Infrared percentage vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return (nir / (nir + red + consts.data.EPS) / 2) * (
            ((red - green) / (red + consts.data.EPS) + green) + 1 + consts.data.EPS
        )

kelp.core.indices.AppendIndex

Bases: Module, ABC

Base class for appending spectral indices to the input Tensor.

Source code in kelp/core/indices.py

class AppendIndex(nn.Module, abc.ABC):
    """
    Base class for appending spectral indices to the input Tensor.
    """

    def __init__(
        self,
        index_qa: int = 5,
        index_water_mask: int = 7,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **band_kwargs: Any,
    ) -> None:
        super().__init__()
        assert all(k.startswith("index_") for k in band_kwargs), (
            "Passed keyword arguments must start with 'index_' followed by band name! "
            f"Found following keys: {list(band_kwargs.keys())}"
        )
        self.dim = -3
        self.index_qa = index_qa
        self.index_water_mask = index_water_mask
        self.mask_using_qa = mask_using_qa
        self.mask_using_water_mask = mask_using_water_mask
        self.fill_val = fill_val
        self.band_kwargs = band_kwargs

    def _append_index(self, sample: Tensor, index: Tensor) -> Tensor:
        index = index.unsqueeze(self.dim)
        sample = torch.cat([sample, index], dim=self.dim)
        return sample

    def _mask_index(self, index: Tensor, sample: Tensor, masking_band_index: int, apply_mask: bool) -> Tensor:
        if not apply_mask:
            return index
        mask = sample[..., masking_band_index, :, :]
        index = torch.where(mask == 0, index, self.fill_val)
        return index

    @abc.abstractmethod
    def _compute_index(self, **kwargs: Any) -> Tensor:
        pass

    def forward(self, x: Tensor) -> Tensor:
        # Compute the index
        compute_kwargs: Dict[str, Tensor] = {
            k.replace("index_", ""): x[..., v, :, :] for k, v in self.band_kwargs.items()
        }
        index = self._compute_index(**compute_kwargs)

        # Mask using QA band if requested
        index = self._mask_index(
            index=index,
            sample=x,
            masking_band_index=self.index_qa,
            apply_mask=self.mask_using_qa,
        )

        # Mask using Water Mask if requested
        index = self._mask_index(
            index=index,
            sample=x,
            masking_band_index=self.index_water_mask,
            apply_mask=self.mask_using_water_mask,
        )

        # Append to the input tensor
        x = self._append_index(sample=x, index=index)

        return x

kelp.core.indices.AppendKIVU

Bases: AppendIndex

KIVU

References

Boucher et al. 2018

Source code in kelp/core/indices.py

class AppendKIVU(AppendIndex):
    """
    KIVU

    References:
        [Boucher et al. 2018](https://doi.org/10.1002/eap.1708)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (blue - red) / (green + consts.data.EPS)

kelp.core.indices.AppendKab1

Bases: AppendIndex

Kabbara Index 1

References

Boucher et al. 2018

Source code in kelp/core/indices.py

class AppendKab1(AppendIndex):
    """
    Kabbara Index 1

    References:
        [Boucher et al. 2018](https://doi.org/10.1002/eap.1708)
    """

    def __init__(
        self,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, green: Tensor, blue: Tensor) -> Tensor:
        return 1.67 - 3.94 * torch.log(blue + consts.data.EPS) + 3.78 * torch.log(green + consts.data.EPS)

kelp.core.indices.AppendLogR

Bases: AppendIndex

Log Ratio

References

Index DataBase

Source code in kelp/core/indices.py

class AppendLogR(AppendIndex):
    """
    Log Ratio

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return torch.log(nir / (red + consts.data.EPS) + consts.data.EPS)

kelp.core.indices.AppendMCARI

Bases: AppendIndex

Modified Chlorophyll Absorption in Reflectance Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendMCARI(AppendIndex):
    """
    Modified Chlorophyll Absorption in Reflectance Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return ((nir - red) - 0.2 * (nir - green)) * (nir / (red + consts.data.EPS))

kelp.core.indices.AppendMCRIG

Bases: AppendIndex

mCRIG

References

Index DataBase

Source code in kelp/core/indices.py

class AppendMCRIG(AppendIndex):
    """
    mCRIG

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (blue**-1 - green**-1) * nir

kelp.core.indices.AppendMSAVI

Bases: AppendIndex

Modified Soil Adjusted Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendMSAVI(AppendIndex):
    """
    Modified Soil Adjusted Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return (2 * nir + 1 - torch.sqrt((2 * nir + 1) ** 2 - 8 * (nir - red))) / 2

kelp.core.indices.AppendMSRNirRed

Bases: AppendIndex

Modified Simple Ratio NIR/RED

References

Index DataBase

Source code in kelp/core/indices.py

class AppendMSRNirRed(AppendIndex):
    """
    Modified Simple Ratio NIR/RED

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return ((nir / red + consts.data.EPS) - 1) / torch.sqrt((nir / (red + consts.data.EPS)) + 1)

kelp.core.indices.AppendMVI

Bases: AppendIndex

Mid-infrared vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendMVI(AppendIndex):
    """
    Mid-infrared vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_swir: int,
        index_nir: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_swir=index_swir,
            index_nir=index_nir,
        )

    def _compute_index(self, swir: Tensor, nir: Tensor) -> Tensor:
        return nir / (swir + consts.data.EPS)

kelp.core.indices.AppendNDAVI

Bases: AppendIndex

Normalized Difference Aquatic Vegetation Index

References

Villa et al. 2014

Source code in kelp/core/indices.py

class AppendNDAVI(AppendIndex):
    """
    Normalized Difference Aquatic Vegetation Index

    References:
        [Villa et al. 2014](https://doi.org/10.1016/j.jag.2014.01.017)
    """

    def __init__(
        self,
        index_nir: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, blue: Tensor) -> Tensor:
        return (nir - blue) / (nir + blue + consts.data.EPS)

kelp.core.indices.AppendNDVI

Bases: AppendIndex

Normalized Difference Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNDVI(AppendIndex):
    """
    Normalized Difference Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return (nir - red) / (nir + red + consts.data.EPS)

kelp.core.indices.AppendNDVIWM

Bases: AppendIndex

NDVI Water Mask

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNDVIWM(AppendIndex):
    """
    NDVI Water Mask

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return torch.maximum((nir - red) / (nir + red + consts.data.EPS), torch.zeros_like(nir))

kelp.core.indices.AppendNDWI

Bases: AppendIndex

Normalized Difference Water Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNDWI(AppendIndex):
    """
    Normalized Difference Water Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return (nir - green) / (nir + green + consts.data.EPS)

kelp.core.indices.AppendNDWIWM

Bases: AppendIndex

NDWI Water Mask

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNDWIWM(AppendIndex):
    """
    NDWI Water Mask

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return torch.maximum((nir - green) / (nir + green + consts.data.EPS), torch.zeros_like(nir))

kelp.core.indices.AppendNLI

Bases: AppendIndex

Nonlinear vegetation index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNLI(AppendIndex):
    """
    Nonlinear vegetation index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return (nir**2 - red) / (nir**2 + red + consts.data.EPS)

kelp.core.indices.AppendNormG

Bases: AppendIndex

Norm Green

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNormG(AppendIndex):
    """
    Norm Green

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return green / (nir + red + green + consts.data.EPS)

kelp.core.indices.AppendNormNIR

Bases: AppendIndex

Norm NIR

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNormNIR(AppendIndex):
    """
    Norm NIR

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return nir / (nir + red + green + consts.data.EPS)

kelp.core.indices.AppendNormR

Bases: AppendIndex

Norm R

References

Index DataBase

Source code in kelp/core/indices.py

class AppendNormR(AppendIndex):
    """
    Norm R

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor) -> Tensor:
        return red / (nir + red + green + consts.data.EPS)

kelp.core.indices.AppendPNDVI

Bases: AppendIndex

Pan NDVI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendPNDVI(AppendIndex):
    """
        Pan NDVI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (nir - (red + green + blue)) / (nir + red + green + blue + consts.data.EPS)

kelp.core.indices.AppendRBNDVI

Bases: AppendIndex

Red-Blue NDVI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendRBNDVI(AppendIndex):
    """
    Red-Blue NDVI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, blue: Tensor) -> Tensor:
        return (nir - (red + blue)) / (nir + red + blue + consts.data.EPS)

kelp.core.indices.AppendSABI

Bases: AppendIndex

Surface Algal Bloom Index

References

Boucher et al. 2018

Source code in kelp/core/indices.py

class AppendSABI(AppendIndex):
    """
    Surface Algal Bloom Index

    References:
        [Boucher et al. 2018](https://doi.org/10.1002/eap.1708)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (nir - red) / (green + blue + consts.data.EPS)

kelp.core.indices.AppendSQRTNIRR

Bases: AppendIndex

SQRT(IR/R)

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSQRTNIRR(AppendIndex):
    """
    SQRT(IR/R)

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return torch.sqrt(nir / (red + consts.data.EPS))

kelp.core.indices.AppendSRGR

Bases: AppendIndex

Simple Ratio NIR/Blue

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSRGR(AppendIndex):
    """
    Simple Ratio NIR/Blue

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, red: Tensor, green: Tensor) -> Tensor:
        return green / (red + consts.data.EPS)

kelp.core.indices.AppendSRNIRG

Bases: AppendIndex

Simple Ratio NIR/Green

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSRNIRG(AppendIndex):
    """
    Simple Ratio NIR/Green

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_green=index_green,
        )

    def _compute_index(self, nir: Tensor, green: Tensor) -> Tensor:
        return nir / (green + consts.data.EPS)

kelp.core.indices.AppendSRNIRR

Bases: AppendIndex

Simple Ratio NIR/Red

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSRNIRR(AppendIndex):
    """
    Simple Ratio NIR/Red

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return nir / (red + consts.data.EPS)

kelp.core.indices.AppendSRNIRSWIR

Bases: AppendIndex

Simple Ratio NIR/SWIR

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSRNIRSWIR(AppendIndex):
    """
    Simple Ratio NIR/SWIR

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_swir: int,
        index_nir: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_swir=index_swir,
            index_nir=index_nir,
        )

    def _compute_index(self, swir: Tensor, nir: Tensor) -> Tensor:
        return nir / (swir + consts.data.EPS)

kelp.core.indices.AppendSRSWIRNIR

Bases: AppendIndex

Simple Ratio SWIR/NIR

References

Index DataBase

Source code in kelp/core/indices.py

class AppendSRSWIRNIR(AppendIndex):
    """
    Simple Ratio SWIR/NIR

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_swir: int,
        index_nir: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_swir=index_swir,
            index_nir=index_nir,
        )

    def _compute_index(self, swir: Tensor, nir: Tensor) -> Tensor:
        return swir / (nir + consts.data.EPS)

kelp.core.indices.AppendTNDVI

Bases: AppendIndex

Transformed NDVI

References

Index DataBase

Source code in kelp/core/indices.py

class AppendTNDVI(AppendIndex):
    """
    Transformed NDVI

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return torch.sqrt((nir - red) / (nir + red + consts.data.EPS) + 0.5)

kelp.core.indices.AppendTURB

Bases: AppendIndex

Water Turbidity

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendTURB(AppendIndex):
    """
    Water Turbidity

    References:
       [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, green: Tensor, blue: Tensor) -> Tensor:
        return 8.93 * (green / (blue + consts.data.EPS)) - 6.39

kelp.core.indices.AppendTVI

Bases: AppendIndex

Transformed Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendTVI(AppendIndex):
    """
    Transformed Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, red: Tensor, green: Tensor) -> Tensor:
        return torch.sqrt(((red - green) / (red + green + consts.data.EPS)) + 0.5)

kelp.core.indices.AppendVARIGreen

Bases: AppendIndex

Visible Atmospherically Resistant Index Green

References

Index DataBase

Source code in kelp/core/indices.py

class AppendVARIGreen(AppendIndex):
    """
    Visible Atmospherically Resistant Index Green

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
            index_blue=index_blue,
        )

    def _compute_index(self, red: Tensor, green: Tensor, blue: Tensor) -> Tensor:
        return (green - red) / (green + red - blue + consts.data.EPS)

kelp.core.indices.AppendWAVI

Bases: AppendIndex

Water Adjusted Vegetation Index

References

Villa et al. 2014

Source code in kelp/core/indices.py

class AppendWAVI(AppendIndex):
    """
    Water Adjusted Vegetation Index

    References:
        [Villa et al. 2014](https://doi.org/10.1016/j.jag.2014.01.017)
    """

    def __init__(
        self,
        index_nir: int,
        index_blue: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_blue=index_blue,
        )

    def _compute_index(self, nir: Tensor, blue: Tensor) -> Tensor:
        return 1.5 * (nir - blue) / (nir + blue + 0.5 + consts.data.EPS)

kelp.core.indices.AppendWDRVI

Bases: AppendIndex

Wide Dynamic Range Vegetation Index

References

Index DataBase

Source code in kelp/core/indices.py

class AppendWDRVI(AppendIndex):
    """
    Wide Dynamic Range Vegetation Index

    References:
        [Index DataBase](https://www.indexdatabase.de/)
    """

    def __init__(
        self,
        index_nir: int,
        index_red: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_nir=index_nir,
            index_red=index_red,
        )

    def _compute_index(self, nir: Tensor, red: Tensor) -> Tensor:
        return (0.1 * nir - red) / (0.1 * nir + red + consts.data.EPS)

kelp.core.indices.AppendWaterColor

Bases: AppendIndex

Water color index

References

Se2WaQ - Sentinel-2 Water Quality

Source code in kelp/core/indices.py

class AppendWaterColor(AppendIndex):
    """
    Water color index

    References:
       [Se2WaQ - Sentinel-2 Water Quality](https://custom-scripts.sentinel-hub.com/custom-scripts/sentinel-2/se2waq/)
    """

    def __init__(
        self,
        index_red: int,
        index_green: int,
        index_qa: int = 5,
        index_water_mask: int = 8,
        mask_using_qa: bool = False,
        mask_using_water_mask: bool = False,
        fill_val: float = 0.0,
        **kwargs: Any,
    ) -> None:
        super().__init__(
            index_qa=index_qa,
            index_water_mask=index_water_mask,
            mask_using_qa=mask_using_qa,
            mask_using_water_mask=mask_using_water_mask,
            fill_val=fill_val,
            index_red=index_red,
            index_green=index_green,
        )

    def _compute_index(self, red: Tensor, green: Tensor) -> Tensor:
        return 25366 * torch.exp(-4.53 * green / (red + consts.data.EPS))