hypmix 0.1.0__tar.gz

hypmix-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zach
+
+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.

hypmix-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: hypmix
+Version: 0.1.0
+Summary: A Hyperspectral Linear Mixture anlysis code for python.
+License-File: LICENSE
+Author: Z.M. Vig
+Author-email: zvig@umd.edu
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: h5py (>=3.14.0,<4.0.0)
+Requires-Dist: numpy (>=2.2,<3.0.0)
+Requires-Dist: pyqt6 (>=6.10.0,<7.0.0)
+Requires-Dist: rasterio (>=1.4.3,<2.0.0)
+Requires-Dist: superqt (>=0.7.6,<0.8.0)
+Requires-Dist: typing-extensions (>=4.14.1,<5.0.0)
+Description-Content-Type: text/markdown
+
+# hypmix
+Hyperspectral Unmixing Library for Python
+
+## Installation
+
+```bash
+pip install hypmix
+```
+
+## Usage
+```python
+import hypmix
+
+em_list = []
+for data, wvl in zip(spectrum_list, wvl_list):
+    spec=hypmix.Spectrum(data, wvl)
+    em_list.append(hypmix.EndMember("endmember1", spec))
+
+model = hypmix.MixtureModel(em_list, data_cube)
+model.add_virtual_shade()
+
+res = model.run("save/path/results.hdf5", "model_name")
+hypmix.save_model_result(res)
+```
+

hypmix-0.1.0/README.md

@@ -0,0 +1,24 @@
+# hypmix
+Hyperspectral Unmixing Library for Python
+
+## Installation
+
+```bash
+pip install hypmix
+```
+
+## Usage
+```python
+import hypmix
+
+em_list = []
+for data, wvl in zip(spectrum_list, wvl_list):
+    spec=hypmix.Spectrum(data, wvl)
+    em_list.append(hypmix.EndMember("endmember1", spec))
+
+model = hypmix.MixtureModel(em_list, data_cube)
+model.add_virtual_shade()
+
+res = model.run("save/path/results.hdf5", "model_name")
+hypmix.save_model_result(res)
+```

