izisat 0.1.0__py3-none-any.whl

izisat/misc/files.py

@@ -0,0 +1,135 @@
+import os
+from loguru import logger
+from datetime import datetime
+
+
+class Files:
+    def __init__(self):
+        pass
+    
+    
+    def save_path_sentinel2_data(self, dir_out, etc, date, type, tile, band=None):
+        """
+        Generate a directory path for Sentinel-2 data and create it if it doesn't exist.
+
+        Parameters:
+        ------------
+        dir_out: str
+            The base output directory.
+        date: str
+            The date in the format '%Y-%m-%dT%H:%M:%S.%fZ'.
+        etc: str
+            Additional information for the directory path.
+        tile: str
+            The tile information for the directory path.
+        band: str, optional
+            The band information for the directory path.
+
+        Returns:
+        ----------
+        str 
+            The path of the generated or existing directory.
+        """
+        dt_object = datetime.strptime(date, '%Y-%m-%dT%H:%M:%S.%fZ')
+        # Format the datetime object as 'YYYY/MM/DD'
+        date = dt_object.strftime('%Y/%m/%d')
+
+        if band is not None:
+            directory = os.path.join(dir_out, etc, date, type, tile, band)
+        else:
+            directory = os.path.join(dir_out, etc, date, type, tile)
+
+        if os.path.exists(directory):
+            logger.warning(f"Directory {directory} already exists.")
+            return directory
+        else:
+            os.makedirs(directory, exist_ok=True)
+            logger.success(f"Directory {directory} created!")
+            return directory
+        
+        
+    def create_output_folders(self, output_base_path, products_info, bands_dict):
+        """
+        Create, if necessary, folders to save the downloaded bands.
+
+        Parameters:
+        -----------
+        output_base_path: str
+            The base path where the output folders will be created.
+        products_info: list
+            A list of product information, where each item contains:
+            [product_id, product_name, product_path, product_origin_date, product_tile, product_platform_name, product_type]
+        bands_dict: dict
+            A dictionary containing information about bands for different product types and resolutions.
+
+        Returns:
+        --------
+        created_directories: list
+            A list of paths to the created output directories.
+        """
+        logger.info("Creating, if necessary, folders to save the downloaded bands...")
+        created_directories = []
+        for product_info in products_info:
+            product_type = product_info[6]
+            product_tile = product_info[4]
+            product_date = product_info[3]
+            product_plataform = product_info[5]
+            if product_type == "L1C":
+                directory_path = self.save_path_sentinel2_data(output_base_path, product_plataform, product_date, product_tile, product_type)
+                created_directories.append(directory_path)
+            elif product_type == "L2A":
+                for resolution, _ in bands_dict.items():
+                    if resolution == "L1C":
+                        pass
+                    else:
+                        l2a_dict = bands_dict.get("L2A", {})
+                        for resolution_key in l2a_dict:
+                            directory_path = self.save_path_sentinel2_data(output_base_path, product_plataform, product_date, product_tile, product_type, resolution_key)
+                            created_directories.append(directory_path)
+
+        return created_directories
+
+
+    def check_file_exist(self, base_dir, etc, date, tile, type, filename, resolution = None):
+        """
+        Check if a file exists based on the specified parameters.
+
+        Parameters:
+        -----------
+        base_dir: str
+            The base directory where the file is expected to exist.
+        etc: str
+            Additional subdirectory for categorization (e.g., product platform or other metadata).
+        date: str
+            The date of the product in 'YYYY-MM-DDTHH:MM:SS.sssZ' format.
+        tile: str
+            The tile identifier associated with the product.
+        type: str
+            The type of the product (e.g., 'L1C', 'L2A').
+        filename: str
+            The name of the file to check.
+        resolution: str, optional
+            The resolution category (e.g., 'resolution10m', 'resolution20m').
+            If provided, the file path will include this resolution subdirectory.
+
+        Returns:
+        --------
+        exists: bool
+            True if the file exists, False otherwise.
+        file_path: str
+            The full path to the checked file.
+
+        """
+        date_obj = datetime.strptime(date, '%Y-%m-%dT%H:%M:%S.%fZ')
+        # Format datetime object as 'YYYY/MM/DD'
+        date = date_obj.strftime('%Y/%m/%d')
+        
+        if resolution is None:
+            file = os.path.join(base_dir, etc, date, tile, type, filename)
+            return os.path.exists(file), file
+        else:
+            file = os.path.join(base_dir, etc, date, tile, type, resolution, filename)
+            return os.path.exists(file), file
+    
+                    
+    

