s1-denoise 0.0.0.dev0__py3-none-any.whl

s1_denoise/logger.py

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Logging configuration module for the denoising processor.
+
+Sets up a named logger with colorized console output and plain-text file output, using a structured log format
+that includes timestamp, hostname, processor name, version, and process ID. Exposes a module-level
+``denoise_logger`` instance for use across the package.
+"""
+
+import logging
+import colorlog
+import socket 
+
+from s1_denoise import __version__, PROCESSOR_NAME
+
+def setup_logger():
+    """
+    Set up the ``denoise`` logger with colorized console output and file output.
+
+    Handlers are attached only if the logger has none yet, so repeated calls do not duplicate output. Log levels
+    are renamed to short tags (``[D]``, ``[I]``, ``[W]``, ``[E]``, ``[P]``), records are written both to the console
+    (colorized) and to ``denoise.log`` in the current working directory, and the level is set to ``INFO``.
+
+    Returns
+    -------
+    logging.Logger
+        The configured ``denoise`` logger.
+    """
+    
+    # Check if the logger has already handlers attached
+    logger = logging.getLogger("denoise")
+
+    # Only set up logging if no handlers are already attached
+    if not logger.hasHandlers():
+
+        logging.addLevelName(logging.NOTSET, "")
+        logging.addLevelName(logging.DEBUG, "[D]")
+        logging.addLevelName(logging.INFO, "[I]")
+        logging.addLevelName(logging.WARNING, "[W]")
+        logging.addLevelName(logging.ERROR, "[E]")
+        logging.addLevelName(logging.CRITICAL, "[P]")
+        
+        log_colors = {
+            '': 'green',
+            '[D]': 'cyan',
+            # '[I]': 'white',
+            '[W]': 'yellow',
+            '[E]': 'red',
+            '[P]': 'bold_red',
+        }
+
+        HOSTNAME=socket.gethostname()
+
+        LOG_STRING = f'%(asctime)s.%(msecs)03d000 {HOSTNAME} {PROCESSOR_NAME} {__version__} [%(process)d] %(levelname)s %(message)s'
+        COLORED_LOG_STRING = "%(log_color)s" + LOG_STRING
+        DATE_FMT = "%Y-%m-%dT%H:%M:%S"
+
+        # Create a colored formatter
+        formatter = colorlog.ColoredFormatter(COLORED_LOG_STRING, log_colors=log_colors, datefmt=DATE_FMT)
+
+        # Create console handler for colored logs
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+
+        # Create file handler to log to "denoise.log"
+        file_handler = logging.FileHandler("denoise.log")
+        file_handler.setFormatter(logging.Formatter(LOG_STRING, datefmt=DATE_FMT))
+
+        # Create logger and set level
+        logger = logging.getLogger("denoise")
+
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
+
+        logger.setLevel(logging.INFO)
+
+    return logger
+
+denoise_logger = setup_logger()

s1_denoise/noise_norm_factor.py

@@ -0,0 +1,291 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Utility module providing signal processing helpers for noise profile generation.
+
+Includes functions for FFT size selection, Hamming window computation, look
+start index and overlap calculation, and window normalisation factor estimation.
+
+IPF noise normalization factor
+------------------------------
+During L1 post-processing (LBP), each look is extracted with a Hamming window
+and, in azimuth, possibly corrected for the azimuth antenna pattern (AAP). The
+signal is then scaled by the window normalization factor so that its power is
+preserved:
+
+    windowNorm = sum(w^2) / sum(AAP^2 over the processing bandwidth)
+
+Thermal noise has a flat spectrum, so this normalization changes its power
+differently. Since the AAP correction (division by AAP) also boosts the noise
+at the spectrum edges, its processing gain is:
+
+    noiseProcGain = sum(w^2 / AAP^2) / bwInSamples
+
+The noise normalization factor is the ratio between the two, averaged over the
+looks:
+
+    noiseNormFactor = mean_looks(noiseProcGain / windowNorm)
+
+It is computed in azimuth and in range (flat spectrum, so the range factor is
+~1) and the final value is their product. The IPF multiplies the noise vectors
+by this factor when noiseNormalizationFlag is set, and annotates its average
+over the blocks of each swath in noiseNormalizationFactorList (1.0 if the flag
+is not set). If the AAP correction is not applied, AAP is not divided out:
+sum(w^2) is used in noiseProcGain and sum((AAP * w)^2) per look in windowNorm.
+"""
+
+import numpy as np
+import math
+
+def find_fft_size(desired_fft_size):
+    """
+    Return the smallest valid IPF FFT length not lower than the desired size.
+
+    Parameters
+    ----------
+    desired_fft_size : int
+        Minimum required FFT length [samples].
+
+    Returns
+    -------
+    int
+        Smallest FFT length in the list of lengths supported by the IPF that is >= `desired_fft_size`.
+
+    Raises
+    ------
+    ValueError
+        If `desired_fft_size` exceeds the largest supported FFT length.
+    """
+
+    FFT_VALID_LENGTHS = [ 240, 256, 288, 320, 384, 480, 512, 576, 640, 720, 768, 960, 1024, 1152, 1300, 1400, 1584, 1800, 1950, 2080, 2464, 2560, 2880, 3072, 3564, 3750, 3822, 4096, 4400, 5000, 5760, 6144, 7840, 8100, 8400, 8640, 8736, 8820, 9072, 9216, 11520, 12288, 15360, 15552, 16000, 16384, 17280, 18000, 18480, 19008, 19440, 19500, 20000, 20580, 22400, 23760, 24576, 25920, 27648, 28800, 30720, 31104, 32000, 32768, 34560, 36000, 36864, 38400, 40000, 40960, 41472, 43200, 46080, 48000, 49152, 51200, 51840, 54000, 55296, 57600, 60000, 61440, 62208, 64000, 64800, 65536, 69120, 72000, 73728, 76800, 77760, 80000, 81920, 82944, 86400, 92160, 93312, 96000, 98304 ]
+
+    for size in FFT_VALID_LENGTHS:
+
+        if desired_fft_size <= size:
+            return size
+        
+    raise ValueError(f"No valid FFT size found for the desired FFT size {desired_fft_size}.")
+
+def update_window_noise_norm(data_spectra, window, look_start_indices, in_line_len, correct_spectra=True):
+    """
+    Compute the per-look sum of the squared window divided by the squared spectrum (noise processing gain numerator).
+
+    For each look, the window is aligned to the FFT grid at the look start index (wrapping around the grid) and
+    ``sum((window / data_spectra)**2)`` is computed. If the spectra are not corrected (or not given), the sum of the
+    squared window is used for each look, as in the IPF.
+
+    Parameters
+    ----------
+    data_spectra : numpy.ndarray or None
+        Azimuth antenna pattern on the FFT grid, in linear amplitude, with at least `in_line_len` samples.
+    window : numpy.ndarray
+        Look window (Hamming) of length not greater than `in_line_len`.
+    look_start_indices : array_like of int
+        Start index of each look on the FFT grid, lower than `in_line_len`.
+    in_line_len : int
+        FFT length [samples].
+    correct_spectra : bool, optional
+        Whether the azimuth antenna pattern correction is applied (division by the AAP). Default is True.
+
+    Returns
+    -------
+    numpy.ndarray
+        Sum of squared (window / AAP) for each look, or of squared window if the correction is not applied.
+
+    Raises
+    ------
+    ValueError
+        If a look start index is not lower than `in_line_len`, if the window is longer than `in_line_len`, or if
+        `data_spectra` is shorter than `in_line_len`.
+    """
+
+    window = np.asarray(window, dtype=np.float64)
+    look_start_indices = np.asarray(look_start_indices, dtype=np.int64)
+
+    window_len = window.size
+    window_sq = window ** 2
+
+    if data_spectra is None or not correct_spectra:
+        return np.full(look_start_indices.size, np.sum(window_sq))
+
+    data_spectra = np.asarray(data_spectra, dtype=np.float64)
+
+    if np.any(look_start_indices >= in_line_len):
+        raise ValueError(f"look_start_indices ({look_start_indices}) must be less than in_line_len ({in_line_len})")
+    if window_len > in_line_len:
+        raise ValueError(f"window length ({window_len}) must be <= in_line_len ({in_line_len})")
+    if data_spectra.size < in_line_len:
+        raise ValueError(f"data_spectra is shorter ({data_spectra.size}) than in_line_len ({in_line_len})")
+
+    base_idx = np.arange(window_len, dtype=np.int64)
+
+    idx = (look_start_indices[:, None] + base_idx) % in_line_len
+    segments = data_spectra[idx]
+
+    sum_window_sq_noise = np.sum(window_sq / (segments**2), axis=1)
+
+    return sum_window_sq_noise
+
+
+def calculate_window_norm_factor(data_spectra, bw_in_samples, in_line_len, window, look_start_indices, correct_spectra=True):
+    """
+    Compute the window normalization factor of each look (IPF ``LBP_GenerateLook::calcNormFactor``).
+
+    The factor is the sum of the squared window divided by the sum of the squared spectrum over the processing
+    bandwidth, centered on the zero frequency. If the spectra are not corrected, the spectrum remaining at the end
+    of processing is included in the sum of the squared window, separately for each look.
+
+    Parameters
+    ----------
+    data_spectra : numpy.ndarray or None
+        Azimuth antenna pattern on the FFT grid, in linear amplitude. If None, a flat unit spectrum is assumed.
+    bw_in_samples : int
+        Processing bandwidth [samples].
+    in_line_len : int
+        FFT length [samples].
+    window : numpy.ndarray
+        Look window (Hamming).
+    look_start_indices : array_like of int
+        Start index of each look on the FFT grid.
+    correct_spectra : bool, optional
+        Whether the azimuth antenna pattern correction is applied (division by the AAP). Default is True.
+
+    Returns
+    -------
+    numpy.ndarray
+        Window normalization factor for each look.
+    """
+
+    window = np.asarray(window, dtype=np.float64)
+    look_start_indices = np.asarray(look_start_indices, dtype=np.int64)
+
+    if data_spectra is not None:
+        data_spectra = np.array(data_spectra, dtype=np.float32)
+
+        start_index = math.floor((-1.0 * bw_in_samples + 1) / 2)
+        start_index %= in_line_len
+
+        indices = (start_index + np.arange(bw_in_samples)) % in_line_len
+
+        selected = np.take(data_spectra, indices, mode="wrap")
+
+        sum_adjustment_sq = np.sum(selected ** 2)
+
+    else:
+        sum_adjustment_sq = bw_in_samples
+
+    if data_spectra is not None and not correct_spectra:
+        idx = (look_start_indices[:, None] + np.arange(window.size)) % in_line_len
+        sum_window_sq = np.sum((data_spectra[idx] * window) ** 2, axis=1)
+    else:
+        sum_window_sq = np.full(look_start_indices.size, np.sum(window ** 2))
+
+    window_norm_factor = sum_window_sq / sum_adjustment_sq
+
+    return window_norm_factor
+
+def hamming(nsize, alpha):
+    """
+    Compute a generalized Hamming window as in the IPF.
+
+    The window is ``alpha + (1 - alpha) * cos(2 * pi * (n - centre) / (nsize - 1))`` for ``n = 1, ..., nsize``,
+    with ``centre = (nsize + 1) / 2``.
+
+    Parameters
+    ----------
+    nsize : int
+        Window length [samples].
+    alpha : float
+        Window coefficient. Values >= 1 give a flat (rectangular) window.
+
+    Returns
+    -------
+    numpy.ndarray or None
+        Window samples, or None if `alpha` is negative.
+    """
+
+    whamm = np.zeros(nsize, dtype=np.float64)
+
+    # alpha >= 1.0 -> flat window
+    if alpha >= 1.0:
+        whamm[:] = 1.0
+        return whamm
+
+    if alpha < 0.0:
+        return None
+
+    # Constants
+    TWO_PI = 2.0 * math.pi
+    centre = float(nsize + 1) / 2.0  # central index
+    fsize = float(nsize - 1)
+
+    # Hamming (sample indices from 1 to nsize)
+    arg = TWO_PI * (np.arange(1, nsize + 1, dtype=np.float64) - centre) / fsize
+    whamm = alpha + (1.0 - alpha) * np.cos(arg)
+
+    return whamm
+
+def get_look_overlap_samples(window_len, bw_in_samples, number_of_looks = 1):
+    """
+    Compute the look overlap in frequency samples, as in the IPF (``LBP_GenerateLook::initBlock``).
+
+    Parameters
+    ----------
+    window_len : int
+        Look length [samples].
+    bw_in_samples : int
+        Processing bandwidth [samples].
+    number_of_looks : int, optional
+        Number of looks. Default is 1.
+
+    Returns
+    -------
+    int
+        Overlap between consecutive looks [samples], ``ceil((L * window_len - bw_in_samples) / (L - 1))`` for
+        ``L > 1`` looks, 0 for single-look processing.
+    """
+
+    if number_of_looks <= 1:
+        return 0
+
+    extra_samples = window_len * number_of_looks - bw_in_samples
+
+    return int(math.ceil(extra_samples / (number_of_looks - 1.0)))
+
+def get_start_indices(look_overlap, window_len, in_line_len, number_of_looks = 1):
+    """
+    Compute the start index of each look on the FFT grid.
+
+    The looks are centered on the zero frequency and spaced by ``window_len - look_overlap`` samples; indices are
+    wrapped modulo `in_line_len`.
+
+    Parameters
+    ----------
+    look_overlap : int
+        Overlap between consecutive looks [samples].
+    window_len : int
+        Look length [samples].
+    in_line_len : int
+        FFT length [samples].
+    number_of_looks : int, optional
+        Number of looks. Default is 1.
+
+    Returns
+    -------
+    list of int
+        Start index of each look on the FFT grid.
+    """
+
+    extracted_freq_samples = window_len + (window_len - look_overlap) * (number_of_looks - 1)
+    start_offset = int(np.floor((1.0 - extracted_freq_samples) / 2))
+
+    look_start_indices = [0] * number_of_looks
+    look_end_indices = [0] * number_of_looks
+
+    for lookIdx in range(number_of_looks):
+        look_start_indices[lookIdx] = int((start_offset + (window_len - look_overlap) * lookIdx) % in_line_len)
+
+        look_end_indices[lookIdx] = int((look_start_indices[lookIdx] + window_len - 1) % in_line_len)
+
+    return look_start_indices

