Datasets:

musmb
/

CPAZMaL

#!/usr/bin/env python3
"""
Utilities for loading and manipulating HDF5 dataset optimized for ML.
Features:
- Fast extraction by class, temporal period
- Create temporal sequences for LSTM/Transformer
- Automatic data normalization
- Filter by metadata (angle, resolution, etc.)
- Extract sliding windows for learning
- Support filtering by mask values
Learning scenarios:
1. Temporal stacking classification (group k-fold)
2. Temporal prediction LSTM (time series)
3. Domain adaptation HH vs HV
4. Domain adaptation PAZ vs TerraSAR-X
"""

import h5py
import numpy as np
import json
from typing import List, Dict, Tuple, Optional, Union
from tqdm import tqdm
from joblib import Parallel, delayed


class MLDatasetLoader:
    """Class to efficiently load the optimized HDF5 dataset with window extraction"""
    
    def __init__(self, hdf5_path: str):
        """
        Args:
            hdf5_path: Path to HDF5 file
        """
        self.hdf5_path = hdf5_path
        self.file = None
        self._load_metadata()
    
    def _load_metadata(self):
        """Load metadata in memory for fast access"""
        with h5py.File(self.hdf5_path, 'r') as f:
            meta = f['metadata']
            self.classes = json.loads(meta.attrs['classes'])
            self.n_groups = meta.attrs['n_total_groups']
            self.nodata = meta.attrs['nodata_value']
            
            # Charger les index
            self.class_index = {}
            for class_name in f['index/by_class'].keys():
                entries_json = f[f'index/by_class/{class_name}'].attrs['entries_json']
                self.class_index[class_name] = json.loads(entries_json)
            
            temp_ranges_json = f['index/temporal_ranges'].attrs['ranges_json']
            self.temporal_ranges = json.loads(temp_ranges_json)
    
    def __enter__(self):
        """Context manager entry"""
        self.file = h5py.File(self.hdf5_path, 'r')
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Context manager exit"""
        if self.file:
            self.file.close()
    
    def get_group_info(self, group_name: str) -> Dict:
        """Get information for a group"""
        with h5py.File(self.hdf5_path, 'r') as f:
            if group_name not in f['data']:
                raise ValueError(f"Group {group_name} not found")
            
            group = f['data'][group_name]
            return {
                'class': group.attrs['class'],
                'latitude': group.attrs['latitude'],
                'longitude': group.attrs['longitude'],
                'elevation': group.attrs['elevation'],
                'orientation': group.attrs['orientation'],
                'slope': group.attrs['slope'],
                'orbits': list(group.keys())
            }
    
    def extract_windows(
        self,
        image: np.ndarray,
        mask: np.ndarray,
        window_size: int,
        stride: Optional[int] = None,
        max_mask_value: int = 3,
        max_mask_percentage: float = 100.0,
        min_valid_percentage: float = 50.0,
        skip_optim_offset: bool = False
    ) -> Tuple[np.ndarray, np.ndarray, List[Tuple[int, int]]]:
        """
        Extract windows from an image with mask filtering.
        Automatically optimize starting positions to maximize the number of valid windows.
        
        Args:
            image: Image (H, W) or (H, W, C) or (H, W, T) or (H, W, C, T)
            mask: Mask (H, W) or (H, W, T)
            window_size: Window size (square)
            stride: Stride step (if None, = window_size for non-overlapping)
            max_mask_value: Maximum accepted mask value (0, 1, 2, 3)
            max_mask_percentage: Max percentage of pixels with mask > max_mask_value
            min_valid_percentage: Min percentage of valid pixels (non nodata)
            skip_optim_offset: If True, skip offset optimization and use (0, 0)
        
        Returns:
            windows: Array of extracted windows
            window_masks: Array of corresponding masks
            positions: List of (y, x) positions for each window
        """
        if stride is None:
            stride = window_size
        
        # Handle dimensions
        if image.ndim == 2:  # (H, W)
            h, w = image.shape
            has_channels = False
            has_time = False
        elif image.ndim == 3:  # (H, W, C) ou (H, W, T)
            h, w, c = image.shape
            has_channels = True
            has_time = False
        elif image.ndim == 4:  # (H, W, C, T)
            h, w, c, t = image.shape
            has_channels = True
            has_time = True
        
        if mask.ndim == 2:
            mask_has_time = False
        elif mask.ndim == 3:
            mask_has_time = True
        
        # =====================================================================
        # OPTIMIZATION: Find the best starting offset (start_y, start_x)
        # to maximize the number of valid windows
        # =====================================================================
        if skip_optim_offset:
            # Skip optimization and use (0, 0) directly
            best_start_y = 0
            best_start_x = 0
            best_count = -1  # Unknown count when skipping optimization
        else:
            def count_valid_windows(start_y, start_x):
                """Count the number of valid windows for a given offset"""
                count = 0
                for y in range(start_y, h - window_size + 1, stride):
                    for x in range(start_x, w - window_size + 1, stride):
                        # Extract window for testing
                        if mask_has_time:
                            window_mask = mask[y:y+window_size, x:x+window_size, :]
                        else:
                            window_mask = mask[y:y+window_size, x:x+window_size]
                        
                        # Check mask criterion
                        if mask_has_time:
                            bad_pixels = np.any(window_mask > max_mask_value, axis=-1)
                        else:
                            bad_pixels = window_mask > max_mask_value
                        
                        bad_percentage = (np.sum(bad_pixels) / (window_size * window_size)) * 100.0
                        
                        # Check nodata
                        if image.ndim == 2:
                            window = image[y:y+window_size, x:x+window_size]
                        elif image.ndim == 3:
                            window = image[y:y+window_size, x:x+window_size, :]
                        elif image.ndim == 4:
                            window = image[y:y+window_size, x:x+window_size, :, :]
                        
                        # Check nodata and NaN (handle both invalid value types)
                        if has_time:
                            # Check if pixels are nodata OR NaN
                            is_invalid = (window == self.nodata) | np.isnan(window)
                            valid_pixels = np.all(~is_invalid, axis=-1)
                            if has_channels:
                                valid_pixels = np.all(valid_pixels, axis=-1)
                            valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
                        else:
                            if has_channels:
                                is_invalid = (window == self.nodata) | np.isnan(window)
                                valid_pixels = np.all(~is_invalid, axis=-1)
                            else:
                                is_invalid = (window == self.nodata) | np.isnan(window)
                                valid_pixels = ~is_invalid
                            valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
                        
                        # Count if criteria are met
                        if bad_percentage <= max_mask_percentage and valid_percentage >= min_valid_percentage:
                            count += 1
                
                return count
            
            # Test all possible offsets (0 to stride-1 for each dimension)
            # OPTIMIZATION: Parallelization with joblib
            best_count = 0
            best_start_y = 0
            best_start_x = 0
            
            # Limit search to stride (or window_size if non-overlapping)
            max_offset = min(stride, window_size)
            
            # Create list of all offsets to test
            offsets_to_test = []
            for start_y in range(max_offset):
                for start_x in range(max_offset):
                    if start_y + window_size <= h and start_x + window_size <= w:
                        offsets_to_test.append((start_y, start_x))
            
            # Calculate in parallel the number of valid windows for each offset
            counts = Parallel(n_jobs=-1)(
                delayed(count_valid_windows)(start_y, start_x)
                for start_y, start_x in tqdm(offsets_to_test, desc="Optimizing offset", leave=False)
            )
            
            # Find the best offset
            if len(counts) > 0:
                best_idx = np.argmax(counts)
                best_start_y, best_start_x = offsets_to_test[best_idx]
                best_count = counts[best_idx]
        
        # =====================================================================
        # EXTRACTION with the best offset found
        # =====================================================================
        windows = []
        window_masks = []
        positions = []
        
        # Sweep the image with optimal offset
        for y in range(best_start_y, h - window_size + 1, stride):
            for x in range(best_start_x, w - window_size + 1, stride):
                # Extract window
                if image.ndim == 2:
                    window = image[y:y+window_size, x:x+window_size]
                elif image.ndim == 3:
                    window = image[y:y+window_size, x:x+window_size, :]
                elif image.ndim == 4:
                    window = image[y:y+window_size, x:x+window_size, :, :]
                
                if mask_has_time:
                    window_mask = mask[y:y+window_size, x:x+window_size, :]
                else:
                    window_mask = mask[y:y+window_size, x:x+window_size]
                
                # Check mask criterion
                # Pixels with mask > max_mask_value
                if mask_has_time:
                    bad_pixels = np.any(window_mask > max_mask_value, axis=-1)
                else:
                    bad_pixels = window_mask > max_mask_value
                
                bad_percentage = (np.sum(bad_pixels) / (window_size * window_size)) * 100.0
                
                # Check nodata and NaN (handle both invalid value types)
                if has_time:
                    # Check if pixels are nodata OR NaN
                    is_invalid = (window == self.nodata) | np.isnan(window)
                    valid_pixels = np.all(~is_invalid, axis=-1)
                    if has_channels:
                        valid_pixels = np.all(valid_pixels, axis=-1)
                    valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
                else:
                    if has_channels:
                        is_invalid = (window == self.nodata) | np.isnan(window)
                        valid_pixels = np.all(~is_invalid, axis=-1)
                    else:
                        is_invalid = (window == self.nodata) | np.isnan(window)
                        valid_pixels = ~is_invalid
                    valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
                
                # Accept window if criteria are met (use strict inequalities for determinism)
                if bad_percentage <= max_mask_percentage and valid_percentage >= min_valid_percentage:
                    # Ensure float32 type and keep NaN values as-is
                    window = window.astype(np.float32)
                    
                    windows.append(window)
                    window_masks.append(window_mask)
                    positions.append((y, x))
        
        if len(windows) == 0:
            return None, None, []
        
        return np.array(windows), np.array(window_masks), positions
    
    def load_data(
        self,
        group_name: str,
        orbit: str = 'DSC',
        polarisation: Union[str, List[str]] = 'HH',
        start_date: Optional[str] = None,
        end_date: Optional[str] = None,
        normalize: bool = False,
        remove_nodata: bool = True,
        scale_type: str = 'intensity'
    ) -> Dict:
        """
        Load data for a specific group.
        
        Args:
            group_name: Group name (e.g. 'ABL001')
            orbit: 'ASC' or 'DSC'
            polarisation: 'HH', 'HV' or ['HH', 'HV'] for dual-pol
            start_date: Start date (format 'YYYYMMDD')
            end_date: End date (format 'YYYYMMDD')
            normalize: If True, normalize with pre-calculated stats
            remove_nodata: If True, replace nodata with NaN
            scale_type: 'intensity' (default), 'amplitude' (data**0.5), or 'log10' (log10 scale)
        
        Returns:
            Dict containing: images, masks, timestamps, metadata
        """
        with h5py.File(self.hdf5_path, 'r') as f:
            # Support dual-pol
            if isinstance(polarisation, list):
                # Dual-pol: load HH and HV with aligned timestamps
                data_list = []
                for pol in polarisation:
                    path = f'data/{group_name}/{orbit}/{pol}'
                    if path not in f:
                        raise ValueError(f"Path {path} not found in dataset")
                    data_list.append(f[path])
                
                # Trouver les timestamps communs
                timestamps_hh = data_list[0]['timestamps'][:]
                timestamps_hv = data_list[1]['timestamps'][:]
                
                # Intersection of timestamps
                common_ts = np.intersect1d(timestamps_hh, timestamps_hv)
                
                if len(common_ts) == 0:
                    raise ValueError(f"No common timestamps between HH and HV for {group_name}")
                
                # Filter by dates if specified
                if start_date or end_date:
                    mask_ts = np.ones(len(common_ts), dtype=bool)
                    if start_date:
                        mask_ts &= common_ts >= start_date.encode('utf-8')
                    if end_date:
                        mask_ts &= common_ts <= end_date.encode('utf-8')
                    common_ts = common_ts[mask_ts]
                
                if len(common_ts) == 0:
                    raise ValueError(f"No data in specified date range")
                
                # Load data for common timestamps
                images_list = []
                masks_list = []
                angles_list = []
                
                # First, determine minimum dimensions
                min_h, min_w = None, None
                for pol, data_pol in zip(polarisation, data_list):
                    ts_pol = data_pol['timestamps'][:]
                    indices = [np.where(ts_pol == ts)[0][0] for ts in common_ts]
                    img_pol = data_pol['images'][:, :, indices]
                    h, w, t = img_pol.shape
                    if min_h is None:
                        min_h, min_w = h, w
                    else:
                        min_h = min(min_h, h)
                        min_w = min(min_w, w)
                
                # Load and crop
                for pol, data_pol in zip(polarisation, data_list):
                    # Find indices
                    ts_pol = data_pol['timestamps'][:]
                    indices = [np.where(ts_pol == ts)[0][0] for ts in common_ts]
                    
                    # Load and crop to min_h, min_w
                    img_pol = data_pol['images'][:min_h, :min_w, indices]
                    mask_pol = data_pol['masks'][:min_h, :min_w, indices]
                    
                    images_list.append(img_pol)
                    masks_list.append(mask_pol)
                    
                    if pol == polarisation[0]:  # Only once
                        angles_list = data_pol['angles_incidence'][:][indices]
                
                # Stack in last dimension: (H, W, T, 2)
                images = np.stack(images_list, axis=-1)
                
                # Mask: take max between HH and HV
                masks = np.maximum(masks_list[0], masks_list[1])
                
                timestamps = common_ts
                angles = angles_list
                
                metadata = {
                    'polarisation': polarisation,
                    'dual_pol': True
                }
                
            else:
                # Single pol
                path = f'data/{group_name}/{orbit}/{polarisation}'
                
                if path not in f:
                    raise ValueError(f"Path {path} not found in dataset")
                
                pol_data = f[path]
                
                # Load data
                images = pol_data['images'][:]
                masks = pol_data['masks'][:]
                timestamps = pol_data['timestamps'][:]
                angles = pol_data['angles_incidence'][:]
                
                # Filter by dates
                if start_date or end_date:
                    mask_ts = np.ones(len(timestamps), dtype=bool)
                    if start_date:
                        mask_ts &= timestamps >= start_date.encode('utf-8')
                    if end_date:
                        mask_ts &= timestamps <= end_date.encode('utf-8')
                    
                    if not np.any(mask_ts):
                        raise ValueError(f"No data in specified date range")
                    
                    images = images[:, :, mask_ts]
                    masks = masks[:, :, mask_ts]
                    timestamps = timestamps[mask_ts]
                    angles = angles[mask_ts]
                
                metadata = {
                    'mean': pol_data.attrs['stat_mean'],
                    'std': pol_data.attrs['stat_std'],
                    'min': pol_data.attrs['stat_min'],
                    'max': pol_data.attrs['stat_max'],
                    'n_samples': pol_data.attrs['n_timestamps'],
                    'polarisation': polarisation,
                    'dual_pol': False
                }
            
            # Replace nodata BEFORE applying transformations
            if remove_nodata:
                images = np.where(images == self.nodata, np.nan, images)
            
            # Apply scale transformation
            if scale_type == 'amplitude':
                # Use sqrt and handle NaN properly
                images_transformed = np.where(images >= 0, np.sqrt(images), np.nan)
                images = images_transformed.astype(np.float32)
            elif scale_type == 'log10':
                # Handle both NaN and non-positive values
                images = np.where(images > 0, np.log10(images), np.nan)
            # If 'intensity', keep as is (default)
            
            if normalize and not isinstance(polarisation, list):
                mean = metadata['mean']
                std = metadata['std']
                if std > 0:
                    images = (images - mean) / std
            
            return {
                'images': images,
                'masks': masks,
                'timestamps': [t.decode('utf-8') for t in timestamps],
                'angles_incidence': angles,
                'metadata': metadata,
                'group': group_name,
                'orbit': orbit
            }
    
    def get_groups_by_class(self, class_name: str) -> List[str]:
        """Return the list of groups for a given class"""
        if class_name not in self.class_index:
            return []
        return [entry['group'] for entry in self.class_index[class_name]]
    
    def get_all_groups_with_classes(self) -> Dict[str, str]:
        """Return a dictionary {group_name: class_name}"""
        group_to_class = {}
        for class_name in self.classes:
            for group in self.get_groups_by_class(class_name):
                group_to_class[group] = class_name
        return group_to_class
    
    def get_statistics_summary(self) -> Dict:
        """Return a summary of dataset statistics"""
        stats = {
            'by_class': {},
            'global': {
                'n_groups': self.n_groups,
                'n_classes': len(self.classes),
            }
        }
        
        # Stats by class
        for class_name in self.classes:
            groups = self.get_groups_by_class(class_name)
            stats['by_class'][class_name] = {
                'n_groups': len(groups),
                'groups': groups
            }
    
        
        return stats

	#!/usr/bin/env python3
	"""
	Utilities for loading and manipulating HDF5 dataset optimized for ML.

	Features:
	- Fast extraction by class, temporal period
	- Create temporal sequences for LSTM/Transformer
	- Automatic data normalization
	- Filter by metadata (angle, resolution, etc.)
	- Extract sliding windows for learning
	- Support filtering by mask values

	Learning scenarios:
	1. Temporal stacking classification (group k-fold)
	2. Temporal prediction LSTM (time series)
	3. Domain adaptation HH vs HV
	4. Domain adaptation PAZ vs TerraSAR-X
	"""

	import h5py
	import numpy as np
	import json
	from typing import List, Dict, Tuple, Optional, Union
	from tqdm import tqdm
	from joblib import Parallel, delayed


	class MLDatasetLoader:
	"""Class to efficiently load the optimized HDF5 dataset with window extraction"""

	def __init__(self, hdf5_path: str):
	"""
	Args:
	hdf5_path: Path to HDF5 file
	"""
	self.hdf5_path = hdf5_path
	self.file = None
	self._load_metadata()

	def _load_metadata(self):
	"""Load metadata in memory for fast access"""
	with h5py.File(self.hdf5_path, 'r') as f:
	meta = f['metadata']
	self.classes = json.loads(meta.attrs['classes'])
	self.n_groups = meta.attrs['n_total_groups']
	self.nodata = meta.attrs['nodata_value']

	# Charger les index
	self.class_index = {}
	for class_name in f['index/by_class'].keys():
	entries_json = f[f'index/by_class/{class_name}'].attrs['entries_json']
	self.class_index[class_name] = json.loads(entries_json)

	temp_ranges_json = f['index/temporal_ranges'].attrs['ranges_json']
	self.temporal_ranges = json.loads(temp_ranges_json)

	def __enter__(self):
	"""Context manager entry"""
	self.file = h5py.File(self.hdf5_path, 'r')
	return self

	def __exit__(self, exc_type, exc_val, exc_tb):
	"""Context manager exit"""
	if self.file:
	self.file.close()

	def get_group_info(self, group_name: str) -> Dict:
	"""Get information for a group"""
	with h5py.File(self.hdf5_path, 'r') as f:
	if group_name not in f['data']:
	raise ValueError(f"Group {group_name} not found")

	group = f['data'][group_name]
	return {
	'class': group.attrs['class'],
	'latitude': group.attrs['latitude'],
	'longitude': group.attrs['longitude'],
	'elevation': group.attrs['elevation'],
	'orientation': group.attrs['orientation'],
	'slope': group.attrs['slope'],
	'orbits': list(group.keys())
	}

	def extract_windows(
	self,
	image: np.ndarray,
	mask: np.ndarray,
	window_size: int,
	stride: Optional[int] = None,
	max_mask_value: int = 3,
	max_mask_percentage: float = 100.0,
	min_valid_percentage: float = 50.0,
	skip_optim_offset: bool = False
	) -> Tuple[np.ndarray, np.ndarray, List[Tuple[int, int]]]:
	"""
	Extract windows from an image with mask filtering.
	Automatically optimize starting positions to maximize the number of valid windows.

	Args:
	image: Image (H, W) or (H, W, C) or (H, W, T) or (H, W, C, T)
	mask: Mask (H, W) or (H, W, T)
	window_size: Window size (square)
	stride: Stride step (if None, = window_size for non-overlapping)
	max_mask_value: Maximum accepted mask value (0, 1, 2, 3)
	max_mask_percentage: Max percentage of pixels with mask > max_mask_value
	min_valid_percentage: Min percentage of valid pixels (non nodata)
	skip_optim_offset: If True, skip offset optimization and use (0, 0)

	Returns:
	windows: Array of extracted windows
	window_masks: Array of corresponding masks
	positions: List of (y, x) positions for each window
	"""
	if stride is None:
	stride = window_size

	# Handle dimensions
	if image.ndim == 2: # (H, W)
	h, w = image.shape
	has_channels = False
	has_time = False
	elif image.ndim == 3: # (H, W, C) ou (H, W, T)
	h, w, c = image.shape
	has_channels = True
	has_time = False
	elif image.ndim == 4: # (H, W, C, T)
	h, w, c, t = image.shape
	has_channels = True
	has_time = True

	if mask.ndim == 2:
	mask_has_time = False
	elif mask.ndim == 3:
	mask_has_time = True

	# =====================================================================
	# OPTIMIZATION: Find the best starting offset (start_y, start_x)
	# to maximize the number of valid windows
	# =====================================================================
	if skip_optim_offset:
	# Skip optimization and use (0, 0) directly
	best_start_y = 0
	best_start_x = 0
	best_count = -1 # Unknown count when skipping optimization
	else:
	def count_valid_windows(start_y, start_x):
	"""Count the number of valid windows for a given offset"""
	count = 0
	for y in range(start_y, h - window_size + 1, stride):
	for x in range(start_x, w - window_size + 1, stride):
	# Extract window for testing
	if mask_has_time:
	window_mask = mask[y:y+window_size, x:x+window_size, :]
	else:
	window_mask = mask[y:y+window_size, x:x+window_size]

	# Check mask criterion
	if mask_has_time:
	bad_pixels = np.any(window_mask > max_mask_value, axis=-1)
	else:
	bad_pixels = window_mask > max_mask_value

	bad_percentage = (np.sum(bad_pixels) / (window_size * window_size)) * 100.0

	# Check nodata
	if image.ndim == 2:
	window = image[y:y+window_size, x:x+window_size]
	elif image.ndim == 3:
	window = image[y:y+window_size, x:x+window_size, :]
	elif image.ndim == 4:
	window = image[y:y+window_size, x:x+window_size, :, :]

	# Check nodata and NaN (handle both invalid value types)
	if has_time:
	# Check if pixels are nodata OR NaN
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = np.all(~is_invalid, axis=-1)
	if has_channels:
	valid_pixels = np.all(valid_pixels, axis=-1)
	valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
	else:
	if has_channels:
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = np.all(~is_invalid, axis=-1)
	else:
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = ~is_invalid
	valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0

	# Count if criteria are met
	if bad_percentage <= max_mask_percentage and valid_percentage >= min_valid_percentage:
	count += 1

	return count

	# Test all possible offsets (0 to stride-1 for each dimension)
	# OPTIMIZATION: Parallelization with joblib
	best_count = 0
	best_start_y = 0
	best_start_x = 0

	# Limit search to stride (or window_size if non-overlapping)
	max_offset = min(stride, window_size)

	# Create list of all offsets to test
	offsets_to_test = []
	for start_y in range(max_offset):
	for start_x in range(max_offset):
	if start_y + window_size <= h and start_x + window_size <= w:
	offsets_to_test.append((start_y, start_x))

	# Calculate in parallel the number of valid windows for each offset
	counts = Parallel(n_jobs=-1)(
	delayed(count_valid_windows)(start_y, start_x)
	for start_y, start_x in tqdm(offsets_to_test, desc="Optimizing offset", leave=False)
	)

	# Find the best offset
	if len(counts) > 0:
	best_idx = np.argmax(counts)
	best_start_y, best_start_x = offsets_to_test[best_idx]
	best_count = counts[best_idx]

	# =====================================================================
	# EXTRACTION with the best offset found
	# =====================================================================
	windows = []
	window_masks = []
	positions = []

	# Sweep the image with optimal offset
	for y in range(best_start_y, h - window_size + 1, stride):
	for x in range(best_start_x, w - window_size + 1, stride):
	# Extract window
	if image.ndim == 2:
	window = image[y:y+window_size, x:x+window_size]
	elif image.ndim == 3:
	window = image[y:y+window_size, x:x+window_size, :]
	elif image.ndim == 4:
	window = image[y:y+window_size, x:x+window_size, :, :]

	if mask_has_time:
	window_mask = mask[y:y+window_size, x:x+window_size, :]
	else:
	window_mask = mask[y:y+window_size, x:x+window_size]

	# Check mask criterion
	# Pixels with mask > max_mask_value
	if mask_has_time:
	bad_pixels = np.any(window_mask > max_mask_value, axis=-1)
	else:
	bad_pixels = window_mask > max_mask_value

	bad_percentage = (np.sum(bad_pixels) / (window_size * window_size)) * 100.0

	# Check nodata and NaN (handle both invalid value types)
	if has_time:
	# Check if pixels are nodata OR NaN
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = np.all(~is_invalid, axis=-1)
	if has_channels:
	valid_pixels = np.all(valid_pixels, axis=-1)
	valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0
	else:
	if has_channels:
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = np.all(~is_invalid, axis=-1)
	else:
	is_invalid = (window == self.nodata) \| np.isnan(window)
	valid_pixels = ~is_invalid
	valid_percentage = (np.sum(valid_pixels) / (window_size * window_size)) * 100.0

	# Accept window if criteria are met (use strict inequalities for determinism)
	if bad_percentage <= max_mask_percentage and valid_percentage >= min_valid_percentage:
	# Ensure float32 type and keep NaN values as-is
	window = window.astype(np.float32)

	windows.append(window)
	window_masks.append(window_mask)
	positions.append((y, x))

	if len(windows) == 0:
	return None, None, []

	return np.array(windows), np.array(window_masks), positions

	def load_data(
	self,
	group_name: str,
	orbit: str = 'DSC',
	polarisation: Union[str, List[str]] = 'HH',
	start_date: Optional[str] = None,
	end_date: Optional[str] = None,
	normalize: bool = False,
	remove_nodata: bool = True,
	scale_type: str = 'intensity'
	) -> Dict:
	"""
	Load data for a specific group.

	Args:
	group_name: Group name (e.g. 'ABL001')
	orbit: 'ASC' or 'DSC'
	polarisation: 'HH', 'HV' or ['HH', 'HV'] for dual-pol
	start_date: Start date (format 'YYYYMMDD')
	end_date: End date (format 'YYYYMMDD')
	normalize: If True, normalize with pre-calculated stats
	remove_nodata: If True, replace nodata with NaN
	scale_type: 'intensity' (default), 'amplitude' (data**0.5), or 'log10' (log10 scale)

	Returns:
	Dict containing: images, masks, timestamps, metadata
	"""
	with h5py.File(self.hdf5_path, 'r') as f:
	# Support dual-pol
	if isinstance(polarisation, list):
	# Dual-pol: load HH and HV with aligned timestamps
	data_list = []
	for pol in polarisation:
	path = f'data/{group_name}/{orbit}/{pol}'
	if path not in f:
	raise ValueError(f"Path {path} not found in dataset")
	data_list.append(f[path])

	# Trouver les timestamps communs
	timestamps_hh = data_list[0]['timestamps'][:]
	timestamps_hv = data_list[1]['timestamps'][:]

	# Intersection of timestamps
	common_ts = np.intersect1d(timestamps_hh, timestamps_hv)

	if len(common_ts) == 0:
	raise ValueError(f"No common timestamps between HH and HV for {group_name}")

	# Filter by dates if specified
	if start_date or end_date:
	mask_ts = np.ones(len(common_ts), dtype=bool)
	if start_date:
	mask_ts &= common_ts >= start_date.encode('utf-8')
	if end_date:
	mask_ts &= common_ts <= end_date.encode('utf-8')
	common_ts = common_ts[mask_ts]

	if len(common_ts) == 0:
	raise ValueError(f"No data in specified date range")

	# Load data for common timestamps
	images_list = []
	masks_list = []
	angles_list = []

	# First, determine minimum dimensions
	min_h, min_w = None, None
	for pol, data_pol in zip(polarisation, data_list):
	ts_pol = data_pol['timestamps'][:]
	indices = [np.where(ts_pol == ts)[0][0] for ts in common_ts]
	img_pol = data_pol['images'][:, :, indices]
	h, w, t = img_pol.shape
	if min_h is None:
	min_h, min_w = h, w
	else:
	min_h = min(min_h, h)
	min_w = min(min_w, w)

	# Load and crop
	for pol, data_pol in zip(polarisation, data_list):
	# Find indices
	ts_pol = data_pol['timestamps'][:]
	indices = [np.where(ts_pol == ts)[0][0] for ts in common_ts]

	# Load and crop to min_h, min_w
	img_pol = data_pol['images'][:min_h, :min_w, indices]
	mask_pol = data_pol['masks'][:min_h, :min_w, indices]

	images_list.append(img_pol)
	masks_list.append(mask_pol)

	if pol == polarisation[0]: # Only once
	angles_list = data_pol['angles_incidence'][:][indices]

	# Stack in last dimension: (H, W, T, 2)
	images = np.stack(images_list, axis=-1)

	# Mask: take max between HH and HV
	masks = np.maximum(masks_list[0], masks_list[1])

	timestamps = common_ts
	angles = angles_list

	metadata = {
	'polarisation': polarisation,
	'dual_pol': True
	}

	else:
	# Single pol
	path = f'data/{group_name}/{orbit}/{polarisation}'

	if path not in f:
	raise ValueError(f"Path {path} not found in dataset")

	pol_data = f[path]

	# Load data
	images = pol_data['images'][:]
	masks = pol_data['masks'][:]
	timestamps = pol_data['timestamps'][:]
	angles = pol_data['angles_incidence'][:]

	# Filter by dates
	if start_date or end_date:
	mask_ts = np.ones(len(timestamps), dtype=bool)
	if start_date:
	mask_ts &= timestamps >= start_date.encode('utf-8')
	if end_date:
	mask_ts &= timestamps <= end_date.encode('utf-8')

	if not np.any(mask_ts):
	raise ValueError(f"No data in specified date range")

	images = images[:, :, mask_ts]
	masks = masks[:, :, mask_ts]
	timestamps = timestamps[mask_ts]
	angles = angles[mask_ts]

	metadata = {
	'mean': pol_data.attrs['stat_mean'],
	'std': pol_data.attrs['stat_std'],
	'min': pol_data.attrs['stat_min'],
	'max': pol_data.attrs['stat_max'],
	'n_samples': pol_data.attrs['n_timestamps'],
	'polarisation': polarisation,
	'dual_pol': False
	}

	# Replace nodata BEFORE applying transformations
	if remove_nodata:
	images = np.where(images == self.nodata, np.nan, images)

	# Apply scale transformation
	if scale_type == 'amplitude':
	# Use sqrt and handle NaN properly
	images_transformed = np.where(images >= 0, np.sqrt(images), np.nan)
	images = images_transformed.astype(np.float32)
	elif scale_type == 'log10':
	# Handle both NaN and non-positive values
	images = np.where(images > 0, np.log10(images), np.nan)
	# If 'intensity', keep as is (default)

	if normalize and not isinstance(polarisation, list):
	mean = metadata['mean']
	std = metadata['std']
	if std > 0:
	images = (images - mean) / std

	return {
	'images': images,
	'masks': masks,
	'timestamps': [t.decode('utf-8') for t in timestamps],
	'angles_incidence': angles,
	'metadata': metadata,
	'group': group_name,
	'orbit': orbit
	}

	def get_groups_by_class(self, class_name: str) -> List[str]:
	"""Return the list of groups for a given class"""
	if class_name not in self.class_index:
	return []
	return [entry['group'] for entry in self.class_index[class_name]]

	def get_all_groups_with_classes(self) -> Dict[str, str]:
	"""Return a dictionary {group_name: class_name}"""
	group_to_class = {}
	for class_name in self.classes:
	for group in self.get_groups_by_class(class_name):
	group_to_class[group] = class_name
	return group_to_class

	def get_statistics_summary(self) -> Dict:
	"""Return a summary of dataset statistics"""
	stats = {
	'by_class': {},
	'global': {
	'n_groups': self.n_groups,
	'n_classes': len(self.classes),
	}
	}

	# Stats by class
	for class_name in self.classes:
	groups = self.get_groups_by_class(class_name)
	stats['by_class'][class_name] = {
	'n_groups': len(groups),
	'groups': groups
	}


	return stats