code/architectures/SpatiotemporalGatedTransformer/dataloader/dataloaderMultiYears.py

import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
import os
from pathlib import Path
import re
import glob
import pandas as pd
from config import bands_list_order , time_before, LOADING_TIME_BEGINNING , window_size


def get_metadata(self, id_num):
    """Get metadata from filename"""
    if id_num not in self.id_to_file:
        raise ValueError(f"ID {id_num} not found")

    filename = self.id_to_file[id_num].name
    pattern = r'ID(\d+)N(\d+\.\d+)S(\d+\.\d+)W(\d+\.\d+)E(\d+\.\d+)'
    match = re.search(pattern, filename)

    if match:
        return {
            'id': int(match.group(1)),
            'north': float(match.group(2)),
            'south': float(match.group(3)),
            'west': float(match.group(4)),
            'east': float(match.group(5))
        }
    return None

def get_available_ids(self):
    """Return list of available IDs"""
    return list(self.id_to_file.keys())


class RasterTensorDataset(Dataset):
    def __init__(self, base_path):
        """
        Initialize the dataset

        Parameters:
        base_path: str, base path to RasterTensorData directory
        subfolder: str, name of the subfolder (e.g., 'Elevation')
        """
        
        self.folder_path = base_path

        # Create ID to filename mapping
        self.id_to_file = self._create_id_mapping()

        # Load all numpy arrays into memory (optional, can be modified to load on demand)
        self.data_cache = {}
        for id_num, filepath in self.id_to_file.items():
            self.data_cache[id_num] = np.load(filepath)

    def _create_id_mapping(self):
        """Create a dictionary mapping IDs to their corresponding file paths"""
        id_to_file = {}
        for file_path in glob.glob(os.path.join(self.folder_path, "*.npy")):
            # Extract ID number from filename
            match = re.search(r'ID(\d+)N', file_path)
            if match:
                id_num = int(match.group(1))
                id_to_file[id_num] = file_path

        return id_to_file

    def get_tensor_by_location(self, id_num, x, y, window_size=window_size):
        """
        Get a window_size x window_size square around the specified x,y coordinates

        Parameters:
        id_num: int, ID number from filename
        x: int, x coordinate
        y: int, y coordinate
        window_size: int, size of the square window (default 17)

        Returns:
        torch.Tensor: window_size x window_size tensor
        """
        # coordinates.npy stores id_num/x/y as float64; coerce so dict lookup and slice indices work.
        id_num = int(id_num)
        x = int(x)
        y = int(y)
        if id_num not in self.id_to_file:
            raise ValueError(
                f"ID {id_num} not found in dataset at {self.folder_path} "
                f"(available IDs: {sorted(self.id_to_file.keys())})"
            )

        # Get the data array
        if id_num in self.data_cache:
            data = self.data_cache[id_num]
        else:
            data = np.load(self.id_to_file[id_num])

        # Calculate window boundaries
        half_window = window_size // 2
        x_start = int(max(0, x - half_window))
        x_end = int(min(data.shape[0], x + half_window + 1))
        y_start = int(max(0, y - half_window))
        y_end = int(min(data.shape[1], y + half_window + 1))

        # Extract window
        window = data[x_start:x_end, y_start:y_end]

        # Pad if necessary
        if window.shape != (window_size, window_size):
            padded_window = np.zeros((window_size, window_size))
            x_offset = half_window - (x - x_start)
            y_offset = half_window - (y - y_start)
            padded_window[
                x_offset:x_offset+window.shape[0],
                y_offset:y_offset+window.shape[1]
            ] = window
            window = padded_window
        
        #window = np.asarray(window)
        return torch.from_numpy(window).float()

    def __len__(self):
        return len(self.id_to_file)

    def __getitem__(self, idx):
        # This is a placeholder implementation
        # Modify according to your specific needs
        id_num = list(self.id_to_file.keys())[idx]
        return self.data_cache[id_num]

