hyppo-hsi 0.1.0__tar.gz

hyppo_hsi-0.1.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# What's new?
+
+<!-- BODY -->
+
+## Version 0.1.0
+
+First public release.
+
+### Features
+
+- **HSI container** (`hyppo.core.HSI`) with reflectance, wavelengths,
+  mask, and metadata. Includes `describe`, `pseudo_rgb`, `crop`, and
+  plot accessor.
+- **17 feature extractors**:
+    - **Dimensionality reduction:** PCA, ICA, MNF
+    - **Spectral indices:** NDVI, NDWI, SAVI
+    - **Texture:** GLCM, LBP, Gabor
+    - **Moments:** GeometricMoment, LegendreMoment, ZernikeMoment
+    - **Morphological / projection:** MP (Morphological Profile),
+      PP (Projection Pursuit)
+    - **Wavelet:** DWT1D, DWT2D, DWT3D
+- **4 runners**: `SequentialRunner`, `DaskThreadsRunner`,
+  `DaskProcessesRunner`, `LocalProcessRunner` (shared-memory).
+- **`FeatureSpace` orchestrator** with NetworkX-based dependency
+  graph and topological sort over extractor inputs.
+- **I/O**:
+    - HDF5 loader for HSI data with heuristic dataset discovery.
+    - HDF5 saver for `FeatureCollection`.
+    - YAML and JSON config support (`Config`).
+- **Extractor registry** for plugin-style discovery.
+- **Python 3.11–3.14 support**, including free-threaded builds.

hyppo_hsi-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, QuatroPe
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

hyppo_hsi-0.1.0/MANIFEST.in

@@ -0,0 +1,32 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+include pyproject.toml
+
+recursive-include hyppo *.py
+
+exclude tox.ini
+exclude requirements.txt
+exclude requirements_dev.txt
+exclude requirements_no_gil.txt
+exclude CLAUDE.md
+exclude INFORMATION.md
+exclude audit.md
+exclude coverage.xml
+exclude example.config.yaml
+exclude interpreters_test.py
+exclude NEON_subset.h5
+exclude hyppo.pdf
+exclude demo.ipynb
+exclude demo_free_threaded.ipynb
+exclude notebook_old.ipynb
+
+recursive-exclude tests *
+recursive-exclude docs *
+recursive-exclude demo *
+recursive-exclude benchmark *
+recursive-exclude _build *
+recursive-exclude _static *
+recursive-exclude _templates *
+recursive-exclude build *
+recursive-exclude __pycache__ *

