sct_notch_analysis 1.0.0.dev0__py3-none-any.whl

sct_notch_analysis/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis on L1 SAR Products plugin for SCT.
+
+Discovered by SCT via the ``sct.analyses`` entry-point namespace.
+"""
+
+__version__ = "1.0.0.dev0"

sct_notch_analysis/cli.py

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Command Line Interface for Elevation Notch Analysis."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from sct.cli import common
+from sct.configuration.config import GeneralConfiguration
+from sct.configuration.logger import sct_logger
+
+from sct_notch_analysis.config import SCTElevationNotchAnalysisConfig
+
+
+def notch_analysis(
+    ctx: typer.Context,
+    product: common.InputProductOption,
+    output_directory: common.OutputDirectoryOption,
+    antenna_pattern: common.AntennaPatternInputOption = None,
+    graphs: common.GraphsOption = False,
+) -> None:
+    """Elevation Notch Analysis.
+
+    \b
+    Antenna pattern NetCDF file can be provided to estimate the elevation pointing offset with Least Square fitting
+    of the elevation profile of the focused data with a three parameters internal model.
+    """
+
+    config: GeneralConfiguration = ctx.obj
+
+    log_path = output_directory / "sct_notch_analysis.log" if config.save_log else None
+
+    with common.logging_to_file(log_path):
+        sct_logger.info(f"Product: {product}")
+        if antenna_pattern is not None:
+            sct_logger.info(f"Antenna pattern: {antenna_pattern}")
+        else:
+            sct_logger.warning("No antenna pattern provided, only parabolic fit around minimum will be performed.")
+        sct_logger.info(f"Output folder: {output_directory}")
+        sct_logger.info(f"Graphs generation {'enabled' if graphs else 'disabled'}")
+
+        common.display_title("Elevation  Notch  Analysis")
+
+        analysis_config = (
+            SCTElevationNotchAnalysisConfig.from_toml(config.toml_path)
+            if config.toml_path is not None
+            else SCTElevationNotchAnalysisConfig()
+        )
+        elevation_notch_analysis_implementation(
+            product=product,
+            antenna_pattern=antenna_pattern,
+            output_directory=output_directory,
+            config=analysis_config,
+            graphs=graphs,
+            dump_config=config.save_config_copy,
+        )
+
+
+@common.log_elapsed_time("Elevation Notch Analysis")
+@common.graceful_exit("Elevation Notch Analysis")
+def elevation_notch_analysis_implementation(
+    product: Path,
+    antenna_pattern: Path | None,
+    output_directory: Path,
+    config: SCTElevationNotchAnalysisConfig,
+    graphs: bool,
+    dump_config: bool,
+) -> None:
+    """Implement the elevation notch analysis command."""
+    from sct_notch_analysis.main import full_elevation_notch_analysis
+
+    full_elevation_notch_analysis(
+        product=product,
+        antenna_pattern=antenna_pattern,
+        output_directory=output_directory,
+        config=config,
+        graphs=graphs,
+    )

sct_notch_analysis/config.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis Configuration."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from perseo_quality.elevation_notch_analysis.config import ElevationNotchConfig
+from sct.configuration.config_abc import AnalysisConfigABC
+
+from sct_notch_analysis.resources import config_schema
+
+
+@dataclass
+class SCTElevationNotchAnalysisConfig(AnalysisConfigABC):
+    """SCT Elevation Notch Analysis configuration"""
+
+    base_config: ElevationNotchConfig = field(default_factory=ElevationNotchConfig)
+    config_group_name = "elevation_notch_analysis"
+    validation_schema = Path(config_schema)
+
+    @classmethod
+    def from_dict(cls, arg: dict) -> SCTElevationNotchAnalysisConfig:
+        """Convert from dict"""
+        return cls(base_config=ElevationNotchConfig.from_dict(arg))
+
+    def to_dict(self):
+        """Convert to dict"""
+        return {self.config_group_name: asdict(self.base_config)}

sct_notch_analysis/core/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis - Core implementation"""
+
+from sct_notch_analysis.core.analysis import sct_elevation_notch_analysis
+
+__all__ = ["sct_elevation_notch_analysis"]