# Example usage:
"""
# Initialize the dataset
base_path = "/content/drive/MyDrive/Colab Notebooks/MappingSOC/Data/RasterTensorData"
dataset = RasterTensorDataset(base_path, "Elevation")

# Get the dictionary mapping IDs to filenames
id_mapping = dataset.id_to_file
print("ID to filename mapping:", id_mapping)

# Get a 17x17 window for a specific location
id_num = 10  # example ID
x, y = 100, 100  # example coordinates
window = dataset.get_tensor_by_location(id_num, x, y)
print("Window shape:", window.shape)

# Create a DataLoader if needed
from torch.utils.data import DataLoader
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
"""


class MultiRasterDatasetMultiYears(Dataset):
    def __init__(self, samples_coordinates_array_subfolders ,  data_array_subfolders , dataframe, time_before = time_before):
        """
        Parameters:
        subfolders: list of str, names of subfolders to include
        dataframe: pandas.DataFrame, contains columns GPS_LONG, GPS_LAT, and OC (target variable)
        """
        self.data_array_subfolders = data_array_subfolders
        self.seasonalityBased = self.check_seasonality(data_array_subfolders)
        self.time_before = time_before
        self.samples_coordinates_array_subfolders = samples_coordinates_array_subfolders
        self.dataframe = dataframe
        self.datasets = {
            self.get_last_three_folders(subfolder): RasterTensorDataset(subfolder)
            for subfolder in  self.data_array_subfolders
        }
        
        self.coordinates = {
            self.get_last_three_folders(subfolder): np.load(f"{subfolder}/coordinates.npy")#[np.isfinite(np.load(f"{subfolder}/coordinates.npy"))]
            for subfolder in self.samples_coordinates_array_subfolders
        }

        # O(1) (lat, lon) lookup hashmap — replaces a per-call np.where scan
        # over the 30k-row coordinates.npy. Cuts dataset materialisation
        # from minutes to seconds.
        self._coord_index = {
            subfolder: {
                (round(float(row[0]), 9), round(float(row[1]), 9)):
                    (row[2], row[3], row[4])
                for row in coords
            }
            for subfolder, coords in self.coordinates.items()
        }

    def check_seasonality(self,data_array_subfolders):
        seasons = ['winter', 'spring', 'summer', 'autumn']

        # Check if any subfolder contains a season name
        is_seasonal = any(
            any(season in str(subfolder).lower() for season in seasons)
            for subfolder in data_array_subfolders
        )

        return 1 if is_seasonal else 0


    def get_last_three_folders(self,path):
        # Split the path into components
        parts = path.rstrip('/').split('/')
        # Return last 3 components, or all if less than 3
        return '/'.join(parts[-2:])

    def find_coordinates_index(self, subfolder, longitude, latitude):
        """O(1) lookup via the (lat, lon) hashmap built in __init__,
        with the legacy linear scan kept as a fallback for any edge-case
        keys that don't round-trip cleanly through float→round(9)."""
        key = (round(float(latitude), 9), round(float(longitude), 9))
        idx = self._coord_index[subfolder].get(key)
        if idx is not None:
            return idx
        coords = self.coordinates[subfolder]
        match = np.where((coords[:, 1] == longitude) & (coords[:, 0] == latitude))[0]
        if match.size == 0:
            raise ValueError(f"{coords} Coordinates ({longitude}, {latitude}) not found in {subfolder}")
        return coords[match[0], 2], coords[match[0], 3], coords[match[0], 4]

    def __getitem__(self, index):
        """
        Retrieve tensor and target value for a given index.

        Parameters:
        index: int, index of the row in the dataframe

        Returns:
        tuple: (tensor, OC), where tensor is the data and OC is the target variable
        """
        row = self.dataframe.iloc[index]
        longitude, latitude, oc = row["GPS_LONG"], row["GPS_LAT"], row["OC"]
        tensors = []
        
        filtered_array = self.filter_by_season_or_year(row['season'],row['year'],self.seasonalityBased)
                # Initialize a dictionary to hold the tensors for each band
        band_tensors = {band: [] for band in bands_list_order}

        for subfolder in filtered_array:
            subfolder = self.get_last_three_folders(subfolder)

            # Check if the forelast subfolder is 'Elevation'
            if subfolder.split(os.path.sep)[-1] == 'Elevation':
                # Get the tensor for 'Elevation'
                id_num, x, y = self.find_coordinates_index(subfolder, longitude, latitude)
                elevation_tensor = self.datasets[subfolder].get_tensor_by_location(id_num, x, y)

                if elevation_tensor is not None:
                    # Repeat the 'Elevation' tensor self.time_before times
                    for _ in range(self.time_before):
                        band_tensors['Elevation'].append(elevation_tensor)
            else:
                # Get the year from the last subfolder
                year = int(subfolder.split(os.path.sep)[-1])

                # Decrement the year by self.time_before
                for decrement in range(self.time_before):
                    current_year = year - decrement

                    # Construct the subfolder with the decremented year
                    decremented_subfolder = os.path.sep.join(subfolder.split(os.path.sep)[:-1] + [str(current_year)])

                    id_num, x, y = self.find_coordinates_index(decremented_subfolder, longitude, latitude)
                    tensor = self.datasets[decremented_subfolder].get_tensor_by_location(id_num, x, y)

                    if tensor is not None:
                        # Append the tensor to the corresponding band in the dictionary
                        band = subfolder.split(os.path.sep)[-2]
                        band_tensors[band].append(tensor)

        # Stack the tensors for each band
        stacked_tensors = []
        for band in bands_list_order:
            if band_tensors[band]:
                # Stack the tensors for the current band
                stacked_tensor = torch.stack(band_tensors[band])
                stacked_tensors.append(stacked_tensor)

        # Concatenate all stacked tensors along the band dimension
        final_tensor = torch.stack(stacked_tensors)
        final_tensor = final_tensor.permute(0, 2, 3, 1)

        return longitude, latitude, final_tensor, oc
       

    
    def filter_by_season_or_year(self, season,year,Season_or_year):

        if Season_or_year:
            filtered_array = [
                path for path in self.samples_coordinates_array_subfolders
                if ('Elevation' in path) or
                ('MODIS_NPP' in path and path.endswith(str(year))) or
                (not 'Elevation' in path and not 'MODIS_NPP' in path and path.endswith(season))
            ]
            
        else:
            filtered_array = [
                            path for path in self.samples_coordinates_array_subfolders
                            if ('Elevation' in path) or
                            (not 'Elevation' in path and path.endswith(str(year)))
                        ]
        return filtered_array

    def __len__(self):
        """
        Return the number of samples in the dataset.
        """
        return len(self.dataframe)

    def get_tensor_by_location(self, subfolder, id_num, x, y):
        """Get tensor from specific subfolder dataset"""
        return self.datasets[subfolder].get_tensor_by_location(id_num, x, y)

