RadGEEToolbox 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

RadGEEToolbox/LandsatCollection.py

@@ -1,6 +1,7 @@
 import ee
 import pandas as pd
 import numpy as np
+import warnings
 
 
 # ---- Reflectance scaling for Landsat Collection 2 SR ----
@@ -159,6 +160,11 @@ class LandsatCollection:
         self._monthly_max = None
         self._monthly_min = None
         self._monthly_sum = None
+        self._yearly_median = None
+        self._yearly_mean = None
+        self._yearly_max = None
+        self._yearly_min = None
+        self._yearly_sum = None
         self._mean = None
         self._max = None
         self._min = None
@@ -181,6 +187,14 @@ class LandsatCollection:
         self._PixelAreaSumCollection = None
         self._Reflectance = None
 
+    def __call__(self):
+        """
+        Allows the object to be called as a function, returning itself. 
+        This enables property-like methods to be accessed with or without parentheses 
+        (e.g., .mosaicByDate or .mosaicByDate()).
+        """
+        return self
+
     @staticmethod
     def image_dater(image):
         """
@@ -239,17 +253,17 @@ class LandsatCollection:
                 ndwi_calc.updateMask(ndwi_calc.gte(threshold))
                 .rename("ndwi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 ndwi_calc.updateMask(ndwi_calc.gte(ng_threshold))
                 .rename("ndwi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             water = (
                 ndwi_calc.updateMask(ndwi_calc.gte(threshold))
                 .rename("ndwi")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return water
 
@@ -282,17 +296,17 @@ class LandsatCollection:
                 mndwi_calc.updateMask(mndwi_calc.gte(threshold))
                 .rename("mndwi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 mndwi_calc.updateMask(mndwi_calc.gte(ng_threshold))
                 .rename("mndwi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             water = (
                 mndwi_calc.updateMask(mndwi_calc.gte(threshold))
                 .rename("mndwi")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return water
 
@@ -320,17 +334,17 @@ class LandsatCollection:
                 ndvi_calc.updateMask(ndvi_calc.gte(threshold))
                 .rename("ndvi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 ndvi_calc.updateMask(ndvi_calc.gte(ng_threshold))
                 .rename("ndvi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             vegetation = (
                 ndvi_calc.updateMask(ndvi_calc.gte(threshold))
                 .rename("ndvi")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return vegetation
 
@@ -356,17 +370,17 @@ class LandsatCollection:
                 halite_index.updateMask(halite_index.gte(threshold))
                 .rename("halite")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 halite_index.updateMask(halite_index.gte(ng_threshold))
                 .rename("halite")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             halite = (
                 halite_index.updateMask(halite_index.gte(threshold))
                 .rename("halite")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return halite
 
@@ -392,17 +406,17 @@ class LandsatCollection:
                 gypsum_index.updateMask(gypsum_index.gte(threshold))
                 .rename("gypsum")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 gypsum_index.updateMask(gypsum_index.gte(ng_threshold))
                 .rename("gypsum")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             gypsum = (
                 gypsum_index.updateMask(gypsum_index.gte(threshold))
                 .rename("gypsum")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return gypsum
 
@@ -427,11 +441,11 @@ class LandsatCollection:
                 NDTI.updateMask(NDTI.gte(threshold))
                 .rename("ndti")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 NDTI.updateMask(NDTI.gte(ng_threshold))
                 .rename("ndti")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             turbidity = (
@@ -471,17 +485,17 @@ class LandsatCollection:
                 KIVU.updateMask(KIVU.gte(threshold))
                 .rename("kivu")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 KIVU.updateMask(KIVU.gte(ng_threshold))
                 .rename("kivu")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
             chlorophyll = (
                 KIVU.updateMask(KIVU.gte(threshold))
                 .rename("kivu")
-                .copyProperties(image)
+                .copyProperties(image).set('system:time_start', image.get('system:time_start'))
             )
         return chlorophyll
 
@@ -505,8 +519,8 @@ class LandsatCollection:
         # otherwise treat as OLI and copy properties after renaming band to "albedo"
         albedo = ee.Algorithms.If(
             ee.String(image.get("SPACECRAFT_ID")).equals("LANDSAT_5"),
-            image.expression(TM_expression).rename("albedo").copyProperties(image),
-            image.expression(OLI_expression).rename("albedo").copyProperties(image))
+            image.expression(TM_expression).rename("albedo").copyProperties(image).set('system:time_start', image.get('system:time_start')),
+            image.expression(OLI_expression).rename("albedo").copyProperties(image).set('system:time_start', image.get('system:time_start')))
         return albedo
 
     @staticmethod
@@ -530,14 +544,14 @@ class LandsatCollection:
                 ndsi_calc.updateMask(ndsi_calc.gte(threshold))
                 .rename("ndsi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 ndsi_calc.updateMask(ndsi_calc.gte(ng_threshold))
                 .rename("ndsi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            ndsi = ndsi_calc.updateMask(ndsi_calc.gte(threshold)).rename("ndsi").copyProperties(image).set("threshold", threshold)
+            ndsi = ndsi_calc.updateMask(ndsi_calc.gte(threshold)).rename("ndsi").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return ndsi
 
     @staticmethod
@@ -567,14 +581,14 @@ class LandsatCollection:
                 evi_calc.updateMask(evi_calc.gte(threshold))
                 .rename("evi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 evi_calc.updateMask(evi_calc.gte(ng_threshold))
                 .rename("evi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            evi = evi_calc.updateMask(evi_calc.gte(threshold)).rename("evi").copyProperties(image).set("threshold", threshold)
+            evi = evi_calc.updateMask(evi_calc.gte(threshold)).rename("evi").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return evi
     
     @staticmethod
@@ -600,14 +614,14 @@ class LandsatCollection:
                 savi_calc.updateMask(savi_calc.gte(threshold))
                 .rename("savi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 savi_calc.updateMask(savi_calc.gte(ng_threshold))
                 .rename("savi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            savi = savi_calc.updateMask(savi_calc.gte(threshold)).rename("savi").copyProperties(image).set("threshold", threshold)
+            savi = savi_calc.updateMask(savi_calc.gte(threshold)).rename("savi").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return savi
     
     @staticmethod
@@ -633,14 +647,14 @@ class LandsatCollection:
                 msavi_calc.updateMask(msavi_calc.gte(threshold))
                 .rename("msavi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 msavi_calc.updateMask(msavi_calc.gte(ng_threshold))
                 .rename("msavi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            msavi = msavi_calc.updateMask(msavi_calc.gte(threshold)).rename("msavi").copyProperties(image).set("threshold", threshold)
+            msavi = msavi_calc.updateMask(msavi_calc.gte(threshold)).rename("msavi").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return msavi
 
     @staticmethod
@@ -666,14 +680,14 @@ class LandsatCollection:
                 ndmi_calc.updateMask(ndmi_calc.gte(threshold))
                 .rename("ndmi")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 ndmi_calc.updateMask(ndmi_calc.gte(ng_threshold))
                 .rename("ndmi")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            ndmi = ndmi_calc.updateMask(ndmi_calc.gte(threshold)).rename("ndmi").copyProperties(image).set("threshold", threshold)
+            ndmi = ndmi_calc.updateMask(ndmi_calc.gte(threshold)).rename("ndmi").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return ndmi
 
     @staticmethod
@@ -698,14 +712,14 @@ class LandsatCollection:
                 nbr_calc.updateMask(nbr_calc.gte(threshold))
                 .rename("nbr")
                 .copyProperties(image)
-                .set("threshold", threshold),
+                .set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
                 nbr_calc.updateMask(nbr_calc.gte(ng_threshold))
                 .rename("nbr")
                 .copyProperties(image)
-                .set("threshold", ng_threshold),
+                .set("threshold", ng_threshold, 'system:time_start', image.get('system:time_start')),
             )
         else:
-            nbr = nbr_calc.updateMask(nbr_calc.gte(threshold)).rename("nbr").copyProperties(image).set("threshold", threshold)
+            nbr = nbr_calc.updateMask(nbr_calc.gte(threshold)).rename("nbr").copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start'))
         return nbr
     
     @staticmethod
@@ -767,7 +781,7 @@ class LandsatCollection:
             return image.addBands(anomaly_image, overwrite=True).copyProperties(image)
 
     @staticmethod
-    def MaskWaterLandsat(image):
+    def maskWater(image):
         """
         Masks water pixels based on Landsat image QA band.
 