hypmix-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "hypmix"
+version = "0.1.0"
+description = "A Hyperspectral Linear Mixture anlysis code for python."
+authors = [
+    {name = "Z.M. Vig",email = "zvig@umd.edu"}
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "numpy (>=2.2,<3.0.0)",
+    "h5py (>=3.14.0,<4.0.0)",
+    "typing-extensions (>=4.14.1,<5.0.0)",
+    "pyqt6 (>=6.10.0,<7.0.0)",
+    "superqt (>=0.7.6,<0.8.0)",
+    "rasterio (>=1.4.3,<2.0.0)"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

hypmix-0.1.0/src/hypmix/__init__.py

@@ -0,0 +1,15 @@
+from .endmember import InSceneEndMember, ExternalEndMember, EndMember
+from .io import ModelResult, save_model_result, load_model_result
+from .run_model import MixtureModel
+from .typing import Spectrum
+
+__all__ = [
+    "InSceneEndMember",
+    "ExternalEndMember",
+    "EndMember",
+    "ModelResult",
+    "save_model_result",
+    "load_model_result",
+    "MixtureModel",
+    "Spectrum",
+]

hypmix-0.1.0/src/hypmix/endmember.py

@@ -0,0 +1,52 @@
+# Standard Libraries
+from dataclasses import dataclass
+from typing import Tuple
+
+# Dependencies
+import numpy as np
+
+# Relative Imports
+from .typing import Spectrum, PathLike
+
+
+@dataclass
+class EndMember:
+    name: str
+    spectrum: Spectrum
+
+
+@dataclass
+class InSceneEndMember(EndMember):
+    coord: Tuple[int, int]
+
+
+@dataclass
+class ExternalEndMember(EndMember):
+    file_path: PathLike
+
+
+class EndMemberGroup:
+    def __init__(self, endmember_list: list[EndMember]):
+        self.endmember_list = endmember_list
+        self.endmember_array = np.empty(
+            (len(endmember_list[0].spectrum.data), len(endmember_list)),
+            dtype=np.float32,
+        )
+        self.endmember_name_list: list[str] = []
+
+        for n, i in enumerate(endmember_list):
+            self.endmember_array[:, n] = i.spectrum.data
+            self.endmember_name_list.append(i.name)
+
+    def __len__(self):
+        return len(self.endmember_name_list)
+
+
+def read_endmember_set(
+    names: list[str], arr: np.ndarray, wvl: np.ndarray
+) -> list[EndMember]:
+    em_list: list[EndMember] = []
+    for n, name in enumerate(names):
+        spec = Spectrum(arr[n, :], wvl)
+        em_list.append(EndMember(name, spec))
+    return em_list

hypmix-0.1.0/src/hypmix/io.py

@@ -0,0 +1,164 @@
+# Standard Libraries
+from dataclasses import dataclass
+from pathlib import Path
+from enum import Enum
+from typing import Optional
+
+# Dependencies
+import rasterio as rio  # type: ignore
+from rasterio.crs import CRS  # type: ignore
+import numpy.typing as npt
+import h5py as h5  # type: ignore
+
+# Relative Imports
+from .typing import PathLike, Spectrum
+from .endmember import EndMemberGroup, EndMember
+from .model_math import UnMixedCube
+
+
+type GeotransformType = tuple[float, float, float, float, float, float]
+
+
+class UnsupportedFileExtensionError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+@dataclass
+class ModelResult:
+    savefile: PathLike
+    modelID: str
+    unmixed_image: UnMixedCube
+    endmembers: EndMemberGroup
+    rsquared: npt.NDArray
+
+
+class SaveMode(Enum):
+    HDF5 = ".hdf5"
+    SMA = ".sma"
+    CSV = ".csv"
+
+
+def save_model_result(res: ModelResult):
+    file_ext = Path(res.savefile).suffix
+
+    try:
+        mode = SaveMode(file_ext)
+    except ValueError:
+        raise UnsupportedFileExtensionError(
+            f"{file_ext} is not a supported" "file type."
+        )
+    match mode:
+        case SaveMode.HDF5:
+            if Path(res.savefile).is_file():
+                open_flag = "r+"
+            else:
+                open_flag = "w"
+
+            with h5.File(res.savefile, open_flag) as f:
+                try:
+                    g = f.create_group(res.modelID)
+                except ValueError:
+                    del f[res.modelID]
+                    g = f.create_group(res.modelID)
+
+                g.attrs["wavelengths"] = res.endmembers.endmember_list[
+                    0
+                ].spectrum.wvl
+                gg = g.create_group("endmembers")
+                for n, name in enumerate(res.endmembers.endmember_name_list):
+                    gg.create_dataset(
+                        name,
+                        data=res.endmembers.endmember_list[n].spectrum.data,
+                    )
+                    gg[name].attrs["index"] = n
+                g.create_dataset("fractions", data=res.unmixed_image.fracs)
+                g.create_dataset("residuals", data=res.unmixed_image.res)
+                g.create_dataset("model", data=res.unmixed_image.model)
+                g.create_dataset("rsquared", data=res.rsquared)
+        case SaveMode.SMA:
+            raise NotImplementedError(
+                "Saving to .sma has not been implemented."
+            )
+        case SaveMode.CSV:
+            raise NotImplementedError(
+                "Saving to .csv has not been implemented."
+            )
+
+
+def load_model_result(p: PathLike, model_name: str):
+    with h5.File(p) as f:
+        g = f[model_name]
+        endmember_list_with_idx = [
+            [
+                EndMember(
+                    name,
+                    Spectrum(dat[...], g.attrs["wavelengths"]),  # type: ignore
+                ),
+                dat.attrs["index"][...],  # type: ignore
+            ]
+            for (name, dat) in g["endmembers"].items()  # type: ignore
+        ]
+        endmember_list_sorted = [
+            i[0] for i in sorted(endmember_list_with_idx, key=lambda x: x[1])
+        ]
+
+        endmember_grp = EndMemberGroup(endmember_list_sorted)
+
+        return ModelResult(
+            p,
+            model_name,
+            UnMixedCube(
+                g["model"][...],  # type: ignore
+                g["fractions"][:, :, :-1],  # type: ignore
+                g["residuals"][...],  # type: ignore
+            ),
+            endmember_grp,
+            g["rsquared"][...],  # type: ignore
+        )
+
+
+def write_model_to_gis(
+    model: ModelResult,
+    geotransform: GeotransformType,
+    crs: str,
+    save_directory: str | Path,
+    name_prefix: Optional[str] = None,
+):
+    profile = {
+        "driver": "ENVI",
+        "height": model.unmixed_image.fracs.shape[0],
+        "width": model.unmixed_image.fracs.shape[1],
+        "count": model.unmixed_image.fracs.shape[2],
+        "transform": geotransform,
+        "crs": CRS.from_wkt(crs),
+        "dtype": "float32",
+        "nodata": -999,
+    }
+
+    if name_prefix is not None:
+        file_name = f"{name_prefix}_"
+    else:
+        file_name = f"{model.modelID}_"
+    with rio.open(
+        Path(save_directory, f"{file_name}fractions").with_suffix(".bsq"),
+        "w",
+        **profile,
+    ) as f:
+        for n in range(model.unmixed_image.fracs.shape[-1]):
+            f.write(model.unmixed_image.fracs[:, :, n], n + 1)
+    with open(
+        Path(save_directory, f"{file_name}fractions").with_suffix(".hdr"), "a"
+    ) as f:
+        f.write("band_names = {\n")
+        for i in model.endmembers.endmember_name_list:
+            f.write(f"    {i},\n")
+        f.write("}")
+
+    profile["count"] = 1
+    with rio.open(
+        Path(save_directory, f"{file_name}residual").with_suffix(".bsq"),
+        "w",
+        **profile,
+    ) as f:
+        f.write(model.rsquared, 1)

hypmix-0.1.0/src/hypmix/mixview/__init__.py

@@ -0,0 +1,3 @@
+from .main import run_mixview, run_residualview
+
+__all__ = ["run_mixview", "run_residualview"]

hypmix-0.1.0/src/hypmix/mixview/main.py

@@ -0,0 +1,101 @@
+# Standard Libraries
+import sys
+
+# Dependencies
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import (
+    QApplication,
+    QMainWindow,
+    QVBoxLayout,
+    QWidget,
+    QSlider,
+)
+from superqt import QRangeSlider
+
+# Relative Imports
+from .mixture_image_canvas import MixtureImageCanvas
+from .residual_image_canvas import ResidualImageCanvas
+import numpy.typing as npt
+
+# Top-Level Imports
+from hypmix.endmember import EndMemberGroup
+from hypmix.run_model import ModelResult
+
+
+class ResidualViewWindow(QMainWindow):
+    def __init__(self, residual_image: npt.NDArray):
+        super().__init__()
+
+        self.res_canvas = ResidualImageCanvas(residual_image)
+        self.res_canvas.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.res_canvas.setFocus()
+
+        self.range_slider = QRangeSlider()
+        self.range_slider.setValue((20, 80))
+        self.range_slider.setRange(min=0, max_=100)
+        self.range_slider.setOrientation(Qt.Orientation.Horizontal)
+        self.range_slider.valueChanged.connect(self.res_canvas._update)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.res_canvas)
+        layout.addWidget(self.range_slider)
+
+        widget = QWidget()
+        widget.setLayout(layout)
+
+        self.setWindowTitle("ResidualView v0.0.1")
+        # self.setFixedSize(QSize(1200, 6))
+        self.setCentralWidget(widget)
+
+
+class MixViewWindow(QMainWindow):
+    def __init__(
+        self,
+        mixture_cube: npt.NDArray,
+        endmembers: EndMemberGroup,
+    ):
+        super().__init__()
+
+        self.im_canvas = MixtureImageCanvas(mixture_cube, endmembers)
+        self.im_canvas.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.im_canvas.setFocus()
+
+        self.band_slider = QSlider()
+        self.band_slider.setRange(0, mixture_cube.shape[-1] - 1)
+        self.band_slider.setOrientation(Qt.Orientation.Horizontal)
+
+        self.band_slider.valueChanged.connect(self.im_canvas.change_image)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.im_canvas)
+        layout.addWidget(self.band_slider)
+
+        widget = QWidget()
+        widget.setLayout(layout)
+
+        self.setWindowTitle("MixView v0.0.1")
+        # self.setFixedSize(QSize(1200, 900))
+        self.setCentralWidget(widget)
+
+        self.im_canvas.image_changed.connect(self._move_slider)
+
+    def _move_slider(self):
+        self.band_slider.setSliderPosition(self.im_canvas.selected_band)
+
+
+def run_mixview(result: ModelResult) -> None:
+    app = QApplication(sys.argv)
+
+    window = MixViewWindow(result.unmixed_image.fracs, result.endmembers)
+    window.show()
+
+    app.exec()
+
+
+def run_residualview(result: ModelResult) -> None:
+    app = QApplication(sys.argv)
+
+    window = ResidualViewWindow(result.rsquared)
+    window.show()
+
+    app.exec()

