pycubeview 0.1.0__tar.gz

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

pycubeview-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: pycubeview
+Version: 0.1.0
+Summary: A Hyperspectral Image Viewer for Python
+License: LICENSE
+License-File: LICENSE
+Author: Z.M. Vig
+Author-email: zvig@umd.edu
+Requires-Python: >=3.13,<4
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: alphashape (>=1.3.1,<2.0.0)
+Requires-Dist: arguably (>=1.3.0,<2.0.0)
+Requires-Dist: pandas (>=2.3.3,<3.0.0)
+Requires-Dist: pandas-stubs (>=2.3.3.251201,<3.0.0.0)
+Requires-Dist: pyqt6 (>=6.10.0,<7.0.0)
+Requires-Dist: pyqtgraph (>=0.14.0,<0.15.0)
+Requires-Dist: shapely (>=2.1.2,<3.0.0)
+Requires-Dist: spectralio (>=0.1.4,<0.2.0)
+Requires-Dist: types-shapely (>=2.1.0.20250917,<3.0.0.0)
+Description-Content-Type: text/markdown
+
+# `cubeview` 🔎
+
+A Flexible and Interactive Spectral (and more!) Image Viewer for Python
+
+---
+
+## Motivation ✨
+
+Whether it's an imaging spectrometer or an InSAR time-series, many remotely
+sensed scientific data comes in the form of a cube, which is here defined as
+any dataset that has spatial information in two dimensions and measured values
+in a third dimension. Below are listed some examples of scientific data cubes:
+
+- Hyperspectral Imagery
+- Multispectral Imagery
+- InSAR Time Series
+- Cloud Cover Evolution Map
+- Spectral Maps from lab spectrometers
+- And Many More!
+
+
+## Installation ⬇️
+
+`cubeview` can be directly install from the Python Package Index using `pip`.
+
+```bash
+pip install cubeview
+```
+
+## Usage ⚙️
+
+The basic `cubeview` GUI can be opened directly from the command line by ensuring you are in a python environment that has `cubeview` installed and running
+
+```bash
+cubeview.exe
+```
+
+The `cubeview` GUI can also be started from a python script.
+
+```python
+from cubeview import open_cubeview
+open_cubeview(image_data, cube_data, wvl_data)
+```
+Where the data can optionally provided as either a Numpy-Array or a filepath to one of the supported file types.
+
+## Supported File Types 📂
+### Image and Cube Data
+#### `spectralio` files
+
+  - .geospcub
+  - .spcub
+
+#### `rasterio`-compatible files
+  - .img
+  - .bsq
+  - .tif
+
+### Wavelength Data
+  - .wvl
+  - .hdr
+  - .txt
+  - .csv
+
+
+

pycubeview-0.1.0/README.md

@@ -0,0 +1,64 @@
+# `cubeview` 🔎
+
+A Flexible and Interactive Spectral (and more!) Image Viewer for Python
+
+---
+
+## Motivation ✨
+
+Whether it's an imaging spectrometer or an InSAR time-series, many remotely
+sensed scientific data comes in the form of a cube, which is here defined as
+any dataset that has spatial information in two dimensions and measured values
+in a third dimension. Below are listed some examples of scientific data cubes:
+
+- Hyperspectral Imagery
+- Multispectral Imagery
+- InSAR Time Series
+- Cloud Cover Evolution Map
+- Spectral Maps from lab spectrometers
+- And Many More!
+
+
+## Installation ⬇️
+
+`cubeview` can be directly install from the Python Package Index using `pip`.
+
+```bash
+pip install cubeview
+```
+
+## Usage ⚙️
+
+The basic `cubeview` GUI can be opened directly from the command line by ensuring you are in a python environment that has `cubeview` installed and running
+
+```bash
+cubeview.exe
+```
+
+The `cubeview` GUI can also be started from a python script.
+
+```python
+from cubeview import open_cubeview
+open_cubeview(image_data, cube_data, wvl_data)
+```
+Where the data can optionally provided as either a Numpy-Array or a filepath to one of the supported file types.
+
+## Supported File Types 📂
+### Image and Cube Data
+#### `spectralio` files
+
+  - .geospcub
+  - .spcub
+
+#### `rasterio`-compatible files
+  - .img
+  - .bsq
+  - .tif
+
+### Wavelength Data
+  - .wvl
+  - .hdr
+  - .txt
+  - .csv
+
+