sct_notch_analysis/core/analysis.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from perseo_quality.elevation_notch_analysis.analysis import elevation_notch_analysis
+from perseo_quality.elevation_notch_analysis.custom_dataclasses import (
+    ElevationNotchOutput,
+)
+from sct.configuration.logger import sct_logger
+from sct.io.antenna_pattern_manager import read_antenna_pattern_netcdf
+from sct.io.io_manager import InvalidProductType, product_loader
+
+from sct_notch_analysis.config import SCTElevationNotchAnalysisConfig
+
+
+def sct_elevation_notch_analysis(
+    product_path: str | Path,
+    antenna_pattern_file: str | Path | None = None,
+    config: SCTElevationNotchAnalysisConfig | None = None,
+) -> list[ElevationNotchOutput]:
+    """Elevation Notch Analysis performed on the input product, taking into account the antenna pattern data, if
+    provided.
+
+    Parameters
+    ----------
+    product_path : str | Path
+        path to the product to be analyzed
+    antenna_pattern_file : str | Path | None, optional
+        path to the antenna pattern NetCDF file, if needed, by default None
+    config : SCTElevationNotchAnalysisConfig | None, optional
+        configuration parameters, by default None
+
+    Returns
+    -------
+    list[ElevationNotchOutput]
+        list of ElevationNotchOutput analysis output, one for each product channel
+    """
+    product_path = Path(product_path)
+    sct_logger.info(f"Input product: {product_path}")
+
+    config = config or SCTElevationNotchAnalysisConfig()
+
+    # LOADING PRODUCT
+    try:
+        product, _ = product_loader(
+            product_path=product_path,
+        )
+    except InvalidProductType as err:
+        sct_logger.critical(f"Unknown product type {product_path}.")
+        sct_logger.critical("Please check that the dedicated format plugin is installed.")
+        raise InvalidProductType from err
+
+    # LOADING ANTENNA PATTERN
+    antenna_pattern = None
+    if antenna_pattern_file is not None:
+        sct_logger.info(f"Antenna Pattern provided. Loading data from {antenna_pattern_file}")
+        try:
+            antenna_pattern = read_antenna_pattern_netcdf(antenna_pattern_file)
+        except Exception as err:
+            sct_logger.critical("Error while reading antenna pattern file")
+            sct_logger.critical(err)
+            raise RuntimeError from err
+
+    return elevation_notch_analysis(
+        product=product,
+        antenna_pattern=antenna_pattern,
+        config=config.base_config,
+    )

sct_notch_analysis/interface.py

@@ -0,0 +1,56 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis plugin entry point.
+
+Lightweight module: importing it must not pull in the heavy analysis implementation
+or the scientific stack. All heavy imports are deferred to the accessor methods.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from sct_notch_analysis import __version__
+
+if TYPE_CHECKING:
+    from sct.core.base import AnalysisHandler
+    from typer import Typer
+
+ANALYSIS_NAME = "elevation_notch"
+
+
+class ElevationNotchAnalysisPlugin:
+    """Elevation Notch Analysis plugin."""
+
+    version = __version__
+    short_help = "Elevation Notch Analysis."
+
+    @classmethod
+    def get_cli(cls) -> Typer | Callable:
+        from sct_notch_analysis.cli import notch_analysis
+
+        return notch_analysis
+
+    @classmethod
+    def get_handlers(cls) -> dict[str, AnalysisHandler]:
+        from sct.core.base import AnalysisHandler, AnalysisTestingHandler
+
+        from sct_notch_analysis.config import SCTElevationNotchAnalysisConfig
+        from sct_notch_analysis.testing import (
+            run_notch_api,
+            run_notch_cli,
+            validate_notch_results,
+        )
+
+        return {
+            ANALYSIS_NAME: AnalysisHandler(
+                config=SCTElevationNotchAnalysisConfig,
+                cli=cls.get_cli(),
+                testing=AnalysisTestingHandler(
+                    api_runner=run_notch_api,
+                    cli_runner=run_notch_cli,
+                    validator=validate_notch_results,
+                ),
+            )
+        }

