RadGEEToolbox 1.6.3__py3-none-any.whl → 1.6.5__py3-none-any.whl

RadGEEToolbox/LandsatCollection.py

@@ -1,12 +1,35 @@
 import ee
 import pandas as pd
 import numpy as np
+
+
+# ---- Reflectance scaling for Landsat Collection 2 SR ----
+_LS_SR_BANDS = ["SR_B1", "SR_B2", "SR_B3", "SR_B4", "SR_B5", "SR_B6", "SR_B7"]
+_LS_SCALE = 0.0000275
+_LS_OFFSET = -0.2
+
+def _scale_landsat_sr(img):
+    """
+    Converts Landsat C2 SR DN values to reflectance values for SR_B1..SR_B7 (overwrite bands).
+
+    Args:
+        img (ee.Image): Input Landsat image without scaled bands.
+
+    Returns:
+        ee.Image: Image with scaled reflectance bands.
+    """
+    img = ee.Image(img)
+    already = ee.String(img.get('rgt:scaled')).eq('landsat_sr')
+    scaled = img.select(_LS_SR_BANDS).multiply(_LS_SCALE).add(_LS_OFFSET)
+    scaled = img.addBands(scaled, None, True).set('rgt:scaled','landsat_sr')
+    return ee.Image(ee.Algorithms.If(already, img, scaled))
+
 class LandsatCollection:
     """
     Represents a user-defined collection of NASA/USGS Landsat 5, 8, and 9 TM & OLI surface reflectance satellite images at 30 m/px from Google Earth Engine (GEE).
 
     This class enables simplified definition, filtering, masking, and processing of multispectral Landsat imagery.
-    It supports multiple spatial and temporal filters, caching for efficient computation, and direct computation of 
+    It supports multiple spatial and temporal filters, caching for efficient computation, and direct computation of
     key spectral indices like NDWI, NDVI, halite index, and more. It also includes utilities for cloud masking,
     mosaicking, zonal statistics, and transect analysis.
 
@@ -22,10 +45,11 @@ class LandsatCollection:
         cloud_percentage_threshold (int, optional): Max allowed cloud cover percentage. Defaults to 100.
         boundary (ee.Geometry, optional): A geometry for filtering to images that intersect with the boundary shape. Overrides `tile_path` and `tile_row` if provided.
         collection (ee.ImageCollection, optional): A pre-filtered Landsat ee.ImageCollection object to be converted to a LandsatCollection object. Overrides all other filters.
+        scale_bands (bool, optional): If True, all SR bands will be scaled from DN values to reflectance values. Defaults to False.
 
     Attributes:
-        collection (ee.ImageCollection): The filtered or user-supplied image collection converted to an ee.ImageCollection object.        
-        
+        collection (ee.ImageCollection): The filtered or user-supplied image collection converted to an ee.ImageCollection object.
+
     Raises:
         ValueError: Raised if required filter parameters are missing, or if both `collection` and other filters are provided.
 
@@ -48,11 +72,31 @@ class LandsatCollection:
         >>> latest_image = cloud_masked.image_grab(-1)
         >>> ndwi_collection = image_collection.ndwi
     """
-    def __init__(self, start_date=None, end_date=None, tile_row=None, tile_path=None, cloud_percentage_threshold=None, boundary=None,  collection=None):
+
+    def __init__(
+        self,
+        start_date=None,
+        end_date=None,
+        tile_row=None,
+        tile_path=None,
+        cloud_percentage_threshold=None,
+        boundary=None,
+        collection=None,
+        scale_bands=False,
+    ):
         if collection is None and (start_date is None or end_date is None):
-            raise ValueError("Either provide all required fields (start_date, end_date, tile_row, tile_path ; or boundary in place of tiles) or provide a collection.")
-        if tile_row is None and tile_path is None and boundary is None and collection is None:
-            raise ValueError("Provide either tile or boundary/geometry specifications to filter the image collection")
+            raise ValueError(
+                "Either provide all required fields (start_date, end_date, tile_row, tile_path ; or boundary in place of tiles) or provide a collection."
+            )
+        if (
+            tile_row is None
+            and tile_path is None
+            and boundary is None
+            and collection is None
+        ):
+            raise ValueError(
+                "Provide either tile or boundary/geometry specifications to filter the image collection"
+            )
         if collection is None:
             self.start_date = start_date
             self.end_date = end_date
@@ -85,11 +129,13 @@ class LandsatCollection:
                 self.collection = self.get_boundary_filtered_collection()
         else:
             self.collection = collection
+        if scale_bands:
+            self.collection = self.collection.map(_scale_landsat_sr)
 
-        
         self._dates_list = None
         self._dates = None
         self.ndwi_threshold = -1
+        self.mndwi_threshold = -1
         self.ndvi_threshold = -1
         self.halite_threshold = -1
         self.gypsum_threshold = -1
@@ -105,6 +151,7 @@ class LandsatCollection:
         self._max = None
         self._min = None
         self._ndwi = None
+        self._mndwi = None
         self._ndvi = None
         self._halite = None
         self._gypsum = None
@@ -113,42 +160,88 @@ class LandsatCollection:
         self._LST = None
         self._MosaicByDate = None
         self._PixelAreaSumCollection = None
+        self._Reflectance = None
 
     @staticmethod
     def image_dater(image):
         """
         Adds date to image properties as 'Date_Filter'.
 
-        Args: 
+        Args:
             image (ee.Image): Input image
 
-        Returns: 
+        Returns:
             ee.Image: Image with date in properties.
         """
-        date = ee.Number(image.date().format('YYYY-MM-dd'))
-        return image.set({'Date_Filter': date})
-    
+        date = ee.Number(image.date().format("YYYY-MM-dd"))
+        return image.set({"Date_Filter": date})
+
     @staticmethod
     def landsat5bandrename(img):
         """
         Renames Landsat 5 bands to match Landsat 8 & 9.
 
-        Args: 
+        Args:
             image (ee.Image): input image
-        
-        Returns: 
+
+        Returns:
             ee.Image: image with renamed bands
         """