pycubeview-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "pycubeview"
+version = "0.1.0"
+description = "A Hyperspectral Image Viewer for Python"
+authors = [
+    {name = "Z.M. Vig",email = "zvig@umd.edu"}
+]
+license = "LICENSE"
+readme = "README.md"
+requires-python = ">=3.13,<4"
+dependencies = [
+    "pyqt6 (>=6.10.0,<7.0.0)",
+    "pyqtgraph (>=0.14.0,<0.15.0)",
+    "shapely (>=2.1.2,<3.0.0)",
+    "alphashape (>=1.3.1,<2.0.0)",
+    "types-shapely (>=2.1.0.20250917,<3.0.0.0)",
+    "spectralio (>=0.1.4,<0.2.0)",
+    "arguably (>=1.3.0,<2.0.0)",
+    "pandas (>=2.3.3,<3.0.0)",
+    "pandas-stubs (>=2.3.3.251201,<3.0.0.0)"
+]
+
+[project.scripts]
+cubeview = "cubeview.cli:main"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

pycubeview-0.1.0/src/pycubeview/__init__.py

@@ -0,0 +1,14 @@
+"""
+# `specview`
+
+A Hyperspectral Image Viewer for Python
+
+---
+
+## Example
+"""
+
+from .spectral_viewing_window import CubeViewWindow
+from .helper_functions import open_cubeview
+
+__all__ = ["open_cubeview", "CubeViewWindow"]

pycubeview-0.1.0/src/pycubeview/base_window.py

@@ -0,0 +1,66 @@
+# Built-ins
+from dataclasses import dataclass
+from importlib.metadata import version
+
+# Dependencies
+import pyqtgraph as pg  # type: ignore
+import numpy as np
+
+# PyQt6 Imports
+from PyQt6.QtWidgets import QMainWindow, QStatusBar, QMenu
+from PyQt6.QtGui import QAction
+
+
+@dataclass
+class MasterGUIState:
+    spectrum_cache: dict[str, tuple[pg.PlotDataItem, pg.ErrorBarItem]]
+    spectrum_edit_open: bool
+    drawing: bool
+
+    @classmethod
+    def initial(cls) -> "MasterGUIState":
+        return cls(
+            spectrum_cache={},
+            spectrum_edit_open=False,
+            drawing=False,
+        )
+
+
+class BaseWindow(QMainWindow):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.state = MasterGUIState.initial()
+
+        self.open_cube = QAction("Open Spectral Cube", self)
+        self.open_cube.setStatusTip("Open a new spectral cube.")
+
+        self.open_display = QAction("Open Display", self)
+        self.open_display.setStatusTip("Open new display data.")
+
+        self.clear_spectra = QAction("Clear Spectrum Plot", self)
+        self.clear_spectra.setStatusTip("Clear 0 spectra from memory.")
+
+        menubar = self.menuBar()
+        if menubar is not None:
+            self.open_menu = QMenu(title="Open")
+            menubar.addMenu(self.open_menu)
+            self.open_menu.addAction(self.open_cube)
+            self.open_menu.addAction(self.open_display)
+
+            self.spectrum_menu = QMenu(title="Spectrum")
+            menubar.addMenu(self.spectrum_menu)
+            self.spectrum_menu.addAction(self.clear_spectra)
+
+        self.status_bar = QStatusBar(self)
+        self.setStatusBar(self.status_bar)
+
+        self.setWindowTitle(f"SpecView v{version("cubeview")}")
+
+    def set_window_size(self, image: np.ndarray) -> None:
+        if image.shape[0] > image.shape[1]:
+            self.resize(600, 800)
+        elif image.shape[1] > image.shape[0]:
+            self.resize(800, 600)
+        else:
+            self.resize(600, 600)

pycubeview-0.1.0/src/pycubeview/cli.py

@@ -0,0 +1,20 @@
+# Dependencies
+import arguably
+
+# PyQt6 Imports
+from PyQt6.QtWidgets import QApplication
+
+# Local Imports
+from .spectral_viewing_window import CubeViewWindow
+
+
+@arguably.command
+def cubeview():
+    app = QApplication([])
+    main = CubeViewWindow()
+    main.show()
+    app.exec()
+
+
+def main():
+    arguably.run()

pycubeview-0.1.0/src/pycubeview/file_opening_utils.py