class NormalizedMultiRasterDatasetMultiYears(MultiRasterDatasetMultiYears):
    """Wrapper around MultiRasterDatasetMultiYears that adds feature normalization"""
    def __init__(self, samples_coordinates_array_path, data_array_path, df):
        super().__init__(samples_coordinates_array_path, data_array_path, df)
        self.compute_statistics()

    def compute_statistics(self):
        """Compute mean and std across all features for normalization"""
        features_list = []
        for i in range(len(self)):
            _, _, features, _ = super().__getitem__(i)
            features_list.append(features.numpy())

        features_array = np.stack(features_list)
        self._feature_means = torch.tensor(np.mean(features_array, axis=(0, 2, 3)), dtype=torch.float32)
        self._feature_stds = torch.tensor(np.std(features_array, axis=(0, 2, 3)), dtype=torch.float32)
        self._feature_stds = torch.clamp(self._feature_stds, min=1e-8)

    def __getitem__(self, idx):
        longitude, latitude, features, target = super().__getitem__(idx)
        features = (features - self._feature_means[:, None, None]) / self._feature_stds[:, None, None]
        return longitude, latitude, features, target

    def get_statistics(self):
        """Getter for feature means and standard deviations"""
        return self._feature_means, self._feature_stds

    def get_feature_means(self):
        """Getter for feature means"""
        return self._feature_means

    def get_feature_stds(self):
        """Getter for feature standard deviations"""
        return self._feature_stds

    def set_feature_means(self, means):
        """Setter for feature means"""
        self._feature_means = means

    def set_feature_stds(self, stds):
        """Setter for feature standard deviations"""
        self._feature_stds = stds