s1_denoise/noise_profiles.py

@@ -0,0 +1,292 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Core module orchestrating the generation of simulated thermal noise profiles for
+Sentinel-1 SLC and GRD products.
+
+Iterates over all polarisation/subswath channels of a SAFE product, applies
+thermal noise modelling via the ThermalNoise class, and returns structured output
+noise vectors. Optionally incorporates noise power correction derived from the
+associated L0N file.
+"""
+
+import sys
+from pathlib import Path
+import numpy as np
+
+from perseo_core.timing import PreciseDateTime
+
+# Local imports
+from s1_denoise.logger import denoise_logger
+from s1_denoise.s1safe import S1Safe
+from s1_denoise.xml_reader import create_slant_range_times, read_metadata_from_safe_annotation
+from s1_denoise.thermal_noise import ThermalNoise
+from s1_denoise.auxiliary_files import AuxiliaryFiles
+from s1_denoise.output import OutputNoiseVectors_SLC, OutputNoiseVectors_GRD
+from s1_denoise.l0_noise_power_calculation import get_noise_pwr_from_l0n
+from s1_denoise.utils import ensure_list, slant2ground
+
+def print_exec_time(elapsed_seconds: float) -> None:
+    """
+    Log the execution time in a human-readable format.
+
+    The time is split into hours, minutes and seconds and logged at debug level.
+
+    Parameters
+    ----------
+    elapsed_seconds : float
+        Elapsed time [s].
+    """
+
+    hours = int(elapsed_seconds // 3600)
+    remaining = elapsed_seconds % 3600
+    minutes = int(remaining // 60)
+    seconds = remaining % 60
+
+    time_parts = []
+    if hours > 0:
+        time_parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
+    if minutes > 0:
+        time_parts.append(f"{minutes} minute{'s' if minutes != 1 else ''}")
+    if seconds > 0 or not time_parts:
+        time_parts.append(f"{seconds:.3f} seconds")
+
+    denoise_logger.debug("Execution time: %s", ", ".join(time_parts))
+
+def slc_processing(safe, aux_files, dn_value, noise_power_correction):
+    """
+    Generate the simulated noise range vectors of an SLC product.
+
+    For each polarization/subswath channel, one noise vector is computed per burst, at the burst center azimuth
+    time, on the slant range axis of the swath.
+
+    Parameters
+    ----------
+    safe : S1Safe
+        Input SLC SAFE product.
+    aux_files : AuxiliaryFiles
+        Auxiliary files used for processing.
+    dn_value : float
+        Digital number calibration value from AUX_PP1, used to scale the output noise values.
+    noise_power_correction : dict or None
+        Noise power extracted from the L0N product, mapping ``(swath, polarization)`` to
+        ``[azimuth_times, noise_powers]``, or None to use the noise power annotated in the product.
+
+    Returns
+    -------
+    list of OutputNoiseVectors_SLC
+        Output noise vectors, one element per channel.
+    """
+
+    simulated_noises = []
+
+    # loop on annotation files
+    for pol, subswath in safe._channels:
+
+        channel = safe.channel(pol, subswath)
+        denoise_logger.info(f"Processing bursts from polarization {pol}, subswath {subswath}")        
+
+        metadata_dict = read_metadata_from_safe_annotation(channel.annotation)
+        ads_header = metadata_dict['product']['adsHeader']
+        lines_per_burst = int(metadata_dict['product']['swathTiming']['linesPerBurst'])
+        az_dt = float(metadata_dict['product']['imageAnnotation']['imageInformation']['azimuthTimeInterval'])
+
+        thermal_noise = ThermalNoise(metadata_dict=metadata_dict, 
+                                     channel=channel, 
+                                     aux_info=aux_files,
+                                     product_id=safe.path.stem[4:13],
+                                     noise_power_from_l0=noise_power_correction)
+
+        sim_noises = {}
+        geo_grid_info = metadata_dict['product']['geolocationGrid']
+
+        # slant range times are the same for all the bursts of the swath
+        range_t = create_slant_range_times(metadata_dict)
+        thermal_noise.set_range_values(range_t)
+
+        denoise_logger.info(f"Generating noise profiles for subswath {subswath} ({pol})")
+
+        for rel_burst in range(channel.num_bursts):
+
+            denoise_logger.debug(f"Generating noise profiles for burst {rel_burst+1} ({pol}, {subswath})")
+
+            az_t0 = PreciseDateTime.from_utc_string((channel.annotation.find('antennaPattern/antennaPatternList/antennaPattern[{}]/azimuthTime'.format(rel_burst+1)).text))
+
+            az_central_time = az_t0 + az_dt * lines_per_burst/2
+
+            # create simulated noise
+            thermal_noise.rel_burst = rel_burst
+            thermal_noise.get_shrink_factor()
+            
+            sim_noise, incidence_angles = thermal_noise.compute_simulated_noise(az_central_time)
+
+            start_az_time = az_t0.isoformat(sep="T", timespec="microseconds").rstrip("Z")
+
+            sim_noises.update({
+                (rel_burst, start_az_time): (sim_noise, geo_grid_info, incidence_angles, dn_value)
+            })
+        
+        # Append it
+        simulated_noises.append(OutputNoiseVectors_SLC(adsHeader=ads_header, noiseRangeVectors=sim_noises))
+
+    return simulated_noises
+
+def grd_processing(safe, aux_files, dn_value, noise_power_correction):
+    """
+    Generate the simulated noise range vectors of a GRD product.
+
+    For each polarization, the subswaths merged in the annotation are processed separately: one noise vector is
+    computed in slant range for each antenna pattern record (block) of the subswath and converted to ground range.
+    The subswaths are then merged into cross-subswath noise vectors by `OutputNoiseVectors_GRD`.
+
+    Parameters
+    ----------
+    safe : S1Safe
+        Input GRD SAFE product.
+    aux_files : AuxiliaryFiles
+        Auxiliary files used for processing.
+    dn_value : float
+        Digital number calibration value from AUX_PP1, used to scale the output noise values.
+    noise_power_correction : dict or None
+        Noise power extracted from the L0N product, mapping ``(swath, polarization)`` to
+        ``[azimuth_times, noise_powers]``, or None to use the noise power annotated in the product.
+
+    Returns
+    -------
+    list of OutputNoiseVectors_GRD
+        Output noise vectors, one element per polarization.
+    """
+
+    simulated_noises = []
+
+    for pol, swath in safe._channels:
+
+        channel = safe.channel(pol, swath)
+        denoise_logger.info(f"Processing bursts from polarization {pol}, subswath {swath}")        
+
+        metadata_dict = read_metadata_from_safe_annotation(channel.annotation)
+        ads_header = metadata_dict['product']['adsHeader']
+
+        count_noise_list = int(channel.annotation.find('generalAnnotation/noiseList').attrib['count'])
+        antenna_patterns = channel.annotation.findall('antennaPattern/antennaPatternList/antennaPattern')
+        tot_noise_vectors_out = int(channel.annotation.find('antennaPattern/antennaPatternList').attrib['count'])
+        swath_merging_info = ensure_list(metadata_dict['product']['swathMerging']['swathMergeList']['swathMerge'])
+
+        # for slant to range conversion
+        raw_cc = metadata_dict['product']['coordinateConversion']['coordinateConversionList']['coordinateConversion']
+        coordinate_conversions = []
+        for cc in raw_cc:
+            coordinate_conversions.append({
+                "azimuthTime": cc["azimuthTime"],
+                "sr0": float(cc["sr0"]),
+                "gr0": float(cc["gr0"]),  # adjust if needed
+                "srgrCoeffs": [float(x) for x in cc["srgrCoefficients"]["#text"].split()]
+            })
+        
+        # separate noise by subswath
+        noise_subswaths = []
+        for idx in range(1, count_noise_list+1):
+            tmp_subswath = channel.annotation.find('generalAnnotation/noiseList/noise[{}]/swath'.format(idx)).text
+            if tmp_subswath not in noise_subswaths:
+                noise_subswaths.append(tmp_subswath)
+
+        sim_noises = {}
+
+        for subswath in noise_subswaths:
+
+            thermal_noise = ThermalNoise(metadata_dict=metadata_dict, 
+                                         channel=channel, 
+                                         aux_info=aux_files, 
+                                         product_id=safe.path.stem[4:13],
+                                         noise_power_from_l0=noise_power_correction,
+                                         subswath=subswath)
+
+            subswath_antenna_patterns = [
+                ap for ap in antenna_patterns
+                if ap.findtext('swath') == subswath
+            ]
+
+            denoise_logger.info(f"Generating noise profiles for subswath {subswath} ({pol})")
+                    
+            for index in range(len(subswath_antenna_patterns)):
+
+                denoise_logger.debug(f"Generating noise profiles for block {index+1} ({pol}, {subswath})")
+                            
+                az_t0 = PreciseDateTime.from_utc_string(subswath_antenna_patterns[index].findtext('azimuthTime'))
+
+                range_t = create_slant_range_times(metadata_dict, subswath=subswath, az_t0=az_t0)
+                
+                # create simulated noise
+                thermal_noise.set_range_values(range_t)
+                thermal_noise.rel_burst = index
+                thermal_noise.get_shrink_factor()
+                
+                # slant range simulated noise
+                sim_noise, incidence_angles = thermal_noise.compute_simulated_noise(az_t0)
+
+                # convert from slant range to ground range using actual SR distances
+                az_t0_string = az_t0.isoformat(sep="T", timespec="microseconds").rstrip("Z")
+                sim_noise, incidence_angles = slant2ground(
+                    az_t0_string, sim_noise, incidence_angles,
+                    coordinate_conversions, thermal_noise.range_distances
+                )
+
+                sim_noises.update({
+                    (index, subswath): (az_t0_string, sim_noise, incidence_angles)
+                })
+
+        # append it
+        simulated_noises.append(OutputNoiseVectors_GRD(adsHeader=ads_header, 
+                                                       swath_merges=swath_merging_info, 
+                                                       noiseRangeVectors=sim_noises,
+                                                       dn_value=dn_value,
+                                                       tot_vec_out=tot_noise_vectors_out))
+
+    return simulated_noises
+
+def generate_noise_profiles(prod: Path, aux_files: AuxiliaryFiles, l0n_file: Path = None):
+    """
+    Generate the simulated noise range vectors of a Sentinel-1 L1 product.
+
+    Dispatches to `slc_processing` or `grd_processing` depending on the product type. If an L0N product is given,
+    the noise power is extracted from it instead of being read from the product annotation.
+
+    Parameters
+    ----------
+    prod : pathlib.Path
+        Path to the input L1 SAFE product (SLC or GRD).
+    aux_files : AuxiliaryFiles
+        Auxiliary files used for processing.
+    l0n_file : pathlib.Path, optional
+        Path to the associated L0N SAFE product. If None (default), the annotated noise power is used.
+
+    Returns
+    -------
+    list of OutputNoiseVectors_SLC or list of OutputNoiseVectors_GRD
+        Output noise vectors, one element per output noise file.
+
+    Notes
+    -----
+    The process exits with code 128 if the product type is neither SLC nor GRD.
+    """
+
+    safe = S1Safe(prod)
+    dn_value = aux_files.get_dn_value(safe.mode, safe.product_type)
+
+    denoise_logger.info(f"Denoising product: {prod.resolve()}")
+
+    if l0n_file is not None:        
+        noise_power_correction = get_noise_pwr_from_l0n(l0n_path = l0n_file, aux_ins_path = aux_files.ins_filepath)
+    else:
+        noise_power_correction = None
+
+    if safe.product_type == "SLC":
+        simulated_noises = slc_processing(safe, aux_files, dn_value, noise_power_correction)
+    elif safe.product_type.startswith("GRD"):
+        simulated_noises = grd_processing(safe, aux_files, dn_value, noise_power_correction)
+    else:
+        denoise_logger.error(f"Unknown product type: {safe.product_type}")
+        sys.exit(128)
+    
+    return simulated_noises