Update PASTIS.py

PASTIS.py

@@ -14,10 +14,49 @@ S2_MEAN = [1180.2278549 , 1387.76882557, 1436.67627781, 1773.66437066, 2735.8641
 
 S2_STD = [1976.91493068, 1917.02121286, 1996.45123112, 1903.34296117, 1785.08356262, 1796.4477813 , 1811.90019014, 1793.47036145, 1474.46979658, 1309.88416505]
 
+S1A_MEAN = [-10.91848081, -17.34320436]
+
+S1A_STD = [3.26830557, 3.19895575]
+
+S1D_MEAN = [-11.07395082, -17.45261358]
+
+S1D_STD = [3.33774017, 3.15584225]
+
+S1_MEAN = [-10.996215815 -17.39790897]
+
+S1_STD = [3.30411987, 3.177943]
+
+s1_metadata = {
+    'radar': {
+        'mean': S1_MEAN,
+        'std': S1_STD,
+    },
+    'radar_a': {
+        'mean': S1A_MEAN,
+        'std': S1A_STD,
+    },
+    'radar_d': {
+        'mean': S1D_MEAN,
+        'std': S1D_STD,
+    },
+}
+
+s1_num_seq = {
+    'radar': 142,
+    'radar_a': 71,
+    'radar_d': 71,
+}
+
+sats = {
+    "radar": ["S2", "S1A", "S1D"],
+    "radar_a": ["S2", "S1A"],
+    "radar_d": ["S2", "S1D"],
+}
+
 class PASTISDataset(datasets.GeneratorBasedBuilder):
     VERSION = datasets.Version("1.0.0")
     
-    DATA_URL = "https://huggingface.co/datasets/GFM-Bench/PASTIS/resolve/main/PASTIS.zip"
+    DATA_URL = "https://huggingface.co/datasets/GFM-Bench/PASTIS/resolve/main/PASTIS.tar.xz"
 
     metadata = {
         "s2c": {
@@ -27,10 +66,8 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
             "std": S2_STD,
         },
         "s1": {
-            "bands": None,
-            "channel_wv": None,
-            "mean": None,
-            "std": None   
+            "bands": ["VV", "VH"],
+            "channel_wv": [5500, 5700],
         }
     }
 
@@ -40,11 +77,26 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
 
     NUM_CLASSES = 20 # 0 is background class, and 19 is the void label
 
-    def __init__(self, reference_date="2018-09-10", **kwargs):
-        super().__init__(**kwargs)
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="default"),
+        *[datasets.BuilderConfig(name=name) for name in ['radar', 'radar_a', 'radar_d']]
+    ] 
+
+    DEFAULT_CONFIG_NAME = "radar"
+
+    def __init__(self, reference_date="2018-09-10", config_name="default", **kwargs):
+        super().__init__(config_name=config_name, **kwargs)
         self.reference_date = datetime(*map(int, reference_date.split("-")))
         print(f"reference_date: {reference_date} -> {self.reference_date}")
-    
+        print(f"config_name: {config_name}")
+
+        config_name = "radar" if config_name == "default" else config_name
+        self.NUM_RADAR_SEQ = s1_num_seq[config_name]
+        self.sats = sats[config_name]
+        self.metadata["s1"].update(s1_metadata[config_name])
+        self.sats_name = config_name
+
     def _split_generators(self, dl_manager):
         if isinstance(self.DATA_URL, list):
             downloaded_files = dl_manager.download(self.DATA_URL)
@@ -87,20 +139,26 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
         metadata['size'] = self.SIZE
         metadata['num_classes'] = self.NUM_CLASSES
         metadata['spatial_resolution'] = self.spatial_resolution
+
         return datasets.DatasetInfo(
             description=json.dumps(metadata),
             features=datasets.Features({
                 "optical": datasets.Array4D(shape=(61, 10, self.HEIGHT, self.WIDTH), dtype="float32"),
+                "radar": datasets.Array4D(shape=(self.NUM_RADAR_SEQ, 2, self.HEIGHT, self.WIDTH), dtype="float32"),
                 "label": datasets.Array2D(shape=(self.HEIGHT, self.WIDTH), dtype="int32"),
-                "dates": datasets.Sequence(datasets.Value("int32")),
-                "sequence_len": datasets.Value("int32"),
+                "optical_dates": datasets.Sequence(datasets.Value("int32")),
+                "radar_dates": datasets.Sequence(datasets.Value("int32")),
+                "optical_sequence_len": datasets.Value("int32"),
+                "radar_sequence_len": datasets.Value("int32"),
                 "optical_channel_wv": datasets.Sequence(datasets.Value("float32")),
+                "radar_channel_wv": datasets.Sequence(datasets.Value("float32")),
                 "spatial_resolution": datasets.Value("int32"),
             }),
         )
 
     def _generate_examples(self, split, data_dir):
         optical_channel_wv = self.metadata["s2c"]["channel_wv"]
+        radar_channel_wv = self.metadata["s1"]["channel_wv"]
         spatial_resolution = self.spatial_resolution
 
         data_dir = os.path.join(data_dir, "PASTIS")
@@ -108,26 +166,53 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
         metadata = metadata[metadata["split"] == split].reset_index(drop=True)
 
         self._prepare_meta_patch(data_dir)
-        self._prepare_date_tables(data_dir)
+        self._prepare_date_tables()
 
         for index, row in metadata.iterrows():
             id_patch = row.optical_path.replace("DATA_S2/S2_", "").replace(".tif", "")