@@ -0,0 +1,289 @@
+"""
+File Opening Utilities
+
+This module provides a centralized, type-safe dispatch for opening three
+categories of files for the operation ofthe SpecView GUI.
+
+Supported File Types
+--------------------
+
+
+Available Helper Functions::
+
+    from pathlib import Path
+
+    wvl = open_wvl(Path("wvlvals.wvl"))
+    img = open_cube(Path("cube.geospcub"))
+
+"""
+
+# Built-Ins
+from pathlib import Path
+from typing import Protocol
+from dataclasses import dataclass
+
+# Dependencies
+import numpy as np
+import rasterio as rio  # type: ignore
+import spectralio as sio
+import re
+import pandas as pd
+
+
+# ---- Handling Wavelength Data Files ----
+
+
+class WvlHandler(Protocol):
+    """
+    Protocol for handling wavelength (or other context data) files.
+    """
+
+    def __call__(self, path: Path) -> np.ndarray: ...
+
+    """
+    Handle a file at the given path.
+
+    Parameters
+    ----------
+    path: Path
+        Path to an existing file whose suffix is one of the following
+
+        - .wvl
+        - .hdr
+        - .txt
+        - .csv
+
+    Returns
+    -------
+    wvl_array: np.ndarray
+        A 1D numpy array that holds the wavelength values.
+
+    Raises
+    ------
+    OSError
+        If the file cannot be read.
+    """
+
+
+def open_wvl_file(path: Path) -> np.ndarray:
+    """Reads .wvl files using `spectralio`"""
+    wvl = sio.read_wvl(path)
+    return wvl.asarray()
+
+
+def open_hdr_file(path: Path) -> np.ndarray:
+    """Read an ENVI .hdr file"""
+    wvl_pattern = re.compile(r"wavelength\s=\s\{([^}]*)\}")
+    with open(path, "r") as f:
+        file_contents = f.read()
+    result = re.findall(wvl_pattern, file_contents)
+    if len(result) == 0:
+        raise OSError("Unable to open .hdr file. Is there a wavelength field?")
+    vals = np.asarray([float(i) for i in result[0].split(",")])
+    return vals
+
+
+def open_txt_file(path: Path) -> np.ndarray:
+    """
+    Read a .txt file. Wavelength values should be seperated by commas.
+    """
+    with open(path, "r") as f:
+        contents = f.read()
+    vals = contents.split(",")
+    if vals[-1] == " ":
+        vals = vals[:-1]
+    return np.asarray([float(i) for i in vals])
+
+
+def open_csv_file(path: Path) -> np.ndarray:
+    """
+    Opens a csv file where there is one row of headers and at least one is
+    "wavelength". Make sure there are no spaces around the commas!
+    """
+    df = pd.read_csv(path)
+    wvl_col_idx = [i.lower() for i in df.columns.to_list()].index("wavelength")
+    wvl = df.iloc[:, wvl_col_idx].to_numpy()
+    return wvl
+
+
+# Mapping from lowercase string file extensions to handler functions.
+WVL_HANDLERS: dict[str, WvlHandler] = {
+    ".wvl": open_wvl_file,
+    ".hdr": open_hdr_file,
+    ".txt": open_txt_file,
+    ".csv": open_csv_file,
+}
+
+
+def open_wvl(path: str | Path) -> np.ndarray:
+    """
+    Open a file that stores wavelength information.
+
+    This function inspects the files extension name and passes it to the
+    appropriate handler for that file type.
+
+    Parameters
+    ----------
+    path: str or Path
+        Path to file containing wavelength data that is to be opened.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the file does not exist.
+    ValueError
+        If the file does not have a valid extension.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(path)
+
+    suffix = path.suffix.lower()
+
+    handler = WVL_HANDLERS.get(suffix)
+
+    if handler is None:
+        raise ValueError(f"Unsupported file type: {suffix}")
+
+    return handler(path)
+
+
+# ---- Handling Cube Data Files ----
+@dataclass
+class CubeAxisOrder:
+    """
+    Holds information for orienting spectral data cubes.
+
+    Parameters
+    ----------
+    x: int
+        Axis index for the horizontal image direction.
+    y: int
+        Axis index for the vertical image direction.
+    b: int
+        Axis index for the spectral band (or other context data) direction.
+    """
+
+    x: int
+    y: int
+    b: int
+
+
+class CubeHandler(Protocol):
+    """
+    Protocol for handling cube data files.
+    """
+
+    def __call__(self, path: Path, axis_map: dict[str, int]) -> np.ndarray: ...
+
+    """
+    Handle a file at the given path.
+
+    Parameters
+    ----------
+    path: Path
+        Path to an existing file whose suffix is one of the following
+
+        - .spcub
+        - .geospcub
+        - .bsq
+        - .img
+        - .tif
+
+
+
+    Returns
+    -------
+    cube_array: np.ndarray
+        A 3D numpy array where axis 0 is the vertical image dimension, axis 1
+        is the horizontal image dimension and axis 2 is the wavelength (or
+        other context data) dimension.
+
+    Raises
+    ------
+    OSError
+        If the file cannot be read.
+    """
+
+
+def open_spcub_cube(path: Path, axis_map: dict[str, int]) -> np.ndarray:
+    """
+    Read .spcub or .geospcub files using `spectralio`
+    """
+    cub_obj: sio.Spectrum3D
+    if path.suffix.lower() == ".geospcub":
+        cub_obj = sio.read_spec3D(path, kind="geospcub")
+    elif path.suffix.lower() == ".spcub":
+        cub_obj = sio.read_spec3D(path, kind="spcub")
+    else:
+        raise ValueError(
+            "Invalid File Type passed to `open_spcub_file()`: "
+            f"{path.suffix.lower()}"
+        )
+    return cub_obj.load_raster(bbl=True)
+
+
+def open_rasterio_cube(path: Path, axis_map: dict[str, int]) -> np.ndarray:
+    """
+    Reads any rasterio-compatible file type.
+    """
+    try:
+        axis_order_obj = CubeAxisOrder(**axis_map)
+    except TypeError:
+        raise TypeError(
+            "Invalid axis_order dictionary with keys: "
+            f"{list(axis_map.keys())}. The keys should be ['x', 'y', 'b']"
+            " for the horizontal, vertical and spectral (or other) dimension,"
+            " respectively."
+        )
+
+    with rio.open(path, "r") as f:
+        cube_array = f.read()
+    transpose_order = (axis_order_obj.y, axis_order_obj.x, axis_order_obj.b)
+    cube_array = np.transpose(cube_array, transpose_order)
+    return cube_array
+
+
+# Mapping from lowercase file extension to handler function.
+CUBE_HANDLERS: dict[str, CubeHandler] = {
+    ".spcub": open_spcub_cube,
+    ".geospcub": open_spcub_cube,
+    ".bsq": open_rasterio_cube,
+    ".img": open_rasterio_cube,
+    ".tif": open_rasterio_cube,
+}
+
+
+def open_cube(
+    path: str | Path, axis_map: dict[str, int] = {"x": 2, "y": 1, "b": 0}
+) -> np.ndarray:
+    """
+    Open a file that stores spectral (or other) cube-based information.
+
+    This function inspects the files extension name and passes it to the
+    appropriate handler for that file type.
+
+    Parameters
+    ----------
+    path: str or Path
+        Path to file containing wavelength data that is to be opened.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the file does not exist.
+    ValueError
+        If the file does not have a valid extension.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(path)
+
+    suffix = path.suffix.lower()
+
+    handler = CUBE_HANDLERS.get(suffix)
+
+    if handler is None:
+        raise ValueError(f"Unsupported file type: {suffix}")
+
+    return handler(path, axis_map)

