onboard-methane-detection 0.1.0__tar.gz

onboard_methane_detection-0.1.0/LICENSE.md

@@ -0,0 +1,57 @@
+The majority of code is licensed under:
+MIT License
+
+Copyright (c) 2025 Jonáš Herec, Zaitra s.r.o.
+
+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.
+
+However, the onboard_methane_detection/mag1c_sas_base.py file and onboard_methane_detection/onground/utils.py contains Mag1c edited code and use files from Mag1c, which is licensed under the BSD 3-Clause License.
+The original code can be found at https://github.com/markusfoote/mag1c
+It is licensed under this license and copyright:
+BSD 3-Clause License
+
+Copyright (c) 2019, 
+	Scientific Computing and Imaging Institute and 
+	Utah Remote Sensing Applications Lab
+All rights reserved.
+
+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.

onboard_methane_detection-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+exclude showcase.ipynb

onboard_methane_detection-0.1.0/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: onboard-methane-detection
+Version: 0.1.0
+Summary: Onboard methane detection
+Author-email: Jonáš Herec <jonas.herec@zaitra.io>
+License: The majority of code is licensed under:
+        MIT License
+        
+        Copyright (c) 2025 Jonáš Herec, Zaitra s.r.o.
+        
+        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.
+        
+        However, the onboard_methane_detection/mag1c_sas_base.py file and onboard_methane_detection/onground/utils.py contains Mag1c edited code and use files from Mag1c, which is licensed under the BSD 3-Clause License.
+        The original code can be found at https://github.com/markusfoote/mag1c
+        It is licensed under this license and copyright:
+        BSD 3-Clause License
+        
+        Copyright (c) 2019, 
+        	Scientific Computing and Imaging Institute and 
+        	Utah Remote Sensing Applications Lab
+        All rights reserved.
+        
+        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: Homepage, https://github.com/zaitra/onboard-methane-detection
+Project-URL: Repository, https://github.com/zaitra/onboard-methane-detection
+Keywords: methane,detection,hyperspectral,remote-sensing,satellite
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: onnxruntime
+Dynamic: license-file
+
+# Onboard Methane Detection
+
+This library provides an end-to-end pipeline for processing hyperspectral imagery to detect methane emissions. It includes tools for band selection, methane spectrum generation, preprocessing via Mag1c SAS, and model inference.
+
+## Installation
+
+```bash
+pip install onboard-methane-detection
+```
+
+### Dependencies and Performance
+
+Onboard Methane Detection is lightweight and depends only on NumPy for processing. ONNX Runtime is required only if you want inference. You can omit ONNX Runtime by using the lightweight build (see `Lightweight Onboard Package Build` below).
+
+Important: NumPy can be very slow without an acceleration library, so make sure one is installed on your device. We tested with [OpenBLAS](https://github.com/OpenMathLib/OpenBLAS); the build was about 3.9 MB on ARM Cortex-A53 when compiled without LAPACK. After installing OpenBLAS, reinstall NumPy via `pip` so it can be detected and used.
+
+## End-to-End Example
+
+The following example demonstrates a complete workflow, divided into distinct stages: on-ground preparation, and onboard session execution. The same example is available in
+<a href="https://colab.research.google.com/github/zaitra/onboard-methane-detection/blob/main/showcase.ipynb">showcase.ipynb <img src="https://colab.research.google.com/assets/colab-badge.svg" height=16px></a>.
+
+### On-Ground
+
+```python
+# Core imports for on-ground processing
+import numpy as np
+from onboard_methane_detection import (
+    select_the_bands_by_transmittance, 
+    generate_methane_spectrum, 
+    select_rgb_bands
+)
+
+# 1. Define or load sensor specifications
+# wavelengths = [...]  # List of all available sensor wavelengths
+# fwhms = [...]        # List of corresponding FWHMs
+
+# 2. Select RGB bands
+rgb_wavelengths, rgb_indices = select_rgb_bands(wavelengths)
+
+# 3. Select bands specifically for Methane detection
+# First, generate the baseline CH4 spectrum across all sensor bands
+ch4_spectrum_full = generate_methane_spectrum(wavelengths, fwhms)
+
+# Then, select the most informative bands based on transmittance
+selected_wvs_ch4, selected_ch4_spectrum = select_the_bands_by_transmittance(
+    wavelengths, ch4_spectrum_full, N=50, strategy="highest-variance"
+)
+selected_indices_ch4 = [wavelengths.tolist().index(w) for w in selected_wvs_ch4]
+
+# 4. Export artifacts for the onboard inference session
+np.save('rgb_indices.npy', np.array(rgb_indices))
+np.save('selected_indices_ch4.npy', np.array(selected_indices_ch4))
+np.save('selected_ch4_spectrum.npy', selected_ch4_spectrum)
+```
+
+### Onboard
+
+```python
+import numpy as np
+
+# Core imports for onboard execution
+from onboard_methane_detection import (
+    mag1c_sas,
+    initialize_model,
+    normalize_image,
+    model_inference
+)
+
+# 1. Load exported artifacts (indices and spectrum) from On-Ground preparation
+rgb_indices = np.load('rgb_indices.npy')
+selected_indices_ch4 = np.load('selected_indices_ch4.npy')
+selected_ch4_spectrum = np.load('selected_ch4_spectrum.npy')
+
+# 2. Session Initialization
+# Initialize the inference model before the processing loop begins
+session, input_name = initialize_model(dynamic_output_size=True)
+
+# 3. Processing Images (Onboard Loop)
+# acquired_images: list of images in shape (C, H, W)
+
+for image in acquired_images:
+    # Extract RGB channels using previously found indices
+    rgb_image = image[rgb_indices, :, :]
+    
+    # Extract the CH4 detection bands from the image
+    methane_bands_image = image[selected_indices_ch4, :, :]
+    
+    # Apply Mag1c SAS preprocessing.
+    # Optional tiling args (`tiling`, `tile_size`) can be used if the image is too large.
+    mag1c_output = mag1c_sas(methane_bands_image, selected_ch4_spectrum, tiling=False)
+    
+    # Concatenate Mag1c SAS output with local RGB context.
+    # Correct channel order is R, G, B, Mag1c-SAS.
+    model_input = np.concatenate([rgb_image, mag1c_output], axis=0)
+    
+    # Normalize input: sensor_or_factors can be "emit", "aviris_ng", 
+    # or a custom array of 4 division factors for a different sensor.
+    model_input = normalize_image(model_input, sensor_or_factors='emit') 
+    
+    # Run model inference.
+    # Tiling arguments can also be provided here if the image is too large.
+    predictions = model_inference(session, input_name, model_input, use_tiling=False, logits_to_probs=True)
+    
+    print("Processed image and generated predictions.")
+```
+
+## Lightweight Onboard Package Build
+
+For deployment on resource-constrained satellite hardware, you may want to build a minimal version of this library containing only the necessary modules. A deployment script `build_package_for_deployment.py` is provided for this purpose. The lightweight build depends only on NumPy, and adds ONNX Runtime only if you include `inference`.
+
+### Usage
+
+Run the script to generate a lightweight installable package:
+
+```bash
+# Base-only build (no optional subpackages):
+# Includes only `compute_base_mag1c_SAS` (Mag1c-SAS core math).
+python build_package_for_deployment.py --output satellite_pkg
+
+# Add optional subpackages as needed:
+python build_package_for_deployment.py --parts processing inference --output satellite_pkg
+```
+
+### What Gets Included
+
+The build script always includes the base Mag1c-SAS implementation and then optionally adds subpackages. You can omit `--parts` entirely to keep the package as small as possible.
+
+- Base (always included):
+  - Exports `compute_base_mag1c_SAS(...)` which expects batched, flattened radiance data shaped like `(B, N, C)`.
+  - Import path: `from onboard_methane_detection import compute_base_mag1c_SAS`
+  - This is the minimal dependency footprint and is suitable if you already handle reshaping/masking/sampling in your own pipeline.
+- `processing` (optional):
+  - Adds `mag1c_sas(image, methane_spectrum, ...)`, a more convenient Mag1c-SAS wrapper for CHW hyperspectral cubes.
+  - Automatically handles masking invalid pixels, reshaping CHW -> `(B, N, C)`, sampling pixels for covariance estimation, and reshaping the output back.
+- `inference` (optional):
+  - Adds LinkNet ONNX inference utilities: `initialize_model(...)`, `normalize_image(...)`, and `model_inference(...)`.
+  - `model_inference(...)` can use tiling, but tiling utilities live in `processing`, so include both `inference` and `processing` if you want tiled inference.
+  - Use this when you want to run the segmentation model onboard.
+- `onground` (optional):
+  - Adds on-ground preparation helpers: `generate_methane_spectrum(...)`, `select_the_bands_by_transmittance(...)`, and `select_rgb_bands(...)`.
+  - Use this to generate the methane spectrum template and select bands/indices to export for the onboard session.
+
+### Arguments
+
+- `--parts`: A space-separated list of optional subpackages to include in the build. Available options are `inference`, `processing`, and `onground`. If you want the smallest possible package, omit `--parts` entirely (base-only Mag1c-SAS).
+- `--output`: The destination directory where the lightweight package will be generated (default: `satellite_package`).
+- `--source`: The directory of the source package (default: `onboard_methane_detection`).
+
+Once the package is generated, you can install it on your target hardware using:
+
+```bash
+pip install ./satellite_pkg
+```
+
+# Acknowledgments
+A huge thank you to the creators of [Mag1c](https://github.com/markusfoote/mag1c). This project uses core files and edited code from their original repository, and it wouldn't have been possible without their foundational work!

onboard_methane_detection-0.1.0/README.md

@@ -0,0 +1,156 @@
+# Onboard Methane Detection
+
+This library provides an end-to-end pipeline for processing hyperspectral imagery to detect methane emissions. It includes tools for band selection, methane spectrum generation, preprocessing via Mag1c SAS, and model inference.
+
+## Installation
+
+```bash
+pip install onboard-methane-detection
+```
+
+### Dependencies and Performance
+
+Onboard Methane Detection is lightweight and depends only on NumPy for processing. ONNX Runtime is required only if you want inference. You can omit ONNX Runtime by using the lightweight build (see `Lightweight Onboard Package Build` below).
+
+Important: NumPy can be very slow without an acceleration library, so make sure one is installed on your device. We tested with [OpenBLAS](https://github.com/OpenMathLib/OpenBLAS); the build was about 3.9 MB on ARM Cortex-A53 when compiled without LAPACK. After installing OpenBLAS, reinstall NumPy via `pip` so it can be detected and used.
+
+## End-to-End Example
+
+The following example demonstrates a complete workflow, divided into distinct stages: on-ground preparation, and onboard session execution. The same example is available in
+<a href="https://colab.research.google.com/github/zaitra/onboard-methane-detection/blob/main/showcase.ipynb">showcase.ipynb <img src="https://colab.research.google.com/assets/colab-badge.svg" height=16px></a>.
+
+### On-Ground
+
+```python
+# Core imports for on-ground processing
+import numpy as np
+from onboard_methane_detection import (
+    select_the_bands_by_transmittance, 
+    generate_methane_spectrum, 
+    select_rgb_bands
+)
+
+# 1. Define or load sensor specifications
+# wavelengths = [...]  # List of all available sensor wavelengths
+# fwhms = [...]        # List of corresponding FWHMs
+
+# 2. Select RGB bands
+rgb_wavelengths, rgb_indices = select_rgb_bands(wavelengths)
+
+# 3. Select bands specifically for Methane detection
+# First, generate the baseline CH4 spectrum across all sensor bands
+ch4_spectrum_full = generate_methane_spectrum(wavelengths, fwhms)
+
+# Then, select the most informative bands based on transmittance
+selected_wvs_ch4, selected_ch4_spectrum = select_the_bands_by_transmittance(
+    wavelengths, ch4_spectrum_full, N=50, strategy="highest-variance"
+)
+selected_indices_ch4 = [wavelengths.tolist().index(w) for w in selected_wvs_ch4]
+
+# 4. Export artifacts for the onboard inference session
+np.save('rgb_indices.npy', np.array(rgb_indices))
+np.save('selected_indices_ch4.npy', np.array(selected_indices_ch4))
+np.save('selected_ch4_spectrum.npy', selected_ch4_spectrum)
+```
+
+### Onboard
+
+```python
+import numpy as np
+
+# Core imports for onboard execution
+from onboard_methane_detection import (
+    mag1c_sas,
+    initialize_model,
+    normalize_image,
+    model_inference
+)
+
+# 1. Load exported artifacts (indices and spectrum) from On-Ground preparation
+rgb_indices = np.load('rgb_indices.npy')
+selected_indices_ch4 = np.load('selected_indices_ch4.npy')
+selected_ch4_spectrum = np.load('selected_ch4_spectrum.npy')
+
+# 2. Session Initialization
+# Initialize the inference model before the processing loop begins
+session, input_name = initialize_model(dynamic_output_size=True)
+
+# 3. Processing Images (Onboard Loop)
+# acquired_images: list of images in shape (C, H, W)
+
+for image in acquired_images:
+    # Extract RGB channels using previously found indices
+    rgb_image = image[rgb_indices, :, :]
+    
+    # Extract the CH4 detection bands from the image
+    methane_bands_image = image[selected_indices_ch4, :, :]
+    
+    # Apply Mag1c SAS preprocessing.
+    # Optional tiling args (`tiling`, `tile_size`) can be used if the image is too large.
+    mag1c_output = mag1c_sas(methane_bands_image, selected_ch4_spectrum, tiling=False)
+    
+    # Concatenate Mag1c SAS output with local RGB context.
+    # Correct channel order is R, G, B, Mag1c-SAS.
+    model_input = np.concatenate([rgb_image, mag1c_output], axis=0)
+    
+    # Normalize input: sensor_or_factors can be "emit", "aviris_ng", 
+    # or a custom array of 4 division factors for a different sensor.
+    model_input = normalize_image(model_input, sensor_or_factors='emit') 
+    
+    # Run model inference.
+    # Tiling arguments can also be provided here if the image is too large.
+    predictions = model_inference(session, input_name, model_input, use_tiling=False, logits_to_probs=True)
+    
+    print("Processed image and generated predictions.")
+```
+
+## Lightweight Onboard Package Build
+
+For deployment on resource-constrained satellite hardware, you may want to build a minimal version of this library containing only the necessary modules. A deployment script `build_package_for_deployment.py` is provided for this purpose. The lightweight build depends only on NumPy, and adds ONNX Runtime only if you include `inference`.
+
+### Usage
+
+Run the script to generate a lightweight installable package:
+
+```bash
+# Base-only build (no optional subpackages):
+# Includes only `compute_base_mag1c_SAS` (Mag1c-SAS core math).
+python build_package_for_deployment.py --output satellite_pkg
+
+# Add optional subpackages as needed:
+python build_package_for_deployment.py --parts processing inference --output satellite_pkg
+```
+
+### What Gets Included
+
+The build script always includes the base Mag1c-SAS implementation and then optionally adds subpackages. You can omit `--parts` entirely to keep the package as small as possible.
+
+- Base (always included):
+  - Exports `compute_base_mag1c_SAS(...)` which expects batched, flattened radiance data shaped like `(B, N, C)`.
+  - Import path: `from onboard_methane_detection import compute_base_mag1c_SAS`
+  - This is the minimal dependency footprint and is suitable if you already handle reshaping/masking/sampling in your own pipeline.
+- `processing` (optional):
+  - Adds `mag1c_sas(image, methane_spectrum, ...)`, a more convenient Mag1c-SAS wrapper for CHW hyperspectral cubes.
+  - Automatically handles masking invalid pixels, reshaping CHW -> `(B, N, C)`, sampling pixels for covariance estimation, and reshaping the output back.
+- `inference` (optional):
+  - Adds LinkNet ONNX inference utilities: `initialize_model(...)`, `normalize_image(...)`, and `model_inference(...)`.
+  - `model_inference(...)` can use tiling, but tiling utilities live in `processing`, so include both `inference` and `processing` if you want tiled inference.
+  - Use this when you want to run the segmentation model onboard.
+- `onground` (optional):
+  - Adds on-ground preparation helpers: `generate_methane_spectrum(...)`, `select_the_bands_by_transmittance(...)`, and `select_rgb_bands(...)`.
+  - Use this to generate the methane spectrum template and select bands/indices to export for the onboard session.
+
+### Arguments
+
+- `--parts`: A space-separated list of optional subpackages to include in the build. Available options are `inference`, `processing`, and `onground`. If you want the smallest possible package, omit `--parts` entirely (base-only Mag1c-SAS).
+- `--output`: The destination directory where the lightweight package will be generated (default: `satellite_package`).
+- `--source`: The directory of the source package (default: `onboard_methane_detection`).
+
+Once the package is generated, you can install it on your target hardware using:
+
+```bash
+pip install ./satellite_pkg
+```
+
+# Acknowledgments
+A huge thank you to the creators of [Mag1c](https://github.com/markusfoote/mag1c). This project uses core files and edited code from their original repository, and it wouldn't have been possible without their foundational work!

onboard_methane_detection-0.1.0/onboard_methane_detection/__init__.py

@@ -0,0 +1,17 @@
+from .mag1c_sas_base import compute_base_mag1c_SAS
+# Optional imports.
+try:
+    from .processing.pipeline import mag1c_sas
+except ImportError:
+    pass
+
+try:
+    from .inference.utils import initialize_model, normalize_image
+    from .inference.pipeline import model_inference
+except ImportError:
+    pass
+
+try:
+    from .onground.utils import select_the_bands_by_transmittance, generate_methane_spectrum, select_rgb_bands
+except ImportError:
+    pass

onboard_methane_detection-0.1.0/onboard_methane_detection/inference/pipeline.py

@@ -0,0 +1,67 @@
+import numpy as np
+from .utils import run_inference_full, pad_to_32, reverse_32_padding
+from ..processing.utils import tile_image, stitch_tiles
+
+def model_inference(session, input_name, image, use_tiling=True, tile_size=512, logits_to_probs=False):
+    """
+    Pipeline for performing model inference on a CHW image with optional tiling.
+    
+    Args:
+        session: Initialized ONNX inference session.
+        input_name: Input node name for the ONNX session.
+        image: Input image of shape (C, H, W) or (B, C, H, W).
+        use_tiling: If True, process the image in tiles. If False, process the whole image at once.
+        tile_size: Size of tiles (default 512).
+        logits_to_probs: If True, apply sigmoid to convert logits to probabilities.
+    
+    Returns:
+        Model inference result of shape (1, H, W).
+    """
+    is_chw = image.ndim == 3
+    if is_chw:
+        image = np.expand_dims(image, axis=0)
+
+    if not use_tiling:
+        padded_image, pad_info = pad_to_32(image)
+        result = _process_tile_inference(session, input_name, padded_image, logits_to_probs)
+        result_unpadded = reverse_32_padding(result, pad_info)
+        return result_unpadded
+
+    # Tile the image
+    tiles, tiling_info = tile_image(image, tile_size)
+    
+    # Process each tile
+    result_tiles = []
+    for tile in tiles:
+        tile_result = _process_tile_inference(session, input_name, tile, logits_to_probs)
+        result_tiles.append(tile_result)
+    
+    # Stitch results back together
+    # Update tiling_info for single-channel output
+    orig_bchw = tiling_info['original_shape']
+    orig_h, orig_w = orig_bchw[-2:]
+    tiling_info['original_shape'] = (1, orig_h, orig_w)
+    
+    result = stitch_tiles(result_tiles, tiling_info)
+    return result
+
+
+def _process_tile_inference(session, input_name, image_batched, logits_to_probs):
+    """
+    Process a single tile/image through model inference.
+    
+    Args:
+        session: Initialized ONNX inference session.
+        input_name: Input node name for the ONNX session.
+        image_batched: Input image of shape (B, C, H, W).
+        logits_to_probs: If True, apply sigmoid to convert logits to probabilities.
+    
+    Returns:
+        Model inference result of shape (1, H, W).
+    """
+    image_batched = image_batched.astype(np.float32)
+    
+    # Run inference
+    result = run_inference_full(session, input_name, image_batched, logits_to_probs=logits_to_probs)
+    
+    return result

onboard_methane_detection-0.1.0/onboard_methane_detection/inference/utils.py

@@ -0,0 +1,129 @@
+import os
+import numpy as np
+import onnxruntime as ort
+
+
+def initialize_model(model_path: str = None, dynamic_output_size: bool = False) -> tuple[ort.InferenceSession, str]:
+    """
+    Initialize and return the ONNX inference session and input name.
+    """
+    if model_path is None:
+        model_filename = "linknet_exported_dynamic.onnx" if dynamic_output_size else "linknet_exported.onnx"
+        print(f"Using model: {model_filename}")
+        model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), model_filename)
+    session = ort.InferenceSession(model_path)
+    input_name = session.get_inputs()[0].name
+    return session, input_name
+
+
+def run_sole_inference(session: ort.InferenceSession, input_name: str, image: np.ndarray) -> np.ndarray:
+    """
+    Run the inference session with the given image.
+    """
+    outputs = session.run(None, {input_name: image})
+    return outputs[0]
+
+
+def postprocess_result(result: np.ndarray, logits_to_probs: bool = False) -> np.ndarray:
+    """
+    Postprocess the inference results, converting logits to probabilities if requested.
+    """
+    if logits_to_probs:
+        result = 1 / (1 + np.exp(-result))  # Sigmoid function
+    return result[0]  # Remove batch dimension if present
+
+
+def normalize_image(image: np.ndarray, sensor_or_factors: str | list | np.ndarray = 'emit') -> np.ndarray:
+    """
+    Normalize a CHW image and return BCHW.
+
+    Args:
+        image: Numpy array of shape (C, H, W). If BCHW is provided, it is used as-is.
+        sensor_or_factors: 'emit', 'aviris_ng', or a list/array of length 4 containing custom division factors.
+    """
+    if isinstance(sensor_or_factors, str):
+        if sensor_or_factors.lower() == 'emit':
+            factors = np.array([98.91703491210939, 112.33824462890625, 119.84940185546876, 2436.562744140625], dtype=image.dtype)
+        elif sensor_or_factors.lower() == 'aviris_ng':
+            factors = np.array([247.29258728, 280.84561157, 299.62350464, 1218.28137207], dtype=image.dtype)
+        else:
+            raise ValueError("String must be 'emit' or 'aviris_ng'")
+    elif isinstance(sensor_or_factors, (list, np.ndarray)) and len(sensor_or_factors) == 4:
+        factors = np.array(sensor_or_factors, dtype=image.dtype)
+    else:
+        raise ValueError("Must be 'emit', 'aviris_ng', or a custom list/array of length 4")
+        
+    if image.ndim == 3:
+        image_bchw = image[None, :, :, :]
+    elif image.ndim == 4:
+        image_bchw = image
+    else:
+        raise ValueError("Image must be CHW or BCHW")
+
+    factors = factors[None, :, None, None]
+    normalized = image_bchw / factors
+    return np.clip(normalized, 0, 2)
+
+
+def run_inference_full(session: ort.InferenceSession, input_name: str, image: np.ndarray, logits_to_probs: bool = False) -> np.ndarray:
+    """
+    Load an ONNX model and perform inference on a numpy image.
+    
+    Args:
+        session: Initialized ONNX inference session.
+        input_name: Input node name for the ONNX session.
+        image: Input numpy image array of shape (B, C, H, W) where:
+               - B is batch size
+               - C is number of channels (4)
+               - H is image height
+               - W is image width
+        logits_to_probs: If True, apply sigmoid to convert logits to probabilities 
+                         (for binary segmentation).
+    
+    Returns:
+        Inference output as numpy array of shape (B, 1, H, W).
+        Contains probabilities if logits_to_probs=True, else raw logits.
+    """
+    result = run_sole_inference(session, input_name, image)
+    return postprocess_result(result, logits_to_probs)
+
+
+def pad_to_32(image: np.ndarray) -> tuple[np.ndarray, dict]:
+    """
+    Pad a BCHW image so its spatial dimensions (H, W) are divisible by 32.
+    Returns the padded image and a dictionary with padding information.
+    """
+    b, c, orig_h, orig_w = image.shape
+    pad_h = (32 - (orig_h % 32)) % 32
+    pad_w = (32 - (orig_w % 32)) % 32
+    
+    pad_top = pad_h // 2
+    pad_bottom = pad_h - pad_top
+    pad_left = pad_w // 2
+    pad_right = pad_w - pad_left
+    
+    padded_image = np.pad(image, ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), mode='constant')
+    
+    pad_info = {
+        'orig_h': orig_h,
+        'orig_w': orig_w,
+        'pad_top': pad_top,
+        'pad_left': pad_left,
+        'pad_h': pad_h,
+        'pad_w': pad_w
+    }
+    return padded_image, pad_info
+
+
+def reverse_32_padding(result_image: np.ndarray, pad_info: dict) -> np.ndarray:
+    """
+    Crop the padded inference result back to its original shape.
+    Assumes result_image is of shape (1, H, W).
+    """
+    if pad_info['pad_h'] > 0 or pad_info['pad_w'] > 0:
+        pad_top = pad_info['pad_top']
+        pad_left = pad_info['pad_left']
+        orig_h = pad_info['orig_h']
+        orig_w = pad_info['orig_w']
+        return result_image[:, pad_top:pad_top+orig_h, pad_left:pad_left+orig_w]
+    return result_image