@@ -780,11 +794,21 @@ class LandsatCollection:
         WaterBitMask = ee.Number(2).pow(7).int()
         qa = image.select("QA_PIXEL")
         water_extract = qa.bitwiseAnd(WaterBitMask).eq(0)
-        masked_image = image.updateMask(water_extract).copyProperties(image)
+        masked_image = image.updateMask(water_extract).copyProperties(image).set('system:time_start', image.get('system:time_start'))
         return masked_image
+    
+    @staticmethod
+    def MaskWaterLandsat(image):
+        warnings.warn(
+            "MaskWaterLandsat is deprecated and will be removed in a future release. "
+            "Please use maskWater instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return LandsatCollection.maskWater(image)
 
     @staticmethod
-    def MaskWaterLandsatByNDWI(image, threshold, ng_threshold=None):
+    def maskWaterByNDWI(image, threshold, ng_threshold=None):
         """
         Masks water pixels (mask land and cloud pixels) for all bands based on NDWI and a set threshold where
         all pixels less than NDWI threshold are masked out. Can specify separate thresholds for Landsat 5 vs 8&9 images, where the threshold
@@ -805,23 +829,34 @@ class LandsatCollection:
             ndwi_calc.updateMask(ndwi_calc.gte(threshold))
             .rename("ndwi")
             .copyProperties(image)
+            .set('system:time_start', image.get('system:time_start'))
         )
         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
+                image.updateMask(ndwi_calc.lt(threshold)).copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
+                image.updateMask(ndwi_calc.lt(ng_threshold)).copyProperties(image).set(
+                    "threshold", ng_threshold, 'system:time_start', image.get('system:time_start')
                 ),
             )
         else:
-            water = image.updateMask(ndwi_calc.lt(threshold)).set(
-                "threshold", threshold
+            water = image.updateMask(ndwi_calc.lt(threshold)).copyProperties(image).set(
+                "threshold", threshold, 'system:time_start', image.get('system:time_start')
             )
         return water
-
+    
     @staticmethod
-    def MaskToWaterLandsat(image):
+    def MaskWaterLandsatByNDWI(image, threshold, ng_threshold=None):
+        warnings.warn(
+            "MaskWaterLandsatByNDWI is deprecated and will be removed in a future release. "
+            "Please use maskWaterByNDWI instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return LandsatCollection.maskWaterByNDWI(image, threshold, ng_threshold=ng_threshold)
+    
+    @staticmethod
+    def maskToWater(image):
         """
         Masks image to water pixels by masking land and cloud pixels based on Landsat image QA band.
 
@@ -834,11 +869,21 @@ class LandsatCollection:
         WaterBitMask = ee.Number(2).pow(7).int()
         qa = image.select("QA_PIXEL")
         water_extract = qa.bitwiseAnd(WaterBitMask).neq(0)
-        masked_image = image.updateMask(water_extract).copyProperties(image)
+        masked_image = image.updateMask(water_extract).copyProperties(image).set('system:time_start', image.get('system:time_start'))
         return masked_image
+    
+    @staticmethod
+    def MaskToWaterLandsat(image):
+        warnings.warn(
+            "MaskToWaterLandsat is deprecated and will be removed in a future release. "
+            "Please use maskToWater instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return LandsatCollection.maskToWater(image)
 
     @staticmethod
-    def MaskToWaterLandsatByNDWI(image, threshold, ng_threshold=None):
+    def maskToWaterByNDWI(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
@@ -858,20 +903,65 @@ class LandsatCollection:
             ndwi_calc.updateMask(ndwi_calc.gte(threshold))
             .rename("ndwi")
             .copyProperties(image)
+            .set('system:time_start', image.get('system:time_start'))
         )
         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
+                image.updateMask(ndwi_calc.gte(threshold)).copyProperties(image).set("threshold", threshold, 'system:time_start', image.get('system:time_start')),
+                image.updateMask(ndwi_calc.gte(ng_threshold)).copyProperties(image).set(
+                    "threshold", ng_threshold, 'system:time_start', image.get('system:time_start')
                 ),
             )
         else:
-            water = image.updateMask(ndwi_calc.gte(threshold)).set(
-                "threshold", threshold
+            water = image.updateMask(ndwi_calc.gte(threshold)).copyProperties(image).set(
+                "threshold", threshold, 'system:time_start', image.get('system:time_start')
             )
         return water
+    
+    @staticmethod
+    def MaskToWaterLandsatByNDWI(image, threshold, ng_threshold=None):
+        warnings.warn(
+            "MaskToWaterLandsatNDWI is deprecated and will be removed in a future release. "
+            "Please use maskToWaterByNDWI instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return LandsatCollection.maskToWaterByNDWI(image, threshold, ng_threshold=ng_threshold)
+
+    # @staticmethod
+    # def maskClouds(image):
+    #     """
+    #     Masks clouds pixels based on Landsat image QA band.
+
+    #     Args:
+    #         image (ee.Image): input ee.Image
+
+    #     Returns:
+    #         ee.Image: ee.Image with cloud pixels masked.
+    #     """
+    #     CloudBitMask = ee.Number(2).pow(3).int()
+    #     qa = image.select("QA_PIXEL")
+    #     cloud_extract = qa.bitwiseAnd(CloudBitMask).eq(0)
+    #     masked_image = image.updateMask(cloud_extract).copyProperties(image).set('system:time_start', image.get('system:time_start'))
+    #     return masked_image
+    
+    # @staticmethod
+    # def maskShadows(image):
+    #     """
+    #     Masks shadows pixels based on Landsat image QA band.
+
+    #     Args:
+    #         image (ee.Image): input ee.Image
+
+    #     Returns:
+    #         ee.Image: ee.Image with cloud pixels masked.
+    #     """
+    #     ShadowBitMask = ee.Number(2).pow(4).int()
+    #     qa = image.select("QA_PIXEL")
+    #     shadow_extract = qa.bitwiseAnd(ShadowBitMask).eq(0)
+    #     masked_image = image.updateMask(shadow_extract).copyProperties(image).set('system:time_start', image.get('system:time_start'))
+    #     return masked_image
 
     @staticmethod
     def mask_via_band_fn(image, band_to_mask, band_for_mask, threshold, mask_above=False, add_band_to_original_image=False):
@@ -899,7 +989,7 @@ class LandsatCollection:
         if add_band_to_original_image:
             return image.addBands(band_to_mask_image.updateMask(mask).rename(band_to_mask), overwrite=True)
         else:
-            return ee.Image(band_to_mask_image.updateMask(mask).rename(band_to_mask).copyProperties(image))
+            return ee.Image(band_to_mask_image.updateMask(mask).rename(band_to_mask).copyProperties(image).set('system:time_start', image.get('system:time_start')))
     
     @staticmethod
     def mask_via_singleband_image_fn(image_to_mask, image_for_mask, threshold, band_name_to_mask=None, band_name_for_mask=None, mask_above=True):
@@ -935,7 +1025,7 @@ class LandsatCollection:
             mask = band_for_mask_image.gt(threshold)
         else:
             mask = band_for_mask_image.lt(threshold)
-        return band_to_mask_image.updateMask(mask).rename(band_to_mask).copyProperties(image_to_mask)
+        return band_to_mask_image.updateMask(mask).rename(band_to_mask).copyProperties(image_to_mask).set('system:time_start', image_to_mask.get('system:time_start'))
 
     @staticmethod
     def halite_mask(image, threshold, ng_threshold=None):
@@ -959,11 +1049,11 @@ class LandsatCollection:
         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),
+                image.updateMask(halite_index.lt(threshold)).copyProperties(image).set('system:time_start', image.get('system:time_start')),
+                image.updateMask(halite_index.lt(ng_threshold)).copyProperties(image).set('system:time_start', image.get('system:time_start')),
             )
         else:
-            mask = image.updateMask(halite_index.lt(threshold)).copyProperties(image)
+            mask = image.updateMask(halite_index.lt(threshold)).copyProperties(image).set('system:time_start', image.get('system:time_start'))
         return mask
 
     @staticmethod
@@ -1000,11 +1090,13 @@ class LandsatCollection:
                 gypsum_index.updateMask(halite_index.lt(halite_threshold))
                 .updateMask(gypsum_index.lt(gypsum_threshold))
                 .rename("carbonate_muds")
-                .copyProperties(image),
+                .copyProperties(image)
+                .set('system:time_start', image.get('system:time_start')),
                 gypsum_index.updateMask(halite_index.lt(halite_ng_threshold))
                 .updateMask(gypsum_index.lt(gypsum_ng_threshold))
                 .rename("carbonate_muds")
-                .copyProperties(image),
+                .copyProperties(image)
+                .set('system:time_start', image.get('system:time_start')),
             )
         else:
             mask = (
@@ -1012,11 +1104,12 @@ class LandsatCollection:
                 .updateMask(gypsum_index.lt(gypsum_threshold))
                 .rename("carbonate_muds")
                 .copyProperties(image)
+                .set('system:time_start', image.get('system:time_start'))
             )
         return mask
 
     @staticmethod