izisat/misc/raster_processing.py

@@ -0,0 +1,373 @@
+import os
+import rasterio
+import rasterio.mask
+from shapely import wkt
+from shapely.geometry import mapping
+from typing import Union
+from pathlib import Path
+import geopandas as gpd
+import numpy as np
+from rasterio.crs import CRS
+from rasterio.transform import from_origin
+from rasterio.merge import merge
+import numpy as np
+import rasterio
+from rasterio.io import MemoryFile
+from rasterio.warp import reproject, Resampling, calculate_default_transform
+
+
+class RasterProcessing:
+    def __init__(self):
+        pass
+
+    def crop_band_by_footprint_wkt(self,
+                                    jp2_path: str,
+                                    footprint_wkt: str,
+                                    output_path: str = None
+                                ):
+        """
+        Crops a georeferenced JP2 image using a WKT footprint (MULTIPOLYGON).
+
+        Args:
+            jp2_path (str): Path to the .jp2 image (satellite band).
+            footprint_wkt (str): WKT string of the footprint polygon (e.g. 'MULTIPOLYGON (...)').
+            output_path (str, optional): Output .tif file path or directory. If None, nothing is saved.
+            suffix (str): Suffix to append to the output file name if saving to a directory.
+
+        Returns:
+            dict: {
+                "image": Cropped image as a NumPy array,
+                "profile": Raster metadata dictionary,
+                "output_name": Full output path if saved, else None
+            }
+        """
+        # Convert WKT string to geometry
+        geometry = [mapping(wkt.loads(footprint_wkt))]
+
+        with rasterio.open(jp2_path) as src:
+            cropped_image, transform = rasterio.mask.mask(src, geometry, crop=True)
+            cropped_image = cropped_image.squeeze()
+            profile = src.profile.copy()
+            profile.update({
+                "height": cropped_image.shape[0],
+                "width": cropped_image.shape[1],
+                "transform": transform
+            })
+        if output_path is not None:
+            with rasterio.open(output_path, "w", **profile) as dst:
+                dst.write(cropped_image)
+        return cropped_image, profile
+
+    def ensure_array_in_epsg(self, array: np.ndarray, profile: dict, target_epsg: int):
+        import numpy as np
+        import rasterio
+        from rasterio.io import MemoryFile
+        from rasterio.warp import reproject, Resampling, calculate_default_transform
+        from rasterio.transform import array_bounds
+        """
+        Garante que o array raster esteja no EPSG desejado. Se necessário, reprojeta.
+
+        Parâmetros:
+        - array: np.ndarray (2D)
+        - profile: dict com as chaves: 'transform', 'crs', 'width', 'height'
+        - target_epsg: int
+
+        Retorna:
+        - dst_array: np.ndarray reprojetado ou original
+        - new_profile: dict atualizado
+        """
+        src_crs = profile.get("crs")
+        dst_crs = rasterio.crs.CRS.from_epsg(target_epsg)
+
+        if src_crs == dst_crs:
+            new_profile = profile.copy()
+            new_profile["crs"] = dst_crs
+            return array, new_profile
+
+        # Calcula os bounds a partir do transform
+        bounds = array_bounds(profile["height"], profile["width"], profile["transform"])
+
+        transform, width, height = calculate_default_transform(
+            src_crs, dst_crs,
+            profile["width"], profile["height"],
+            *bounds
+        )
+
+        dst_array = np.empty((height, width), dtype=array.dtype)
+
+        reproject(
+            source=array,
+            destination=dst_array,
+            src_transform=profile["transform"],
+            src_crs=src_crs,
+            dst_transform=transform,
+            dst_crs=dst_crs,
+            resampling=Resampling.nearest
+        )
+
+        new_profile = profile.copy()
+        new_profile.update({
+            "crs": dst_crs,
+            "transform": transform,
+            "width": width,
+            "height": height
+        })
+
+        return dst_array, new_profile
+
+    def get_cropped_bands_no_merge(self, gdf:gpd.GeoDataFrame, band_paths):
+        utm_zones = {
+            19:31979,
+            20:31980,
+            21:31981,
+            22:31982,
+            23:31983,
+            24:31984,
+            25:31985,
+        }
+        bands_list = ['B02','B03','B04','B08']
+        cropped_bands = []
+
+        epsg = utm_zones[int(os.path.basename(band_paths['B02']).split('_')[0][1:3])]
+        gdf = gdf.to_crs(epsg)
+        footprint_wkt = gdf.iloc[0].geometry.wkt
+        
+        for band in bands_list:
+            path = band_paths.get(band)
+            if path:
+                cropped, profile = self.crop_band_by_footprint_wkt(path, footprint_wkt)
+                cropped_bands.append(cropped)
+            
+        return (*cropped_bands, profile)
+
+    def get_cropped_bands_with_merge(self, gdf: gpd.GeoDataFrame, band_dicts: list):
+        """
+        Recorta e mescla múltiplas bandas de entrada organizadas como uma lista de dicionários.
+        
+        Parâmetros:
+        - gdf: GeoDataFrame com a geometria para recorte.
+        - band_dicts: lista de dicionários, cada um contendo os caminhos das bandas 'B02', 'B03', 'B04' e 'B08'.
+        
+        Retorna:
+        - Tupla com arrays mesclados para cada banda: B02, B03, B04, B08 e o profile do merge.
+        """
+
+        utm_zones = {
+            19: 31979,
+            20: 31980,
+            21: 31981,
+            22: 31982,
+            23: 31983,
+            24: 31984,
+            25: 31985,
+        }
+        bands_list = ['B02', 'B03', 'B04', 'B08']
+        cropped_bands_by_type = {band: [] for band in bands_list}
+        final_profile = None
+        final_crs = gdf.estimate_utm_crs('SIRGAS 2000').to_epsg()
+
+        # Recorta todas as bandas e armazena por tipo
+        for band_paths in band_dicts:
+            try:
+                for band in bands_list:
+                    path = band_paths.get(band)
+                    if path:
+                        epsg = utm_zones[int(os.path.basename(path).split('_')[0][1:3])]
+                        gdf = gdf.to_crs(epsg)
+                        footprint_wkt = gdf.iloc[0].geometry.wkt
+                        cropped, profile = self.crop_band_by_footprint_wkt(path, footprint_wkt)
+                        cropped_bands_by_type[band].append((cropped, profile))
+            except:
+                pass
+
+        # Faz merge por banda
+        merged_bands = []
+        for band in bands_list:
+            datasets = []
+            for cropped, profile in cropped_bands_by_type[band]:
+                cropped_epsg, profile_epsg = self.ensure_array_in_epsg(cropped, profile, final_crs)
+                profile_epsg.update({
+                    'driver': 'GTiff',
+                    'dtype': 'uint16',
+                    'compress': None,
+                    'tiled': False,
+                    'nodata': 0
+                })
+                memfile = rasterio.io.MemoryFile()
+                with memfile.open(**profile_epsg) as tmp:
+                    tmp.write(cropped_epsg, 1)
+                datasets.append(memfile.open())
+
+            merged, out_transform = merge(datasets, method='first')
+            merged_bands.append(merged.squeeze())
+
+        # Pega profile de um dos arquivos e atualiza
+        if final_profile is None:
+            final_profile = datasets[0].profile.copy()
+            final_profile.update({
+                "height": merged.shape[1],
+                "width": merged.shape[2],
+                "transform": out_transform,
+                "count": 1
+            })
+
+            # Fecha arquivos temporários
+
+        return (*merged_bands, final_profile)
+
+
+    def create_rgb(self, b02_array, b03_array, b04_array, reference_profile=None, output_path=None):
+        """
+        Cria uma imagem RGB a partir das bandas B02 (Blue), B03 (Green) e B04 (Red) do Sentinel-2.
+        
+        Parâmetros:
+        - b02_array (np.ndarray): Banda 2 (azul)
+        - b03_array (np.ndarray): Banda 3 (verde)
+        - b04_array (np.ndarray): Banda 4 (vermelho)
+        - reference_profile (dict): Perfil de metadados de referência de uma das bandas originais
+        - output_path (str, opcional): Caminho para salvar o arquivo. Se None, apenas retorna o array.
+        
+        Retorna:
+        - rgb_array (np.ndarray): Array RGB com shape (3, height, width)
+        """
+
+        # Verifica se as dimensões batem
+        if not (b02_array.shape == b03_array.shape == b04_array.shape):
+            raise ValueError("As bandas devem ter as mesmas dimensões")
+
+        # Cria array RGB no formato (3, altura, largura)
+        rgb_array = np.stack([b04_array, b03_array, b02_array], axis=0)  # (R, G, B)
+
+        # Atualiza o perfil para refletir 3 bandas
+        profile = reference_profile.copy()
+        profile.update({
+            'count': 3,
+            'dtype': rgb_array.dtype,
+            'driver': 'GTiff'
+        })
+
+        # Salva ou retorna
+        if output_path:
+            with rasterio.open(output_path, 'w', **profile) as dst:
+                dst.write(rgb_array)
+        return rgb_array
+
+    def create_ndvi(self, b04_array, b08_array, reference_profile, output_path=None):
+        """
+        Calcula o NDVI (Normalized Difference Vegetation Index) usando as bandas B04 (Red) e B08 (NIR) do Sentinel-2.
+
+        Parâmetros:
+        - b04_array (np.ndarray): Banda 4 (vermelho)
+        - b08_array (np.ndarray): Banda 8 (infravermelho próximo)
+        - reference_profile (dict): Perfil de metadados de referência de uma das bandas originais
+        - output_path (str, opcional): Caminho para salvar o arquivo. Se None, apenas retorna o array.
+
+        Retorna:
+        - ndvi (np.ndarray): Array 2D com valores de NDVI
+        """
+
+        # Verifica se as dimensões batem
+        if b04_array.shape != b08_array.shape:
+            raise ValueError("As bandas devem ter as mesmas dimensões")
+
+        # Converte para float32 para evitar problemas de divisão inteira
+        b04 = b04_array.astype('float32')
+        b08 = b08_array.astype('float32')
+
+        # NDVI = (NIR - Red) / (NIR + Red)
+        denominator = b08 + b04
+        with np.errstate(divide='ignore', invalid='ignore'):
+            ndvi = (b08 - b04) / denominator
+            ndvi[np.isnan(ndvi)] = -9999  # valor nodata
+
+        # Atualiza o perfil
+        profile = reference_profile.copy()
+        profile.update({
+            'count': 1,
+            'dtype': 'float32',
+            'driver': 'GTiff',
+            'nodata': -9999
+        })
+
+        # Salva ou retorna
+        if output_path:
+            with rasterio.open(output_path, 'w', **profile) as dst:
+                dst.write(ndvi, 1)
+        return ndvi
+
+    def create_evi(self, b02_array, b04_array, b08_array, reference_profile, output_path=None):
+        """
+        Calcula o EVI (Enhanced Vegetation Index) usando as bandas B02 (Blue), B04 (Red) e B08 (NIR) do Sentinel-2.
+
+        Parâmetros:
+        - b02_array (np.ndarray): Banda 2 (azul)
+        - b04_array (np.ndarray): Banda 4 (vermelho)
+        - b08_array (np.ndarray): Banda 8 (infravermelho próximo)
+        - reference_profile (dict): Perfil de metadados de referência de uma das bandas originais
+        - output_path (str, opcional): Caminho para salvar o arquivo. Se None, apenas retorna o array.
+
+        Retorna:
+        - evi (np.ndarray): Array 2D com valores de EVI
+        """
+
+        # Verifica se as dimensões batem
+        if not (b02_array.shape == b04_array.shape == b08_array.shape):
+            raise ValueError("As bandas devem ter as mesmas dimensões")
+
+        # Converte para float32
+        b02 = b02_array.astype('float32') / 10000 # Blue
+        b04 = b04_array.astype('float32') / 10000 # Red
+        b08 = b08_array.astype('float32') / 10000  # NIR
+
+        # Parâmetros do EVI
+        G = 2.5
+        C1 = 6.0
+        C2 = 7.5
+        L = 1.0
+
+        # Fórmula do EVI
+        denominator = b08 + C1 * b04 - C2 * b02 + L
+        with np.errstate(divide='ignore', invalid='ignore'):
+            evi = G * ((b08 - b04) / denominator)
+            evi[np.isnan(evi)] = -9999  # valor nodata
+
+        # Atualiza o perfil
+        profile = reference_profile.copy()
+        profile.update({
+            'count': 1,
+            'dtype': 'float32',
+            'driver': 'GTiff',
+            'nodata': -9999
+        })
+
+        # Salva ou retorna
+        if output_path:
+            with rasterio.open(output_path, 'w', **profile) as dst:
+                dst.write(evi, 1)
+        return evi
+
+if __name__ == '__main__':
+    import rasterio
+    b02 = '/home/ppz/Documentos/coding/izisat/auxiliary/Sentinel-2/2025/04/06/T22KGD/L2A/10m/T22KGD_20250406T133211_B02_10m.jp2'
+    b03 = '/home/ppz/Documentos/coding/izisat/auxiliary/Sentinel-2/2025/04/06/T22KGD/L2A/10m/T22KGD_20250406T133211_B03_10m.jp2'
+    b04 = '/home/ppz/Documentos/coding/izisat/auxiliary/Sentinel-2/2025/04/06/T22KGD/L2A/10m/T22KGD_20250406T133211_B04_10m.jp2'
+    b08 = '/home/ppz/Documentos/coding/izisat/auxiliary/Sentinel-2/2025/04/06/T22KGD/L2A/10m/T22KGD_20250406T133211_B08_10m.jp2'
+    
+    # Lê as bandas como arrays e pega o perfil de uma delas
+    with rasterio.open(b02) as b2_src:
+        b02 = b2_src.read(1)
+        profile = b2_src.profile
+
+    with rasterio.open(b03) as b3_src:
+        b03 = b3_src.read(1)
+
+    with rasterio.open(b04) as b4_src:
+        b04 = b4_src.read(1)
+    
+    with rasterio.open(b08) as b8_src:
+        b08 = b8_src.read(1)
+
+    # Chama a função
+    instance = RasterProcessing()
+    rgb_array = instance.create_rgb(b02, b03, b04, reference_profile=profile, output_path='rgb_composite.tif')
+    ndvi_array = instance.create_ndvi(b04, b08, profile, output_path='ndvi_composite.tif')