pycubeview-0.1.0/src/pycubeview/helper_functions.py

@@ -0,0 +1,19 @@
+# Dependencies
+import numpy as np
+
+# PyQt6 Imports
+from PyQt6.QtWidgets import QApplication
+
+# Local Imports
+from .spectral_viewing_window import CubeViewWindow
+
+
+def open_cubeview(
+    image_data: np.ndarray | str | None,
+    cube_data: np.ndarray | str | None,
+    wvl_data: np.ndarray | str | None,
+):
+    app = QApplication([])
+    main = CubeViewWindow(wvl_data, image_data, cube_data)
+    main.show()
+    app.exec()

pycubeview-0.1.0/src/pycubeview/image_display_widget.py

@@ -0,0 +1,193 @@
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QApplication
+from PyQt6.QtCore import pyqtSignal, Qt, QPointF
+import pyqtgraph as pg  # type: ignore
+from pyqtgraph.GraphicsScene.mouseEvents import MouseClickEvent  # type: ignore
+import numpy as np
+from shapely.geometry import Polygon, Point
+from alphashape import alphashape  # type: ignore
+import math
+
+
+class ImagePickerWidget(QWidget):
+    mouse_moved = pyqtSignal(float, float, float)
+    pixel_picked = pyqtSignal(int, int)
+    lasso_finished = pyqtSignal(np.ndarray, np.ndarray)
+
+    def __init__(self):
+        super().__init__()
+
+        self.imview = pg.ImageView()
+        self.imview.scene.sigMouseClicked.connect(  # type: ignore
+            self.pixel_select
+        )
+        self.imview.scene.sigMouseClicked.connect(  # type: ignore
+            self.lasso_click
+        )
+        self.imview.scene.sigMouseMoved.connect(  # type: ignore
+            self.lasso_movement
+        )
+        self.imview.scene.sigMouseMoved.connect(  # type: ignore
+            self.track_cursor
+        )
+        self._drawing = False
+
+        self.lasso = pg.PolyLineROI(
+            [[0, 0]],
+            closed=True,
+            pen=pg.mkPen("r", width=2),
+            movable=False,
+            removable=False,
+        )
+        self.imview.getView().addItem(self.lasso)
+        self.lasso.setVisible(False)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.imview)
+        self.setLayout(layout)
+
+    def set_image(self, data: np.ndarray) -> None:
+        # Setting imview image
+        if data.ndim == 3:
+            if data.shape[-1] == 3:
+                _ax_interp = {"y": 0, "x": 1, "c": 2}
+                self.imview.setImage(data, axes=_ax_interp, levelMode="rgba")
+            elif data.shape[-1] > 3:
+                _ax_interp = {"y": 0, "x": 1, "t": 2}
+                self.imview.setImage(data, axes=_ax_interp, levelMode="mono")
+            self.imview.setCurrentIndex(0)
+        elif data.ndim == 2:
+            _ax_interp = {"y": 0, "x": 1}
+            self.imview.setImage(data, axes=_ax_interp, levelMode="mono")
+            self.img = data
+        else:
+            print("Data is the wrong number of dimensions.")
+            return
+        self.reset_levels(0.2, 99.8)
+
+    def reset_levels(
+        self, low_percentile: float, high_percentile: float
+    ) -> None:
+        # Setting levels
+        img = self.imview.image
+        pct_range = [low_percentile, high_percentile]
+        if img is None:
+            return
+        if img.ndim == 3:
+            if img.shape[-1] > 3:
+                lo, hi = np.percentile(
+                    img[np.isfinite(img[:, :, 0]), 0], pct_range
+                )
+                self.imview.setLevels(min=lo, max=hi)
+            elif img.shape[-1] == 3:
+                rgb_lohi = []
+                for i in img.shape[-1]:
+                    rgb_lohi.append(
+                        np.percentile(
+                            img[np.isfinite(img[:, :, i]), i],
+                            [0.2, 99.8],
+                        )
+                    )
+                self.imview.setLevels(rgba=rgb_lohi)
+        else:
+            return
+
+    def pixel_select(self, mouse_event) -> None:
+        mods = QApplication.keyboardModifiers()
+        if mods == Qt.KeyboardModifier.ControlModifier:
+            return
+        if self._drawing:
+            return
+        img = self.imview.image
+        if img is None:
+            return
+        data_pos = self.imview.getView().mapSceneToView(mouse_event.pos())
+        x = int(data_pos.x())
+        y = int(data_pos.y())
+        if y < 0 or y > img.shape[0]:
+            print(f"Out of Image Bounds. ({x}, {y})")
+            return
+        if x < 0 or x > img.shape[1]:
+            print(f"Out of Image Bounds. ({x}, {y})")
+            return
+        self.pixel_picked.emit(y, x)
+
+    def lasso_click(self, mouse_event: MouseClickEvent) -> None:
+        mods = QApplication.keyboardModifiers()
+        if mods != Qt.KeyboardModifier.ControlModifier:
+            return
+
+        pos = mouse_event.scenePos()
+        view_pos = self.imview.getView().mapSceneToView(pos)
+
+        if not self._drawing:
+            self.start_lasso([[view_pos.x(), view_pos.y()]])
+        else:
+            if mouse_event.double():
+                self.finish_lasso()
+
+    def lasso_movement(self, pos: QPointF):
+        if not self._drawing:
+            return
+        view_pos = self.imview.getView().mapSceneToView(pos)
+        pts = self.lasso.getState()["points"]
+        pts.append([view_pos.x(), view_pos.y()])
+        self.lasso.setPoints(pts)
+        for h in self.lasso.handles:
+            h["item"].setVisible(False)
+
+    def start_lasso(self, pos):
+        self._drawing = True
+        self.lasso.clearPoints()
+        self.lasso.setPoints(pos)
+        self.lasso.setVisible(True)
+
+    def finish_lasso(self) -> None:
+        self._drawing = False
+        point_list = self.lasso.getState()["points"]
+        self.lasso.setVisible(False)
+        vertices = np.empty((len(point_list), 2))
+        for n, pt in enumerate(point_list):
+            vertices[n, :] = (pt.x(), pt.y())
+        poly = Polygon(vertices)
+        x_pts = np.asarray([i[0] for i in vertices])
+        y_pts = np.asarray([i[1] for i in vertices])
+        x_slice = slice(x_pts.min(), x_pts.max())
+        y_slice = slice(y_pts.min(), y_pts.max())
+
+        x_sample, y_sample = np.mgrid[x_slice, y_slice]
+        pt_list = [
+            (i, j) for i, j in zip(x_sample.flatten(), y_sample.flatten())
+        ]
+        in_x = []
+        in_y = []
+        for i in pt_list:
+            if poly.contains(Point(i)):
+                in_x.append(math.floor(i[0]))
+                in_y.append(math.floor(i[1]))
+        in_x_arr = np.asarray(in_x).astype(int)
+        in_y_arr = np.asarray(in_y).astype(int)
+        in_array = np.stack([in_x_arr, in_y_arr], axis=1)
+        in_pts: list[tuple[float, float]] = [
+            (i, j) for i, j in zip(in_x, in_y)
+        ]
+
+        new_poly = alphashape(points=in_pts, alpha=0.9)  # type: ignore
+        x_verts = np.asarray(new_poly.exterior.xy[0])  # type: ignore
+        y_verts = np.asarray(new_poly.exterior.xy[1])  # type: ignore
+        xy_verts = np.concatenate([x_verts[:, None], y_verts[:, None]], axis=1)
+
+        self.lasso_finished.emit(in_array, xy_verts)
+
+    def track_cursor(self, pos) -> None:
+        view_pos = self.imview.getView().mapSceneToView(pos)
+        x_float = view_pos.x()
+        y_float = view_pos.y()
+        x_int = int(x_float)
+        y_int = int(y_float)
+        img = self.imview.getImageItem().image  # axes flipped
+        if img is None:
+            return
+        if 0 <= y_int < img.shape[1] and 0 <= x_int < img.shape[0]:
+            self.mouse_moved.emit(x_float, y_float, img[x_int, y_int])
+        else:
+            self.mouse_moved.emit(-999, -999, -999)