hyppo_hsi-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: hyppo-hsi
+Version: 0.1.0
+Summary: HYPPO (Hyperspectral Processing) - A modular feature extractor for hyperspectral images
+Author-email: Tomás Ponce Gessi <tomaspgessi@mi.unc.edu.ar>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2026, QuatroPe
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Repository, https://github.com/quatrope/hyppo
+Project-URL: Issues, https://github.com/quatrope/hyppo/issues
+Keywords: hyperspectral,image-processing,feature-extraction,remote-sensing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Image Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dask[distributed]>=2024.1
+Requires-Dist: h5py>=3.10
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.13
+Requires-Dist: networkx>=3.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: attrs>=22.0
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: scikit-image>=0.22
+Requires-Dist: PyWavelets>=1.5
+Requires-Dist: pandas>=2.2
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Requires-Dist: tox>=4.0; extra == "dev"
+Requires-Dist: radon>=5.1; extra == "dev"
+Requires-Dist: xenon>=0.9; extra == "dev"
+Dynamic: license-file
+
+# hyppo-hsi
+
+**Modular feature extractor for hyperspectral images**
+
+[![QuatroPe](https://img.shields.io/badge/QuatroPe-Applications-1c5896)](https://quatrope.github.io/)
+[![PyPI](https://img.shields.io/pypi/v/hyppo-hsi)](https://pypi.org/project/hyppo-hsi/)
+[![License](https://img.shields.io/pypi/l/hyppo-hsi?color=blue)](https://www.tldrlegal.com/l/bsd3)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://pypi.org/project/hyppo-hsi/)
+
+**HYPPO** is a modular feature extraction library for hyperspectral images (HSI). It provides a uniform, configurable interface for computing spectral and spatial features used in hyperspectral image classification.
+
+## Features
+
+- 17 feature extractors (spectral indices, dimensionality reduction, texture, morphological, wavelet, moment-based)
+- Automatic dependency resolution between extractors via DAG
+- Multiple execution backends: sequential, Dask threads/processes, multiprocessing with shared memory
+- HDF5 I/O for HSI loading and feature saving
+- YAML/JSON configuration for reproducible pipelines
+- Python 3.11–3.14 support
+
+## Installation
+
+```bash
+pip install hyppo-hsi
+```
+
+## Code Repository & Issues
+
+<https://github.com/quatrope/hyppo>
+
+## License
+
+HYPPO is under the [BSD 3-Clause License](https://raw.githubusercontent.com/quatrope/hyppo/master/LICENSE).
+
+Copyright (c) 2026, QuatroPe.

hyppo_hsi-0.1.0/README.md

@@ -0,0 +1,35 @@
+# hyppo-hsi
+
+**Modular feature extractor for hyperspectral images**
+
+[![QuatroPe](https://img.shields.io/badge/QuatroPe-Applications-1c5896)](https://quatrope.github.io/)
+[![PyPI](https://img.shields.io/pypi/v/hyppo-hsi)](https://pypi.org/project/hyppo-hsi/)
+[![License](https://img.shields.io/pypi/l/hyppo-hsi?color=blue)](https://www.tldrlegal.com/l/bsd3)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://pypi.org/project/hyppo-hsi/)
+
+**HYPPO** is a modular feature extraction library for hyperspectral images (HSI). It provides a uniform, configurable interface for computing spectral and spatial features used in hyperspectral image classification.
+
+## Features
+
+- 17 feature extractors (spectral indices, dimensionality reduction, texture, morphological, wavelet, moment-based)
+- Automatic dependency resolution between extractors via DAG
+- Multiple execution backends: sequential, Dask threads/processes, multiprocessing with shared memory
+- HDF5 I/O for HSI loading and feature saving
+- YAML/JSON configuration for reproducible pipelines
+- Python 3.11–3.14 support
+
+## Installation
+
+```bash
+pip install hyppo-hsi
+```
+
+## Code Repository & Issues
+
+<https://github.com/quatrope/hyppo>
+
+## License
+
+HYPPO is under the [BSD 3-Clause License](https://raw.githubusercontent.com/quatrope/hyppo/master/LICENSE).
+
+Copyright (c) 2026, QuatroPe.

hyppo_hsi-0.1.0/hyppo/__init__.py

@@ -0,0 +1,16 @@
+"""HYPPO: Hyperspectral Processing for feature extraction."""
+
+import importlib.metadata
+
+import hyppo.core as core
+import hyppo.extractor as extractor
+import hyppo.io as io
+import hyppo.runner as runner
+
+NAME = "hyppo-hsi"
+
+__version__ = importlib.metadata.version(NAME)
+
+__all__ = ["core", "runner", "io", "extractor", "__version__"]
+
+del importlib

hyppo_hsi-0.1.0/hyppo/core/__init__.py

@@ -0,0 +1,14 @@
+"""Core module for hyperspectral feature extraction."""
+
+from ._feature_space.dependency_graph import FeatureDependencyGraph
+from ._feature_space.feature import Feature, FeatureCollection
+from ._feature_space.feature_space import FeatureSpace
+from ._hsi import HSI
+
+__all__ = [
+    "FeatureSpace",
+    "HSI",
+    "Feature",
+    "FeatureCollection",
+    "FeatureDependencyGraph",
+]

hyppo_hsi-0.1.0/hyppo/core/_feature_space/__init__.py

@@ -0,0 +1 @@
+"""Feature space subpackage."""

hyppo_hsi-0.1.0/hyppo/core/_feature_space/dependency_graph.py

@@ -0,0 +1,178 @@
+from typing import TYPE_CHECKING
+
+import networkx as nx
+
+if TYPE_CHECKING:
+    from hyppo.extractor.base import Extractor
+
+
+class FeatureDependencyGraph:
+    """Manages feature extraction dependencies as a directed acyclic graph."""
+
+    def __init__(self):
+        """Initialize dependency graph with empty graph and mappings."""
+        self.graph = nx.DiGraph()
+        self.extractors = {}
+        self.input_mappings = {}
+
+    def add_extractor(
+        self,
+        name: str,
+        extractor: "Extractor",
+        input_mapping: dict | None = None,
+    ):
+        """
+        Add extractor with input mapping to dependency graph.
+
+        Parameters
+        ----------
+        name : Unique name for this extractor instance
+        extractor : The extractor instance
+        input_mapping : dict mapping {input_name: source_extractor_name}
+        """
+        if input_mapping is None:
+            input_mapping = {}
+
+        # Add node to graph
+        self.graph.add_node(name, extractor=extractor)
+        self.extractors[name] = extractor
+        self.input_mappings[name] = input_mapping
+
+        # Add edges for dependencies
+        for input_name, source_name in input_mapping.items():
+            # Add edge from source to this extractor
+            self.graph.add_edge(source_name, name, input_name=input_name)
+
+    def validate(self) -> None:
+        """
+        Validate the dependency graph for cycles and type compatibility.
+
+        Raises
+        ------
+        ValueError : If circular dependencies are detected
+        TypeError : If input type mismatches are found
+        ValueError : If required inputs are missing
+        """
+        # Check for cycles using NetworkX
+        if not nx.is_directed_acyclic_graph(self.graph):
+            cycles = list(nx.simple_cycles(self.graph))
+            raise ValueError(f"Circular dependencies detected: {cycles}")
+
+        # Validate types and requirements
+        self._validate_types_and_requirements()
+
+    def _check_required_input(
+        self, node_name, input_name, dep_spec, input_mapping
+    ):
+        """Check that a required input is present in the mapping."""
+        is_required = dep_spec.get("required", True)
+        if is_required and input_name not in input_mapping:
+            msg = (
+                f"Extractor '{node_name}' requires input "
+                f"'{input_name}' but it was not provided"
+            )
+            raise ValueError(msg)
+
+    def _validate_single_dependency(
+        self, node_name, input_name, dep_spec, input_mapping
+    ) -> None:
+        """Validate a single input dependency for an extractor."""
+        self._check_required_input(
+            node_name, input_name, dep_spec, input_mapping
+        )
+
+        if input_name not in input_mapping:
+            return
+
+        source_name = input_mapping[input_name]
+        if source_name not in self.extractors:
+            msg = (
+                f"Source extractor '{source_name}' not found "
+                f"for input '{input_name}' of '{node_name}'"
+            )
+            raise ValueError(msg)
+
+        source_extractor = self.extractors[source_name]
+        expected_type = dep_spec["extractor"]
+        if not isinstance(source_extractor, expected_type):
+            msg = (
+                f"Type mismatch for input '{input_name}' "
+                f"of '{node_name}': "
+                f"expected {expected_type.__name__}, "
+                f"got {type(source_extractor).__name__}"
+            )
+            raise TypeError(msg)
+
+    def _validate_types_and_requirements(self) -> None:
+        """Validate input types and requirements for all extractors."""
+        for node_name in self.graph.nodes():
+            extractor = self.extractors[node_name]
+            input_deps = extractor.get_input_dependencies()
+            input_mapping = self.input_mappings.get(node_name, {})
+
+            for input_name, dep_spec in input_deps.items():
+                self._validate_single_dependency(
+                    node_name, input_name, dep_spec, input_mapping
+                )
+
+    def get_execution_order(self) -> list[str]:
+        """
+        Get the execution order for the provided dependencies.
+
+        Returns
+        -------
+        list of extractor names in execution order
+        """
+        try:
+            return list(nx.topological_sort(self.graph))
+        except (nx.NetworkXError, nx.NetworkXUnfeasible) as e:
+            raise ValueError(f"Cannot determine execution order: {e}")
+
+    def get_execution_layers(self) -> list[list[str]]:
+        """
+        Get extractors organized in layers for parallel execution.
+
+        Each layer has dependencies on the previous layer.
+
+        Returns
+        -------
+        List of layers with extractors that can run in parallel
+        """
+        layers = []
+        remaining_nodes = set(self.graph.nodes())
+
+        while remaining_nodes:
+            # Find nodes with no incoming edges from remaining nodes
+            current_layer = []
+            for node in list(remaining_nodes):
+                # Check if all predecessors are already processed
+                predecessors = set(self.graph.predecessors(node))
+                if predecessors.isdisjoint(remaining_nodes):
+                    current_layer.append(node)
+
+            msg = (
+                f"Cannot compute execution layers. "
+                f"Remaining nodes: {remaining_nodes}"
+            )
+            assert current_layer, msg
+
+            layers.append(current_layer)
+            remaining_nodes.difference_update(current_layer)
+
+        return layers
+
+    def get_dependencies_for(self, extractor_name: str) -> set[str]:
+        """Get all transitive dependencies for an extractor."""
+        if extractor_name not in self.graph:
+            return set()
+        return set(nx.ancestors(self.graph, extractor_name))
+
+    def get_dependents_of(self, extractor_name: str) -> set[str]:
+        """Get all extractors that depend on this one."""
+        if extractor_name not in self.graph:
+            return set()
+        return set(nx.descendants(self.graph, extractor_name))
+
+    def get_input_mapping_for(self, extractor_name: str) -> dict[str, str]:
+        """Get the input mapping for a specific extractor."""
+        return self.input_mappings.get(extractor_name, {}).copy()

hyppo_hsi-0.1.0/hyppo/core/_feature_space/feature.py

@@ -0,0 +1,183 @@
+import pandas as pd
+
+from hyppo.utils.bunch import Bunch
+
+
+class Feature(Bunch):
+    """
+    Dictionary for feature extraction results.
+
+    Examples
+    --------
+    >>> result = Feature({'mean': [1, 2, 3], 'std': [0.1, 0.2, 0.3]})
+    >>> result.mean
+    [1, 2, 3]
+    >>> result['mean']
+    [1, 2, 3]
+    """
+
+    def __init__(self, data, extractor, inputs_used):
+        """Initialize Feature with data, extractor, and inputs used."""
+        mapping = {
+            "result": data.get("features", None),
+            "data": data,
+            "extractor": extractor,
+            "inputs_used": inputs_used,
+        }
+        super().__init__("Feature", mapping)
+
+    @staticmethod
+    def _get_features_shape(data):
+        """Extract shape from features entry if available."""
+        if not isinstance(data, dict) or "features" not in data:
+            return None
+
+        features = data["features"]
+        if hasattr(features, "shape"):
+            return features.shape
+        return None
+
+    def describe(self):
+        """
+        Get summary information about this feature result.
+
+        Returns
+        -------
+        Dictionary with dimensions and extra_data keys
+        """
+        data = self.get("data", {})
+        features_shape = self._get_features_shape(data)
+
+        extra_keys = []
+        if isinstance(data, dict):
+            extra_keys = [k for k in data.keys() if k != "features"]
+
+        return {
+            "dimensions": features_shape,
+            "extra_data": ", ".join(extra_keys) if extra_keys else "",
+        }
+
+
+class FeatureCollection(Bunch):
+    """
+    Collection of Feature objects.
+
+    This class manages results from multiple feature extractors.
+
+    Examples
+    --------
+    >>> results = FeatureCollection()
+    >>> results['mean'] = Feature({'data': [1, 2, 3]})
+    >>> results.mean.data
+    [1, 2, 3]
+    >>> results['mean']['data']
+    [1, 2, 3]
+    """
+
+    def __init__(self, data: dict[str, Feature]):
+        """Initialize FeatureCollection with dictionary of Feature objects."""
+        super().__init__("FeatureCollection", data)
+
+    @classmethod
+    def from_features(
+        cls, features: dict[str, Feature]
+    ) -> "FeatureCollection":
+        """
+        Create a FeatureCollection from a dictionary of features.
+
+        Parameters
+        ----------
+        features : Dictionary of features (extractor_name -> Feature)
+
+        Returns
+        -------
+        FeatureCollection
+        """
+        return cls(features)
+
+    def get_all_features(self):
+        """Get all extracted feature data (without metadata)."""
+        features = {}
+        for extractor_name, result in self.items():
+            if hasattr(result, "data") and isinstance(result.data, dict):
+                features.update(result.data)
+            else:
+                features[extractor_name] = (
+                    result.data if hasattr(result, "data") else result
+                )
+        return features
+
+    def get_metadata(self):
+        """Get metadata about extractors and their usage."""
+        metadata: dict[str, dict] = {}
+        for extractor_name, result in self.items():
+            if isinstance(result, Feature):
+                metadata[extractor_name] = {
+                    "extractor_type": (
+                        type(result.extractor).__name__
+                        if result.extractor
+                        else None
+                    ),
+                    "inputs_used": result.inputs_used,
+                    "feature_keys": (
+                        list(result.data.keys())
+                        if isinstance(result.data, dict)
+                        else []
+                    ),
+                }
+        return metadata
+
+    def get_extractor_names(self) -> list:
+        """Get list of all extractor names."""
+        return list(self.keys())
+
+    def to_dict(self):
+        """Convert to a regular nested dictionary."""
+        return {
+            name: (
+                result.to_dict()
+                if isinstance(result, Feature)
+                else dict(result)
+            )
+            for name, result in self.items()
+        }
+
+    def describe(self) -> pd.DataFrame:
+        """
+        Get summary information for all feature results.
+
+        Returns
+        -------
+        DataFrame with columns:
+            - feature_name: Name of each feature
+            - dimensions: Shape of the 'features' array
+            - extra_data: Comma-separated list of extra data keys
+        """
+        rows = []
+        for feature_name, result in self.items():
+            info = result.describe()
+            info["feature_name"] = feature_name
+            rows.append(info)
+
+        columns = ["feature_name", "dimensions", "extra_data"]
+        return pd.DataFrame(rows, columns=columns)
+
+    def save(self, path) -> None:
+        """
+        Save this FeatureCollection to HDF5 file.
+
+        Parameters
+        ----------
+        path : Output file path (must have .h5 extension)
+
+        Examples
+        --------
+        >>> results = fs.extract(hsi)
+        >>> results.save("output.h5")
+        """
+        from hyppo import io
+
+        io.save_feature_collection(self, path)
+
+
+__all__ = ["Feature", "FeatureCollection"]