sct_notch_analysis/main.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis implementation."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from perseo_quality.elevation_notch_analysis.support import elevation_notch_profiles_to_netcdf
+from sct.configuration.logger import sct_logger
+
+from sct_notch_analysis.config import SCTElevationNotchAnalysisConfig
+from sct_notch_analysis.core import sct_elevation_notch_analysis
+
+
+def full_elevation_notch_analysis(
+    product: Path,
+    antenna_pattern: Path | None,
+    output_directory: Path,
+    config: SCTElevationNotchAnalysisConfig | None,
+    graphs: bool,
+) -> Path:
+    """Full implementation of Elevation Notch Analysis.
+
+    Parameters
+    ----------
+    product : Path
+        Path to the product to be analyzed
+    antenna_pattern : Path | None
+        Path to the antenna pattern NetCDF file
+    output_directory : Path
+        Path to the output directory
+    config : SCTElevationNotchAnalysisConfig | None
+        analysis configuration parameters, if needed
+    graphs : bool
+        flag to enable graphs generation
+
+    Returns
+    -------
+    Path
+        Path to the NetCDF file containing the results
+    """
+    graphs_func = _import_notch_graphs_func(graphs)
+    output = sct_elevation_notch_analysis(product_path=product, antenna_pattern_file=antenna_pattern, config=config)
+    sct_logger.info("Saving results to NetCDF...")
+    netcdf_file = elevation_notch_profiles_to_netcdf(data=output, output_dir=output_directory)
+
+    if graphs_func is not None:
+        sct_logger.info("Generating graphs...")
+        output_graphs_dir = output_directory.joinpath("graphs")
+        output_graphs_dir.mkdir(exist_ok=True)
+        graphs_func(data=output, output_dir=output_graphs_dir)
+
+    return netcdf_file
+
+
+def _import_notch_graphs_func(graphs: bool) -> Callable | None:
+    """Importing the elevation notch analysis graphs plotting function."""
+    plot_elevation_notch_analysis = None
+    if graphs:
+        try:
+            from perseo_quality.elevation_notch_analysis.graphical_output import plot_elevation_notch_analysis
+        except ImportError as err:
+            sct_logger.critical(
+                'Cannot generate graphical output: install graphs requirements "pip install sct[graphs]"'
+            )
+            raise ImportError from err
+    return plot_elevation_notch_analysis