izisat/misc/utils.py

@@ -0,0 +1,162 @@
+from loguru import logger
+from pathlib import Path
+from datetime import datetime
+
+class Utils:
+    def __init__(self):
+        pass
+    
+    
+    def construct_query_for_sentinel2_products(self, footprint: str, start_date: str, end_date: str, cloud_cover_percentage: str, type, 
+              platform_name: str):
+        """
+        Create a query for downloading Sentinel data based on specified parameters.
+
+        Parameters:
+        ------------
+        footprint: str
+            The spatial geometry (POLYGON) of the area of interest.
+        start_date: str
+            The start date for the time range of interest in the format 'YYYY-MM-DD'.
+        end_date: str
+            The end date for the time range of interest in the format 'YYYY-MM-DD'.
+        cloud_cover_percentage: str
+            The maximum allowable cloud cover percentage.
+        type: str or list
+            Type of MSI to download
+        platform_name: str, optional
+            The name of the Sentinel platform (default: 'SENTINEL-2').
+
+        Returns:
+        params: str
+            The query string for downloading Sentinel data.
+        """
+        
+        logger.info("Creating query to download Sentinel data...")
+        try:
+            if footprint and start_date and end_date and platform_name and cloud_cover_percentage and type: 
+                footprint = footprint.replace(" ", "%20")
+                if isinstance(type, str):
+                    params = f"?&$filter=(Collection/Name%20eq%20%27{platform_name}%27%20and%20(Attributes/OData.CSC.StringAttribute/any(att:att/Name%20eq%20%27instrumentShortName%27%20and%20att/OData.CSC.StringAttribute/Value%20eq%20%27MSI%27)%20and%20Attributes/OData.CSC.DoubleAttribute/any(att:att/Name%20eq%20%27cloudCover%27%20and%20att/OData.CSC.DoubleAttribute/Value%20le%20{cloud_cover_percentage})%20and%20(contains(Name,%27{type}%27)%20and%20OData.CSC.Intersects(area=geography%27SRID=4326;{footprint}%27)))%20and%20Online%20eq%20true)%20and%20ContentDate/Start%20ge%20{start_date}T00:00:00.000Z%20and%20ContentDate/Start%20lt%20{end_date}T23:59:59.999Z&$orderby=ContentDate/Start%20desc&$expand=Attributes&$count=True&$top=50&$expand=Assets&$skip=0"
+                    logger.success("Query created successfully")
+                    return params
+                elif isinstance(type, list):
+                    params = f"?&$filter=(Collection/Name%20eq%20%27{platform_name}%27%20and%20(Attributes/OData.CSC.StringAttribute/any(att:att/Name%20eq%20%27instrumentShortName%27%20and%20att/OData.CSC.StringAttribute/Value%20eq%20%27MSI%27)%20and%20Attributes/OData.CSC.DoubleAttribute/any(att:att/Name%20eq%20%27cloudCover%27%20and%20att/OData.CSC.DoubleAttribute/Value%20le%20{cloud_cover_percentage})%20and%20((contains(Name,%27{type[0]}%27)%20and%20OData.CSC.Intersects(area=geography%27SRID=4326;{footprint}%27))%20or%20(contains(Name,%27{type[1]}%27)%20and%20OData.CSC.Intersects(area=geography%27SRID=4326;{footprint}%27))))%20and%20Online%20eq%20true)%20and%20ContentDate/Start%20ge%20{start_date}T00:00:00.000Z%20and%20ContentDate/Start%20lt%20{end_date}T23:59:59.999Z&$orderby=ContentDate/Start%20desc&$expand=Attributes&$count=True&$top=50&$expand=Assets&$skip=0"
+                    logger.success("Query created successfully")
+                    return params
+                else: 
+                    raise ValueError("Please provide valid values for type.")
+            else:
+                raise ValueError("Please provide valid values for all required parameters.")
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}")
+            raise
+        
+    def retrieve_products_info(self, products):
+        """
+        Retrieve information about Sentinel products.
+
+        Parameters:
+        -----------
+        products: list
+            List of Sentinel products, each represented as a dictionary.
+
+        Returns:
+        ---------
+        list:
+            A list containing information about each product. Each element in the list is a sublist with the following format:
+            [product_id, product_name, product_s3path, product_origin_date, product_tile, product_platform_name, product_type]
+        """
+        result_list = []
+        logger.info(f"Retrieving information about {len(products)} products...")
+
+        for i, product in enumerate(products):
+            logger.info(f"Retrieving information about product {i+1}")
+            product_id = product['Id']
+            product_name = product['Name']
+            product_s3path = product["S3Path"]
+            product_origin_date = product['ContentDate']['End']
+
+            # Creating output directory to save downloaded data
+            product_tile = product_name.split("_")[5]
+            product_platform_name = product_s3path.split('/')[2]
+            product_type = product_name.split('_')[1][-3:]
+
+            # Append product information to the result list
+            result_list.append([product_id, product_name, product_s3path, product_origin_date, product_tile, product_platform_name, product_type])
+            logger.success(f"ID, Name, S3Path, Origin Date, Tile, Plataform Name and Type successfully retrieved for product {i+1}")
+
+        logger.success("Information successfully retrieved for all products. A list with these informations were created!")
+        return result_list
+    
+    def modify_string(self, url):
+        """
+        Modify a URL by replacing the last occurrence of "Nodes" with "$value".
+
+        Parameters:
+        -----------
+        url: str
+            The input URL to be modified.
+
+        Returns:
+        ---------
+        modified_url: str
+            The modified URL with the last "Nodes" replaced by "$value".
+        ValueError
+            If "Nodes" is not found in the input URL.
+    """
+        last_nodes_index = url.rfind("Nodes")
+
+        if last_nodes_index != -1:
+        # Remove the last "Nodes" and replace it with "/$value"
+            modified_url = url[:last_nodes_index] + "$value"
+            return modified_url
+        else:
+            raise ValueError("Error: 'Nodes' not found in the URL")
+
+    def generate_sentinel2_band_paths_nested_by_tile(self, download_folder: str, products: list[list[str]]) -> dict[str, dict[str, str]]:
+        """
+        Gera dicionário aninhado com caminhos das bandas Sentinel-2, agrupados por data e tile (fuso).
+
+        Retorna:
+            {
+                "2025-04-13_T23": {
+                    "B02": "/.../T23KKV_20250413T132251_B02_10m.jp2",
+                    "B03": "/.../T23KKV_..._B03_10m.jp2",
+                    ...
+                },
+                ...
+            }
+        """
+        from collections import defaultdict
+        result = {}
+        grouped = defaultdict(list)
+        for variables in products:
+            date_obj = datetime.fromisoformat(variables[3].replace("Z", ""))
+            date_str = date_obj.strftime("%Y-%m-%d")
+            tile = variables[4]            # Ex: T23KKV
+            tile_id = tile[1:3]            # Pega apenas o fuso "23"
+            sensor = variables[5]
+            product_level = variables[6]
+            year = f"{date_obj.year}"
+            month = f"{date_obj.month:02}"
+            day = f"{date_obj.day:02}"
+            timestamp_part = variables[1].split("_")[2]  # Ex: 20250413T132251
+
+            bands = ["B02", "B03", "B04", "B08"]
+            base_path = Path(download_folder) / sensor / year / month / day / tile / product_level / "10m"
+
+            band_paths = {
+                band: str(base_path / f"{tile}_{timestamp_part}_{band}_10m.jp2")
+                for band in bands
+            }
+
+            key = f"{date_str}_T{tile_id}"  # Ex: 2025-04-13_T23
+            result[key] = band_paths
+            
+            for key, bands in result.items():
+                date = key.split('_')[0]
+                grouped[date].append(bands)
+
+        return grouped
+