pycubeview-0.1.0/src/pycubeview/spectral_display_widget.py

@@ -0,0 +1,140 @@
+from PyQt6.QtWidgets import QWidget, QVBoxLayout
+from PyQt6.QtCore import pyqtSignal
+import pyqtgraph as pg  # type: ignore
+import numpy as np
+from functools import partial
+
+from .spectrum_edit_window import SpectrumEditWindow
+
+
+class SpectralDisplayWidget(QWidget):
+    data_added = pyqtSignal(pg.PlotDataItem, pg.ErrorBarItem)
+    data_updated = pyqtSignal(pg.PlotDataItem, pg.ErrorBarItem, str, str)
+    data_removed = pyqtSignal(str)
+    plot_reset = pyqtSignal()
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.spec_plot = pg.PlotWidget()
+        self.spec_legend = self.spec_plot.addLegend()
+
+        self.wvl = np.empty((0, 0, 0), dtype=np.float32)
+        self.cube = np.empty((0, 0, 0), dtype=np.float32)
+        self._count = 0
+        self._editing = False
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.spec_plot)
+        self.setLayout(layout)
+
+        self.plot_reset.connect(self.handle_reset)
+
+    def set_cube(self, wvl: np.ndarray, data: np.ndarray) -> None:
+        if data.ndim != 3:
+            return
+        self.wvl = wvl
+        self.cube = data.astype(np.float32)
+
+    def add_spectrum(self, coord: tuple[int, int]) -> str:
+        self._count += 1
+        spectrum = self.cube[*coord, :]
+        spec_item = pg.PlotDataItem(
+            self.wvl,
+            spectrum,
+            clickable=True,
+            name=f"SPECTRUM_{self._count:02d}",
+        )
+        errbars = pg.ErrorBarItem(x=self.wvl, y=spectrum, height=0)
+        errbars.setVisible(False)
+
+        self.spec_plot.addItem(spec_item)
+        self.data_added.emit(spec_item, errbars)
+
+        spec_item.sigClicked.connect(
+            partial(self.edit_spectrum, spec_item, errbars)
+        )
+
+        name = spec_item.name()
+        if name is not None:
+            return name
+        else:
+            raise ValueError(f"Spectrum name ({name}) is invalid")
+
+    def add_group(self, coords: np.ndarray) -> str:
+        self._count += 1
+        if coords.ndim != 2:
+            raise ValueError("Group Coordinate Array is the wrong size")
+        if coords.shape[1] != 2:
+            raise ValueError("Group Coordinate Array is the wrong size")
+
+        spec_array = self.cube[coords[:, 1], coords[:, 0], :]
+        mean_spectrum = np.mean(spec_array, axis=0)
+        err_spectrum = np.std(spec_array, axis=0, ddof=1)
+        spec_item = pg.PlotDataItem(
+            self.wvl,
+            mean_spectrum,
+            clickable=True,
+            name=f"SPECTRUM_{self._count:02d}",
+        )
+        errbars = pg.ErrorBarItem(
+            x=self.wvl, y=mean_spectrum, height=2 * err_spectrum, beam=10
+        )
+
+        self.spec_plot.addItem(spec_item)
+        self.spec_plot.addItem(errbars)
+        self.data_added.emit(spec_item, errbars)
+
+        spec_item.sigClicked.connect(
+            partial(self.edit_spectrum, spec_item, errbars)
+        )
+
+        name = spec_item.name()
+        if name is not None:
+            return name
+        else:
+            raise ValueError("Group Name is None")
+
+    def edit_spectrum(self, plot: pg.PlotDataItem, err: pg.ErrorBarItem):
+        if self._editing:
+            print(
+                "Close the current spectrum edit window to edit another"
+                " spectrum."
+            )
+            return
+        self._editing = True
+        current_color = plot.opts["pen"]
+        _pen = pg.mkPen({"color": "red"})
+        plot.setPen(_pen)
+
+        self.edit_win = SpectrumEditWindow(plot)
+        self.edit_win.show()
+
+        def rename_spectrum(old_name: str, new_name: str):
+            self.spec_legend.removeItem(plot)
+            self.spec_legend.addItem(plot, plot.name())
+            self.data_updated.emit(plot, err, old_name, new_name)
+
+        self.edit_win.name_changed.connect(rename_spectrum)
+
+        def delete_spectrum():
+            # self.state.current_spectra.remove(plot_curve)
+            self.spec_plot.removeItem(plot)
+            if err is not None:
+                self.spec_plot.removeItem(err)
+            self.edit_win.close()
+            self._editing = False
+            self.data_removed.emit(plot.name())
+
+        self.edit_win.spectrum_deleted.connect(delete_spectrum)
+
+        def close_window():
+            self.edit_win.close()
+            _pen = pg.mkPen(current_color)
+            plot.setPen(_pen)
+            self._editing = False
+
+        self.edit_win.closed.connect(close_window)
+
+    def handle_reset(self):
+        self._count = 0