sct_notch_analysis/resources/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Elevation Notch Analysis resources"""
+
+from importlib import resources
+
+config_schema = resources.files(__package__).joinpath("config_schema.json")

sct_notch_analysis/resources/config_schema.json

@@ -0,0 +1,21 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "elevation_notch_analysis": {
+            "type": "object",
+            "description": "Elevation Notch analysis configuration",
+            "properties": {
+                "azimuth_block_size": {
+                    "type": "integer",
+                    "description": "Number of lines for partitioning the scene along azimuth direction"
+                },
+                "range_pixel_margin": {
+                    "type": "integer",
+                    "description": "Pixel margin to remove near and far range"
+                }
+            }
+        }
+    },
+    "required": ["elevation_notch_analysis"]
+}

sct_notch_analysis/testing.py

@@ -0,0 +1,146 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""SCT Testing - Elevation Notch Analysis"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+from netCDF4 import Dataset
+from sct.testing.utilities.common import ReferenceOutput, TestOutput, TestParams, cli_launcher
+
+from sct_notch_analysis.config import SCTElevationNotchAnalysisConfig
+from sct_notch_analysis.main import full_elevation_notch_analysis
+
+ABSOLUTE_TOLERANCE = 1e-5
+
+
+def run_notch_api(
+    params: TestParams, output_dir: Path, config: SCTElevationNotchAnalysisConfig | None, graphs: bool
+) -> TestOutput:
+    """Running SCT Elevation Notch Analysis from API forwarding the inputs.
+
+    Parameters
+    ----------
+    params : TestParams
+        test parameters
+    output_dir : Path
+        output directory
+    config : SCTElevationNotchAnalysisConfig | None
+        analysis configuration, if needed
+    graphs : bool
+        flag to enable graphs generation
+
+    Returns
+    -------
+    TestOutput
+        path to output netcdf file
+    """
+    nc_output = full_elevation_notch_analysis(
+        product=params.product,
+        antenna_pattern=params.antenna_pattern,
+        output_directory=output_dir,
+        config=config,
+        graphs=graphs,
+    )
+    return TestOutput(netcdf_results=nc_output)
+
+
+def run_notch_cli(params: TestParams, output_dir: Path, config: Path | None, graphs: bool) -> TestOutput:
+    """Running SCT Elevation Notch Analysis using CLI tool forwarding the inputs.
+
+    Parameters
+    ----------
+    params : TestParams
+        test parameters
+    output_dir : Path
+        output directory
+    config : Path | None
+        configuration file
+    graphs : bool
+        flag to enable graphs generation
+
+    Returns
+    -------
+    TestOutput
+        path to NetCDF output file
+
+    RuntimeError
+        if missing output configuration file
+    RuntimeError
+        if missing output log file
+    RuntimeError
+        if missing output NetCDF results file
+    """
+    cli_args = []
+    if config is not None:
+        cli_args.extend(["--config", str(config)])
+    cli_args.extend(
+        [
+            "elevation_notch",
+            "-p",
+            str(params.product),
+            "-out",
+            str(output_dir),
+        ]
+    )
+    if params.antenna_pattern is not None:
+        cli_args.extend(["-ap", str(params.antenna_pattern)])
+    if graphs:
+        cli_args.extend(["-g"])
+
+    cli_launcher(cli_args)
+
+    # checking successful run
+    if not output_dir.joinpath("analysis_config.toml").exists():
+        raise RuntimeError("Missing analysis_config.toml file")
+    if not output_dir.joinpath("sct_notch_analysis.log").exists():
+        raise RuntimeError("Missing sct_notch_analysis.log file")
+    nc_output_file = list(output_dir.glob("*.nc"))
+    if not len(nc_output_file) == 1:
+        raise RuntimeError("No output NetCDF file found")
+
+    return TestOutput(netcdf_results=nc_output_file[0])
+
+
+def validate_notch_results(current_output: TestOutput, reference_output: ReferenceOutput) -> None:
+    """Compare elevation notch netCDF output results with tolerances.
+
+    Parameters
+    ----------
+    current_output : TestOutput
+        current run output
+    reference_output : ReferenceOutput
+        reference output
+    """
+
+    current_ds = Dataset(current_output.netcdf_results, "r", format="NETCDF4")
+    reference_ds = Dataset(reference_output.netcdf_reference, "r", format="NETCDF4")
+
+    assert reference_ds.groups.keys() == current_ds.groups.keys()
+    for key, group in reference_ds.groups.items():
+        current_group = current_ds.groups[key]
+        assert group.groups.keys() == current_group.groups.keys()
+        for s_key, subgroup in group.groups.items():
+            current_subgroup = current_group.groups[s_key]
+            assert subgroup.azimuth_blocks_num == current_subgroup.azimuth_blocks_num
+            assert subgroup.lines_per_block == current_subgroup.lines_per_block
+            assert subgroup.samples_per_block == current_subgroup.samples_per_block
+            assert subgroup.variables.keys() == current_subgroup.variables.keys()
+            for var_name, var in subgroup.variables.items():
+                current_var = current_subgroup.variables[var_name]
+                try:
+                    assert var.units == current_var.units
+                except AttributeError:
+                    pass
+                np.testing.assert_allclose(
+                    var[:],
+                    current_var[:],
+                    atol=ABSOLUTE_TOLERANCE,
+                    rtol=0,
+                )
+
+    reference_ds.close()
+    current_ds.close()

sct_notch_analysis-1.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.5
+Name: sct_notch_analysis
+Version: 1.0.0.dev0
+Summary: SCT Plugin for Notch Analysis of L1 SAR Products.
+Project-URL: Homepage, https://github.com/aresys-srl/sct_plugins_analyses
+Project-URL: Repository, https://github.com/aresys-srl/sct_plugins_analyses
+Project-URL: Documentation, https://opensource.aresys.it/sct_plugins_analyses
+Author-email: "Aresys S.R.L." <info@aresys.it>
+License: MIT License
+        
+        Copyright (C) Aresys S.r.l. <info@aresys.it>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE.txt
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: jsonschema
+Requires-Dist: netcdf4
+Requires-Dist: numpy>2
+Requires-Dist: perseo-core>=1.0.0
+Requires-Dist: perseo-quality>=1.1.0
+Requires-Dist: sct
+Requires-Dist: typer>=0.24.1
+Provides-Extra: dev
+Requires-Dist: pylint; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocstrings-python; extra == 'docs'
+Requires-Dist: zensical; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Requires-Dist: sct[graphs]>=3.1.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# SCT Plugin: Elevation Notch Analysis
+
+[![PyPI version](https://img.shields.io/pypi/v/sct-notch-analysis)](https://pypi.org/project/sct-notch-analysis/)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE.txt)
+
+[![CI](https://github.com/aresys-srl/sct_plugins_analyses/actions/workflows/notch.yml/badge.svg)](https://github.com/aresys-srl/sct_plugins_analyses/actions/workflows/notch.yml)
+
+[SCT (SAR Calibration Toolbox)](https://github.com/aresys-srl/sct) plugin for performing
+Elevation Notch Analysis on L1 SAR products. Enables antenna mispointing computation from dedicated notch products.
+
+## Installation
+
+``` bash
+pip install sct-notch-analysis
+```
+
+SCT is automatically installed as a dependency.
+
+## Compatibility
+
+This plugin must be installed in the same Python environment as SCT. Once installed,
+the plugin is automatically discovered and registered by SCT through its entry-point
+based plugin system; no additional configuration is required.
+
+## Documentation
+
+- [SCT documentation](https://opensource.aresys.it/sct/)
+- [Quality Analysis documentation](https://opensource.aresys.it/perseo/documentation/quality/)
+- [Analysis Plugins documentation](https://opensource.aresys.it/sct_plugins_analyses)
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE.txt](LICENSE.txt) file for details.
+
+Copyright &copy; 2026-present Aresys S.r.l. <info@aresys.it>

sct_notch_analysis-1.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,15 @@
+sct_notch_analysis/__init__.py,sha256=cQ7f6zW7dAjTHlqTQEKvk3LjG64RonaixJHjIIMlOeo,260
+sct_notch_analysis/cli.py,sha256=qL26JrjVvuJ08cAhzshyq8XbAYIYEGgmgqLWsusY25Y,2833
+sct_notch_analysis/config.py,sha256=nsSsnum0T-IQ7S5fRdEXtnMmtxr5quIGOiNvC0jIVvQ,1086
+sct_notch_analysis/interface.py,sha256=V0A_uz-U-TgfWq38xkeqWIZCiSGdMuAuxa7Lcx3WIOI,1684
+sct_notch_analysis/main.py,sha256=OSQQOmZFcu6ODmaQTciFjDMBdaPewfabE4weoBTGjYQ,2524
+sct_notch_analysis/testing.py,sha256=c5ryl8SG1DM9vtvXqy4e9In8-CszlC5GXJRcerFnZhs,4822
+sct_notch_analysis/core/__init__.py,sha256=QNw5ABy_pj4h3uL4XKrHmq6IzBJsxoyJ2wkyPC0kCi4,269
+sct_notch_analysis/core/analysis.py,sha256=ftgvrjKsKlYAt4tDVoNhITYU55oJ9683AuMHkCq_GdM,2655
+sct_notch_analysis/resources/__init__.py,sha256=8qVyjxbucCUmP0pEKv3Rg3yqjYKbtAijpHZEp6bkWI0,248
+sct_notch_analysis/resources/config_schema.json,sha256=Mu3T6kls0WAMfpaRCEeI83NWOjAl25CM1bMeQi8Nzus,742
+sct_notch_analysis-1.0.0.dev0.dist-info/METADATA,sha256=B8EU1u3uZDVSS1uka6MUrnepNCFfYTlrrAnX2qjO50Q,4618
+sct_notch_analysis-1.0.0.dev0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sct_notch_analysis-1.0.0.dev0.dist-info/entry_points.txt,sha256=cOLPBpnl6suXlDGTacDrXsMjvR3bQZEOmtpO_-aORU4,91
+sct_notch_analysis-1.0.0.dev0.dist-info/licenses/LICENSE.txt,sha256=ghpoTMO3cD8pZJfaY7VtSv57JvZOsLuSCiysG-ERAuY,1103
+sct_notch_analysis-1.0.0.dev0.dist-info/RECORD,,

sct_notch_analysis-1.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sct_notch_analysis-1.0.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sct.analyses]
+elevation_notch = sct_notch_analysis.interface:ElevationNotchAnalysisPlugin

sct_notch_analysis-1.0.0.dev0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) Aresys S.r.l. <info@aresys.it>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.