hypmix-0.1.0/src/hypmix/mixview/mixture_image_canvas.py

@@ -0,0 +1,118 @@
+# Standard Libraries
+from typing import Any
+from dataclasses import dataclass
+
+# Dependencies
+import numpy as np
+import numpy.typing as npt
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from matplotlib.colors import ListedColormap
+from matplotlib.backend_bases import Event, MouseEvent, KeyEvent
+from PyQt6.QtCore import pyqtSignal
+
+# Relative Imports
+from .pan_zoom_canvas import PanZoomCanvas
+from .utils import square_image, set_image_axis
+
+# Top-Level Imports
+from hypmix.endmember import EndMemberGroup
+
+
+gray_cmap = colormaps["gray"](np.linspace(0, 1, 100))
+teal = np.asarray([0, 0.807843137254902, 0.819607843137255, 1])
+red = np.asarray([0.698039215686274, 0.133333333333333, 0.133333333333333, 1])
+cmap_array = np.concat([teal[None, :], gray_cmap, red[None, :]], axis=0)
+minmax_cmap = ListedColormap(colors=cmap_array)
+
+
+@dataclass
+class HoverData:
+    _img: npt.NDArray
+    xexact: float = 0.0
+    yexact: float = 0.0
+
+    def __post_init__(self) -> None:
+        self.xpixel: int = round(self.xexact)
+        self.ypixel: int = round(self.yexact)
+        if self.xpixel < 0:
+            self.xpixel = 0
+        if self.ypixel < 0:
+            self.ypixel = 0
+        self.value: float = self._img[self.ypixel, self.xpixel]
+
+
+class MixtureImageCanvas(PanZoomCanvas):
+    image_changed = pyqtSignal()
+
+    def __init__(self, mixture_cube: npt.NDArray, endmembers: EndMemberGroup):
+        fig, ax = plt.subplots()
+        set_image_axis(ax)
+        super().__init__(ax)
+
+        self.selected_band: int = 0
+        self.mixture_cube = mixture_cube
+        self.endmembers = endmembers
+        self.clipmin = -0.1
+        self.clipmax = 1.1
+        offsets, self.show_band = square_image(
+            self.mixture_cube[:, :, self.selected_band]
+        )
+        self.img_obj = self.main_axis.imshow(
+            self.show_band,
+            cmap=minmax_cmap,
+            vmin=self.clipmin,
+            vmax=self.clipmax,
+        )
+
+        self.band_names = self.endmembers.endmember_name_list
+        self.main_axis.set_title(self.band_names[self.selected_band])
+
+        self.state.x_offset = offsets.x_offset
+        self.state.y_offset = offsets.y_offset
+
+        self.hover = HoverData(self.show_band)
+
+    def change_image(self, new_band: int):
+        self.img_obj.remove()
+        self.selected_band = new_band
+        _, self.show_band = square_image(
+            self.mixture_cube[:, :, self.selected_band]
+        )
+        self.img_obj = self.main_axis.imshow(
+            self.show_band,
+            cmap=minmax_cmap,
+            vmin=self.clipmin,
+            vmax=self.clipmax,
+        )
+        self.main_axis.set_title(self.band_names[self.selected_band])
+        self.image_changed.emit()
+        self.draw_idle()
+
+    def on_motion(self, event: Event, draw: bool = True) -> Any:
+        super().on_motion(event, draw)
+        if not isinstance(event, MouseEvent):
+            return
+        if event.xdata is None or event.ydata is None:
+            return
+        self.hover = HoverData(
+            self.show_band,
+            xexact=event.xdata,
+            yexact=event.ydata,
+        )
+
+    def on_key_press(self, event: Event) -> Any:
+        super().on_key_press(event)
+
+        if not isinstance(event, KeyEvent):
+            return
+
+        if event.key == "right":
+            if self.selected_band < self.mixture_cube.shape[-1] - 1:
+                self.selected_band += 1
+            self.change_image(self.selected_band)
+
+        if event.key == "left":
+            if self.selected_band > 0:
+                self.selected_band -= 1
+            self.change_image(self.selected_band)