-        return img.select('SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B7', 'QA_PIXEL').rename('SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7', 'QA_PIXEL')
-    
+        return img.select(
+            "SR_B1", "SR_B2", "SR_B3", "SR_B4", "SR_B5", "SR_B7", "QA_PIXEL"
+        ).rename("SR_B2", "SR_B3", "SR_B4", "SR_B5", "SR_B6", "SR_B7", "QA_PIXEL")
+
     @staticmethod
     def landsat_ndwi_fn(image, threshold, ng_threshold=None):
         """
-        Calculates ndwi from GREEN and NIR bands (McFeeters, 1996 - https://doi.org/10.1080/01431169608948714) for Landsat imagery and mask image based on threshold. 
-        
+        Calculates ndwi from GREEN and NIR bands (McFeeters, 1996 - https://doi.org/10.1080/01431169608948714) for Landsat imagery and mask image based on threshold.
+
+        Can specify separate thresholds for Landsat 5 vs 8 & 9 images, where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8 & 9.
+
+        Args:
+            image (ee.Image): input image
+            threshold (float): value between -1 and 1 where pixels less than threshold will be masked, applies to landsat 5 when ng_threshold is also set.
+            ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where pixels less than threshold are masked
+
+        Returns:
+            ee.Image: ndwi image
+        """
+        ndwi_calc = image.normalizedDifference(
+            ["SR_B3", "SR_B5"]
+        )  # green-NIR / green+NIR -- full NDWI image
+        water = (
+            ndwi_calc.updateMask(ndwi_calc.gte(threshold))
+            .rename("ndwi")
+            .copyProperties(image)
+        )
+        if ng_threshold != None:
+            water = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                ndwi_calc.updateMask(ndwi_calc.gte(threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                ndwi_calc.updateMask(ndwi_calc.gte(ng_threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
+        else:
+            water = (
+                ndwi_calc.updateMask(ndwi_calc.gte(threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+            )
+        return water
+
+    @staticmethod
+    def landsat_mndwi_fn(image, threshold, ng_threshold=None):
+        """
+        Calculates Modified Normalized Difference Water Index (MNDWI) from GREEN and SWIR bands for Landsat imagery and mask image based on threshold.
+
         Can specify separate thresholds for Landsat 5 vs 8 & 9 images, where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8 & 9.
 
-        Args: 
+        Args:
             image (ee.Image): input image
             threshold (float): value between -1 and 1 where pixels less than threshold will be masked, applies to landsat 5 when ng_threshold is also set.
             ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where pixels less than threshold are masked
@@ -156,14 +249,32 @@ class LandsatCollection:
         Returns:
             ee.Image: ndwi image
         """
-        ndwi_calc = image.normalizedDifference(['SR_B3', 'SR_B5']) #green-NIR / green+NIR -- full NDWI image
-        water = ndwi_calc.updateMask(ndwi_calc.gte(threshold)).rename('ndwi').copyProperties(image) 
+        mndwi_calc = image.normalizedDifference(
+            ["SR_B3", "SR_B6"]
+        )  # green-SWIR / green+SWIR -- full NDWI image
+        water = (
+            mndwi_calc.updateMask(mndwi_calc.gte(threshold))
+            .rename("ndwi")
+            .copyProperties(image)
+        )
         if ng_threshold != None:
-            water = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      ndwi_calc.updateMask(ndwi_calc.gte(threshold)).rename('ndwi').copyProperties(image).set('threshold', threshold), \
-                                        ndwi_calc.updateMask(ndwi_calc.gte(ng_threshold)).rename('ndwi').copyProperties(image).set('threshold', ng_threshold))
+            water = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                mndwi_calc.updateMask(mndwi_calc.gte(threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                mndwi_calc.updateMask(mndwi_calc.gte(ng_threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            water = ndwi_calc.updateMask(ndwi_calc.gte(threshold)).rename('ndwi').copyProperties(image)
+            water = (
+                mndwi_calc.updateMask(mndwi_calc.gte(threshold))
+                .rename("ndwi")
+                .copyProperties(image)
+            )
         return water
 
     @staticmethod
@@ -181,20 +292,34 @@ class LandsatCollection:
         Returns:
             ee.Image: ndvi ee.Image
         """
-        ndvi_calc = image.normalizedDifference(['SR_B5', 'SR_B4']) #NIR-RED/NIR+RED -- full NDVI image
+        ndvi_calc = image.normalizedDifference(
+            ["SR_B5", "SR_B4"]
+        )  # NIR-RED/NIR+RED -- full NDVI image
         if ng_threshold != None:
-            vegetation = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      ndvi_calc.updateMask(ndvi_calc.gte(threshold)).rename('ndvi').copyProperties(image).set('threshold', threshold), \
-                                        ndvi_calc.updateMask(ndvi_calc.gte(ng_threshold)).rename('ndvi').copyProperties(image).set('threshold', ng_threshold))
+            vegetation = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                ndvi_calc.updateMask(ndvi_calc.gte(threshold))
+                .rename("ndvi")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                ndvi_calc.updateMask(ndvi_calc.gte(ng_threshold))
+                .rename("ndvi")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            vegetation = ndvi_calc.updateMask(ndvi_calc.gte(threshold)).rename('ndvi').copyProperties(image)
+            vegetation = (
+                ndvi_calc.updateMask(ndvi_calc.gte(threshold))
+                .rename("ndvi")
+                .copyProperties(image)
+            )
         return vegetation
-    
+
     @staticmethod
     def landsat_halite_fn(image, threshold, ng_threshold=None):
         """
         Calculates multispectral halite index from RED and SWIR1 bands (Radwin & Bowen, 2021 - https://onlinelibrary.wiley.com/doi/10.1002/esp.5089) for Landsat imagery and mask image based on threshold.
-        
+
         Can specify separate thresholds for Landsat 5 vs 8 & 9 images, where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8 & 9.
 
         Args:
@@ -205,20 +330,32 @@ class LandsatCollection:
         Returns:
             ee.Image: halite ee.Image
         """
-        halite_index = image.normalizedDifference(['SR_B4', 'SR_B6'])
+        halite_index = image.normalizedDifference(["SR_B4", "SR_B6"])
         if ng_threshold != None:
-            halite = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      halite_index.updateMask(halite_index.gte(threshold)).rename('halite').copyProperties(image).set('threshold', threshold), \
-                                        halite_index.updateMask(halite_index.gte(ng_threshold)).rename('halite').copyProperties(image).set('threshold', ng_threshold))
+            halite = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                halite_index.updateMask(halite_index.gte(threshold))
+                .rename("halite")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                halite_index.updateMask(halite_index.gte(ng_threshold))
+                .rename("halite")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            halite = halite_index.updateMask(halite_index.gte(threshold)).rename('halite').copyProperties(image)
-        return halite 
-      
+            halite = (
+                halite_index.updateMask(halite_index.gte(threshold))
+                .rename("halite")
+                .copyProperties(image)
+            )
+        return halite
+
     @staticmethod
     def landsat_gypsum_fn(image, threshold, ng_threshold=None):
         """
         Calculates multispectral gypsum index from SWIR1 and SWIR2 bands(Radwin & Bowen, 2024 - https://onlinelibrary.wiley.com/doi/10.1002/esp.5089) for Landsat imagery and mask image based on threshold.
-        
+
         Can specify separate thresholds for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9.
 
         Args:
@@ -229,19 +366,31 @@ class LandsatCollection:
         Returns:
             ee.Image: gypsum ee.Image
         """
-        gypsum_index = image.normalizedDifference(['SR_B6', 'SR_B7'])
+        gypsum_index = image.normalizedDifference(["SR_B6", "SR_B7"])
         if ng_threshold != None:
-            gypsum = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      gypsum_index.updateMask(gypsum_index.gte(threshold)).rename('gypsum').copyProperties(image).set('threshold', threshold), \
-                                        gypsum_index.updateMask(gypsum_index.gte(ng_threshold)).rename('gypsum').copyProperties(image).set('threshold', ng_threshold))
+            gypsum = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                gypsum_index.updateMask(gypsum_index.gte(threshold))
+                .rename("gypsum")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                gypsum_index.updateMask(gypsum_index.gte(ng_threshold))
+                .rename("gypsum")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            gypsum = gypsum_index.updateMask(gypsum_index.gte(threshold)).rename('gypsum').copyProperties(image)
+            gypsum = (
+                gypsum_index.updateMask(gypsum_index.gte(threshold))
+                .rename("gypsum")
+                .copyProperties(image)
+            )
         return gypsum
-    
+
     @staticmethod
     def landsat_ndti_fn(image, threshold, ng_threshold=None):
         """
-        Calculates turbidity of water pixels using Normalized Difference Turbidity Index (NDTI; Lacaux et al., 2007 - https://doi.org/10.1016/j.rse.2006.07.012) 
+        Calculates turbidity of water pixels using Normalized Difference Turbidity Index (NDTI; Lacaux et al., 2007 - https://doi.org/10.1016/j.rse.2006.07.012)
         and mask image based on threshold. Can specify separate thresholds for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9.
 
         Args:
@@ -252,20 +401,32 @@ class LandsatCollection:
         Returns:
             ee.Image: turbidity ee.Image
         """
-        NDTI = image.normalizedDifference(['SR_B4', 'SR_B3'])
+        NDTI = image.normalizedDifference(["SR_B4", "SR_B3"])
         if ng_threshold != None:
-            turbidity = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      NDTI.updateMask(NDTI.gte(threshold)).rename('ndti').copyProperties(image).set('threshold', threshold), \
-                                        NDTI.updateMask(NDTI.gte(ng_threshold)).rename('ndti').copyProperties(image).set('threshold', ng_threshold))
+            turbidity = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                NDTI.updateMask(NDTI.gte(threshold))
+                .rename("ndti")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                NDTI.updateMask(NDTI.gte(ng_threshold))
+                .rename("ndti")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            turbidity = NDTI.updateMask(NDTI.gte(threshold)).rename('ndti').copyProperties(image)
+            turbidity = (
+                NDTI.updateMask(NDTI.gte(threshold))
+                .rename("ndti")
+                .copyProperties(image)
+            )
         return turbidity
-    
+
     @staticmethod
     def landsat_kivu_chla_fn(image, threshold, ng_threshold=None):
         """
-        Calculates relative chlorophyll-a concentrations of water pixels using 3BDA/KIVU index 
-        (see Boucher et al., 2018 for review - https://esajournals.onlinelibrary.wiley.com/doi/10.1002/eap.1708) and mask image based on threshold. Can specify separate thresholds 
+        Calculates relative chlorophyll-a concentrations of water pixels using 3BDA/KIVU index
+        (see Boucher et al., 2018 for review - https://esajournals.onlinelibrary.wiley.com/doi/10.1002/eap.1708) and mask image based on threshold. Can specify separate thresholds
         for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 and the ng_threshold
         argument applies to Landsat 8&9.
 
@@ -277,16 +438,34 @@ class LandsatCollection:
         Returns:
             ee.Image: chlorophyll-a ee.Image
         """
-        KIVU = image.expression('(BLUE - RED) / GREEN', {'BLUE':image.select('SR_B2'), 'RED':image.select('SR_B4'), 'GREEN':image.select('SR_B3')})
+        KIVU = image.expression(
+            "(BLUE - RED) / GREEN",
+            {
+                "BLUE": image.select("SR_B2"),
+                "RED": image.select("SR_B4"),
+                "GREEN": image.select("SR_B3"),
+            },
+        )
         if ng_threshold != None:
-            chlorophyll = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      KIVU.updateMask(KIVU.gte(threshold)).rename('kivu').copyProperties(image).set('threshold', threshold), \
-                                        KIVU.updateMask(KIVU.gte(ng_threshold)).rename('kivu').copyProperties(image).set('threshold', ng_threshold))
+            chlorophyll = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                KIVU.updateMask(KIVU.gte(threshold))
+                .rename("kivu")
+                .copyProperties(image)
+                .set("threshold", threshold),
+                KIVU.updateMask(KIVU.gte(ng_threshold))
+                .rename("kivu")
+                .copyProperties(image)
+                .set("threshold", ng_threshold),
+            )
         else:
-            chlorophyll = KIVU.updateMask(KIVU.gte(threshold)).rename('kivu').copyProperties(image)
+            chlorophyll = (
+                KIVU.updateMask(KIVU.gte(threshold))
+                .rename("kivu")
+                .copyProperties(image)
+            )
         return chlorophyll
 
-
     @staticmethod
     def MaskWaterLandsat(image):
         """
@@ -299,11 +478,11 @@ class LandsatCollection:
             ee.Image: ee.Image with water pixels masked.
         """
         WaterBitMask = ee.Number(2).pow(7).int()
-        qa = image.select('QA_PIXEL')
+        qa = image.select("QA_PIXEL")
         water_extract = qa.bitwiseAnd(WaterBitMask).eq(0)
         masked_image = image.updateMask(water_extract).copyProperties(image)
         return masked_image
-    
+
     @staticmethod
     def MaskWaterLandsatByNDWI(image, threshold, ng_threshold=None):
         """
@@ -311,24 +490,36 @@ class LandsatCollection:
         all pixels less than NDWI threshold are masked out. Can specify separate thresholds for Landsat 5 vs 8&9 images, where the threshold
         argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9
 
-        Args: 
+        Args:
             image (ee.Image): input image
             threshold (float): value between -1 and 1 where NDWI pixels greater than threshold will be masked, applies to landsat 5 when ng_threshold is also set.
             ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where NDWI pixels greater than threshold are masked
-        
+
         Returns:
             ee.Image: ee.Image with water pixels masked
         """
-        ndwi_calc = image.normalizedDifference(['SR_B3', 'SR_B5']) #green-NIR / green+NIR -- full NDWI image
-        water = ndwi_calc.updateMask(ndwi_calc.gte(threshold)).rename('ndwi').copyProperties(image) 
+        ndwi_calc = image.normalizedDifference(
+            ["SR_B3", "SR_B5"]
+        )  # green-NIR / green+NIR -- full NDWI image
+        water = (
+            ndwi_calc.updateMask(ndwi_calc.gte(threshold))
+            .rename("ndwi")
+            .copyProperties(image)
+        )
         if ng_threshold != None:
-            water = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      image.updateMask(ndwi_calc.lt(threshold)).set('threshold', threshold), \
-                                        image.updateMask(ndwi_calc.lt(ng_threshold)).set('threshold', ng_threshold))
+            water = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                image.updateMask(ndwi_calc.lt(threshold)).set("threshold", threshold),
+                image.updateMask(ndwi_calc.lt(ng_threshold)).set(
+                    "threshold", ng_threshold
+                ),
+            )
         else:
-            water = image.updateMask(ndwi_calc.lt(threshold)).set('threshold', threshold)
+            water = image.updateMask(ndwi_calc.lt(threshold)).set(
+                "threshold", threshold
+            )
         return water
-    
+
     @staticmethod
     def MaskToWaterLandsat(image):
         """
@@ -341,86 +532,123 @@ class LandsatCollection:
             ee.Image: ee.Image with water pixels masked.
         """
         WaterBitMask = ee.Number(2).pow(7).int()
-        qa = image.select('QA_PIXEL')
+        qa = image.select("QA_PIXEL")
         water_extract = qa.bitwiseAnd(WaterBitMask).neq(0)
         masked_image = image.updateMask(water_extract).copyProperties(image)
         return masked_image
-    
+
     @staticmethod
     def MaskToWaterLandsatByNDWI(image, threshold, ng_threshold=None):
         """
         Masks water pixels using NDWI based on threshold. Can specify separate thresholds for Landsat 5 vs 8&9 images, where the threshold
         argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9
 
-        Args: 
+        Args:
             image (ee.Image): input image
             threshold (float): value between -1 and 1 where NDWI pixels less than threshold will be masked, applies to landsat 5 when ng_threshold is also set.
             ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where NDWI pixels less than threshold are masked
-        
+
         Returns:
             ee.Image: ee.Image with water pixels masked.
         """
-        ndwi_calc = image.normalizedDifference(['SR_B3', 'SR_B5']) #green-NIR / green+NIR -- full NDWI image
-        water = ndwi_calc.updateMask(ndwi_calc.gte(threshold)).rename('ndwi').copyProperties(image) 
+        ndwi_calc = image.normalizedDifference(
+            ["SR_B3", "SR_B5"]
+        )  # green-NIR / green+NIR -- full NDWI image
+        water = (
+            ndwi_calc.updateMask(ndwi_calc.gte(threshold))
+            .rename("ndwi")
+            .copyProperties(image)
+        )
         if ng_threshold != None:
-            water = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      image.updateMask(ndwi_calc.gte(threshold)).set('threshold', threshold), \
-                                        image.updateMask(ndwi_calc.gte(ng_threshold)).set('threshold', ng_threshold))
+            water = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                image.updateMask(ndwi_calc.gte(threshold)).set("threshold", threshold),
+                image.updateMask(ndwi_calc.gte(ng_threshold)).set(
+                    "threshold", ng_threshold
+                ),
+            )
         else:
-            water = image.updateMask(ndwi_calc.gte(threshold)).set('threshold', threshold)
+            water = image.updateMask(ndwi_calc.gte(threshold)).set(
+                "threshold", threshold
+            )
         return water
 
     @staticmethod
     def halite_mask(image, threshold, ng_threshold=None):
         """
-        Masks halite pixels after specifying index to isolate/mask-to halite pixels. 
-        
+        Masks halite pixels after specifying index to isolate/mask-to halite pixels.
+
         Can specify separate thresholds for Landsat 5 vs 8&9 images where the threshold
         argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9.
 
         Args:
             image (ee.Image): input ee.Image
             threshold (float): value between -1 and 1 where pixels less than threshold will be masked, applies to landsat 5 when ng_threshold is also set.
-            ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where pixels less than threshold are masked 
+            ng_threshold (float, optional): integer threshold to be applied to landsat 8 or 9 where pixels less than threshold are masked
 
         Returns:
             image (ee.Image): masked ee.Image
         """
-        halite_index = image.normalizedDifference(['SR_B4', 'SR_B6']) # red-swir1 / red+swir1
+        halite_index = image.normalizedDifference(
+            ["SR_B4", "SR_B6"]
+        )  # red-swir1 / red+swir1
         if ng_threshold != None:
-            mask = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      image.updateMask(halite_index.lt(threshold)).copyProperties(image), \
-                                        image.updateMask(halite_index.lt(ng_threshold)).copyProperties(image)) 
+            mask = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                image.updateMask(halite_index.lt(threshold)).copyProperties(image),
+                image.updateMask(halite_index.lt(ng_threshold)).copyProperties(image),
+            )
         else:
             mask = image.updateMask(halite_index.lt(threshold)).copyProperties(image)
-        return mask 
-    
+        return mask
+
     @staticmethod
-    def gypsum_and_halite_mask(image, halite_threshold, gypsum_threshold, halite_ng_threshold=None, gypsum_ng_threshold=None):
+    def gypsum_and_halite_mask(
+        image,
+        halite_threshold,
+        gypsum_threshold,
+        halite_ng_threshold=None,
+        gypsum_ng_threshold=None,
+    ):
         """
-        Masks both gypsum and halite pixels. Must specify threshold for isolating halite and gypsum pixels. 
-        
-        Can specify separate thresholds for Landsat 5 vs 8&9 images where the threshold argument applies to Landsat 5 
+        Masks both gypsum and halite pixels. Must specify threshold for isolating halite and gypsum pixels.
+
+        Can specify separate thresholds for Landsat 5 vs 8&9 images where the threshold argument applies to Landsat 5
         and the ng_threshold argument applies to Landsat 8&9.
 
         Args:
             image (ee.Image): input ee.Image
             halite_threshold (float): integer threshold for halite where pixels less than threshold are masked, applies to landsat 5 when ng_threshold is also set.
             gypsum_threshold (float): integer threshold for gypsum where pixels less than threshold are masked, applies to landsat 5 when ng_threshold is also set.
-            halite_ng_threshold (float, optional): integer threshold for halite to be applied to landsat 8 or 9 where pixels less than threshold are masked 
-            gypsum_ng_threshold (float, optional): integer threshold for gypsum to be applied to landsat 8 or 9 where pixels less than threshold are masked 
+            halite_ng_threshold (float, optional): integer threshold for halite to be applied to landsat 8 or 9 where pixels less than threshold are masked
+            gypsum_ng_threshold (float, optional): integer threshold for gypsum to be applied to landsat 8 or 9 where pixels less than threshold are masked
 
         Returns:
             image (ee.Image): masked ee.Image
         """
-        halite_index = image.normalizedDifference(['SR_B4', 'SR_B6']) # red-swir1 / red+swir1
-        gypsum_index = image.normalizedDifference(['SR_B6', 'SR_B7'])
+        halite_index = image.normalizedDifference(
+            ["SR_B4", "SR_B6"]
+        )  # red-swir1 / red+swir1
+        gypsum_index = image.normalizedDifference(["SR_B6", "SR_B7"])
         if halite_ng_threshold and gypsum_ng_threshold != None:
-            mask = ee.Algorithms.If(ee.String(image.get('SPACECRAFT_ID')).equals('LANDSAT_5'), \
-                                      gypsum_index.updateMask(halite_index.lt(halite_threshold)).updateMask(gypsum_index.lt(gypsum_threshold)).rename('carbonate_muds').copyProperties(image), \
-                                        gypsum_index.updateMask(halite_index.lt(halite_ng_threshold)).updateMask(gypsum_index.lt(gypsum_ng_threshold)).rename('carbonate_muds').copyProperties(image))
+            mask = ee.Algorithms.If(
+                ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
+                gypsum_index.updateMask(halite_index.lt(halite_threshold))
+                .updateMask(gypsum_index.lt(gypsum_threshold))
+                .rename("carbonate_muds")
+                .copyProperties(image),
+                gypsum_index.updateMask(halite_index.lt(halite_ng_threshold))
+                .updateMask(gypsum_index.lt(gypsum_ng_threshold))
+                .rename("carbonate_muds")
+                .copyProperties(image),
+            )
         else:
-            mask = gypsum_index.updateMask(halite_index.lt(halite_threshold)).updateMask(gypsum_index.lt(gypsum_threshold)).rename('carbonate_muds').copyProperties(image)
+            mask = (
+                gypsum_index.updateMask(halite_index.lt(halite_threshold))
+                .updateMask(gypsum_index.lt(gypsum_threshold))
+                .rename("carbonate_muds")
+                .copyProperties(image)
+            )
         return mask
 
     @staticmethod
@@ -436,11 +664,11 @@ class LandsatCollection:
         """
         cloudBitMask = ee.Number(2).pow(3).int()
         CirrusBitMask = ee.Number(2).pow(2).int()
-        qa = image.select('QA_PIXEL')
+        qa = image.select("QA_PIXEL")
         cloud_mask = qa.bitwiseAnd(cloudBitMask).eq(0)
         cirrus_mask = qa.bitwiseAnd(CirrusBitMask).eq(0)
         return image.updateMask(cloud_mask).updateMask(cirrus_mask)
-    
+
     @staticmethod
     def temperature_bands(img):
         """
@@ -452,44 +680,53 @@ class LandsatCollection:
         Returns:
             ee.Image: ee.Image
         """
-        #date = ee.Number(img.date().format('YYYY-MM-dd'))
-        scale1 = ['ST_ATRAN', 'ST_EMIS']
-        scale2 = ['ST_DRAD', 'ST_TRAD', 'ST_URAD']
-        scale1_names = ['transmittance', 'emissivity']
-        scale2_names = ['downwelling', 'B10_radiance', 'upwelling']
-        scale1_bands = img.select(scale1).multiply(0.0001).rename(scale1_names) #Scaled to new L8 collection
-        scale2_bands = img.select(scale2).multiply(0.001).rename(scale2_names) #Scaled to new L8 collection
+        # date = ee.Number(img.date().format('YYYY-MM-dd'))
+        scale1 = ["ST_ATRAN", "ST_EMIS"]
+        scale2 = ["ST_DRAD", "ST_TRAD", "ST_URAD"]
+        scale1_names = ["transmittance", "emissivity"]
+        scale2_names = ["downwelling", "B10_radiance", "upwelling"]
+        scale1_bands = (
+            img.select(scale1).multiply(0.0001).rename(scale1_names)
+        )  # Scaled to new L8 collection
+        scale2_bands = (
+            img.select(scale2).multiply(0.001).rename(scale2_names)
+        )  # Scaled to new L8 collection
         return img.addBands(scale1_bands).addBands(scale2_bands).copyProperties(img)
-    
+
     @staticmethod
     def landsat_LST(image):
         """
-        Calculates land surface temperature (LST) from landsat TIR bands. 
+        Calculates land surface temperature (LST) from landsat TIR bands.
         Based on Sekertekin, A., & Bonafoni, S. (2020) https://doi.org/10.3390/rs12020294
 
         Args:
             image (ee.Image): input ee.Image
 
         Returns:
-            ee.Image: LST ee.Image 
+            ee.Image: LST ee.Image
         """
         # Based on Sekertekin, A., & Bonafoni, S. (2020) https://doi.org/10.3390/rs12020294
-        
+
         k1 = 774.89
         k2 = 1321.08
         LST = image.expression(
-            '(k2/log((k1/((B10_rad - upwelling - transmittance*(1 - emissivity)*downwelling)/(transmittance*emissivity)))+1)) - 273.15',
-            {'k1': k1,
-            'k2': k2,
-            'B10_rad': image.select('B10_radiance'),
-            'upwelling': image.select('upwelling'),
-            'transmittance': image.select('transmittance'),
-            'emissivity': image.select('emissivity'),
-            'downwelling': image.select('downwelling')}).rename('LST')
-        return image.addBands(LST).copyProperties(image) #Outputs temperature in C
-    
+            "(k2/log((k1/((B10_rad - upwelling - transmittance*(1 - emissivity)*downwelling)/(transmittance*emissivity)))+1)) - 273.15",
+            {
+                "k1": k1,
+                "k2": k2,
+                "B10_rad": image.select("B10_radiance"),
+                "upwelling": image.select("upwelling"),
+                "transmittance": image.select("transmittance"),
+                "emissivity": image.select("emissivity"),
+                "downwelling": image.select("downwelling"),
+            },
+        ).rename("LST")
+        return image.addBands(LST).copyProperties(image)  # Outputs temperature in C
+
     @staticmethod
-    def PixelAreaSum(image, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12):
+    def PixelAreaSum(
+        image, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12
+    ):
         """
         Calculates the summation of area for pixels of interest (above a specific threshold) in a geometry
         and store the value as image property (matching name of chosen band).
@@ -501,27 +738,35 @@ class LandsatCollection:
             threshold (float): integer threshold to specify masking of pixels below threshold (defaults to -1)
             scale (int): integer scale of image resolution (meters) (defaults to 30)
             maxPixels (int): integer denoting maximum number of pixels for calculations
-        
+
         Returns:
             ee.Image: ee.Image with area calculation stored as property matching name of band
         """
         area_image = ee.Image.pixelArea()
         mask = image.select(band_name).gte(threshold)
         final = image.addBands(area_image)
-        stats = final.select('area').updateMask(mask).rename(band_name).reduceRegion(
-            reducer = ee.Reducer.sum(),
-            geometry= geometry,
-            scale=scale,
-            maxPixels = maxPixels)
+        stats = (
+            final.select("area")
+            .updateMask(mask)
+            .rename(band_name)
+            .reduceRegion(
+                reducer=ee.Reducer.sum(),
+                geometry=geometry,
+                scale=scale,
+                maxPixels=maxPixels,
+            )
+        )
         return image.set(band_name, stats.get(band_name))
-    
-    def PixelAreaSumCollection(self, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12):
+
+    def PixelAreaSumCollection(
+        self, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12
+    ):
         """
-        Calculates the summation of area for pixels of interest (above a specific threshold) 
+        Calculates the summation of area for pixels of interest (above a specific threshold)
         within a geometry and store the value as image property (matching name of chosen band) for an entire
         image collection.
 
-        The resulting value has units of square meters. 
+        The resulting value has units of square meters.
 
         Args:
             band_name (string): name of band (string) for calculating area
@@ -529,18 +774,27 @@ class LandsatCollection:
             threshold (float): integer threshold to specify masking of pixels below threshold (defaults to -1)
             scale (int): integer scale of image resolution (meters) (defaults to 30)
             maxPixels (int): integer denoting maximum number of pixels for calculations
-        
+
         Returns:
             ee.ImageCollection: Image with area calculation stored as property matching name of band.
         """
         if self._PixelAreaSumCollection is None:
             collection = self.collection
-            AreaCollection = collection.map(lambda image: LandsatCollection.PixelAreaSum(image, band_name=band_name, geometry=geometry, threshold=threshold, scale=scale, maxPixels=maxPixels))
+            AreaCollection = collection.map(
+                lambda image: LandsatCollection.PixelAreaSum(
+                    image,
+                    band_name=band_name,
+                    geometry=geometry,
+                    threshold=threshold,
+                    scale=scale,
+                    maxPixels=maxPixels,
+                )
+            )
             self._PixelAreaSumCollection = AreaCollection
         return self._PixelAreaSumCollection
 
     @staticmethod
-    def dNDWIPixelAreaSum(image, geometry, band_name='ndwi', scale=30, maxPixels=1e12):
+    def dNDWIPixelAreaSum(image, geometry, band_name="ndwi", scale=30, maxPixels=1e12):
         """
         Dynamically calulates the summation of area for water pixels of interest and store the value as image property named 'ndwi'
         Uses Otsu thresholding to dynamically choose the best threshold rather than needing to specify threshold.
@@ -556,9 +810,10 @@ class LandsatCollection:
         Returns:
             ee.Image: ee.Image with area calculation stored as property matching name of band
         """
+
         def OtsuThreshold(histogram):
-            counts = ee.Array(ee.Dictionary(histogram).get('histogram'))
-            means = ee.Array(ee.Dictionary(histogram).get('bucketMeans'))
+            counts = ee.Array(ee.Dictionary(histogram).get("histogram"))
+            means = ee.Array(ee.Dictionary(histogram).get("bucketMeans"))
             size = means.length().get([0])
             total = counts.reduce(ee.Reducer.sum(), [0]).get([0])
             sum = means.multiply(counts).reduce(ee.Reducer.sum(), [0]).get([0])
@@ -578,27 +833,35 @@ class LandsatCollection:
                 bCount = total.subtract(aCount)
                 bMean = sum.subtract(aCount.multiply(aMean)).divide(bCount)
                 return aCount.multiply(aMean.subtract(mean).pow(2)).add(
-                    bCount.multiply(bMean.subtract(mean).pow(2)))
+                    bCount.multiply(bMean.subtract(mean).pow(2))
+                )
 
             bss = indices.map(func_xxx)
             return means.sort(bss).get([-1])
 
         area_image = ee.Image.pixelArea()
         histogram = image.select(band_name).reduceRegion(
-            reducer = ee.Reducer.histogram(255, 2),
-            geometry = geometry.geometry().buffer(6000),
-            scale = scale,
-            bestEffort= True,)
+            reducer=ee.Reducer.histogram(255, 2),
+            geometry=geometry.geometry().buffer(6000),
+            scale=scale,
+            bestEffort=True,
+        )
         threshold = OtsuThreshold(histogram.get(band_name)).add(0.15)
         mask = image.select(band_name).gte(threshold)
         final = image.addBands(area_image)
-        stats = final.select('area').updateMask(mask).rename(band_name).reduceRegion(
-            reducer = ee.Reducer.sum(),
-            geometry= geometry,
-            scale=scale,
-            maxPixels = maxPixels)
+        stats = (
+            final.select("area")
+            .updateMask(mask)
+            .rename(band_name)
+            .reduceRegion(
+                reducer=ee.Reducer.sum(),
+                geometry=geometry,
+                scale=scale,
+                maxPixels=maxPixels,
+            )
+        )
         return image.set(band_name, stats.get(band_name))
-    
+
     @property
     def dates_list(self):
         """
@@ -608,7 +871,7 @@ class LandsatCollection:
             ee.List: Server-side ee.List of dates.
         """
         if self._dates_list is None:
-            dates = self.collection.aggregate_array('Date_Filter')
+            dates = self.collection.aggregate_array("Date_Filter")
             self._dates_list = dates
         return self._dates_list
 
@@ -621,7 +884,7 @@ class LandsatCollection:
             list: list of date strings.
         """
         if self._dates_list is None:
-            dates = self.collection.aggregate_array('Date_Filter')
+            dates = self.collection.aggregate_array("Date_Filter")
             self._dates_list = dates
         if self._dates is None:
             dates = self._dates_list.getInfo()
@@ -637,11 +900,25 @@ class LandsatCollection:
         """
         landsat8 = ee.ImageCollection("LANDSAT/LC08/C02/T1_L2")
         landsat9 = ee.ImageCollection("LANDSAT/LC09/C02/T1_L2")
-        landsat5 = ee.ImageCollection("LANDSAT/LT05/C02/T1_L2").map(LandsatCollection.landsat5bandrename)  # Replace with the correct Landsat 5 collection ID
-        filtered_collection = landsat8.merge(landsat9).merge(landsat5).filterDate(self.start_date, self.end_date).filter(ee.Filter.And(ee.Filter.inList('WRS_PATH', self.tile_path),
-                                ee.Filter.inList('WRS_ROW', self.tile_row))).filter(ee.Filter.lte('CLOUD_COVER', self.cloud_percentage_threshold)).map(LandsatCollection.image_dater).sort('Date_Filter')
+        landsat5 = ee.ImageCollection("LANDSAT/LT05/C02/T1_L2").map(
+            LandsatCollection.landsat5bandrename
+        )  # Replace with the correct Landsat 5 collection ID
+        filtered_collection = (
+            landsat8.merge(landsat9)
+            .merge(landsat5)
+            .filterDate(self.start_date, self.end_date)
+            .filter(
+                ee.Filter.And(
+                    ee.Filter.inList("WRS_PATH", self.tile_path),
+                    ee.Filter.inList("WRS_ROW", self.tile_row),
+                )
+            )
+            .filter(ee.Filter.lte("CLOUD_COVER", self.cloud_percentage_threshold))
+            .map(LandsatCollection.image_dater)
+            .sort("Date_Filter")
+        )
         return filtered_collection
-    
+
     def get_boundary_filtered_collection(self):
         """
         Filters and masks image collection based on LandsatCollection class arguments. Automatically calculated when using collection method, depending on provided class arguments (when boundary info is provided).
@@ -652,10 +929,33 @@ class LandsatCollection:
         """
         landsat8 = ee.ImageCollection("LANDSAT/LC08/C02/T1_L2")
         landsat9 = ee.ImageCollection("LANDSAT/LC09/C02/T1_L2")
-        landsat5 = ee.ImageCollection("LANDSAT/LT05/C02/T1_L2").map(LandsatCollection.landsat5bandrename)  # Replace with the correct Landsat 5 collection ID
-        filtered_collection = landsat8.merge(landsat9).merge(landsat5).filterDate(self.start_date, self.end_date).filterBounds(self.boundary).filter(ee.Filter.lte('CLOUD_COVER', self.cloud_percentage_threshold)).map(LandsatCollection.image_dater).sort('Date_Filter')
+        landsat5 = ee.ImageCollection("LANDSAT/LT05/C02/T1_L2").map(
+            LandsatCollection.landsat5bandrename
+        )  # Replace with the correct Landsat 5 collection ID
+        filtered_collection = (
+            landsat8.merge(landsat9)
+            .merge(landsat5)
+            .filterDate(self.start_date, self.end_date)
+            .filterBounds(self.boundary)
+            .filter(ee.Filter.lte("CLOUD_COVER", self.cloud_percentage_threshold))
+            .map(LandsatCollection.image_dater)
+            .sort("Date_Filter")
+        )
         return filtered_collection
     
+    @property
+    def scale_to_reflectance(self):
+        """
+        Scales each band in the Landsat collection from DN values to surface reflectance values.
+
+        Returns:
+            LandsatCollection: A new LandsatCollection object with bands scaled to reflectance.
+        """
+        if self._Reflectance is None:
+            self._Reflectance = self.collection.map(_scale_landsat_sr)
+        return LandsatCollection(collection=self._Reflectance)
+
+
     @property
     def median(self):
         """
@@ -668,7 +968,7 @@ class LandsatCollection:
             col = self.collection.median()
             self._median = col
         return self._median
-    
+
     @property
     def mean(self):
         """
@@ -682,7 +982,7 @@ class LandsatCollection:
             col = self.collection.mean()
             self._mean = col
         return self._mean
-    
+
     @property
     def max(self):
         """
@@ -695,7 +995,7 @@ class LandsatCollection:
             col = self.collection.max()
             self._max = col
         return self._max
-    
+
     @property
     def min(self):
         """
@@ -708,28 +1008,43 @@ class LandsatCollection:
             col = self.collection.min()
             self._min = col
         return self._min
-    
+
     @property
     def ndwi(self):
         """
-        Property attribute to calculate and access the NDWI (Normalized Difference Water Index) imagery of the LandsatCollection. 
-        This property initiates the calculation of NDWI using a default threshold of -1 (or a previously set threshold of self.ndwi_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the NDWI (Normalized Difference Water Index) imagery of the LandsatCollection.
+        This property initiates the calculation of NDWI using a default threshold of -1 (or a previously set threshold of self.ndwi_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._ndwi is None:
             self._ndwi = self.ndwi_collection(self.ndwi_threshold)
         return self._ndwi
 
+    @property
+    def mndwi(self):
+        """
+        Property attribute to calculate and access the MNDWI (Modified Normalized Difference Water Index) imagery of the LandsatCollection.
+        This property initiates the calculation of MNDWI using a default threshold of -1 (or a previously set threshold of self.mndwi_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
+        on subsequent accesses.
+
+        Returns:
+            LandsatCollection: A LandsatCollection image collection
+        """
+        if self._mndwi is None:
+            self._mndwi = self.mndwi_collection(self.mndwi_threshold)
+        return self._mndwi
+
     def ndwi_collection(self, threshold, ng_threshold=None):
         """
         Calculates ndwi and returns collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
-        by default when using the ndwi property attribute. 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
+        by default when using the ndwi property attribute.
 
         Args:
             threshold (float): specify threshold for NDWI function (values less than threshold are masked)
@@ -740,23 +1055,54 @@ class LandsatCollection:
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
 
-        if available_bands.contains('SR_B3') and available_bands.contains('SR_B5'):
+        if available_bands.contains("SR_B3") and available_bands.contains("SR_B5"):
             pass
         else:
             raise ValueError("Insufficient Bands for ndwi calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_ndwi_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_ndwi_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
     
+    def mndwi_collection(self, threshold, ng_threshold=None):
+        """
+        Calculates mndwi and returns collection as class object, allows specifying threshold(s) for masking.
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
+        by default when using the mndwi property attribute.
+
+        Args:
+            threshold (float): specify threshold for MNDWI function (values less than threshold are masked)
+
+        Returns:
+            LandsatCollection: A LandsatCollection image collection
+        """
+        first_image = self.collection.first()
+        available_bands = first_image.bandNames()
+
+        if available_bands.contains("SR_B3") and available_bands.contains("SR_B6"):
+            pass
+        else:
+            raise ValueError("Insufficient bands for mndwi calculation")
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_mndwi_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
+        return LandsatCollection(collection=col)
+
     @property
     def ndvi(self):
         """
-        Property attribute to calculate and access the NDVI (Normalized Difference Vegetation Index) imagery of the LandsatCollection. 
-        This property initiates the calculation of NDVI using a default threshold of -1 (or a previously set threshold of self.ndvi_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the NDVI (Normalized Difference Vegetation Index) imagery of the LandsatCollection.
+        This property initiates the calculation of NDVI using a default threshold of -1 (or a previously set threshold of self.ndvi_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._ndvi is None:
             self._ndvi = self.ndvi_collection(self.ndvi_threshold)
@@ -765,35 +1111,39 @@ class LandsatCollection:
     def ndvi_collection(self, threshold, ng_threshold=None):
         """
         Function to calculate the NDVI (Normalized Difference Vegetation Index) and return collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
         by default when using the ndwi property attribute.
 
         Args:
             threshold (float): specify threshold for NDVI function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('SR_B4') and available_bands.contains('SR_B5'):
+        if available_bands.contains("SR_B4") and available_bands.contains("SR_B5"):
             pass
         else:
             raise ValueError("Insufficient Bands for ndwi calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_ndvi_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_ndvi_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
 
     @property
     def halite(self):
         """
-        Property attribute to calculate and access the halite index (see Radwin & Bowen, 2021) imagery of the LandsatCollection. 
-        This property initiates the calculation of halite using a default threshold of -1 (or a previously set threshold of self.halite_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the halite index (see Radwin & Bowen, 2021) imagery of the LandsatCollection.
+        This property initiates the calculation of halite using a default threshold of -1 (or a previously set threshold of self.halite_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._halite is None:
             self._halite = self.halite_collection(self.halite_threshold)
@@ -802,8 +1152,8 @@ class LandsatCollection:
     def halite_collection(self, threshold, ng_threshold=None):
         """
         Function to calculate the halite index (see Radwin & Bowen, 2021) and return collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
         by default when using the ndwi property attribute.
 
         Args:
@@ -811,27 +1161,31 @@ class LandsatCollection:
             ng_threshold (float, optional): specify threshold for Landsat 8&9 halite function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('SR_B4') and available_bands.contains('SR_B6'):
+        if available_bands.contains("SR_B4") and available_bands.contains("SR_B6"):
             pass
         else:
             raise ValueError("Insufficient Bands for halite calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_halite_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_halite_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
 
     @property
     def gypsum(self):
         """
-        Property attribute to calculate and access the gypsum/sulfate index (see Radwin & Bowen, 2021) imagery of the LandsatCollection. 
-        This property initiates the calculation of gypsum using a default threshold of -1 (or a previously set threshold of self.gypsum_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the gypsum/sulfate index (see Radwin & Bowen, 2021) imagery of the LandsatCollection.
+        This property initiates the calculation of gypsum using a default threshold of -1 (or a previously set threshold of self.gypsum_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._gypsum is None:
             self._gypsum = self.gypsum_collection(self.gypsum_threshold)
@@ -840,8 +1194,8 @@ class LandsatCollection:
     def gypsum_collection(self, threshold, ng_threshold=None):
         """
         Function to calculate the gypsum index (see Radwin & Bowen, 2021) and return collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
         by default when using the ndwi property attribute.
 
         Args:
@@ -849,27 +1203,31 @@ class LandsatCollection:
             ng_threshold (float, optional): specify threshold for Landsat 8&9 gypsum function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('SR_B6') and available_bands.contains('SR_B7'):
+        if available_bands.contains("SR_B6") and available_bands.contains("SR_B7"):
             pass
         else:
             raise ValueError("Insufficient Bands for gypsum calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_gypsum_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_gypsum_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
-    
+
     @property
     def turbidity(self):
         """
-        Property attribute to calculate and access the turbidity (NDTI) imagery of the LandsatCollection. 
-        This property initiates the calculation of turbidity using a default threshold of -1 (or a previously set threshold of self.turbidity_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the turbidity (NDTI) imagery of the LandsatCollection.
+        This property initiates the calculation of turbidity using a default threshold of -1 (or a previously set threshold of self.turbidity_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._turbidity is None:
             self._turbidity = self.turbidity_collection(self.turbidity_threshold)
@@ -878,8 +1236,8 @@ class LandsatCollection:
     def turbidity_collection(self, threshold, ng_threshold=None):
         """
         Calculates the turbidity (NDTI) index and return collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
         by default when using the ndwi property attribute.
 
         Args:
@@ -887,28 +1245,32 @@ class LandsatCollection:
             ng_threshold (float, optional): specify threshold for Landsat 8&9 turbidity function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('SR_B4') and available_bands.contains('SR_B3'):
+        if available_bands.contains("SR_B4") and available_bands.contains("SR_B3"):
             pass
         else:
             raise ValueError("Insufficient Bands for turbidity calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_ndti_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_ndti_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
 
         return LandsatCollection(collection=col)
-    
+
     @property
     def chlorophyll(self):
         """
-        Property attribute to calculate and access the chlorophyll (NDTI) imagery of the LandsatCollection. 
-        This property initiates the calculation of chlorophyll using a default threshold of -1 (or a previously set threshold of self.chlorophyll_threshold) 
-        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned 
+        Property attribute to calculate and access the chlorophyll (NDTI) imagery of the LandsatCollection.
+        This property initiates the calculation of chlorophyll using a default threshold of -1 (or a previously set threshold of self.chlorophyll_threshold)
+        and caches the result. The calculation is performed only once when the property is first accessed, and the cached result is returned
         on subsequent accesses.
 
         Returns:
-            LandsatCollection: A LandsatCollection image collection 
+            LandsatCollection: A LandsatCollection image collection
         """
         if self._chlorophyll is None:
             self._chlorophyll = self.chlorophyll_collection(self.chlorophyll_threshold)
@@ -917,8 +1279,8 @@ class LandsatCollection:
     def chlorophyll_collection(self, threshold, ng_threshold=None):
         """
         Calculates the KIVU chlorophyll index and return collection as class object, allows specifying threshold(s) for masking.
-        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5 
-        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called 
+        Thresholds can be specified for Landsat 5 vs 8&9 images, where the threshold argument applies to Landsat 5
+        and the ng_threshold argument applies to Landsat 8&9. This function can be called as a method but is called
         by default when using the ndwi property attribute.
 
         Args:
@@ -930,26 +1292,34 @@ class LandsatCollection:
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('SR_B4') and available_bands.contains('SR_B3') and available_bands.contains('SR_B2'):
+        if (
+            available_bands.contains("SR_B4")
+            and available_bands.contains("SR_B3")
+            and available_bands.contains("SR_B2")
+        ):
             pass
         else:
             raise ValueError("Insufficient Bands for chlorophyll calculation")
-        col = self.collection.map(lambda image: LandsatCollection.landsat_kivu_chla_fn(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.landsat_kivu_chla_fn(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
-    
+
     @property
     def masked_water_collection(self):
         """
         Property attribute to mask water and return collection as class object.
 
         Returns:
-            LandsatCollection: LandsatCollection image collection 
+            LandsatCollection: LandsatCollection image collection
         """
         if self._masked_water_collection is None:
             col = self.collection.map(LandsatCollection.MaskWaterLandsat)
             self._masked_water_collection = LandsatCollection(collection=col)
         return self._masked_water_collection
-    
+
     def masked_water_collection_NDWI(self, threshold):
         """
         Masks water pixels based on NDWI and user set threshold.
@@ -958,11 +1328,15 @@ class LandsatCollection:
             threshold (float): specify threshold for NDWI function (values greater than threshold are masked)
 
         Returns:
-            LandsatCollection: LandsatCollection image collection 
+            LandsatCollection: LandsatCollection image collection
         """
-        col = self.collection.map(lambda image: LandsatCollection.MaskWaterLandsatByNDWI(image, threshold=threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.MaskWaterLandsatByNDWI(
+                image, threshold=threshold
+            )
+        )
         return LandsatCollection(collection=col)
-    
+
     @property
     def masked_to_water_collection(self):
         """
@@ -975,7 +1349,7 @@ class LandsatCollection:
             col = self.collection.map(LandsatCollection.MaskToWaterLandsat)
             self._masked_to_water_collection = LandsatCollection(collection=col)
         return self._masked_to_water_collection
-    
+
     def masked_to_water_collection_NDWI(self, threshold):
         """
         Function to mask all but water pixels based on NDWI and user set threshold.
@@ -984,29 +1358,33 @@ class LandsatCollection:
             threshold (float): specify threshold for NDWI function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: LandsatCollection image collection 
+            LandsatCollection: LandsatCollection image collection
         """
-        col = self.collection.map(lambda image: LandsatCollection.MaskToWaterLandsatByNDWI(image, threshold=threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.MaskToWaterLandsatByNDWI(
+                image, threshold=threshold
+            )
+        )
         return LandsatCollection(collection=col)
-    
+
     @property
     def masked_clouds_collection(self):
         """
         Property attribute to mask clouds and return collection as class object.
 
         Returns:
-            LandsatCollection: LandsatCollection image collection 
+            LandsatCollection: LandsatCollection image collection
         """
         if self._masked_clouds_collection is None:
             col = self.collection.map(LandsatCollection.maskL8clouds)
             self._masked_clouds_collection = LandsatCollection(collection=col)
         return self._masked_clouds_collection
-    
+
     @property
     def LST(self):
         """
-        Property attribute to calculate and access the LST (Land Surface Temperature - in Celcius) imagery of the LandsatCollection. 
-        This property initiates the calculation of LST and caches the result. The calculation is performed only once 
+        Property attribute to calculate and access the LST (Land Surface Temperature - in Celcius) imagery of the LandsatCollection.
+        This property initiates the calculation of LST and caches the result. The calculation is performed only once
         when the property is first accessed, and the cached result is returned on subsequent accesses.
 
         Returns:
@@ -1015,7 +1393,7 @@ class LandsatCollection:
         if self._LST is None:
             self._LST = self.surface_temperature_collection()
         return self._LST
-    
+
     def surface_temperature_collection(self):
         """
         Function to calculate LST (Land Surface Temperature - in Celcius) and return collection as class object.
@@ -1025,13 +1403,23 @@ class LandsatCollection:
         """
         first_image = self.collection.first()
         available_bands = first_image.bandNames()
-        if available_bands.contains('ST_ATRAN') and available_bands.contains('ST_EMIS') and available_bands.contains('ST_DRAD') and available_bands.contains('ST_TRAD') and available_bands.contains('ST_URAD') :
+        if (
+            available_bands.contains("ST_ATRAN")
+            and available_bands.contains("ST_EMIS")
+            and available_bands.contains("ST_DRAD")
+            and available_bands.contains("ST_TRAD")
+            and available_bands.contains("ST_URAD")
+        ):
             pass
         else:
             raise ValueError("Insufficient Bands for temperature calculation")
-        col = self.collection.map(LandsatCollection.temperature_bands).map(LandsatCollection.landsat_LST).map(LandsatCollection.image_dater)
+        col = (
+            self.collection.map(LandsatCollection.temperature_bands)
+            .map(LandsatCollection.landsat_LST)
+            .map(LandsatCollection.image_dater)
+        )
         return LandsatCollection(collection=col)
-    
+
     def mask_to_polygon(self, polygon):
         """
         Function to mask LandsatCollection image collection by a polygon (ee.Geometry), where pixels outside the polygon are masked out.
@@ -1041,21 +1429,23 @@ class LandsatCollection:
 
         Returns:
             LandsatCollection: masked LandsatCollection image collection
-        
+
         """
         if self._geometry_masked_collection is None:
             # Convert the polygon to a mask
             mask = ee.Image.constant(1).clip(polygon)
-            
+
             # Update the mask of each image in the collection
             masked_collection = self.collection.map(lambda img: img.updateMask(mask))
-            
+
             # Update the internal collection state
-            self._geometry_masked_collection = LandsatCollection(collection=masked_collection)
-        
+            self._geometry_masked_collection = LandsatCollection(
+                collection=masked_collection
+            )
+
         # Return the updated object
         return self._geometry_masked_collection
-    
+
     def mask_out_polygon(self, polygon):
         """
         Function to mask LandsatCollection image collection by a polygon (ee.Geometry), where pixels inside the polygon are masked out.
@@ -1065,7 +1455,7 @@ class LandsatCollection:
 
         Returns:
             LandsatCollection: masked LandsatCollection image collection
-        
+
         """
         if self._geometry_masked_out_collection is None:
             # Convert the polygon to a mask
@@ -1073,19 +1463,21 @@ class LandsatCollection:
 
             # Use paint to set pixels inside polygon as 0
             area = full_mask.paint(polygon, 0)
-            
+
             # Update the mask of each image in the collection
             masked_collection = self.collection.map(lambda img: img.updateMask(area))
-            
+
             # Update the internal collection state
-            self._geometry_masked_out_collection = LandsatCollection(collection=masked_collection)
-        
+            self._geometry_masked_out_collection = LandsatCollection(
+                collection=masked_collection
+            )
+
         # Return the updated object
         return self._geometry_masked_out_collection
 
     def mask_halite(self, threshold, ng_threshold=None):
         """
-        Masks halite and returns collection as class object. Can specify separate thresholds for Landsat 5 vs 8&9 images 
+        Masks halite and returns collection as class object. Can specify separate thresholds for Landsat 5 vs 8&9 images
         where the threshold argument applies to Landsat 5 and the ng_threshold argument applies to Landsat 8&9.
 
         Args:
@@ -1095,12 +1487,22 @@ class LandsatCollection:
         Returns:
             LandsatCollection: LandsatCollection image collection
         """
-        col = self.collection.map(lambda image: LandsatCollection.halite_mask(image, threshold=threshold, ng_threshold=ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.halite_mask(
+                image, threshold=threshold, ng_threshold=ng_threshold
+            )
+        )
         return LandsatCollection(collection=col)
-    
-    def mask_halite_and_gypsum(self, halite_threshold, gypsum_threshold, halite_ng_threshold=None, gypsum_ng_threshold=None):
+
+    def mask_halite_and_gypsum(
+        self,
+        halite_threshold,
+        gypsum_threshold,
+        halite_ng_threshold=None,
+        gypsum_ng_threshold=None,
+    ):
         """
-        Masks halite and gypsum and returns collection as class object. 
+        Masks halite and gypsum and returns collection as class object.
         Can specify separate thresholds for Landsat 5 vs 8&9 images where the threshold argument applies to Landsat 5
         and the ng_threshold argument applies to Landsat 8&9.
 
@@ -1111,9 +1513,48 @@ class LandsatCollection:
             gypsum_ng_threshold (float, optional): specify threshold for Landsat 8&9 gypsum function (values less than threshold are masked)
 
         Returns:
-            LandsatCollection: LandsatCollection image collection 
+            LandsatCollection: LandsatCollection image collection
         """
-        col = self.collection.map(lambda image: LandsatCollection.gypsum_and_halite_mask(image, halite_threshold=halite_threshold, gypsum_threshold=gypsum_threshold, halite_ng_threshold=halite_ng_threshold, gypsum_ng_threshold=gypsum_ng_threshold))
+        col = self.collection.map(
+            lambda image: LandsatCollection.gypsum_and_halite_mask(
+                image,
+                halite_threshold=halite_threshold,
+                gypsum_threshold=gypsum_threshold,
+                halite_ng_threshold=halite_ng_threshold,
+                gypsum_ng_threshold=gypsum_ng_threshold,
+            )
+        )
+        return LandsatCollection(collection=col)
+    
+    def binary_mask(self, threshold=None, band_name=None):
+        """
+        Function to create a binary mask (value of 1 for pixels above set threshold and value of 0 for all other pixels) of the LandsatCollection image collection based on a specified band.
+        If a singleband image is provided, the band name is automatically determined.
+        If multiple bands are available, the user must specify the band name to use for masking.
+
+        Args:
+            band_name (str, optional): The name of the band to use for masking. Defaults to None.
+
+        Returns:
+            LandsatCollection: LandsatCollection singleband image collection with binary masks applied.
+        """
+        if self.collection.size().eq(0).getInfo():
+            raise ValueError("The collection is empty. Cannot create a binary mask.")
+        if band_name is None:
+            first_image = self.collection.first()
+            band_names = first_image.bandNames()
+            if band_names.size().getInfo() == 0:
+                raise ValueError("No bands available in the collection.")
+            if band_names.size().getInfo() > 1:
+                raise ValueError("Multiple bands available, please specify a band name.")
+            else:
+                band_name = band_names.get(0).getInfo()
+        if threshold is None:
+            raise ValueError("Threshold must be specified for binary masking.")
+
+        col = self.collection.map(
+            lambda image: image.select(band_name).gte(threshold).rename(band_name)
+        )
         return LandsatCollection(collection=col)
 
     def image_grab(self, img_selector):
@@ -1122,7 +1563,7 @@ class LandsatCollection:
 
         Args:
             img_selector: index of image in the collection for which user seeks to select/"grab".
-        
+
         Returns:
             ee.Image: ee.Image of selected image
         """
@@ -1141,7 +1582,7 @@ class LandsatCollection:
         Args:
             img_col: ee.ImageCollection with same dates as another LandsatCollection image collection object.
             img_selector: index of image in list of dates for which user seeks to "select".
-        
+
         Returns:
             ee.Image: ee.Image of selected image
         """
@@ -1152,7 +1593,7 @@ class LandsatCollection:
         image = ee.Image(image_list.get(img_selector))
 
         return image
-    
+
     def image_pick(self, img_date):
         """
         Selects ("grabs") image of a specific date in format of 'YYYY-MM-DD' - will not work correctly if collection is composed of multiple images of the same date.
@@ -1163,13 +1604,13 @@ class LandsatCollection:
         Returns:
             ee.Image: ee.Image of selected image
         """
-        new_col = self.collection.filter(ee.Filter.eq('Date_Filter', img_date))
+        new_col = self.collection.filter(ee.Filter.eq("Date_Filter", img_date))
         return new_col.first()
 
     def CollectionStitch(self, img_col2):
         """
-        Function to mosaic two LandsatCollection objects which share image dates. 
-        Mosaics are only formed for dates where both image collections have images. 
+        Function to mosaic two LandsatCollection objects which share image dates.
+        Mosaics are only formed for dates where both image collections have images.
         Image properties are copied from the primary collection. Server-side friendly.
 
         Args:
@@ -1178,26 +1619,38 @@ class LandsatCollection:
         Returns:
             LandsatCollection: LandsatCollection image collection
         """
-        dates_list = ee.List(self._dates_list).cat(ee.List(img_col2.dates_list)).distinct()
+        dates_list = (
+            ee.List(self._dates_list).cat(ee.List(img_col2.dates_list)).distinct()
+        )
         filtered_dates1 = self._dates_list
         filtered_dates2 = img_col2._dates_list
 
-        filtered_col2 = img_col2.collection.filter(ee.Filter.inList('Date_Filter', filtered_dates1))
-        filtered_col1 = self.collection.filter(ee.Filter.inList('Date_Filter', filtered_col2.aggregate_array('Date_Filter')))
+        filtered_col2 = img_col2.collection.filter(
+            ee.Filter.inList("Date_Filter", filtered_dates1)
+        )
+        filtered_col1 = self.collection.filter(
+            ee.Filter.inList(
+                "Date_Filter", filtered_col2.aggregate_array("Date_Filter")
+            )
+        )
 
         # Create a function that will be mapped over filtered_col1
         def mosaic_images(img):
             # Get the date of the image
-            date = img.get('Date_Filter')
-            
+            date = img.get("Date_Filter")
+
             # Get the corresponding image from filtered_col2
-            img2 = filtered_col2.filter(ee.Filter.equals('Date_Filter', date)).first()
+            img2 = filtered_col2.filter(ee.Filter.equals("Date_Filter", date)).first()
 
             # Create a mosaic of the two images
             mosaic = ee.ImageCollection.fromImages([img, img2]).mosaic()
 
             # Copy properties from the first image and set the 'Date_Filter' property
-            mosaic = mosaic.copyProperties(img).set('Date_Filter', date).set('system:time_start', img.get('system:time_start'))
+            mosaic = (
+                mosaic.copyProperties(img)
+                .set("Date_Filter", date)
+                .set("system:time_start", img.get("system:time_start"))
+            )
 
             return mosaic
 
@@ -1206,16 +1659,16 @@ class LandsatCollection:
 
         # Return a LandsatCollection instance
         return LandsatCollection(collection=new_col)
-    
+
     @property
     def MosaicByDate(self):
         """
         Property attribute function to mosaic collection images that share the same date.
 
-        The property CLOUD_COVER for each image is used to calculate an overall mean, 
-        which replaces the CLOUD_COVER property for each mosaiced image. 
-        Server-side friendly. 
-        
+        The property CLOUD_COVER for each image is used to calculate an overall mean,
+        which replaces the CLOUD_COVER property for each mosaiced image.
+        Server-side friendly.
+
         NOTE: if images are removed from the collection from cloud filtering, you may have mosaics composed of only one image.
 
         Returns:
@@ -1223,11 +1676,12 @@ class LandsatCollection:
         """
         if self._MosaicByDate is None:
             input_collection = self.collection
+
             # Function to mosaic images of the same date and accumulate them
             def mosaic_and_accumulate(date, list_accumulator):
                 # date = ee.Date(date)
                 list_accumulator = ee.List(list_accumulator)
-                date_filter = ee.Filter.eq('Date_Filter', date)
+                date_filter = ee.Filter.eq("Date_Filter", date)
                 date_collection = input_collection.filter(date_filter)
                 # Convert the collection to a list
                 image_list = date_collection.toList(date_collection.size())
@@ -1235,24 +1689,30 @@ class LandsatCollection:
                 # Get the image at the specified index
                 first_image = ee.Image(image_list.get(0))
                 # Create mosaic
-                mosaic = date_collection.mosaic().set('Date_Filter', date)
+                mosaic = date_collection.mosaic().set("Date_Filter", date)
 
                 # Calculate cumulative cloud and no data percentages
-                cloud_percentage = date_collection.aggregate_mean('CLOUD_COVER')
+                cloud_percentage = date_collection.aggregate_mean("CLOUD_COVER")
 
-                props_of_interest = ['SPACECRAFT_ID', 'SENSOR_ID', 'PROCESSING_LEVEL', 'ACQUISITION_DATE', 'system:time_start']
+                props_of_interest = [
+                    "SPACECRAFT_ID",
+                    "SENSOR_ID",
+                    "PROCESSING_LEVEL",
+                    "ACQUISITION_DATE",
+                    "system:time_start",
+                ]
 
                 # mosaic = mosaic.copyProperties(self.image_grab(0), props_of_interest).set({
                 #     'CLOUD_COVER': cloud_percentage
                 # })
-                mosaic = mosaic.copyProperties(first_image, props_of_interest).set({
-                    'CLOUD_COVER': cloud_percentage
-                })
+                mosaic = mosaic.copyProperties(first_image, props_of_interest).set(
+                    {"CLOUD_COVER": cloud_percentage}
+                )
 
                 return list_accumulator.add(mosaic)
 
             # Get distinct dates
-            distinct_dates = input_collection.aggregate_array('Date_Filter').distinct()
+            distinct_dates = input_collection.aggregate_array("Date_Filter").distinct()
 
             # Initialize an empty list as the accumulator
             initial = ee.List([])
@@ -1266,9 +1726,11 @@ class LandsatCollection:
 
         # Convert the list of mosaics to an ImageCollection
         return self._MosaicByDate
-    
+
     @staticmethod
-    def ee_to_df(ee_object, columns=None, remove_geom=True, sort_columns=False, **kwargs):
+    def ee_to_df(
+        ee_object, columns=None, remove_geom=True, sort_columns=False, **kwargs
+    ):
         """Converts an ee.FeatureCollection to pandas dataframe. Adapted from the geemap package (https://geemap.org/common/#geemap.common.ee_to_df)
 
         Args:
@@ -1318,8 +1780,19 @@ class LandsatCollection:
             raise Exception(e)
 
     @staticmethod
-    def extract_transect(image, line, reducer="mean", n_segments=100, dist_interval=None, scale=None, crs=None, crsTransform=None, tileScale=1.0, to_pandas=False, **kwargs):
-
+    def extract_transect(
+        image,
+        line,
+        reducer="mean",
+        n_segments=100,
+        dist_interval=None,
+        scale=None,
+        crs=None,
+        crsTransform=None,
+        tileScale=1.0,
+        to_pandas=False,
+        **kwargs,
+    ):
         """Extracts transect from an image. Adapted from the geemap package (https://geemap.org/common/#geemap.common.extract_transect). Exists as an alternative to RadGEEToolbox 'transect' function.
 
         Args:
@@ -1383,9 +1856,17 @@ class LandsatCollection:
 
         except Exception as e:
             raise Exception(e)
-    
+
     @staticmethod
-    def transect(image, lines, line_names, reducer='mean', n_segments=None, dist_interval=30, to_pandas=True):
+    def transect(
+        image,
+        lines,
+        line_names,
+        reducer="mean",
+        n_segments=None,
+        dist_interval=30,
+        to_pandas=True,
+    ):
         """Computes and stores the values along a transect for each line in a list of lines. Builds off of the extract_transect function from the geemap package
             where checks are ran to ensure that the reducer column is present in the transect data. If the reducer column is not present, a column of NaNs is created.
             An ee reducer is used to aggregate the values along the transect, depending on the number of segments or distance interval specified. Defaults to 'mean' reducer.
@@ -1402,46 +1883,71 @@ class LandsatCollection:
         Returns:
             pd.DataFrame or ee.FeatureCollection: organized list of values along the transect(s)
         """
-        #Create empty dataframe
+        # Create empty dataframe
         transects_df = pd.DataFrame()
 
-        #Check if line is a list of lines or a single line - if single line, convert to list
+        # Check if line is a list of lines or a single line - if single line, convert to list
         if isinstance(lines, list):
             pass
         else:
             lines = [lines]
-        
+
         for i, line in enumerate(lines):
             if n_segments is None:
-                transect_data = LandsatCollection.extract_transect(image=image, line=line, reducer=reducer, dist_interval=dist_interval, to_pandas=to_pandas)
+                transect_data = LandsatCollection.extract_transect(
+                    image=image,
+                    line=line,
+                    reducer=reducer,
+                    dist_interval=dist_interval,
+                    to_pandas=to_pandas,
+                )
                 if reducer in transect_data.columns:
                     # Extract the 'mean' column and rename it
-                    mean_column = transect_data[['mean']]
+                    mean_column = transect_data[["mean"]]
                 else:
                     # Handle the case where 'mean' column is not present
-                    print(f"{reducer} column not found in transect data for line {line_names[i]}")
+                    print(
+                        f"{reducer} column not found in transect data for line {line_names[i]}"
+                    )
                     # Create a column of NaNs with the same length as the longest column in transects_df
                     max_length = max(transects_df.shape[0], transect_data.shape[0])
                     mean_column = pd.Series([np.nan] * max_length)
             else:
-                transect_data = LandsatCollection.extract_transect(image=image, line=line, reducer=reducer, n_segments=n_segments, to_pandas=to_pandas)
+                transect_data = LandsatCollection.extract_transect(
+                    image=image,
+                    line=line,
+                    reducer=reducer,
+                    n_segments=n_segments,
+                    to_pandas=to_pandas,
+                )
                 if reducer in transect_data.columns:
                     # Extract the 'mean' column and rename it
-                    mean_column = transect_data[['mean']]
+                    mean_column = transect_data[["mean"]]
                 else:
                     # Handle the case where 'mean' column is not present
-                    print(f"{reducer} column not found in transect data for line {line_names[i]}")
+                    print(
+                        f"{reducer} column not found in transect data for line {line_names[i]}"
+                    )
                     # Create a column of NaNs with the same length as the longest column in transects_df
                     max_length = max(transects_df.shape[0], transect_data.shape[0])
                     mean_column = pd.Series([np.nan] * max_length)
-            
+
             transects_df = pd.concat([transects_df, mean_column], axis=1)
 
         transects_df.columns = line_names
-                
+
         return transects_df
-    
-    def transect_iterator(self, lines, line_names, save_folder_path, reducer='mean', n_segments=None, dist_interval=30, to_pandas=True):
+
+    def transect_iterator(
+        self,
+        lines,
+        line_names,
+        save_folder_path,
+        reducer="mean",
+        n_segments=None,
+        dist_interval=30,
+        to_pandas=True,
+    ):
         """Computes and stores the values along a transect for each line in a list of lines for each image in a LandsatCollection image collection, then saves the data for each image to a csv file. Builds off of the extract_transect function from the geemap package
             where checks are ran to ensure that the reducer column is present in the transect data. If the reducer column is not present, a column of NaNs is created.
             An ee reducer is used to aggregate the values along the transect, depending on the number of segments or distance interval specified. Defaults to 'mean' reducer.
@@ -1462,22 +1968,38 @@ class LandsatCollection:
         Returns:
             csv file: file for each image with an organized list of values along the transect(s)
         """
-        image_collection = self #.collection
+        image_collection = self  # .collection
         # image_collection_dates = self._dates
         image_collection_dates = self.dates
         for i, date in enumerate(image_collection_dates):
             try:
                 print(f"Processing image {i+1}/{len(image_collection_dates)}: {date}")
                 image = image_collection.image_grab(i)
-                transects_df = LandsatCollection.transect(image, lines, line_names, reducer=reducer, n_segments=n_segments, dist_interval=dist_interval, to_pandas=to_pandas)
+                transects_df = LandsatCollection.transect(
+                    image,
+                    lines,
+                    line_names,
+                    reducer=reducer,
+                    n_segments=n_segments,
+                    dist_interval=dist_interval,
+                    to_pandas=to_pandas,
+                )
                 image_id = date
-                transects_df.to_csv(f'{save_folder_path}{image_id}_transects.csv')
-                print(f'{image_id}_transects saved to csv')
+                transects_df.to_csv(f"{save_folder_path}{image_id}_transects.csv")
+                print(f"{image_id}_transects saved to csv")
             except Exception as e:
                 print(f"An error occurred while processing image {i+1}: {e}")
 
     @staticmethod
-    def extract_zonal_stats_from_buffer(image, coordinates, buffer_size=1, reducer_type='mean', scale=30, tileScale=1, coordinate_names=None):
+    def extract_zonal_stats_from_buffer(
+        image,
+        coordinates,
+        buffer_size=1,
+        reducer_type="mean",
+        scale=30,
+        tileScale=1,
+        coordinate_names=None,
+    ):
         """
         Function to extract spatial statistics from an image for a list of coordinates, providing individual statistics for each location.
         A radial buffer is applied around each coordinate to extract the statistics, which defaults to 1 meter.
@@ -1499,15 +2021,26 @@ class LandsatCollection:
         # Check if coordinates is a single tuple and convert it to a list of tuples if necessary
         if isinstance(coordinates, tuple) and len(coordinates) == 2:
             coordinates = [coordinates]
-        elif not (isinstance(coordinates, list) and all(isinstance(coord, tuple) and len(coord) == 2 for coord in coordinates)):
-            raise ValueError("Coordinates must be a list of tuples with two elements each (latitude, longitude).")
-        
+        elif not (
+            isinstance(coordinates, list)
+            and all(
+                isinstance(coord, tuple) and len(coord) == 2 for coord in coordinates
+            )
+        ):
+            raise ValueError(
+                "Coordinates must be a list of tuples with two elements each (latitude, longitude)."
+            )
+
         # Check if coordinate_names is a list of strings
         if coordinate_names is not None:
-            if not isinstance(coordinate_names, list) or not all(isinstance(name, str) for name in coordinate_names):
+            if not isinstance(coordinate_names, list) or not all(
+                isinstance(name, str) for name in coordinate_names
+            ):
                 raise ValueError("coordinate_names must be a list of strings.")
             if len(coordinate_names) != len(coordinates):
-                raise ValueError("coordinate_names must have the same length as the coordinates list.")
+                raise ValueError(
+                    "coordinate_names must have the same length as the coordinates list."
+                )
         else:
             coordinate_names = [f"Location {i+1}" for i in range(len(coordinates))]
 
@@ -1519,73 +2052,95 @@ class LandsatCollection:
         # image = ee.Image(check_singleband(image))
         image = ee.Image(check_singleband(image))
 
-        #Convert coordinates to ee.Geometry.Point, buffer them, and add label/name to feature
-        points = [ee.Feature(ee.Geometry.Point([coord[0], coord[1]]).buffer(buffer_size), {'name': str(coordinate_names[i])}) for i, coord in enumerate(coordinates)]
+        # Convert coordinates to ee.Geometry.Point, buffer them, and add label/name to feature
+        points = [
+            ee.Feature(
+                ee.Geometry.Point([coord[0], coord[1]]).buffer(buffer_size),
+                {"name": str(coordinate_names[i])},
+            )
+            for i, coord in enumerate(coordinates)
+        ]
         # Create a feature collection from the buffered points
         features = ee.FeatureCollection(points)
         # Reduce the image to the buffered points - handle different reducer types
-        if reducer_type == 'mean':
+        if reducer_type == "mean":
             img_stats = image.reduceRegions(
-                    collection=features,
-                    reducer=ee.Reducer.mean(),
-                    scale=scale,
-                    tileScale=tileScale)
+                collection=features,
+                reducer=ee.Reducer.mean(),
+                scale=scale,
+                tileScale=tileScale,
+            )
             mean_values = img_stats.getInfo()
             means = []
             names = []
-            for feature in mean_values['features']:
-                names.append(feature['properties']['name'])
-                means.append(feature['properties']['mean'])
+            for feature in mean_values["features"]:
+                names.append(feature["properties"]["name"])
+                means.append(feature["properties"]["mean"])
             organized_values = pd.DataFrame([means], columns=names)
-        elif reducer_type == 'median':
+        elif reducer_type == "median":
             img_stats = image.reduceRegions(
-                    collection=features,
-                    reducer=ee.Reducer.median(),
-                    scale=scale,
-                    tileScale=tileScale)
+                collection=features,
+                reducer=ee.Reducer.median(),
+                scale=scale,
+                tileScale=tileScale,
+            )
             median_values = img_stats.getInfo()
             medians = []
             names = []
-            for feature in median_values['features']:
-                names.append(feature['properties']['name'])
-                medians.append(feature['properties']['median'])
+            for feature in median_values["features"]:
+                names.append(feature["properties"]["name"])
+                medians.append(feature["properties"]["median"])
             organized_values = pd.DataFrame([medians], columns=names)
-        elif reducer_type == 'min':
+        elif reducer_type == "min":
             img_stats = image.reduceRegions(
-                    collection=features,
-                    reducer=ee.Reducer.min(),
-                    scale=scale,
-                    tileScale=tileScale)
+                collection=features,
+                reducer=ee.Reducer.min(),
+                scale=scale,
+                tileScale=tileScale,
+            )
             min_values = img_stats.getInfo()
             mins = []
             names = []
-            for feature in min_values['features']:
-                names.append(feature['properties']['name'])
-                mins.append(feature['properties']['min'])
+            for feature in min_values["features"]:
+                names.append(feature["properties"]["name"])
+                mins.append(feature["properties"]["min"])
             organized_values = pd.DataFrame([mins], columns=names)
-        elif reducer_type == 'max':
+        elif reducer_type == "max":
             img_stats = image.reduceRegions(
-                    collection=features,
-                    reducer=ee.Reducer.max(),
-                    scale=scale,
-                    tileScale=tileScale)
+                collection=features,
+                reducer=ee.Reducer.max(),
+                scale=scale,
+                tileScale=tileScale,
+            )
             max_values = img_stats.getInfo()
             maxs = []
             names = []
-            for feature in max_values['features']:
-                names.append(feature['properties']['name'])
-                maxs.append(feature['properties']['max'])
+            for feature in max_values["features"]:
+                names.append(feature["properties"]["name"])
+                maxs.append(feature["properties"]["max"])
             organized_values = pd.DataFrame([maxs], columns=names)
         else:
-            raise ValueError("reducer_type must be one of 'mean', 'median', 'min', or 'max'.")
+            raise ValueError(
+                "reducer_type must be one of 'mean', 'median', 'min', or 'max'."
+            )
         return organized_values
 
-    def iterate_zonal_stats(self, coordinates, buffer_size=1, reducer_type='mean', scale=30, tileScale=1, coordinate_names=None, file_path=None, dates=None):
+    def iterate_zonal_stats(
+        self,
+        coordinates,
+        buffer_size=1,
+        reducer_type="mean",
+        scale=30,
+        tileScale=1,
+        coordinate_names=None,
+        file_path=None,
+        dates=None,
+    ):
         """
         Function to iterate over a collection of images and extract spatial statistics for a list of coordinates (defaults to mean). Individual statistics are provided for each location.
         A radial buffer is applied around each coordinate to extract the statistics, which defaults to 1 meter.
         The function returns a pandas DataFrame with the statistics for each coordinate and date, or optionally exports the data to a table in .csv format.
-        
+
         Args:
             coordinates (list): Single tuple or a list of tuples with the coordinates as decimal degrees in the format of (longitude, latitude) for which to extract the statistics. NOTE the format needs to be [(x1, y1), (x2, y2), ...].
             buffer_size (int, optional): The radial buffer size in meters around the coordinates. Defaults to 1.
@@ -1601,22 +2156,32 @@ class LandsatCollection:
             .csv file: Optionally exports the data to a table in .csv format. If file_path is None, the function returns the DataFrame - otherwise the function will only export the csv file.
         """
         img_collection = self
-        #Create empty DataFrame to accumulate results
+        # Create empty DataFrame to accumulate results
         accumulated_df = pd.DataFrame()
-        #Check if dates is None, if not use the dates provided
+        # Check if dates is None, if not use the dates provided
         if dates is None:
             dates = img_collection.dates
         else:
             dates = dates
-        #Iterate over the dates and extract the zonal statistics for each date
+        # Iterate over the dates and extract the zonal statistics for each date
         for date in dates:
-            image = img_collection.collection.filter(ee.Filter.eq('Date_Filter', date)).first()
-            single_df = LandsatCollection.extract_zonal_stats_from_buffer(image, coordinates, buffer_size=buffer_size, reducer_type=reducer_type, scale=scale, tileScale=tileScale, coordinate_names=coordinate_names)
-            single_df['Date'] = date
-            single_df.set_index('Date', inplace=True)
+            image = img_collection.collection.filter(
+                ee.Filter.eq("Date_Filter", date)
+            ).first()
+            single_df = LandsatCollection.extract_zonal_stats_from_buffer(
+                image,
+                coordinates,
+                buffer_size=buffer_size,
+                reducer_type=reducer_type,
+                scale=scale,
+                tileScale=tileScale,
+                coordinate_names=coordinate_names,
+            )
+            single_df["Date"] = date
+            single_df.set_index("Date", inplace=True)
             accumulated_df = pd.concat([accumulated_df, single_df])
-        #Return the DataFrame or export the data to a .csv file
+        # Return the DataFrame or export the data to a .csv file
         if file_path is None:
             return accumulated_df
         else:
-            return accumulated_df.to_csv(f'{file_path}.csv')
+            return accumulated_df.to_csv(f"{file_path}.csv")