-    def maskL8clouds(image):
+    def maskClouds(image):
         """
         Masks clouds baseed on Landsat 8 QA band.
 
@@ -1032,9 +1125,17 @@ class LandsatCollection:
         cloud_mask = qa.bitwiseAnd(cloudBitMask).eq(0)
         cirrus_mask = qa.bitwiseAnd(CirrusBitMask).eq(0)
         return image.updateMask(cloud_mask).updateMask(cirrus_mask)
+    
+    @staticmethod
+    def maskL8clouds(image):
+        warnings.warn(
+            "maskL8clouds is deprecated and will be removed in a future release. Please use maskClouds instead.",
+            DeprecationWarning,
+            stacklevel=2)
+        return LandsatCollection.maskClouds(image)
 
     @staticmethod
-    def maskL8shadows(image):
+    def maskShadows(image):
         """
         Masks cloud shadows based on Landsat 8 QA band.
 
@@ -1048,6 +1149,14 @@ class LandsatCollection:
         qa = image.select("QA_PIXEL")
         shadow_mask = qa.bitwiseAnd(shadowBitMask).eq(0)
         return image.updateMask(shadow_mask)
+    
+    @staticmethod
+    def maskL8shadows(image):
+        warnings.warn(
+            "maskL8shadows is deprecated and will be removed in a future release. Please use maskShadows instead.",
+            DeprecationWarning,
+            stacklevel=2)
+        return LandsatCollection.maskShadows(image)
 
     @staticmethod
     def temperature_bands(img):
@@ -1162,7 +1271,7 @@ class LandsatCollection:
         return out.copyProperties(img)
 
     @staticmethod