hypmix-0.1.0/src/hypmix/mixview/pan_zoom_canvas.py

@@ -0,0 +1,173 @@
+from dataclasses import dataclass
+from typing import Any
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
+from matplotlib.backend_bases import Event, MouseEvent
+
+
+@dataclass
+class PanZoomState:
+    x_offset: int = 0
+    y_offset: int = 0
+    panning_active: bool = False
+    panning_start_coord: tuple = (0, 0)
+
+
+class PanZoomCanvas(FigureCanvasQTAgg):
+    """
+    Subclassing with this class adds zooming and panning with the middle
+    mouse button to any matplotlib GUI figure.
+
+    Parameters
+    ----------
+    axis: Axes
+        Matplotlib Axes object for the zoom/panning to be applied to.
+    zoom_speed: float, optional
+        Adjusts the speed at which the mouse zooms in/out. Default is 1.5.
+    pan_sensitivity: float, optional
+        Adjusts the sensitivty of the panning motion. Default is 0.5.
+
+    Attributes
+    ----------
+    main_axis: Axes
+        Points to the `axis` argument.
+    state: PanZoomState
+        Canvas state variables: x_offset, y_offset, panning_active and
+        panning_start_coord.
+
+    Notes
+    -----
+    If modifying an image to make it square, be sure to adjust the
+    `self.state.xoffset` and `self.state.yoffset` accordingly.
+    """
+
+    def __init__(
+        self,
+        axis: Axes,
+        zoom_speed: float = 1.5,
+        pan_sensitivity: float = 0.5,
+    ):
+        if isinstance(axis.figure, Figure):
+            super().__init__(axis.figure)
+        else:
+            raise ValueError("Axis is part of a SubFigure.")
+        self.main_axis = axis
+        self._zoom_speed = zoom_speed
+        self._pan_sensitivity = pan_sensitivity
+        self.state = PanZoomState()
+        self.mpl_connect("button_press_event", self.on_button_press)
+        self.mpl_connect("button_release_event", self.on_button_release)
+        self.mpl_connect("scroll_event", self.on_scroll)
+        self.mpl_connect("motion_notify_event", self.on_motion)
+        self.mpl_connect("key_press_event", self.on_key_press)
+
+    def on_button_press(self, event: Event) -> Any:
+        """When the middle mouse button is pressed, activate panning"""
+        if not isinstance(event, MouseEvent):
+            return
+        if event.xdata is None or event.ydata is None:
+            return
+
+        if event.button == 2:
+            self.state.panning_active = True
+            self.state.panning_start_coord = (
+                event.xdata + self.state.x_offset,
+                event.ydata + self.state.y_offset,
+            )
+
+    def on_button_release(self, event: Event) -> Any:
+        """On middle mouse button release, deactivate panning"""
+        if not isinstance(event, MouseEvent):
+            return
+
+        if event.button == 2:
+            self.state.panning_active = False
+
+    def on_scroll(self, event: Event, draw: bool = True) -> Any:
+        """Zoom in on a forward scroll and out on a backward scroll"""
+        # Checking if the Event is the right type.
+        if not isinstance(event, MouseEvent):
+            return
+
+        # Checking if the event is in the image axis.
+        ax = event.inaxes
+        if ax is None:
+            return
+        if ax != self.main_axis:
+            return
+
+        # Current cursor position in data coordinates
+        fx = event.xdata
+        fy = event.ydata
+        if fx is None or fy is None:
+            return
+
+        x0, x1 = ax.get_xlim()
+        y0, y1 = ax.get_ylim()
+
+        xdata = event.xdata
+        ydata = event.ydata
+
+        if xdata is None:
+            return
+        if ydata is None:
+            return
+
+        if event.button == "down":
+            scale = 1 / self._zoom_speed
+        elif event.button == "up":
+            scale = self._zoom_speed
+        else:
+            return
+
+        # Distances from cursor to each side
+        dx0 = fx - x0
+        dx1 = x1 - fx
+        dy0 = fy - y0
+        dy1 = y1 - fy
+
+        # Scale distances
+        dx0 /= scale
+        dx1 /= scale
+        dy0 /= scale
+        dy1 /= scale
+
+        ax.set_xlim(fx - dx0, fx + dx1)
+        ax.set_ylim(fy - dy0, fy + dy1)
+
+        if draw:
+            self.draw_idle()
+
+    def on_motion(self, event: Event, draw: bool = True) -> Any:
+        if not isinstance(event, MouseEvent):
+            return
+        if not self.state.panning_active:
+            return
+        if event.inaxes != self.main_axis:
+            return
+        if event.xdata is None or event.ydata is None:
+            return
+
+        start_pt = self.state.panning_start_coord
+        end_pt = (
+            event.xdata + self.state.x_offset,
+            event.ydata + self.state.y_offset,
+        )
+
+        dx_data = (start_pt[0] - end_pt[0]) * self._pan_sensitivity
+        dy_data = (start_pt[1] - end_pt[1]) * self._pan_sensitivity
+
+        cur_xlim = self.main_axis.get_xlim()
+        cur_ylim = self.main_axis.get_ylim()
+
+        self.main_axis.set_xlim(cur_xlim[0] + dx_data, cur_xlim[1] + dx_data)
+        self.main_axis.set_ylim(cur_ylim[0] + dy_data, cur_ylim[1] + dy_data)
+
+        self.state.panning_start_coord = end_pt
+
+        if draw:
+            self.draw_idle()
+
+    def on_key_press(self, event: Event) -> Any:
+        return