+
             optical_path = os.path.join(data_dir, row.optical_path)
             optical = self._read_image(optical_path).astype(np.float32) # TxCxHxW
-            sequence_len = optical.shape[0]
-            optical = self._pad_sequence(optical) # 61xCxHxW
+            optical_sequence_len = optical.shape[0]
+            optical = self._pad_sequence(optical, sat="S2") # 61xCxHxW
+            optical_dates = self._get_dates(id_patch=id_patch, sat="S2")
+
+            radar_sequence_len = 0
+            if self.sats_name in ["radar", "radar_a"]:
+                radar_a_path = os.path.join(data_dir, row.radar_a_path)
+                radar_a = self._read_image(radar_a_path).astype(np.float32)[:, :2, :, :] # T, 2, 128, 128
+                radar_a_dates = self._get_dates(id_patch=id_patch, sat="S1A")
+                radar_sequence_len += radar_a.shape[0]
+                if self.sats_name == "radar_a":
+                    radar = self._pad_sequence(radar_a, "S1A") # 71, 2, 128, 128
+                    radar_dates = radar_a_dates
+            
+            if self.sats_name in ["radar", "radar_d"]:
+                radar_d_path = os.path.join(data_dir, row.radar_d_path)
+                radar_d = self._read_image(radar_d_path).astype(np.float32)[:, :2, :, :]
+                radar_d_dates = self._get_dates(id_patch=id_patch, sat="S1D")
+                radar_sequence_len += radar_d.shape[0]
+                if self.sats_name == "radar_d":
+                    radar = self._pad_sequence(radar_d, sat="S1D") # 71, 2, 128, 128
+                    radar_dates = radar_d_dates
+
+            if self.sats_name == "radar":
+                assert radar_a is not None and radar_d is not None
+                radar, radar_dates = self._merge_sort_dates(radar_a_dates, radar_d_dates, radar_a, radar_d)
+                radar = self._pad_sequence(radar, sat="S1_both") # 142, 2, 128, 128
 
             label_path = os.path.join(data_dir, row.label_path) # 3xHxW
             label = tifffile.imread(label_path)[0] # HxW
 
-            # Retrieve date sequences
-            dates = self._get_dates(id_patch=id_patch, sat="S2")
-
             sample = {
                 "optical": optical,
                 "optical_channel_wv": optical_channel_wv,
-                "dates": dates,
-                "sequence_len": sequence_len,
+                "optical_dates": optical_dates,
+                "optical_sequence_len": optical_sequence_len,
+                "radar": radar,
+                "radar_channel_wv": radar_channel_wv,
+                "radar_dates": radar_dates,
+                "radar_sequence_len": radar_sequence_len,
                 "label": label,
                 "spatial_resolution": spatial_resolution,
             }
@@ -135,16 +220,15 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
             yield f"{index}", sample
 
     # util functions
-
     def _prepare_meta_patch(self, data_dir):
         self.meta_patch = gpd.read_file(os.path.join(data_dir, "metadata.geojson"))
         self.meta_patch.index = self.meta_patch["ID_PATCH"].astype(int)
         self.meta_patch.sort_index(inplace=True)
 
-    def _prepare_date_tables(self, data_dir):
-        self.date_tables = {"S2": None}
+    def _prepare_date_tables(self):
+        self.date_tables = {sat: None for sat in self.sats}
         self.date_range = np.array(range(-200, 600))
-        for s in ["S2"]:
+        for s in self.sats:
             dates = self.meta_patch["dates-{}".format(s)]
             date_table = pd.DataFrame(
                 index=self.meta_patch.index, columns=self.date_range, dtype=int
@@ -169,22 +253,33 @@ class PASTISDataset(datasets.GeneratorBasedBuilder):
     def _get_dates(self, id_patch, sat="S2"):
         id_patch = int(id_patch)
         return self.date_range[np.where(self.date_tables[sat][id_patch] == 1)[0]]
+
+    def _merge_sort_dates(self, radar_a_dates, radar_d_dates, radar_a, radar_d):
+        merged_dates = np.concatenate((radar_a_dates, radar_d_dates))
+        sorted_indices = np.argsort(merged_dates)
+
+        sorted_images = np.concatenate((radar_a, radar_d), axis=0)[sorted_indices]
+        sorted_dates = merged_dates[sorted_indices]
+
+        return sorted_images, sorted_dates
     
-    def _pad_sequence(self, optical):
-        padding_size = 61 - optical.shape[0]
+    def _pad_sequence(self, image, sat="S2"):
+        assert sat in ["S2", "S1A", "S1D", "S1_both"]
+        sizes = {"S2": 61, "S1A": 71, "S1D": 71, "S1_both": 142}
+        assert image.shape[0] <= sizes[sat]
+        padding_size = sizes[sat] - image.shape[0]
         if padding_size == 0:
-            return optical
+            return image
         
-        pad = np.zeros((padding_size, *optical.shape[1:]))
-        padded_optical = np.concatenate((optical, pad), axis=0)
-        return padded_optical
+        pad = np.zeros((padding_size, *image.shape[1:]))
+        padded_image = np.concatenate((image, pad), axis=0)
+        return padded_image
 
     def _read_image(self, image_path):
         """Read tiff image from image_path
         Args:
             image_path: 
                 Image path to read from
-
         Return:
             image: 
                 C, H, W numpy array image