-    def PixelAreaSum(
+    def pixelAreaSum(
         image, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12
     ):
         """
@@ -1221,8 +1330,18 @@ class LandsatCollection:
         # Call to iterate the calculate_and_set_area function over the list of bands, starting with the original image
         final_image = ee.Image(bands.iterate(calculate_and_set_area, image))
         return final_image
+    
+    @staticmethod
+    def PixelAreaSum(image, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12):
+        warnings.warn(
+            "PixelAreaSum is deprecated and will be removed in a future release. "
+            "Please use pixelAreaSum instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return LandsatCollection.pixelAreaSum(image, band_name, geometry, threshold, scale, maxPixels)
 
-    def PixelAreaSumCollection(
+    def pixelAreaSumCollection(
         self, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12, output_type='ImageCollection', area_data_export_path=None):
         """
         Calculates the geodesic summation of area for pixels of interest (above a specific threshold)
@@ -1248,7 +1367,7 @@ class LandsatCollection:
             collection = self.collection
             # Area calculation for each image in the collection, using the PixelAreaSum function
             AreaCollection = collection.map(
-                lambda image: LandsatCollection.PixelAreaSum(
+                lambda image: LandsatCollection.pixelAreaSum(
                     image,
                     band_name=band_name,
                     geometry=geometry,
@@ -1264,17 +1383,27 @@ class LandsatCollection:
 
         # If an export path is provided, the area data will be exported to a CSV file
         if area_data_export_path:
-            LandsatCollection(collection=self._PixelAreaSumCollection).ExportProperties(property_names=prop_names, file_path=area_data_export_path+'.csv')
+            LandsatCollection(collection=self._PixelAreaSumCollection).exportProperties(property_names=prop_names, file_path=area_data_export_path+'.csv')
         # Returning the result in the desired format based on output_type argument or raising an error for invalid input
         if output_type == 'ImageCollection' or output_type == 'ee.ImageCollection':
             return self._PixelAreaSumCollection
         elif output_type == 'LandsatCollection':
             return LandsatCollection(collection=self._PixelAreaSumCollection)
         elif output_type == 'DataFrame' or output_type == 'Pandas' or output_type == 'pd' or output_type == 'dataframe' or output_type == 'df':
-            return LandsatCollection(collection=self._PixelAreaSumCollection).ExportProperties(property_names=prop_names)
+            return LandsatCollection(collection=self._PixelAreaSumCollection).exportProperties(property_names=prop_names)
         else:
             raise ValueError("Incorrect `output_type`. The `output_type` argument must be one of the following: 'ImageCollection', 'ee.ImageCollection', 'LandsatCollection', 'DataFrame', 'Pandas', 'pd', 'dataframe', or 'df'.")
 
+    def PixelAreaSumCollection(
+        self, band_name, geometry, threshold=-1, scale=30, maxPixels=1e12, output_type='ImageCollection', area_data_export_path=None):
+        warnings.warn(
+            "PixelAreaSumCollection is deprecated and will be removed in a future release. "
+            "Please use pixelAreaSumCollection instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.pixelAreaSumCollection(band_name, geometry, threshold, scale, maxPixels, output_type, area_data_export_path)
+    
     @staticmethod
     def add_month_property_fn(image):
         """
@@ -1378,7 +1507,12 @@ class LandsatCollection:
             return LandsatCollection(collection=ee.ImageCollection(paired.map(_pair_two)))
 
         # Preferred path: merge many singleband products into the parent
-        if not isinstance(collections, list) or len(collections) == 0:
+        # if not isinstance(collections, list) or len(collections) == 0:
+        #     raise ValueError("Provide a non-empty list of LandsatCollection objects in `collections`.")
+        if not isinstance(collections, list):
+            collections = [collections]
+            
+        if len(collections) == 0:
             raise ValueError("Provide a non-empty list of LandsatCollection objects in `collections`.")
 
         result = self.collection
@@ -1505,7 +1639,7 @@ class LandsatCollection:
             self._dates = dates
         return self._dates
 
-    def ExportProperties(self, property_names, file_path=None):
+    def exportProperties(self, property_names, file_path=None):
         """
         Fetches and returns specified properties from each image in the collection as a list, and returns a pandas DataFrame and optionally saves the results to a csv file.
 
@@ -1560,6 +1694,15 @@ class LandsatCollection:
             print(f"Properties saved to {file_path}")
             
         return df
+    
+    def ExportProperties(self, property_names, file_path=None):
+        warnings.warn(
+            "ExportProperties is deprecated and will be removed in a future release. "
+            "Please use exportProperties instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.exportProperties(property_names, file_path)
 
     def get_filtered_collection(self):
         """
@@ -1781,6 +1924,7 @@ class LandsatCollection:
         """
         if self._monthly_mean is None:
             collection = self.collection
+            # Capture projection from the first image to restore it after reduction
             target_proj = collection.first().projection()
             # Get the start and end dates of the entire collection.
             date_range = collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
@@ -2092,6 +2236,391 @@ class LandsatCollection:
             pass
 
         return self._monthly_min
+    
+    def yearly_mean_collection(self, start_month=1, end_month=12):
+        """
+        Creates a yearly mean composite from the collection, with optional monthly filtering.
+
+        This function computes the mean for each year within the collection's date range.
+        You can specify a range of months (e.g., start_month=6, end_month=10 for June-October)
+        to calculate the mean only using imagery from that specific season for each year.
+
+        The resulting images have 'system:time_start', 'year', 'image_count', 'season_start',
+        'season_end', and 'Date_Filter' properties. Years with no images (after filtering) are excluded.
+
+        Args:
+            start_month (int): The starting month (1-12) for the filter. Defaults to 1 (January).
+            end_month (int): The ending month (1-12) for the filter. Defaults to 12 (December).
+
+        Returns:
+            Object: A new instance of the same class (e.g., LandsatCollection) containing the yearly mean composites.
+        """
+        if self._yearly_mean is None:
+
+            date_range = self.collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
+            start_date_full = ee.Date(date_range.get('min'))
+            end_date_full = ee.Date(date_range.get('max'))
+            
+            start_year = start_date_full.get('year')
+            end_year = end_date_full.get('year')
+
+            if start_month != 1 or end_month != 12:
+                processing_collection = self.collection.filter(ee.Filter.calendarRange(start_month, end_month, 'month'))
+            else:
+                processing_collection = self.collection
+
+            # Capture projection from the first image to restore it after reduction
+            target_proj = self.collection.first().projection()
+
+            years = ee.List.sequence(start_year, end_year)
+
+            def create_yearly_composite(year):
+                year = ee.Number(year)
+                # Define the full calendar year range
+                start_of_year = ee.Date.fromYMD(year, 1, 1)
+                end_of_year = start_of_year.advance(1, 'year')
+
+                yearly_subset = processing_collection.filterDate(start_of_year, end_of_year)
+
+                # Calculate stats
+                image_count = yearly_subset.size()
+                yearly_reduction = yearly_subset.mean()
+
+                # Define the timestamp for the composite.
+                # We use the start_month of that year to accurately reflect the data start time.
+                composite_date = ee.Date.fromYMD(year, start_month, 1)
+
+                return yearly_reduction.set({
+                    'system:time_start': composite_date.millis(),
+                    'year': year,
+                    'month': start_month,  
+                    'Date_Filter': composite_date.format('YYYY-MM-dd'), 
+                    'image_count': image_count,
+                    'season_start': start_month,
+                    'season_end': end_month
+                }).reproject(target_proj)
+
+            # Map the function over the years list
+            yearly_composites_list = years.map(create_yearly_composite)
+            
+            # Convert to Collection
+            yearly_collection = ee.ImageCollection.fromImages(yearly_composites_list)
+
+            # Filter out any composites that were created from zero images.
+            final_collection = yearly_collection.filter(ee.Filter.gt('image_count', 0))
+
+            self._yearly_mean = LandsatCollection(collection=final_collection)
+        else: 
+            pass
+        return self._yearly_mean
+
+    def yearly_median_collection(self, start_month=1, end_month=12):
+        """
+        Creates a yearly median composite from the collection, with optional monthly filtering.
+
+        This function computes the median for each year within the collection's date range.
+        You can specify a range of months (e.g., start_month=6, end_month=10 for June-October)
+        to calculate the median only using imagery from that specific season for each year.
+        The resulting images have 'system:time_start', 'year', 'image_count', 'season_start',
+        'season_end', and 'Date_Filter' properties. Years with no images (after filtering) are excluded.
+
+        Args:
+            start_month (int): The starting month (1-12) for the filter. Defaults to 1 (January).
+            end_month (int): The ending month (1-12) for the filter. Defaults to 12 (December).
+
+        Returns:
+            Object: A new instance of the same class (e.g., LandsatCollection) containing the yearly median composites.
+        """
+        if self._yearly_median is None:
+
+            date_range = self.collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
+            start_date_full = ee.Date(date_range.get('min'))
+            end_date_full = ee.Date(date_range.get('max'))
+            
+            start_year = start_date_full.get('year')
+            end_year = end_date_full.get('year')
+
+            if start_month != 1 or end_month != 12:
+                processing_collection = self.collection.filter(ee.Filter.calendarRange(start_month, end_month, 'month'))
+            else:
+                processing_collection = self.collection
+
+            # Capture projection from the first image to restore it after reduction
+            target_proj = self.collection.first().projection()
+
+            years = ee.List.sequence(start_year, end_year)
+
+            def create_yearly_composite(year):
+                year = ee.Number(year)
+                # Define the full calendar year range
+                start_of_year = ee.Date.fromYMD(year, 1, 1)
+                end_of_year = start_of_year.advance(1, 'year')
+
+                # Filter to the specific year using the PRE-FILTERED seasonal collection
+                yearly_subset = processing_collection.filterDate(start_of_year, end_of_year)
+
+                # Calculate stats
+                image_count = yearly_subset.size()
+                yearly_reduction = yearly_subset.median()
+
+                # Define the timestamp for the composite.
+                # We use the start_month of that year to accurately reflect the data start time.
+                composite_date = ee.Date.fromYMD(year, start_month, 1)
+
+                return yearly_reduction.set({
+                    'system:time_start': composite_date.millis(),
+                    'year': year,
+                    'month': start_month,  
+                    'Date_Filter': composite_date.format('YYYY-MM-dd'), 
+                    'image_count': image_count,
+                    'season_start': start_month,
+                    'season_end': end_month
+                }).reproject(target_proj)
+
+            # Map the function over the years list
+            yearly_composites_list = years.map(create_yearly_composite)
+            
+            # Convert to Collection
+            yearly_collection = ee.ImageCollection.fromImages(yearly_composites_list)
+
+            # Filter out any composites that were created from zero images.
+            final_collection = yearly_collection.filter(ee.Filter.gt('image_count', 0))
+
+            self._yearly_median = LandsatCollection(collection=final_collection)
+        else: 
+            pass
+        return self._yearly_median
+
+    def yearly_max_collection(self, start_month=1, end_month=12):
+        """
+        Creates a yearly max composite from the collection, with optional monthly filtering.
+
+        This function computes the max for each year within the collection's date range.
+        You can specify a range of months (e.g., start_month=6, end_month=10 for June-October)
+        to calculate the max only using imagery from that specific season for each year.
+        The resulting images have 'system:time_start', 'year', 'image_count', 'season_start',
+        'season_end', and 'Date_Filter' properties. Years with no images (after filtering) are excluded.
+
+        Args:
+            start_month (int): The starting month (1-12) for the filter. Defaults to 1 (January).
+            end_month (int): The ending month (1-12) for the filter. Defaults to 12 (December).
+
+        Returns:
+            Object: A new instance of the same class (e.g., LandsatCollection) containing the yearly max composites.
+        """
+        if self._yearly_max is None:
+
+            date_range = self.collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
+            start_date_full = ee.Date(date_range.get('min'))
+            end_date_full = ee.Date(date_range.get('max'))
+            
+            start_year = start_date_full.get('year')
+            end_year = end_date_full.get('year')
+
+            if start_month != 1 or end_month != 12:
+                processing_collection = self.collection.filter(ee.Filter.calendarRange(start_month, end_month, 'month'))
+            else:
+                processing_collection = self.collection
+
+            # Capture projection from the first image to restore it after reduction
+            target_proj = self.collection.first().projection()
+
+            years = ee.List.sequence(start_year, end_year)
+
+            def create_yearly_composite(year):
+                year = ee.Number(year)
+                # Define the full calendar year range
+                start_of_year = ee.Date.fromYMD(year, 1, 1)
+                end_of_year = start_of_year.advance(1, 'year')
+
+                # Filter to the specific year using the PRE-FILTERED seasonal collection
+                yearly_subset = processing_collection.filterDate(start_of_year, end_of_year)
+
+                # Calculate stats
+                image_count = yearly_subset.size()
+                yearly_reduction = yearly_subset.max()
+
+                # Define the timestamp for the composite.
+                # We use the start_month of that year to accurately reflect the data start time.
+                composite_date = ee.Date.fromYMD(year, start_month, 1)
+
+                return yearly_reduction.set({
+                    'system:time_start': composite_date.millis(),
+                    'year': year,
+                    'month': start_month,  
+                    'Date_Filter': composite_date.format('YYYY-MM-dd'), 
+                    'image_count': image_count,
+                    'season_start': start_month,
+                    'season_end': end_month
+                }).reproject(target_proj)
+
+            # Map the function over the years list
+            yearly_composites_list = years.map(create_yearly_composite)
+            
+            # Convert to Collection
+            yearly_collection = ee.ImageCollection.fromImages(yearly_composites_list)
+
+            # Filter out any composites that were created from zero images.
+            final_collection = yearly_collection.filter(ee.Filter.gt('image_count', 0))
+
+            self._yearly_max = LandsatCollection(collection=final_collection)
+        else: 
+            pass
+        return self._yearly_max
+    
+    def yearly_min_collection(self, start_month=1, end_month=12):
+        """
+        Creates a yearly min composite from the collection, with optional monthly filtering.
+
+        This function computes the min for each year within the collection's date range.
+        You can specify a range of months (e.g., start_month=6, end_month=10 for June-October)
+        to calculate the min only using imagery from that specific season for each year.
+        The resulting images have 'system:time_start', 'year', 'image_count', 'season_start',
+        'season_end', and 'Date_Filter' properties. Years with no images (after filtering) are excluded.
+
+        Args:
+            start_month (int): The starting month (1-12) for the filter. Defaults to 1 (January).
+            end_month (int): The ending month (1-12) for the filter. Defaults to 12 (December).
+
+        Returns:
+            Object: A new instance of the same class (e.g., LandsatCollection) containing the yearly min composites.
+        """
+        if self._yearly_min is None:
+
+            date_range = self.collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
+            start_date_full = ee.Date(date_range.get('min'))
+            end_date_full = ee.Date(date_range.get('max'))
+            
+            start_year = start_date_full.get('year')
+            end_year = end_date_full.get('year')
+
+            if start_month != 1 or end_month != 12:
+                processing_collection = self.collection.filter(ee.Filter.calendarRange(start_month, end_month, 'month'))
+            else:
+                processing_collection = self.collection
+
+            # Capture projection from the first image to restore it after reduction
+            target_proj = self.collection.first().projection()
+
+            years = ee.List.sequence(start_year, end_year)
+
+            def create_yearly_composite(year):
+                year = ee.Number(year)
+                # Define the full calendar year range
+                start_of_year = ee.Date.fromYMD(year, 1, 1)
+                end_of_year = start_of_year.advance(1, 'year')
+
+                # Filter to the specific year using the PRE-FILTERED seasonal collection
+                yearly_subset = processing_collection.filterDate(start_of_year, end_of_year)
+
+                # Calculate stats
+                image_count = yearly_subset.size()
+                yearly_reduction = yearly_subset.min()
+
+                # Define the timestamp for the composite.
+                # We use the start_month of that year to accurately reflect the data start time.
+                composite_date = ee.Date.fromYMD(year, start_month, 1)
+
+                return yearly_reduction.set({
+                    'system:time_start': composite_date.millis(),
+                    'year': year,
+                    'month': start_month,  
+                    'Date_Filter': composite_date.format('YYYY-MM-dd'), 
+                    'image_count': image_count,
+                    'season_start': start_month,
+                    'season_end': end_month
+                }).reproject(target_proj)
+
+            # Map the function over the years list
+            yearly_composites_list = years.map(create_yearly_composite)
+            
+            # Convert to Collection
+            yearly_collection = ee.ImageCollection.fromImages(yearly_composites_list)
+
+            # Filter out any composites that were created from zero images.
+            final_collection = yearly_collection.filter(ee.Filter.gt('image_count', 0))
+
+            self._yearly_min = LandsatCollection(collection=final_collection)
+        else: 
+            pass
+        return self._yearly_min
+
+    def yearly_sum_collection(self, start_month=1, end_month=12):
+        """
+        Creates a yearly sum composite from the collection, with optional monthly filtering.
+
+        This function computes the sum for each year within the collection's date range.
+        You can specify a range of months (e.g., start_month=6, end_month=10 for June-October)
+        to calculate the sum only using imagery from that specific season for each year.
+        The resulting images have 'system:time_start', 'year', 'image_count', 'season_start',
+        'season_end', and 'Date_Filter' properties. Years with no images (after filtering) are excluded.
+
+        Args:
+            start_month (int): The starting month (1-12) for the filter. Defaults to 1 (January).
+            end_month (int): The ending month (1-12) for the filter. Defaults to 12 (December).
+
+        Returns:
+            Object: A new instance of the same class (e.g., LandsatCollection) containing the yearly sum composites.
+        """
+        if self._yearly_sum is None:
+
+            date_range = self.collection.reduceColumns(ee.Reducer.minMax(), ["system:time_start"])
+            start_date_full = ee.Date(date_range.get('min'))
+            end_date_full = ee.Date(date_range.get('max'))
+            
+            start_year = start_date_full.get('year')
+            end_year = end_date_full.get('year')
+
+            if start_month != 1 or end_month != 12:
+                processing_collection = self.collection.filter(ee.Filter.calendarRange(start_month, end_month, 'month'))
+            else:
+                processing_collection = self.collection
+
+            # Capture projection from the first image to restore it after reduction
+            target_proj = self.collection.first().projection()
+
+            years = ee.List.sequence(start_year, end_year)
+
+            def create_yearly_composite(year):
+                year = ee.Number(year)
+                # Define the full calendar year range
+                start_of_year = ee.Date.fromYMD(year, 1, 1)
+                end_of_year = start_of_year.advance(1, 'year')
+
+                # Filter to the specific year using the PRE-FILTERED seasonal collection
+                yearly_subset = processing_collection.filterDate(start_of_year, end_of_year)
+
+                # Calculate stats
+                image_count = yearly_subset.size()
+                yearly_reduction = yearly_subset.sum()
+
+                # Define the timestamp for the composite.
+                # We use the start_month of that year to accurately reflect the data start time.
+                composite_date = ee.Date.fromYMD(year, start_month, 1)
+
+                return yearly_reduction.set({
+                    'system:time_start': composite_date.millis(),
+                    'year': year,
+                    'month': start_month,  
+                    'Date_Filter': composite_date.format('YYYY-MM-dd'), 
+                    'image_count': image_count,
+                    'season_start': start_month,
+                    'season_end': end_month
+                }).reproject(target_proj)
+
+            # Map the function over the years list
+            yearly_composites_list = years.map(create_yearly_composite)
+            
+            # Convert to Collection
+            yearly_collection = ee.ImageCollection.fromImages(yearly_composites_list)
+
+            # Filter out any composites that were created from zero images.
+            final_collection = yearly_collection.filter(ee.Filter.gt('image_count', 0))
+
+            self._yearly_sum = LandsatCollection(collection=final_collection)
+        else: 
+            pass
+        return self._yearly_sum
 
     @property
     def ndwi(self):
@@ -2693,7 +3222,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         if self._masked_water_collection is None:
-            col = self.collection.map(LandsatCollection.MaskWaterLandsat)
+            col = self.collection.map(LandsatCollection.maskWater)
             self._masked_water_collection = LandsatCollection(collection=col)
         return self._masked_water_collection
 
@@ -2708,7 +3237,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         col = self.collection.map(
-            lambda image: LandsatCollection.MaskWaterLandsatByNDWI(
+            lambda image: LandsatCollection.maskWaterByNDWI(
                 image, threshold=threshold
             )
         )
@@ -2723,7 +3252,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         if self._masked_to_water_collection is None:
-            col = self.collection.map(LandsatCollection.MaskToWaterLandsat)
+            col = self.collection.map(LandsatCollection.maskToWater)
             self._masked_to_water_collection = LandsatCollection(collection=col)
         return self._masked_to_water_collection
 
@@ -2738,7 +3267,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         col = self.collection.map(
-            lambda image: LandsatCollection.MaskToWaterLandsatByNDWI(
+            lambda image: LandsatCollection.maskToWaterByNDWI(
                 image, threshold=threshold
             )
         )
@@ -2753,7 +3282,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         if self._masked_clouds_collection is None:
-            col = self.collection.map(LandsatCollection.maskL8clouds)
+            col = self.collection.map(LandsatCollection.maskClouds)
             self._masked_clouds_collection = LandsatCollection(collection=col)
         return self._masked_clouds_collection
     
@@ -2766,7 +3295,7 @@ class LandsatCollection:
             LandsatCollection: LandsatCollection image collection
         """
         if self._masked_shadows_collection is None:
-            col = self.collection.map(LandsatCollection.maskL8shadows)
+            col = self.collection.map(LandsatCollection.maskShadows)
             self._masked_shadows_collection = LandsatCollection(collection=col)
         return self._masked_shadows_collection
 
@@ -2835,20 +3364,14 @@ class LandsatCollection:
             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)
+        # 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 mask of each image in the collection
+        masked_collection = self.collection.map(lambda img: img.updateMask(mask)\
+                                .copyProperties(img).set('system:time_start', img.get('system:time_start')))
 
-            # Update the internal collection state
-            self._geometry_masked_collection = LandsatCollection(
-                collection=masked_collection
-            )
-
-        # Return the updated object
-        return self._geometry_masked_collection
+        return LandsatCollection(collection=masked_collection)
 
     def mask_out_polygon(self, polygon):
         """
@@ -2861,23 +3384,18 @@ class LandsatCollection:
             LandsatCollection: masked LandsatCollection image collection
 
         """
-        if self._geometry_masked_out_collection is None:
-            # Convert the polygon to a mask
-            full_mask = ee.Image.constant(1)
-
-            # Use paint to set pixels inside polygon as 0
-            area = full_mask.paint(polygon, 0)
+        # Convert the polygon to a mask
+        full_mask = ee.Image.constant(1)
 
-            # Update the mask of each image in the collection
-            masked_collection = self.collection.map(lambda img: img.updateMask(area))
+        # Use paint to set pixels inside polygon as 0
+        area = full_mask.paint(polygon, 0)
 
-            # Update the internal collection state
-            self._geometry_masked_out_collection = LandsatCollection(
-                collection=masked_collection
-            )
+        # Update the mask of each image in the collection
+        masked_collection = self.collection.map(lambda img: img.updateMask(area)\
+                            .copyProperties(img).set('system:time_start', img.get('system:time_start')))
 
         # Return the updated object
-        return self._geometry_masked_out_collection
+        return LandsatCollection(collection=masked_collection)
 
     def mask_halite(self, threshold, ng_threshold=None):
         """
@@ -2963,20 +3481,24 @@ class LandsatCollection:
         if classify_above_threshold:
             if mask_zeros is True:
                 col = self.collection.map(
-                    lambda image: image.select(band_name).gte(threshold).rename(band_name).selfMask().copyProperties(image)
+                    lambda image: image.select(band_name).gte(threshold).rename(band_name).selfMask()
+                    .copyProperties(image).set('system:time_start', image.get('system:time_start'))
                 )
             else:
                 col = self.collection.map(
-                    lambda image: image.select(band_name).gte(threshold).rename(band_name).copyProperties(image)
+                    lambda image: image.select(band_name).gte(threshold).rename(band_name)
+                    .copyProperties(image).set('system:time_start', image.get('system:time_start'))
                 )
         else:
             if mask_zeros is True:
                 col = self.collection.map(
-                    lambda image: image.select(band_name).lte(threshold).rename(band_name).selfMask().copyProperties(image)
+                    lambda image: image.select(band_name).lte(threshold).rename(band_name).selfMask()
+                    .copyProperties(image).set('system:time_start', image.get('system:time_start'))
                 )
             else:
                 col = self.collection.map(
-                    lambda image: image.select(band_name).lte(threshold).rename(band_name).copyProperties(image)
+                    lambda image: image.select(band_name).lte(threshold).rename(band_name)
+                    .copyProperties(image).set('system:time_start', image.get('system:time_start'))
                 )
 
         return LandsatCollection(collection=col)
@@ -3017,6 +3539,237 @@ class LandsatCollection:
         col = self.collection.map(lambda image: LandsatCollection.anomaly_fn(image, geometry=geometry, band_name=band_name, anomaly_band_name=anomaly_band_name, replace=replace, scale=scale))
         return LandsatCollection(collection=col)
     
+    def mann_kendall_trend(self, target_band=None, join_method='system:time_start', geometry=None):
+        """
+        Calculates the Mann-Kendall S-value, Variance, Z-Score, and Confidence Level for each pixel in the image collection, in addition to calculating
+        the Sen's slope for each pixel in the image collection. The output is an image with the following bands: 's_statistic', 'variance', 'z_score', 'confidence', and 'slope'.
+
+        This function can be used to identify trends in the image collection over time, such as increasing or decreasing values in the target band, and can be used to assess the significance of these trends.
+        Note that this function is computationally intensive and may take a long time to run for large image collections or high-resolution images.
+
+        The 's_statistic' band represents the Mann-Kendall S-value, which is a measure of the strength and direction of the trend.
+        The 'variance' band represents the variance of the S-value, which is a measure of the variability of the S-value.
+        The 'z_score' band represents the Z-Score, which is a measure of the significance of the trend.
+        The 'confidence' band represents the confidence level of the trend based on the z_score, which is a probabilistic measure of the confidence in the trend (percentage).
+        The 'slope' band represents the Sen's slope, which is a measure of the rate of change in the target band over time. This value can be small as multispectral indices commonly range from -1 to 1, so a slope may have values of <0.2 for most cases.
+
+        Be sure to select the correct band for the `target_band` parameter, as this will be used to calculate the trend statistics.
+        You may optionally provide an ee.Geometry object for the `geometry` parameter to limit the area over which the trend statistics are calculated.
+        The `geometry` parameter is optional and defaults to None, which means that the trend statistics will be calculated over the entire footprint of the image collection.
+
+        Args: 
+            image_collection (LandsatCollection or ee.ImageCollection): The input image collection for which the Mann-Kendall and Sen's slope trend statistics will be calculated.
+            target_band (str): The band name to be used for the output anomaly image. e.g. 'ndvi'
+            join_method (str, optional): The method used to join images in the collection. Options are 'system:time_start' or 'Date_Filter'. Default is 'system:time_start'.
+            geometry (ee.Geometry, optional): An ee.Geometry object to limit the area over which the trend statistics are calculated and mask the output image. Default is None.
+
+        Returns:
+            ee.Image: An image with the following bands: 's_statistic', 'variance', 'z_score', 'confidence', and 'slope'.
+        """
+        ########## PART 1 - S-VALUE CALCULATION ##########
+        ##### https://vsp.pnnl.gov/help/vsample/design_trend_mann_kendall.htm #####
+        image_collection = self
+        if isinstance(image_collection, LandsatCollection):
+            image_collection = image_collection.collection
+        elif isinstance(image_collection, ee.ImageCollection):
+            pass
+        else:
+            raise ValueError(f'The chosen `image_collection`: {image_collection} is not a valid LandsatCollection or ee.ImageCollection object.')
+        
+        if target_band is None:
+            raise ValueError('The `target_band` parameter must be specified.')
+        if not isinstance(target_band, str):
+            raise ValueError(f'The chosen `target_band`: {target_band} is not a valid string.')
+
+        if geometry is not None and not isinstance(geometry, ee.Geometry):
+            raise ValueError(f'The chosen `geometry`: {geometry} is not a valid ee.Geometry object.')
+        # define the join, which will join all images newer than the current image
+        # use system:time_start if the image does not have a Date_Filter property
+        if join_method == 'system:time_start':
+            # get all images where the leftField value is less than (before) the rightField value
+            time_filter = ee.Filter.lessThan(leftField='system:time_start', 
+                                            rightField='system:time_start')
+        elif join_method == 'Date_Filter':
+            # get all images where the leftField value is less than (before) the rightField value
+            time_filter = ee.Filter.lessThan(leftField='Date_Filter', 
+                                            rightField='Date_Filter')
+        else:
+            raise ValueError(f'The chosen `join_method`: {join_method} does not match the options of "system:time_start" or "Date_Filter".')
+        
+        native_projection = image_collection.first().select(target_band).projection()
+
+        # for any matches during a join, set image as a property key called 'future_image'
+        join = ee.Join.saveAll(matchesKey='future_image')
+
+        # apply the join on the input collection 
+        # joining all images newer than the current image with the current image
+        joined_collection = ee.ImageCollection(join.apply(primary=image_collection, 
+                                                secondary=image_collection, condition=time_filter))
+        
+        # defining a collection to calculate the partial S value for each match in the join
+        # e.g. t4-t1, t3-t1, t2-1 if there are 4 images
+        def calculate_partial_s(current_image):
+            # select the target band for arithmetic
+            current_val = current_image.select(target_band)
+            # get the joined images from the current image properties and cast the joined images as a list
+            future_image_list = ee.List(current_image.get('future_image'))
+            # convert the joined list to an image collection
+            future_image_collection = ee.ImageCollection(future_image_list)
+
+            # define a function that will calculate the difference between the joined images and the current image, 
+            # then calculate the partial S sign based on the value of the difference calculation
+            def get_sign(future_image):
+                # select the target band for arithmetic from the future image
+                future_val = future_image.select(target_band)
+                # calculate the difference, i.e. t2-t1
+                difference = future_val.subtract(current_val)
+                # determine the sign of the difference value (1 if diff > 0, 0 if 0, and -1 if diff < 0)
+                # use .unmask(0) to set any masked pixels as 0 to avoid 
+                
+                sign = difference.signum().unmask(0)
+                
+                return sign
+            
+            # map the get_sign() function along the future image col 
+            # then sum the values for each pixel to get the partial S value
+            return future_image_collection.map(get_sign).sum()
+
+        # calculate the partial s value for each image in the joined/input image collection
+        partial_s_col = joined_collection.map(calculate_partial_s)
+
+        # convert the image collection to an image of s_statistic values per pixel
+        # where the s_statistic is the sum of partial s values
+        # renaming the band as 's_statistic' for later usage
+        final_s_image = partial_s_col.sum().rename('s_statistic').setDefaultProjection(native_projection)
+
+
+        ########## PART 2 - VARIANCE and Z-SCORE ##########
+        # to calculate variance we need to know how many pixels were involved in the partial_s calculations per pixel
+        # we do this by using count() and turn the value to a float for later arithmetic
+        n = image_collection.select(target_band).count().toFloat()
+
+        ##### VARIANCE CALCULATION #####
+        # as we are using floating point values with high precision, it is HIGHLY 
+        # unlikely that there will be multiple pixel values with the same value.
+        # Thus, we opt to use the simplified variance calculation approach as the
+        # impacts to the output value are negligible and the processing benefits are HUGE
+        # variance = (n * (n - 1) * (2n + 5)) / 18
+        var_s = n.multiply(n.subtract(1))\
+                .multiply(n.multiply(2).add(5))\
+                .divide(18).rename('variance')
+        
+        z_score = ee.Image().expression(
+                    """
+                    (s > 0) ? (s - 1) / sqrt(var) :
+                    (s < 0) ? (s + 1) / sqrt(var) :
+                    0
+                    """,
+                    {'s': final_s_image, 'var': var_s}
+                ).rename('z_score')
+        
+        confidence = z_score.abs().divide(ee.Number(2).sqrt()).erf().rename('confidence')
+
+        stat_bands = ee.Image([var_s, z_score, confidence])
+
+        mk_stats_image = final_s_image.addBands(stat_bands)
+
+        ########## PART 3 - Sen's Slope ##########
+        def add_year_band(image):
+            if join_method == 'Date_Filter':
+                # Get the string 'YYYY-MM-DD'
+                date_string = image.get('Date_Filter')
+                # Parse it into an ee.Date object (handles the conversion to time math)
+                date = ee.Date.parse('YYYY-MM-dd', date_string)
+            else:
+                # Standard way: assumes system:time_start exists
+                date = image.date()
+            years = date.difference(ee.Date('1970-01-01'), 'year')
+            return image.addBands(ee.Image(years).float().rename('year'))
+        
+        slope_input = image_collection.map(add_year_band).select(['year', target_band])
+
+        sens_slope = slope_input.reduce(ee.Reducer.sensSlope())
+
+        slope_band = sens_slope.select('slope')
+
+        # add a mask to the final image to remove pixels with less than min_observations
+        # mainly an effort to mask pixels outside of the boundary of the input image collection
+        min_observations = 1
+        valid_mask = n.gte(min_observations)
+
+        final_image = mk_stats_image.addBands(slope_band).updateMask(valid_mask)
+
+        if geometry is not None:
+            mask = ee.Image(1).clip(geometry)
+            final_image = final_image.updateMask(mask)
+
+        return final_image.setDefaultProjection(native_projection)
+
+    def sens_slope_trend(self, target_band=None, join_method='system:time_start', geometry=None):
+            """
+            Calculates Sen's Slope (trend magnitude) for the collection.
+            This is a lighter-weight alternative to the full `mann_kendall_trend` function if only
+            the direction and magnitude of the trend are needed.
+
+            Be sure to select the correct band for the `target_band` parameter, as this will be used to calculate the trend statistics.
+            You may optionally provide an ee.Geometry object for the `geometry` parameter to limit the area over which the trend statistics are calculated.
+            The `geometry` parameter is optional and defaults to None, which means that the trend statistics will be calculated over the entire footprint of the image collection.
+
+            Args:
+                target_band (str): The name of the band to analyze. Defaults to 'ndvi'.
+                join_method (str): Property to use for time sorting ('system:time_start' or 'Date_Filter').
+                geometry (ee.Geometry, optional): Geometry to mask the final output.
+
+            Returns:
+                ee.Image: An image containing the 'slope' band.
+            """
+            image_collection = self
+            if isinstance(image_collection, LandsatCollection):
+                image_collection = image_collection.collection
+            elif isinstance(image_collection, ee.ImageCollection):
+                pass
+            else:
+                raise ValueError(f'The chosen `image_collection`: {image_collection} is not a valid LandsatCollection or ee.ImageCollection object.')
+            
+            if target_band is None:
+                raise ValueError('The `target_band` parameter must be specified.')
+            if not isinstance(target_band, str):
+                raise ValueError(f'The chosen `target_band`: {target_band} is not a valid string.')
+
+            if geometry is not None and not isinstance(geometry, ee.Geometry):
+                raise ValueError(f'The chosen `geometry`: {geometry} is not a valid ee.Geometry object.')
+
+            native_projection = image_collection.first().select(target_band).projection()
+
+            # Add Year Band (Time X-Axis)
+            def add_year_band(image):
+                # Handle user-defined date strings vs system time
+                if join_method == 'Date_Filter':
+                    date_string = image.get('Date_Filter')
+                    date = ee.Date.parse('YYYY-MM-dd', date_string)
+                else:
+                    date = image.date()
+                    
+                # Convert to fractional years relative to epoch
+                years = date.difference(ee.Date('1970-01-01'), 'year')
+                return image.addBands(ee.Image(years).float().rename('year'))
+
+            # Prepare Collection: Select ONLY [Year, Target]
+            # sensSlope expects Band 0 = Independent (X), Band 1 = Dependent (Y)
+            slope_input = self.collection.map(add_year_band).select(['year', target_band])
+
+            # Run the Native Reducer
+            sens_result = slope_input.reduce(ee.Reducer.sensSlope())
+            
+            # Extract and Mask
+            slope_band = sens_result.select('slope')
+
+            if geometry is not None:
+                mask = ee.Image(1).clip(geometry)
+                slope_band = slope_band.updateMask(mask)
+
+            return slope_band.setDefaultProjection(native_projection)
+    
     def mask_via_band(self, band_to_mask, band_for_mask, threshold=-1, mask_above=True, add_band_to_original_image=False):
         """
         Masks select pixels of a selected band from an image based on another specified band and threshold (optional). 
@@ -3099,7 +3852,8 @@ class LandsatCollection:
             )
 
             # guarantee single band + keep properties
-            out = ee.Image(out).select([band_name_to_mask]).copyProperties(prim, prim.propertyNames())
+            out = ee.Image(out).select([band_name_to_mask]).copyProperties(prim, prim.propertyNames())\
+                                            .set('system:time_start', prim.get('system:time_start'))
             out = out.set('Date_Filter', prim.get('Date_Filter'))
             return ee.Image(out)                  # <-- return as Image
 
@@ -3181,7 +3935,7 @@ class LandsatCollection:
         new_col = self.collection.filter(ee.Filter.eq("Date_Filter", img_date))
         return new_col.first()
 
-    def CollectionStitch(self, img_col2):
+    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.
@@ -3233,9 +3987,15 @@ class LandsatCollection:
 
         # Return a LandsatCollection instance
         return LandsatCollection(collection=new_col)
+    
+    def CollectionStitch(self, img_col2):
+        warnings.warn(
+            "CollectionStitch is deprecated and will be removed in future versions. Please use the 'collectionStitch' property instead.",
+            DeprecationWarning, stacklevel=2)
+        return self.collectionStitch(img_col2)
 
     @property
-    def MosaicByDate(self):
+    def mosaicByDateDepr(self):
         """
         Property attribute function to mosaic collection images that share the same date.
 
@@ -3300,6 +4060,73 @@ class LandsatCollection:
 
         # Convert the list of mosaics to an ImageCollection
         return self._MosaicByDate
+    
+    @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.
+
+        NOTE: if images are removed from the collection from cloud filtering, you may have mosaics composed of only one image.
+
+        Returns:
+            LandsatCollection: LandsatCollection image collection with mosaiced imagery and mean CLOUD_COVER as a property
+        """
+        if self._MosaicByDate is None:
+            distinct_dates = self.collection.distinct("Date_Filter")
+
+            # Define a join to link images by Date_Filter
+            filter_date = ee.Filter.equals(leftField="Date_Filter", rightField="Date_Filter")
+            join = ee.Join.saveAll(matchesKey="date_matches")
+
+            # Apply the join
+            # Primary: Distinct dates collection
+            # Secondary: The full original collection
+            joined_col = ee.ImageCollection(join.apply(distinct_dates, self.collection, filter_date))
+
+            # Define the mosaicking function 
+            def _mosaic_day(img):
+                # Recover the list of images for this day
+                daily_list = ee.List(img.get("date_matches"))
+                daily_col = ee.ImageCollection.fromImages(daily_list)
+                
+                # Create the mosaic
+                mosaic = daily_col.mosaic().setDefaultProjection(img.projection())
+                
+                # Calculate mean metadata properties
+                cloud_percentage = daily_col.aggregate_mean("CLOUD_COVER")
+
+                # Properties to preserve from the representative image
+                props_of_interest = [
+                    "SPACECRAFT_ID",
+                    "SENSOR_ID",
+                    "PROCESSING_LEVEL",
+                    "ACQUISITION_DATE",
+                    "system:time_start",
+                    "Date_Filter" 
+                ]
+                
+                # Return mosaic with properties set
+                return mosaic.copyProperties(img, props_of_interest).set({
+                    "CLOUD_COVER": cloud_percentage
+                })
+
+            # 5. Map the function and wrap the result
+            mosaiced_col = joined_col.map(_mosaic_day)
+            self._MosaicByDate = LandsatCollection(collection=mosaiced_col)
+
+        # Convert the list of mosaics to an ImageCollection
+        return self._MosaicByDate
+    
+    @property
+    def MosaicByDate(self):
+        warnings.warn(
+            "MosaicByDate is deprecated and will be removed in future versions. Please use the 'mosaicByDate' property instead.",
+            DeprecationWarning, stacklevel=2)
+        return self.mosaicByDate
 
     @staticmethod
     def ee_to_df(