hypmix-0.1.0/src/hypmix/mixview/residual_image_canvas.py

@@ -0,0 +1,32 @@
+# Dependencies
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy.typing as npt
+
+# Relative Imports
+from .pan_zoom_canvas import PanZoomCanvas
+from .utils import square_image, set_image_axis
+
+
+class ResidualImageCanvas(PanZoomCanvas):
+    def __init__(self, residual_image: npt.NDArray):
+        fig, ax = plt.subplots()
+        fig.subplots_adjust(bottom=0.25)
+        set_image_axis(ax)
+        super().__init__(ax)
+
+        self.residual_image = residual_image
+        clean_res_img = residual_image[np.isfinite(residual_image)]
+        self.image_extrema = (np.min(clean_res_img), np.max(clean_res_img))
+
+        offsets, self.sqr_img = square_image(self.residual_image)
+
+        self.img_obj = self.main_axis.imshow(self.sqr_img, cmap="gray")
+        self.state.x_offset = offsets.x_offset
+        self.state.y_offset = offsets.y_offset
+
+    def _update(self, values: tuple[float, float]):
+        vmin, vmax = values
+        self.img_obj.norm.vmin = self.image_extrema[0] * vmin / 100
+        self.img_obj.norm.vmax = self.image_extrema[1] * vmax / 100
+        self.draw_idle()