pycubeview-0.1.0/src/pycubeview/spectral_viewing_window.py

@@ -0,0 +1,188 @@
+# Built-Ins
+from typing import Optional
+from tkinter.filedialog import askopenfilename
+
+# PyQt6 Imports
+from PyQt6 import QtWidgets as qtw
+from PyQt6 import QtGui
+from PyQt6 import QtCore
+
+# Dependencies
+from pyqtgraph.dockarea import Dock, DockArea  # type: ignore
+import numpy as np
+import pyqtgraph as pg  # type: ignore
+
+# Local Imports
+from .base_window import BaseWindow
+from .image_display_widget import ImagePickerWidget
+from .spectral_display_widget import SpectralDisplayWidget
+from .file_opening_utils import open_cube, open_wvl
+
+
+class CubeViewWindow(BaseWindow):
+    def __init__(
+        self,
+        wvl: Optional[np.ndarray | str] = None,
+        image_data: Optional[np.ndarray | str] = None,
+        cube_data: Optional[np.ndarray | str] = None,
+    ) -> None:
+        super().__init__()
+        self.polygon_cache: dict[str, qtw.QGraphicsPolygonItem | None] = {}
+
+        dock_area = DockArea()
+        self.setCentralWidget(dock_area)
+
+        # ---- Connecting menu actions to slots ----
+        self.open_display.triggered.connect(self.load_image)
+        self.open_cube.triggered.connect(self.load_cube)
+        self.clear_spectra.triggered.connect(self.empty_cache)
+
+        # ---- Image Dock ----
+        self.imview_dock = Dock(name="Image Window")
+        dock_area.addDock(self.imview_dock, "top")
+
+        self.img_picker = ImagePickerWidget()
+        self.imview_dock.addWidget(self.img_picker)
+
+        # ---- Spectral Display Dock ----
+        self.spec_dock = Dock(name="Spectral Display Window")
+        dock_area.addDock(self.spec_dock, "bottom")
+
+        self.spectral_display = SpectralDisplayWidget()
+        self.spec_dock.addWidget(self.spectral_display)
+
+        # ---- Linking Image and Spectral Display ----
+        def intercept_pixel_coord(y: int, x: int):
+            spectrum_name = self.spectral_display.add_spectrum((y, x))
+            self.polygon_cache[spectrum_name] = None
+
+        def cache_spectrum(
+            plot: pg.PlotDataItem, err: pg.ErrorBarItem
+        ) -> None:
+            name = plot.name()
+            if name is None:
+                return
+            self.state.spectrum_cache[name] = (plot, err)
+            n_cached = len(self.state.spectrum_cache)
+            self.clear_spectra.setStatusTip(
+                f"Clear {n_cached} spectra from memory."
+            )
+
+        def update_cache(
+            plot: pg.PlotDataItem,
+            err: pg.ErrorBarItem,
+            old_name: str,
+            new_name: str,
+        ):
+            del self.state.spectrum_cache[old_name]
+            self.state.spectrum_cache[new_name] = (plot, err)
+            self.polygon_cache[new_name] = self.polygon_cache.pop(old_name)
+
+        def intercept_roi(in_coords: np.ndarray, verts: np.ndarray):
+            group_name = self.spectral_display.add_group(in_coords)
+            pts = [QtCore.QPointF(*verts[n, :]) for n in range(verts.shape[0])]
+            poly = QtGui.QPolygonF(pts)
+            poly_item = qtw.QGraphicsPolygonItem(poly)
+            poly_item.setPen(pg.mkPen("k", width=2))
+            poly_item.setBrush(QtGui.QBrush(QtGui.QColor(255, 0, 0, 30)))
+            self.polygon_cache[group_name] = poly_item
+            self.img_picker.imview.getView().addItem(poly_item)
+
+        def remove_spectrum(name):
+            poly = self.polygon_cache[name]
+            if poly is not None:
+                self.img_picker.imview.getView().removeItem(poly)
+
+            del self.polygon_cache[name]
+            del self.state.spectrum_cache[name]
+
+            self.clear_spectra.setStatusTip(
+                f"Clear {len(self.state.spectrum_cache)} spectra from memory."
+            )
+
+        # Image Picker Connections
+        self.img_picker.pixel_picked.connect(intercept_pixel_coord)
+        self.img_picker.lasso_finished.connect(intercept_roi)
+
+        # Spectral Display Connections
+        self.spectral_display.data_added.connect(cache_spectrum)
+        self.spectral_display.data_updated.connect(update_cache)
+        self.spectral_display.data_removed.connect(remove_spectrum)
+
+        # Status Bar Connections
+        def cursor_message(x: float, y: float, val: float) -> None:
+            if x == -999 and y == -999 and val == -999:
+                self.status_bar.clearMessage()
+                return
+            self.status_bar.showMessage(
+                f"x={x:.1f}   y={y:.1f}   value={val:.5f}"
+            )
+
+        self.img_picker.mouse_moved.connect(cursor_message)
+
+        if isinstance(image_data, np.ndarray):
+            self.set_window_size(image_data)
+            self.set_image(image_data)
+        else:
+            self.resize(600, 600)
+
+        if isinstance(wvl, np.ndarray) and isinstance(cube_data, np.ndarray):
+            self.set_cube(wvl, cube_data)
+
+        if isinstance(image_data, str):
+            arr = open_cube(image_data)
+            self.set_image(arr)
+
+        if isinstance(wvl, str) and isinstance(cube_data, str):
+            arr = open_cube(cube_data)
+            wvl_arr = open_wvl(wvl)
+            self.set_cube(wvl_arr, arr)
+
+    def load_image(self) -> None:
+        fp = askopenfilename(
+            title="Select Image Data",
+            filetypes=[
+                ("Spectral Cube Files", [".spcub", ".geospcub"]),
+                ("Rasterio-Compatible Files", [".bsq", ".img", ".tif"]),
+            ],
+        )
+        arr = open_cube(fp)
+        self.set_image(arr)
+
+    def load_cube(self) -> None:
+        cube_fp = askopenfilename(
+            title="Select Cube Data",
+            filetypes=[
+                ("Spectral Cube Files", [".spcub", ".geospcub"]),
+                ("Rasterio-Compatible Files", [".bsq", ".img", ".tif"]),
+            ],
+        )
+        wvl_fp = askopenfilename(
+            title="Select Wavelength (or other context) Data",
+            filetypes=[
+                ("Wavelength File", [".wvl"]),
+                ("ENVI Header File", [".hdr"]),
+                ("Text-Based Files", [".txt", ".csv"]),
+            ],
+        )
+        arr = open_cube(cube_fp)
+        wvl = open_wvl(wvl_fp)
+        self.set_cube(wvl, arr)
+
+    def set_image(self, data: np.ndarray) -> None:
+        self.img_picker.set_image(data)
+        self.set_window_size(data)
+
+    def set_cube(self, wvl: np.ndarray, data: np.ndarray) -> None:
+        self.spectral_display.set_cube(wvl, data)
+
+    def empty_cache(self) -> None:
+        for plot, err in self.state.spectrum_cache.values():
+            self.spectral_display.spec_plot.removeItem(plot)
+            self.spectral_display.spec_plot.removeItem(err)
+            self.spectral_display.spec_legend.removeItem(plot)
+        for poly in self.polygon_cache.values():
+            if poly is None:
+                continue
+            self.img_picker.imview.getView().removeItem(poly)
+        self.spectral_display.plot_reset.emit()

