sct_ambiguities_analysis 1.0.0.dev0__py3-none-any.whl

sct_ambiguities_analysis/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Target Ambiguity Ratio Analysis feature.
+
+Discovered by SCT via the ``sct.analyses`` entry-point namespace.
+"""
+
+__version__ = "1.0.0.dev0"

sct_ambiguities_analysis/cli.py

@@ -0,0 +1,71 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Command Line Interface for Target Ambiguity Ratio 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_ambiguities_analysis.config import SCTTargetAmbiguityRatioConfig
+
+
+def ptar_analysis(
+    ctx: typer.Context,
+    product: common.InputProductOption,
+    point_target_source: common.InputPointTargetSource,
+    output_directory: common.OutputDirectoryOption,
+) -> None:
+    """Point Target Ambiguity Ratio Analysis."""
+
+    config: GeneralConfiguration = ctx.obj
+
+    log_path = output_directory / "sct_tar_analysis.log" if config.save_log else None
+
+    with common.logging_to_file(log_path):
+        sct_logger.info(f"Product: {product}")
+        sct_logger.info(f"Point targets: {point_target_source}")
+        sct_logger.info(f"Output folder: {output_directory}")
+
+        common.display_title("Ambiguity  Ratio  Analysis")
+
+        analysis_config = (
+            SCTTargetAmbiguityRatioConfig.from_toml(config.toml_path)
+            if config.toml_path is not None
+            else SCTTargetAmbiguityRatioConfig()
+        )
+        pt_ambiguity_ratio_analysis_implementation(
+            product=product,
+            point_target_source=point_target_source,
+            output_directory=output_directory,
+            config=analysis_config,
+            graphs=True,
+            dump_config=config.save_config_copy,
+        )
+
+
+@common.log_elapsed_time("Point Target Ambiguity Ratio Analysis")
+@common.graceful_exit("Point Target Ambiguity Ratio Analysis")
+def pt_ambiguity_ratio_analysis_implementation(
+    product: Path,
+    point_target_source: Path,
+    output_directory: Path,
+    config: SCTTargetAmbiguityRatioConfig,
+    graphs: bool,
+    dump_config: bool,
+) -> None:
+    """Implement the point target ambiguity ratio analysis command."""
+    from sct_ambiguities_analysis.main import full_pt_ambiguity_ratio_analysis
+
+    full_pt_ambiguity_ratio_analysis(
+        product=product,
+        point_target_source=point_target_source,
+        output_directory=output_directory,
+        config=config,
+        graphs=graphs,
+    )

sct_ambiguities_analysis/config.py

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

sct_ambiguities_analysis/core/__init__.py

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

sct_ambiguities_analysis/core/analysis.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Target Ambiguity Ratio Analysis"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from perseo_quality.tar_analysis.analysis import point_target_ambiguity_ratio_analysis
+from perseo_quality.tar_analysis.custom_dataclasses import PointTargetAmbiguityRatioDataOutput
+from sct.configuration.logger import sct_logger
+from sct.io.io_manager import InvalidProductType, product_loader
+from sct.io.point_target_manager import convert_df_to_nominal_point_target, extract_point_target_data_from_source
+
+from sct_ambiguities_analysis.config import SCTTargetAmbiguityRatioConfig
+
+
+def sct_point_target_ambiguity_ratio_analysis(
+    product_path: str | Path, external_target_source: str | Path, config: SCTTargetAmbiguityRatioConfig | None = None
+) -> list[PointTargetAmbiguityRatioDataOutput]:
+    """Point Target Ambiguity Ratio Analysis performed on the input product.
+
+    Parameters
+    ----------
+    product_path : str | Path
+        path to the product to be analyzed
+    external_target_source : str | Path
+        path to external point target source
+    config : SCTTargetAmbiguityRatioConfig | None, optional
+        configuration parameters, by default None
+
+    Returns
+    -------
+    list[PointTargetAmbiguityRatioDataOutput]
+        list of PointTargetAmbiguityRatioDataOutput analysis output, one for each product channel and each Point Target
+    """
+    # Input parameters analysis
+    product_path = Path(product_path)
+    sct_logger.info(f"Input product: {product_path}")
+
+    external_target_source = Path(external_target_source)
+    sct_logger.info(f"Using external target source provided: {external_target_source}")
+
+    config = config or SCTTargetAmbiguityRatioConfig()
+
+    # 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
+
+    # external target source
+    point_targets_df = extract_point_target_data_from_source(source=external_target_source)
+
+    # converting point target data frame in list of NominalPointTarget dataclasses
+    point_targets_data = convert_df_to_nominal_point_target(data_df=point_targets_df)
+
+    return point_target_ambiguity_ratio_analysis(
+        product=product, point_targets=point_targets_data, config=config.base_config
+    )

sct_ambiguities_analysis/interface.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Target Ambiguity Ratio 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 import __version__
+
+if TYPE_CHECKING:
+    from sct.core.base import AnalysisHandler
+    from typer import Typer
+
+ANALYSIS_NAME = "ambiguity_ratio"
+
+
+class TargetAmbiguityRatioAnalysisPlugin:
+    """Target Ambiguity Ratio Analysis plugin."""
+
+    version = __version__
+    short_help = "Point Target Ambiguity Ratio Analysis."
+
+    @classmethod
+    def get_cli(cls) -> Typer | Callable:
+        from sct_ambiguities_analysis.cli import ptar_analysis
+
+        return ptar_analysis
+
+    @classmethod
+    def get_handlers(cls) -> dict[str, AnalysisHandler]:
+        from sct.core.base import AnalysisHandler
+
+        from sct_ambiguities_analysis.config import SCTTargetAmbiguityRatioConfig
+
+        return {
+            ANALYSIS_NAME: AnalysisHandler(
+                config=SCTTargetAmbiguityRatioConfig,
+                cli=cls.get_cli(),
+                testing=None,
+            )
+        }

sct_ambiguities_analysis/main.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""Ambiguity Ratio Analysis implementation."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from sct.configuration.logger import sct_logger
+
+from sct_ambiguities_analysis.config import SCTTargetAmbiguityRatioConfig
+from sct_ambiguities_analysis.core.analysis import sct_point_target_ambiguity_ratio_analysis
+
+
+def full_pt_ambiguity_ratio_analysis(
+    product: Path,
+    point_target_source: Path,
+    output_directory: Path,
+    config: SCTTargetAmbiguityRatioConfig | None,
+    graphs: bool,
+) -> None:
+    """Full implementation of Point Target Ambiguity Ratio Analysis.
+
+    Parameters
+    ----------
+    product : Path
+        Path to the product to be analyzed
+    point_target_source : Path
+        Path to the point target source file
+    output_directory : Path
+        Path to the output directory
+    config : SCTTargetAmbiguityRatioConfig | None
+        analysis configuration parameters, if needed
+    graphs : bool
+        flag to enable graphs generation
+    """
+    graphs_func = _import_ptar_graphs_func(graphs)
+    output = sct_point_target_ambiguity_ratio_analysis(
+        product_path=product,
+        external_target_source=point_target_source,
+        config=config,
+    )
+
+    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)
+
+
+def _import_ptar_graphs_func(graphs: bool) -> Callable | None:
+    """Importing the target ambiguity ratio analysis graphs plotting function."""
+    ambiguities_graphs = None
+    if graphs:
+        try:
+            from perseo_quality.tar_analysis.graphical_output import ambiguities_graphs
+        except ImportError as err:
+            sct_logger.critical(
+                'Cannot generate graphical output: install graphs requirements "pip install sct[graphs]"'
+            )
+            raise ImportError from err
+    return ambiguities_graphs

sct_ambiguities_analysis/resources/__init__.py

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

sct_ambiguities_analysis/resources/config_schema.json

@@ -0,0 +1,38 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "ambiguity_ratio_analysis": {
+            "type": "object",
+            "description": "Ambiguity ratio analysis configuration",
+            "properties": {
+                "cropping_size": {
+                    "type": "array",
+                    "description": "ROI cropping size in pixels",
+                    "items": [
+                        {
+                            "type": "integer",
+                            "description": "number of samples"
+                        },
+                        {
+                            "type": "integer",
+                            "description": "number of lines"
+                        }
+                    ],
+                    "minItems": 2,
+                    "maxItems": 2
+                },
+                "interpolation_factor": {
+                    "type": "integer",
+                    "description": "ROI interpolation factor"
+                }
+            },
+            "required": [
+                "cropping_size"
+            ]
+        }
+    },
+    "required": [
+        "ambiguity_ratio_analysis"
+    ]
+}

sct_ambiguities_analysis-1.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.5
+Name: sct_ambiguities_analysis
+Version: 1.0.0.dev0
+Summary: SCT Plugin for Point and Distributed Ambiguity Ratio 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: 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: Ambiguity Ratio Analysis
+
+[![PyPI version](https://img.shields.io/pypi/v/sct-ambiguities-analysis)](https://pypi.org/project/sct-ambiguities-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/ambiguities.yml/badge.svg)](https://github.com/aresys-srl/sct_plugins_analyses/actions/workflows/ambiguities.yml)
+
+[SCT (SAR Calibration Toolbox)](https://github.com/aresys-srl/sct) plugin for performing
+Point and Distributed Target Ambiguity Ratio Analysis on L1 SAR products. Enables
+evaluation of signal-to-ambiguity ratios for quality assessment through SCT.
+
+## Installation
+
+``` bash
+pip install sct-ambiguities-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_ambiguities_analysis-1.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sct_ambiguities_analysis/__init__.py,sha256=W5ZpVUizua0toxBTEhmrMP25EScZukSp-htGeA-OnvY,241
+sct_ambiguities_analysis/cli.py,sha256=9dG1zKqaDY9QlBillJeU3vZOMfYRGsX09sHeh8a_vf4,2385
+sct_ambiguities_analysis/config.py,sha256=cFG6rZqteKK7kghEgNVWGGz3t0hjGsntf0c4n1Kz2-0,1083
+sct_ambiguities_analysis/interface.py,sha256=MXRAukiSEWW2bcG3-dzPJauJJEqjvbhrw0g0-aUlZyg,1343
+sct_ambiguities_analysis/main.py,sha256=IPbwcsHQZ2BJuE3oDGOBIGImvinmQwlInG7Oej3Sm4E,2209
+sct_ambiguities_analysis/core/__init__.py,sha256=rQSWdSrY8xub4Qe6UcgVCOzdVQsSckSDf0DHupVxNIA,308
+sct_ambiguities_analysis/core/analysis.py,sha256=75dZpAwlQShDvjTRs1x9cyYu7NHbCdIIVeW2UJJ1p6s,2648
+sct_ambiguities_analysis/resources/__init__.py,sha256=tPdJQcLywPGlbvc5GptYmLe3zYG2kZY8ikwFVpV_5i0,255
+sct_ambiguities_analysis/resources/config_schema.json,sha256=cGuprSWCPWd_2sb1NFSbb3rrEVijJq74o7khSpcr8PI,1232
+sct_ambiguities_analysis-1.0.0.dev0.dist-info/METADATA,sha256=WFp7fscvKWYj9zFzuCDAeoowjnj1er_jwKXYRjCGIa4,4706
+sct_ambiguities_analysis-1.0.0.dev0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sct_ambiguities_analysis-1.0.0.dev0.dist-info/entry_points.txt,sha256=tErVaPRw5u9AruNgSyKrEX2jdWq97cVa00rgsfNPyYM,99
+sct_ambiguities_analysis-1.0.0.dev0.dist-info/licenses/LICENSE.txt,sha256=ghpoTMO3cD8pZJfaY7VtSv57JvZOsLuSCiysG-ERAuY,1103
+sct_ambiguities_analysis-1.0.0.dev0.dist-info/RECORD,,

sct_ambiguities_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_ambiguities_analysis-1.0.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sct.analyses]
+ambiguities = sct_ambiguities_analysis.interface:TargetAmbiguityRatioAnalysisPlugin

sct_ambiguities_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.