hypmix-0.1.0/src/hypmix/mixview/utils.py

@@ -0,0 +1,88 @@
+# Standard Libraries
+from typing import NamedTuple
+
+# Dependencies
+from matplotlib.axes import Axes
+import numpy as np
+
+
+class SquareOffset(NamedTuple):
+    x_offset: int = 0
+    y_offset: int = 0
+
+
+def square_image(
+    img: np.ndarray, rgb: bool = False
+) -> tuple[SquareOffset, np.ndarray]:
+    """
+    Pads a rectangular image to make it square, for the purpose of reshaping
+    an image axis to be better suited for GUI applications.
+
+    Parameters
+    ----------
+    img: np.ndarray
+        Image array.
+    rgb: bool, optional
+        Option to specify RGB image input.
+
+    Returns
+    -------
+    offset: SquareOffset
+        NamedTuple of offset values added due to padding. The 2 attributes are
+        `x_offset` and `y_offset` representing the horizontal and vertical
+        offsets respectively. One will always be zero.
+    square_img: np.ndarray
+        Image with np.nan values padding the sides to fit the square
+    """
+    long_axis = np.argmax(img.shape)
+    if not rgb:
+        short_axis = np.argmin(img.shape)
+        padding_length = (img.shape[long_axis] - img.shape[short_axis]) // 2
+        square_padding = np.full(
+            (img.shape[long_axis], padding_length),
+            np.nan,
+        )
+        square_img = np.concat(
+            [square_padding, img, square_padding], axis=short_axis
+        )
+
+        if long_axis < short_axis:
+            offset = SquareOffset(-padding_length, 0)
+        else:
+            offset = SquareOffset(0, -padding_length)
+
+        return offset, square_img
+    else:
+        short_axis = np.argmin(img.shape[:-1])
+        padding_length = (img.shape[long_axis] - img.shape[short_axis]) // 2
+        square_padding = np.full(
+            (img.shape[long_axis], padding_length, 3),
+            np.nan,
+        )
+        square_img = np.concat(
+            [square_padding, img, square_padding],
+            axis=short_axis,
+        )
+        if long_axis < short_axis:
+            offset = SquareOffset(-padding_length, 0)
+        else:
+            offset = SquareOffset(0, -padding_length)
+        return offset, square_img
+
+
+def set_image_axis(ax: Axes) -> None:
+    """
+    Sets a matplotlib axis up to display an image.
+    """
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.tick_params(
+        axis="both",
+        which="both",
+        bottom=False,
+        top=False,
+        left=False,
+        right=False,
+        labelbottom=False,
+        labelleft=False,
+    )