pycubeview-0.1.0/src/pycubeview/spectrum_edit_window.py

@@ -0,0 +1,45 @@
+from PyQt6 import QtWidgets as qtw
+from PyQt6.QtCore import pyqtSignal
+from pyqtgraph.graphicsItems.PlotDataItem import PlotDataItem  # type: ignore
+
+
+class SpectrumEditWindow(qtw.QWidget):
+    name_changed = pyqtSignal(str, str)
+    spectrum_deleted = pyqtSignal()
+    closed = pyqtSignal()
+
+    def __init__(self, edit_spec: PlotDataItem):
+        super().__init__()
+
+        self.edit_spec = edit_spec
+        layout = qtw.QVBoxLayout()
+
+        layout.addWidget(qtw.QLabel("Spectrum Name:"))
+
+        self.line_edit_widget = qtw.QLineEdit()
+        self.line_edit_widget.setMaxLength(80)
+        self.line_edit_widget.setPlaceholderText(f"{self.edit_spec.name()}")
+        self.line_edit_widget.returnPressed.connect(self.set_spectrum_name)
+
+        layout.addWidget(self.line_edit_widget)
+
+        delete_button = qtw.QPushButton("Delete Spectrum")
+        delete_button.pressed.connect(self.delete_spectrum)
+        layout.addWidget(delete_button)
+
+        self.setLayout(layout)
+        self.setWindowTitle("Spectrum Editor")
+
+    def set_spectrum_name(self):
+        new_name = self.line_edit_widget.text()
+        old_name = self.edit_spec.opts["name"]
+        self.edit_spec.opts["name"] = new_name
+        self.name_changed.emit(old_name, new_name)
+
+    def delete_spectrum(self):
+        self.spectrum_deleted.emit()
+
+    def closeEvent(self, a0):
+        self.closed.emit()
+        if a0 is not None:
+            a0.accept()