update

inspect_timor.py

@@ -2,8 +2,9 @@ import os
 import rasterio
 import matplotlib.pyplot as plt
 import numpy as np
+ 
+USED_BANDS = (1,2,3,8,11,12) 
 
-data_root = "./datasets/Timor_Ml4Floods"
 
 def check_ground_truth(gt_file):
     with rasterio.open(gt_file) as src:
@@ -72,48 +73,50 @@ def visualize_ground_truth(gt_file):
     plt.show()
 
 
-def get_gt():
+def get_category(use: str, data_root: str):
  
-    ground_truth = f"{data_root}/GT"
-
-    timor_data_dir = [
-        f"{ground_truth}/EMSR507_AOI01_DEL_PRODUCT",   # <- Pleiades-1A-1B
-        f"{ground_truth}/EMSR507_AOI02_DEL_PRODUCT",   # <- PlanetScope
-        f"{ground_truth}/EMSR507_AOI03_DEL_PRODUCT",   # <- PlanetScope
-        f"{ground_truth}/EMSR507_AOI05_DEL_PRODUCT",   # <- Sentinel-2
-        f"{ground_truth}/EMSR507_AOI07_GRA_PRODUCT"    # <- PlanetScope
+    if use == 'gt':
+        data_dir = f"{data_root}/GT"
+    elif use == 's2':
+        data_dir = f"{data_root}/S2"
+    else:
+        raise ValueError(f"Invalid use type: {use}. Must be 'gt' or 's2'")
+     
+    aoi_configs = [
+        ("AOI01", "DEL", "pleiades"),
+        ("AOI02", "DEL", "planet"),
+        ("AOI03", "DEL", "planet"),
+        ("AOI05", "DEL", "sentinel2"),
+        ("AOI07", "GRA", "planet"),
     ]
-    O1_incl = f"{timor_data_dir[0]}/include.txt"
-    O2_incl = f"{timor_data_dir[1]}/include.txt"
-    O3_incl = f"{timor_data_dir[2]}/include.txt"
-    O5_incl = f"{timor_data_dir[3]}/include.txt"
-    O7_incl = f"{timor_data_dir[4]}/include.txt"
-
-    def read_include(path):
+    
+    def read_include(path: str) -> list[str]:
+ 
         if not os.path.exists(path):
             return []
         with open(path, 'r') as file:
             return [line.strip() for line in file if line.strip()]
-
-    AOIO1 = read_include(O1_incl)
-    AOIO2 = read_include(O2_incl)
-    AOIO3 = read_include(O3_incl)
-    AOIO5 = read_include(O5_incl)
-    AOIO7 = read_include(O7_incl)
-
-    tif01_gt = [f"{timor_data_dir[0]}/EMSR507_AOI01_DEL_PRODUCT_{i}.tif" for i in AOIO1]
-    tif02_gt = [f"{timor_data_dir[1]}/EMSR507_AOI02_DEL_PRODUCT_{i}.tif" for i in AOIO2]
-    tif03_gt = [f"{timor_data_dir[2]}/EMSR507_AOI03_DEL_PRODUCT_{i}.tif" for i in AOIO3]
-    tif05_gt = [f"{timor_data_dir[3]}/EMSR507_AOI05_DEL_PRODUCT_{i}.tif" for i in AOIO5]
-    tif07_gt = [f"{timor_data_dir[4]}/EMSR507_AOI07_GRA_PRODUCT_{i}.tif" for i in AOIO7]
-
-    return {
-        "tif01_gt": tif01_gt,
-        "tif02_gt": tif02_gt,
-        "tif03_gt": tif03_gt,
-        "tif05_gt": tif05_gt,
-        "tif07_gt": tif07_gt
-    }
+    
+    result = {}
+    
+    for aoi_id, product_type, satellite in aoi_configs:
+        aoi_num = aoi_id[-2:]  # Extract "01", "02", etc.
+         
+        aoi_dir = f"{data_dir}/EMSR507_{aoi_id}_{product_type}_PRODUCT"
+        include_path = f"{aoi_dir}/include.txt"
+         
+        include_items = read_include(include_path)
+         
+        tif_files = [
+            f"{aoi_dir}/EMSR507_{aoi_id}_{product_type}_PRODUCT_{item}.tif"
+            for item in include_items
+        ]
+        
+ 
+        key = f"tif{aoi_num}_{'gt' if use == 'gt' else 's2'}"
+        result[key] = tif_files
+    
+    return result
 
 SATELLITE_MAP = {
     "tif01_s2": "pleiades",
@@ -125,7 +128,7 @@ SATELLITE_MAP = {
 
 def plot_all_gt_with_labels():
  
-    gt_dict = get_gt()
+    gt_dict = get_category(use='s2', data_root='./datasets/Timor_ML4FLood')
     
     for key, file_list in gt_dict.items():
  
@@ -172,9 +175,9 @@ def plot_all_gt_with_labels():
             plt.tight_layout()
             plt.show()
 
-
 plot_all_gt_with_labels()
 
+
  
 
  

process_patches.py

@@ -0,0 +1,207 @@
+import torch
+import rasterio
+from PIL import Image, ImageDraw, ImageFont
+import os
+import numpy as np
+
+class InMemoryDataset(torch.utils.data.Dataset):
+    def __init__(self, data_list, preprocess_func):
+        self.data_list = data_list
+        self.preprocess_func = preprocess_func
+
+    def __getitem__(self, i):
+        return self.preprocess_func(self.data_list[i])
+
+    def __len__(self):
+        return len(self.data_list)
+
+INPUT_SIZE = 224
+PATCH_SIZE = 224
+STRIDE = 224
+
+root = 'datasets/WorldFloodsv2'
+test_path_s2 = f'{root}/train/S2/'
+test_path_labels = f'{root}/train/gt/'  
+ 
+
+extension = '.tif'
+
+timor_leste_events = {
+    "EMSR507_AOI01_DEL_PRODUCT": "Pleiades-1A-1B",
+    "EMSR507_AOI02_DEL_PRODUCT": "PlanetScope",
+    "EMSR507_AOI03_DEL_PRODUCT": "PlanetScope",
+    "EMSR507_AOI05_DEL_PRODUCT": "Sentinel-2",
+    "EMSR507_AOI07_GRA_PRODUCT": "PlanetScope"
+}
+
+files_s2 = [(f"{test_path_s2}{event_id}{extension}", satellite) 
+            for event_id, satellite in timor_leste_events.items()]
+
+files_gt = [(f"{test_path_labels}{event_id}{extension}", satellite) 
+            for event_id, satellite in timor_leste_events.items()]
+
+ 
+output_root_s2 = "./datasets/Timor_Processed/S2"
+os.makedirs(output_root_s2, exist_ok=True)
+
+output_root_gt = "./datasets/Timor_Processed/GT"
+os.makedirs(output_root_gt, exist_ok=True)
+
+output_root_floodmask = "./datasets/Timor_Processed/Floodmask"
+os.makedirs(output_root_gt, exist_ok=True)
+
+def sliding_window_crop(image, window_size=PATCH_SIZE, stride=STRIDE):
+    C, H, W = image.shape
+    patches = []
+    for y in range(0, H, stride):
+        for x in range(0, W, stride):
+            y_end = min(y + window_size, H)
+            x_end = min(x + window_size, W)
+            y_start = max(y_end - window_size, 0)
+            x_start = max(x_end - window_size, 0)
+            patch = image[:, y_start:y_end, x_start:x_end]
+            patches.append(patch)
+    return patches
+
+
+def read_tif_as_tensor(tif_path):
+    with rasterio.open(tif_path) as src:
+        img = src.read()  # shape: (bands, H, W)
+        img = torch.from_numpy(img).float()
+    return img
+
+
+def save_patch_as_tif(patch_tensor, output_path):
+    patch_np = patch_tensor.numpy()
+    with rasterio.open(
+        output_path,
+        'w',
+        driver='GTiff',
+        height=patch_np.shape[1],
+        width=patch_np.shape[2],
+        count=patch_np.shape[0],
+        dtype=patch_np.dtype
+    ) as dst:
+        dst.write(patch_np)
+
+
+def plot_patches(patches, cols=5, save_path=None, is_label=False):
+    rows = (len(patches) + cols - 1) // cols
+    patch_images = []
+    font = ImageFont.load_default()
+
+    for idx, patch in enumerate(patches):
+        if is_label:
+            # Labels assumed to be single-channel
+            patch_np = patch[0].numpy()
+            patch_np = ((patch_np - patch_np.min()) / (patch_np.max() - patch_np.min() + 1e-8) * 255).astype(np.uint8)
+            img = Image.fromarray(patch_np).convert("L")
+        else:
+            # RGB visualization for images
+            patch_np = patch[:3].numpy()
+            patch_np = (patch_np - patch_np.min()) / (patch_np.max() - patch_np.min() + 1e-8) * 255
+            patch_np = patch_np.transpose(1,2,0).astype(np.uint8)
+            img = Image.fromarray(patch_np)
+        draw = ImageDraw.Draw(img)
+        draw.text((5,5), str(idx), fill=(255,0,0), font=font)
+        patch_images.append(img)
+
+    width, height = patch_images[0].size
+    grid_img = Image.new('RGB' if not is_label else 'L', (cols * width, rows * height), color=(255,255,255) if not is_label else 255)
+    for i, img in enumerate(patch_images):
+        row = i // cols
+        col = i % cols
+        grid_img.paste(img, (col*width, row*height))
+
+    if save_path:
+        grid_img.save(save_path)
+
+# Class color map: 0=invalid, 1=land, 2=flood, 3=permanent water
+CLASS_COLORS = {
+    0: (0, 0, 0),       # black for invalid/no data
+    1: (34, 139, 34),   # green for flood (gt)
+    2: (0, 0, 255),     # blue for cloud (gt)
+}
+
+def plot_label_patches(label_patches, cols=5, save_path=None):
+    rows = (len(label_patches) + cols - 1) // cols
+    patch_images = []
+    font = ImageFont.load_default()
+
+    for idx, patch in enumerate(label_patches):
+        patch_np = patch[0].numpy().astype(int)  # assume single channel
+        H, W = patch_np.shape
+        color_img = np.zeros((H, W, 3), dtype=np.uint8)
+        for cls, color in CLASS_COLORS.items():
+            color_img[patch_np == cls] = color
+        img = Image.fromarray(color_img)
+        draw = ImageDraw.Draw(img)
+        draw.text((5,5), str(idx), fill=(255,0,0), font=font)
+        patch_images.append(img)
+
+    width, height = patch_images[0].size
+    grid_img = Image.new('RGB', (cols * width, rows * height), color=(255,255,255))
+    for i, img in enumerate(patch_images):
+        row = i // cols
+        col = i % cols
+        grid_img.paste(img, (col*width, row*height))
+
+    if save_path:
+        grid_img.save(save_path)
+
+
+# Main processing loop
+for tif_path, satellite in files_s2:
+    print(f"Processing {tif_path} ({satellite})...")
+    img_tensor = read_tif_as_tensor(tif_path)
+    patches = sliding_window_crop(img_tensor, PATCH_SIZE, STRIDE)
+
+    base_name = os.path.splitext(os.path.basename(tif_path))[0]
+    patch_output_dir = os.path.join(output_root_s2, base_name)
+    os.makedirs(patch_output_dir, exist_ok=True)
+
+    # Save image patches
+    for idx, patch in enumerate(patches):
+        patch_name = f"{base_name}_{idx}.tif"
+        save_patch_as_tif(patch, os.path.join(patch_output_dir, patch_name))
+
+    # # Plot image patches
+    # plot_save_path = os.path.join(patch_output_dir, f"{base_name}_grid.png")
+    # plot_patches(patches, save_path=plot_save_path)
+
+    # # If labels exist in a corresponding folder
+    # label_path = tif_path.replace('/S2/', '/gt/')  # assuming label folder structure
+    # if os.path.exists(label_path):
+    #     label_tensor = read_tif_as_tensor(label_path)
+    #     label_patches = sliding_window_crop(label_tensor, PATCH_SIZE, STRIDE)
+    #     plot_label_path = os.path.join(patch_output_dir, f"{base_name}_labels_grid.png")
+    #     plot_label_patches(label_patches, save_path=plot_label_path)
+
+
+# Main processing loop
+for tif_path, satellite in files_gt:
+    print(f"Processing {tif_path} ({satellite})...")
+    img_tensor = read_tif_as_tensor(tif_path)
+    patches = sliding_window_crop(img_tensor, PATCH_SIZE, STRIDE)
+
+    base_name = os.path.splitext(os.path.basename(tif_path))[0]
+    patch_output_dir = os.path.join(output_root_gt, base_name)
+    os.makedirs(patch_output_dir, exist_ok=True)
+
+    # Save image patches
+    for idx, patch in enumerate(patches):
+        patch_name = f"{base_name}_{idx}.tif"
+        save_patch_as_tif(patch, os.path.join(patch_output_dir, patch_name))
+
+    # # Plot image patches
+    # plot_save_path = os.path.join(patch_output_dir, f"{base_name}_grid.png")
+    # plot_patches(patches, save_path=plot_save_path)
+
+    # # If labels exist in a corresponding folder
+    # label_path = tif_path.replace('/S2/', '/gt/')  # assuming label folder structure
+    # if os.path.exists(label_path):
+    #     label_tensor = read_tif_as_tensor(label_path)
+    #     label_patches = sliding_window_crop(label_tensor, PATCH_SIZE, STRIDE)
+    #     plot_label_path = os.path.join(patch_output_dir, f"{base_name}_labels_grid.png")
+    #     plot_label_patches(label_patches, save_path=plot_label_path)
+

statistics.py

@@ -0,0 +1,116 @@
+import os
+import rasterio
+import numpy as np
+from tqdm import tqdm
+
+USED_BANDS = (1, 2, 3, 8, 11, 12)
+
+def get_category(use: str, data_root: str):
+    """Get file paths for specified data type"""
+    if use == 'gt':
+        data_dir = f"{data_root}/GT"
+    elif use == 's2':
+        data_dir = f"{data_root}/S2"
+    else:
+        raise ValueError(f"Invalid use type: {use}. Must be 'gt' or 's2'")
+     
+    aoi_configs = [
+        ("AOI01", "DEL", "pleiades"),
+        ("AOI02", "DEL", "planet"),
+        ("AOI03", "DEL", "planet"),
+        ("AOI05", "DEL", "sentinel2"),
+        ("AOI07", "GRA", "planet"),
+    ]
+    
+    def read_include(path: str) -> list[str]:
+        if not os.path.exists(path):
+            return []
+        with open(path, 'r') as file:
+            return [line.strip() for line in file if line.strip()]
+    
+    result = {}
+    
+    for aoi_id, product_type, satellite in aoi_configs:
+        aoi_num = aoi_id[-2:]
+        aoi_dir = f"{data_dir}/EMSR507_{aoi_id}_{product_type}_PRODUCT"
+        include_path = f"{aoi_dir}/include.txt"
+        include_items = read_include(include_path)
+        tif_files = [
+            f"{aoi_dir}/EMSR507_{aoi_id}_{product_type}_PRODUCT_{item}.tif"
+            for item in include_items
+        ]
+        key = f"tif{aoi_num}_{'gt' if use == 'gt' else 's2'}"
+        result[key] = tif_files
+    
+    return result
+
+
+def calculate_s2_statistics(data_root: str, used_bands=USED_BANDS):
+ 
+    print("Getting S2 file paths...")
+    s2_dict = get_category(use='s2', data_root=data_root)
+     
+    all_files = []
+    for key, file_list in s2_dict.items():
+        all_files.extend(file_list)
+     
+    all_files = [f for f in all_files if os.path.exists(f)]
+    
+     
+    band_indices = [b - 1 for b in used_bands]
+    num_bands = len(band_indices)
+     
+    count = 0
+    mean = np.zeros(num_bands, dtype=np.float64)
+    m2 = np.zeros(num_bands, dtype=np.float64)  
+     
+    for file_path in tqdm(all_files, desc="Computing statistics"):
+        try:
+            with rasterio.open(file_path) as src:
+ 
+                data = src.read()
+                
+ 
+                if data.shape[0] < max(used_bands):
+                    print(f"\nWarning: {os.path.basename(file_path)} has only {data.shape[0]} bands, skipping...")
+                    continue
+                 
+                selected_bands = data[band_indices, :, :]
+                 
+                num_pixels = selected_bands.shape[1] * selected_bands.shape[2]
+                pixels = selected_bands.reshape(num_bands, -1)
+                 
+                for i in range(num_pixels):
+                    pixel_values = pixels[:, i]
+                     
+                    if np.any(np.isnan(pixel_values)) or np.any(np.isinf(pixel_values)):
+                        continue
+                    
+                    count += 1
+                    delta = pixel_values - mean
+                    mean += delta / count
+                    delta2 = pixel_values - mean
+                    m2 += delta * delta2
+                    
+        except Exception as e:
+            print(f"\nError processing {os.path.basename(file_path)}: {e}")
+            continue
+    
+    if count == 0:
+        raise ValueError("No valid pixels found in dataset!")
+     
+    variance = m2 / count
+    std = np.sqrt(variance)
+ 
+    print("\nFormatted for code:")
+    print(f"MEANS = [{', '.join([f'{m:.8f}' for m in mean])}]")
+    print(f"STDS  = [{', '.join([f'{s:.8f}' for s in std])}]")
+    
+    return mean.tolist(), std.tolist()
+
+
+if __name__ == "__main__":
+ 
+    data_root = "./datasets/Timor_ML4Floods"
+    
+    means, stds = calculate_s2_statistics(data_root)