hypmix-0.1.0/src/hypmix/model_math.py

@@ -0,0 +1,89 @@
+# Standard Libraries
+from dataclasses import dataclass
+from typing_extensions import Annotated
+from typing import Tuple
+
+# Dependencies
+import numpy as np
+import numpy.typing as npt
+
+# Relative Imports
+from .typing import ImageCubeLike
+
+
+@dataclass
+class MixedCube:
+    """
+    Represents an made up of pixels that are each an areal mixture of spectral
+    endmembers.
+
+    Attributes
+    ----------
+    G: NDArray[np.float32, (2,)]
+        Least squares design matrix. The array is of shape NxM where N is the
+        number of spectral bands and M is the number of endmembers in the
+        unmixing model.
+    d: NDArray[np.float32, (3,)]
+        Data matrix for every pixel. This is just the spectral cube data.
+    """
+
+    G: Annotated[npt.NDArray[np.float32], (2,)]
+    d: Annotated[npt.NDArray[np.float32], (3,)]
+
+
+@dataclass
+class UnMixedCube:
+    """
+    The results of spectral unmixing.
+
+    Attributes
+    ----------
+    model: NDArray[np.float32, (3,)]
+        Modeled spectral cube, where each pixel is a linear combination of
+        endmembers that best fits the actual data.
+    fracs: NDArray[np.float32, (3,)]
+        3D array representing the modeled fractions of endmembers at all
+        pixels.
+    res: NDArray[np.float32, (2,)]
+        Pixel-by-pixel model residuals. That is, a Spectrum-Like vector for
+        each pixel that represents model - data in each spectral band.
+    """
+
+    model: ImageCubeLike
+    fracs: ImageCubeLike
+    res: ImageCubeLike
+
+
+def _solve_cube(
+    G: Annotated[npt.NDArray[np.float32], (2,)],
+    d: Annotated[npt.NDArray[np.float32], (3,)],
+) -> Tuple[ImageCubeLike, ImageCubeLike, ImageCubeLike]:
+    prefix = np.linalg.inv(G.T @ G) @ G.T
+
+    fracs = np.einsum("ij,...j->...i", prefix, d)
+
+    model = np.einsum("ij,...j->...i", G, fracs)
+
+    res = model - d
+
+    return model, fracs, res
+
+
+def unmix_spectral_cube(mixed_cube: MixedCube, add_to_one: bool = True):
+    G = mixed_cube.G
+    d = mixed_cube.d
+
+    if add_to_one:
+        G_aug = np.hstack((G, np.ones([G.shape[0], 1])), dtype=np.float32)
+        bottom_row = np.append(np.ones(G.shape[1]), 0)
+        G_aug = np.vstack((G_aug, bottom_row), dtype=np.float32)
+
+        d_aug = np.concat(
+            [d, np.ones(d.shape[:2])[:, :, None]], axis=2, dtype=np.float32
+        )
+
+        model, fracs, res = _solve_cube(G_aug, d_aug)
+    else:
+        model, fracs, res = _solve_cube(G, d)
+
+    return UnMixedCube(model, fracs, res)

hypmix-0.1.0/src/hypmix/run_model.py

