Removed commented function.

Author: jcrattz

data_cube_utilities/build_cloud_coverage_table_landsat.py

@@ -0,0 +1,67 @@
+import datacube
+from utils.data_cube_utilities.dc_mosaic import ls8_unpack_qa, ls7_unpack_qa 
+import numpy as np
+from functools import partial  
+import pandas as pd
+
+def build_cloud_coverage_table_landsat(product=None,
+                                       platform=None,
+                                       latitude=None,
+                                       longitude=None,
+                                       time=None,
+                                       dc=None,
+                                       extra_band='green'):
+    
+    if product   is None: raise Exception("product argument is required")
+    if platform  is None: raise Exception("platform argument is required")
+    if latitude  is None: raise Exception("latitude argument is required")
+    if longitude is None: raise Exception("longitude argument is required")
+ 
+    def clean_mask(ds, unpacking_func, bands):
+        masks = [unpacking_func(ds, band) for band in bands]
+        return np.logical_or(*masks).values
+    
+    unpack_function = {"LANDSAT_7": ls7_unpack_qa,
+                       "LANDSAT_8": ls8_unpack_qa}
+
+    dc = dc if dc else datacube.Datacube(app="")
+    
+    load_params = dict(product=product,
+                       platform=platform,
+                       latitude=latitude,
+                       longitude=longitude,
+                       measurements=[extra_band, 'pixel_qa'])
+    
+    if time is not None: 
+        load_params["time"] = time
+        
+    geo_data = dc.load(**load_params)
+    
+    times = list(geo_data.time.values)
+    scene_slice_list = list(map(lambda t: geo_data.sel(time=str(t)), times))
+    
+    def create_clean_mask_list(ds):
+        return clean_mask(ds, unpacking_func=unpack_function[platform], bands=["clear", "water"])
+    clean_mask_list = list(map(lambda ds: create_clean_mask_list(ds.pixel_qa), scene_slice_list))
+    no_data_mask_list = list(map(lambda ds: (ds[extra_band] == -9999).values, scene_slice_list))
+    # This method of creating `percentage_list` gives the percentage of pixels with data (i.e. not no_data (-9999))
+    # which are also not cloud.
+#     def create_clean_percentage_with_data_list(masks_tup):
+#         """Merges two masks - passed as a tuple - and calculates the percentage
+#            of pixels that are clean and have data."""
+#         clean_mask, no_data_mask = masks_tup
+#         merged_mask = clean_mask & ~no_data_mask
+#         return merged_mask.sum() / (~no_data_mask).sum() * 100
+#     percentage_list = list(map(create_clean_percentage_with_data_list, 
+#                                zip(clean_mask_list, no_data_mask_list)))
+    # This method of creating `percentage_list` gieves the percentage of all pixels 
+    # which are also not cloud.
+    percentage_list = [clean_mask.mean()*100 for clean_mask in clean_mask_list]
+    clean_pixel_count_list = list(map(np.sum, clean_mask_list))
+    
+    data = {"times": times,
+            # "clean_percentage" is the percent of pixels that are not no_data which are clear.
+            "clean_percentage": percentage_list,
+            "clean_count": clean_pixel_count_list }
+    
+    return geo_data, pd.DataFrame(data=data, columns=["times", "clean_percentage", "clean_count"])

data_cube_utilities/dc_utilities.py

@@ -70,53 +70,6 @@ def get_range(platform, collection, level):
     return range_dict
 
 
-# def convert_range(dataset, from_platform, from_collection, from_level,
-#                   to_platform, to_collection, to_level):
-#     """
-#     Converts an xarray.Dataset's range from its product's range 
-#     to that of another product's range.
-
-#     Parameters
-#     ----------
-#     dataset: xarray.Dataset
-#         The dataset to convert to another range.
-#     from_platform, from_collection, from_level: string
-#         The dataset's product's platform, collection, and level.
-#         For example, ('LANDSAT_8', 'c2', 'l2').
-#     to_platform, to_collection, to_level: string
-#         The platform, collection, and level to convert the 
-#         dataset's range to.
-#         For example, ('LANDSAT_7', 'c1', 'l2').
-#     """
-#     # Get the original and destination ranges.
-#     from_rng = get_range(from_platform, from_collection, from_level)
-#     if from_rng is None:
-#         raise ValueError(
-#             f'The original range is not recorded '\
-#             f'(platform: {from_platform}, collection: {from_collection}, level: {from_level}).')
-#     to_rng = get_range(to_platform, to_collection, to_level)
-#     if to_rng is None:
-#         raise ValueError(
-#             f'The destination range is not recorded '\
-#             f'(platform: {to_platform}, collection: {to_collection}, level: {to_level}).')
-    
-#     # Determine the data variables with ranges in both 
-#     # the original and destination range information.
-#     data_vars_both = list(set(from_rng.keys()) & set(to_rng.keys()))
-#     out_dataset = dataset.copy(deep=True)
-#     for data_var_name in data_vars_both:
-#         from_rng_cur = from_rng[data_var_name]
-#         to_rng_cur = to_rng[data_var_name]
-#         out_dataset[data_var_name].data = np.interp(out_dataset[data_var_name], from_rng_cur, to_rng_cur)
-
-#         # Temporary approximate corrections - range scaling is often very inaccurate.
-#         if (from_platform, from_collection, from_level) == ('LANDSAT_8', 'c2', 'l2') and \
-#            to_platform in ['LANDSAT_7', 'LANDSAT_8'] and \
-#            (to_collection, to_level) == ('c1', 'l2'):
-#             out_dataset[data_var_name] = out_dataset[data_var_name] * 0.1
-    
-#     return out_dataset
-
 def convert_range(dataset, from_platform, from_collection, from_level,
                   to_platform, to_collection, to_level):
     """