@@ -0,0 +1,121 @@
+# Standard Libraries
+from dataclasses import dataclass, field
+
+# Dependencies
+import numpy as np
+
+# Relative Imports
+from .typing import ImageCube, Spectrum, PathLike
+from .io import ModelResult
+from .model_math import unmix_spectral_cube, MixedCube
+from .endmember import EndMember, EndMemberGroup
+
+
+class EndmemberAlreadyExistsError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+@dataclass
+class ModelState:
+    has_reflector: bool = False
+    has_shade: bool = False
+    has_blackbody: bool = False
+    endmember_count: int = 0
+
+
+@dataclass
+class MixtureModel:
+    """
+    Parameters
+    ----------
+    endmembers: list[EndMember]
+        List of model endmembers to use.
+    data_cube: ImageCube
+        Spectral data cube.
+    """
+
+    endmembers: list[EndMember]
+    data_cube: ImageCube
+    state: ModelState = field(default_factory=ModelState)
+
+    def __post_init__(self):
+        if self.data_cube.bands_first:
+            self.data_cube.data = np.transpose(self.data_cube.data, (1, 2, 0))
+        self.state.endmember_count = len(self.endmembers)
+
+    def add_endmember(self, endmember: EndMember) -> None:
+        if endmember.name in [i.name for i in self.endmembers]:
+            raise EndmemberAlreadyExistsError(
+                f"{endmember} has the same name as an existing endmember."
+            )
+        self.endmembers.append(endmember)
+        self.state.endmember_count += 1
+
+    def add_virtual_reflector(self):
+        if not self.state.has_reflector:
+            self.endmembers.append(
+                EndMember(
+                    "Reflector",
+                    Spectrum(
+                        np.ones(len(self.data_cube.wvl)), self.data_cube.wvl
+                    ),
+                )
+            )
+            self.state.endmember_count += 1
+            self.state.has_reflector = True
+
+    def add_virtual_shade(self):
+        if not self.state.has_shade:
+            self.endmembers.append(
+                EndMember(
+                    "Shade",
+                    Spectrum(
+                        0.001 * np.ones(len(self.data_cube.wvl)),
+                        self.data_cube.wvl,
+                    ),
+                )
+            )
+            self.state.endmember_count += 1
+            self.state.has_shade = True
+        else:
+            raise EndmemberAlreadyExistsError(
+                "Virtual Shade already exists in this model."
+            )
+
+    def add_virtual_blackbody(self) -> None:
+        if not self.state.has_blackbody:
+            self.endmembers.append(
+                EndMember(
+                    "Blackbody",
+                    Spectrum(
+                        np.ones(len(self.data_cube.wvl)), self.data_cube.wvl
+                    ),
+                )
+            )
+            self.state.endmember_count += 1
+            self.state.has_blackbody = True
+        else:
+            raise EndmemberAlreadyExistsError(
+                "Virtual blackbody already exists in this model."
+            )
+
+    def run(self, dst_path: PathLike, modelID: str) -> ModelResult:
+        G = np.empty(
+            [len(self.data_cube.wvl), len(self.endmembers)], dtype=np.float32
+        )
+        for n, em in enumerate(self.endmembers):
+            G[:, n] = em.spectrum.data
+        mixed_cube = MixedCube(G, self.data_cube.data)
+        unmixed_cube = unmix_spectral_cube(mixed_cube)
+        rsquared = np.sqrt(np.sum(unmixed_cube.res**2, axis=2))
+
+        result = ModelResult(
+            dst_path,
+            modelID,
+            unmixed_cube,
+            EndMemberGroup(self.endmembers),
+            rsquared,
+        )
+
+        return result

hypmix-0.1.0/src/hypmix/typing.py

@@ -0,0 +1,34 @@
+# Standard Libraries
+from dataclasses import dataclass
+from typing import TypeVar
+from typing_extensions import Annotated
+import os
+from pathlib import Path
+
+# Dependencies
+import numpy.typing as npt
+import numpy as np
+
+PathLike = str | os.PathLike | Path
+
+DType = TypeVar("DType", bound=np.generic)
+SpectrumLike = Annotated[npt.NDArray[DType], (1,)]
+ImageCubeLike = Annotated[npt.NDArray[DType], (3,)]
+ImageLike = Annotated[npt.NDArray[DType], (2,)]
+
+
+@dataclass
+class Spectrum:
+    data: SpectrumLike
+    wvl: SpectrumLike
+
+
+@dataclass
+class ImageCube:
+    data: ImageCubeLike
+    wvl: SpectrumLike
+    bands_first: bool = False
+
+    def __post_init__(self):
+        bands_dim = np.argmin(self.data.shape)
+        self.data = np.moveaxis(self.data, bands_dim, -1)