astrocolor 0.1.0__tar.gz

astrocolor-0.1.0/LICENSE.txt

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

astrocolor-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: astrocolor
+Version: 0.1.0
+Summary: Library to perform spectral reconstruction, calculate synthetic photometry and colors.
+Author: Askaniy Anpilogov
+Author-email: Askaniy Anpilogov <aaskaniy@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: scipy>=1.17.1
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/Askaniy/AstroColor
+Project-URL: Repository, https://github.com/Askaniy/AstroColor
+Project-URL: Issues, https://github.com/Askaniy/AstroColor/issues
+Project-URL: Changelog, https://github.com/Askaniy/AstroColor/releases
+Description-Content-Type: text/markdown
+
+# AstroColor
+
+A Python library for converting between photometric systems, true color calculation, and space image processing.
+
+It performs synthetic photometry on low-resolution (5-nm wavelength grid step) spectra as well as spectral reconstruction from measurements in filters based on Tikhonov regularization.
+
+**Pre-alpha version! Do not use!**
+
+
+## Installation
+
+Use AstroColor in a virtual environment:
+```sh
+python3 -m venv .venv
+.venv/bin/pip install git+https://github.com/Askaniy/AstroColor.git
+```
+
+Or add AstroColor to your [uv](https://github.com/astral-sh/uv) project:
+```sh
+uv add git+https://github.com/Askaniy/AstroColor.git
+```
+
+
+## Key features
+
+- Calculate synthetic photometry
+```py
+import astrocolor as ac
+
+spectrum = ac.Spectrum(
+    wavelength_nm=[400, 500, 600, 700],
+    spectral_dist=[1, 2, 2, 1]
+)
+v_band = ac.Filter.get('Generic_Bessell.V')
+flux_value, flux_error = ac.observe(spectrum, v_band)
+```
+
+- Create a filter system
+```py
+johnson_system = ac.FilterSet.get(
+    'Generic_Bessell.B',
+    'Generic_Bessell.V',
+    'Generic_Bessell.R'
+)
+photospectrum_BVR = ac.observe(spectrum, johnson_system)
+```
+
+- Reconstruct photometry measurements into a smooth spectrum
+```py
+reconstructed = ac.spectral_reconstruction(photospectrum_BVR, requested_wavelengths=[400, 700])
+```
+
+- Convert measurements directly between photometric systems
+```py
+sloan_system = ac.FilterSet.get('SLOAN_SDSS.g', 'SLOAN_SDSS.r')
+photospectrum_gr = ac.observe(photospectrum_BVR, sloan_system)
+```
+
+- Work on your wavelengths
+```py
+custom_filter_set = ac.Filter.monochromatic(656.279) | ac.Filter.monochromatic(486.135)
+```
+
+- Calculate true colors
+```py
+color_xyz = ac.ColorPoint.from_spectral_data(ac.sun_CALSPEC)
+color_system = ac.ColorSystem('sRGB', 'Illuminant E') # recommended
+color_rgb = color_xyz.to_color_system(color_system)
+color_rgb.maximize_brightness = True
+color_html = color_rgb.to_html()
+```
+
+- Model spectra
+```py
+bb_3000K = ac.BlackBodyModel(3000).determine_at_wavelengths([400, 700])
+```
+
+- Process images via spectral cube reconstruction
+```py
+# coming soon after debugging
+```
+
+- Error propagation with covariance matrices
+```py
+# coming soon after debugging
+```
+
+
+
+## History
+
+[TrueColorTools](https://github.com/Askaniy/TrueColorTools) were created in 2020 to resolve disputes regarding the color of celestial bodies.
+It features a graphical user interface and a user-expandable spectral database.
+Over time, the core of the program became self-contained enough to be spun off into a library.
+The refactoring took place in 2026; it opens up a general astronomical application.
+
+
+## For developers
+
+Use `uv sync --group dev` to set the environment and build the library.
+Use `uv run pytest` for testing.
+Use `\dev` folder for local experiments.
+
+Any changes suggested by AI must be thoroughly reviewed by the person who generated them. The responsibility always lies with the person.

astrocolor-0.1.0/README.md

@@ -0,0 +1,104 @@
+# AstroColor
+
+A Python library for converting between photometric systems, true color calculation, and space image processing.
+
+It performs synthetic photometry on low-resolution (5-nm wavelength grid step) spectra as well as spectral reconstruction from measurements in filters based on Tikhonov regularization.
+
+**Pre-alpha version! Do not use!**
+
+
+## Installation
+
+Use AstroColor in a virtual environment:
+```sh
+python3 -m venv .venv
+.venv/bin/pip install git+https://github.com/Askaniy/AstroColor.git
+```
+
+Or add AstroColor to your [uv](https://github.com/astral-sh/uv) project:
+```sh
+uv add git+https://github.com/Askaniy/AstroColor.git
+```
+
+
+## Key features
+
+- Calculate synthetic photometry
+```py
+import astrocolor as ac
+
+spectrum = ac.Spectrum(
+    wavelength_nm=[400, 500, 600, 700],
+    spectral_dist=[1, 2, 2, 1]
+)
+v_band = ac.Filter.get('Generic_Bessell.V')
+flux_value, flux_error = ac.observe(spectrum, v_band)
+```
+
+- Create a filter system
+```py
+johnson_system = ac.FilterSet.get(
+    'Generic_Bessell.B',
+    'Generic_Bessell.V',
+    'Generic_Bessell.R'
+)
+photospectrum_BVR = ac.observe(spectrum, johnson_system)
+```
+
+- Reconstruct photometry measurements into a smooth spectrum
+```py
+reconstructed = ac.spectral_reconstruction(photospectrum_BVR, requested_wavelengths=[400, 700])
+```
+
+- Convert measurements directly between photometric systems
+```py
+sloan_system = ac.FilterSet.get('SLOAN_SDSS.g', 'SLOAN_SDSS.r')
+photospectrum_gr = ac.observe(photospectrum_BVR, sloan_system)
+```
+
+- Work on your wavelengths
+```py
+custom_filter_set = ac.Filter.monochromatic(656.279) | ac.Filter.monochromatic(486.135)
+```
+
+- Calculate true colors
+```py
+color_xyz = ac.ColorPoint.from_spectral_data(ac.sun_CALSPEC)
+color_system = ac.ColorSystem('sRGB', 'Illuminant E') # recommended
+color_rgb = color_xyz.to_color_system(color_system)
+color_rgb.maximize_brightness = True
+color_html = color_rgb.to_html()
+```
+
+- Model spectra
+```py
+bb_3000K = ac.BlackBodyModel(3000).determine_at_wavelengths([400, 700])
+```
+
+- Process images via spectral cube reconstruction
+```py
+# coming soon after debugging
+```
+
+- Error propagation with covariance matrices
+```py
+# coming soon after debugging
+```
+
+
+
+## History
+
+[TrueColorTools](https://github.com/Askaniy/TrueColorTools) were created in 2020 to resolve disputes regarding the color of celestial bodies.
+It features a graphical user interface and a user-expandable spectral database.
+Over time, the core of the program became self-contained enough to be spun off into a library.
+The refactoring took place in 2026; it opens up a general astronomical application.
+
+
+## For developers
+
+Use `uv sync --group dev` to set the environment and build the library.
+Use `uv run pytest` for testing.
+Use `\dev` folder for local experiments.
+
+Any changes suggested by AI must be thoroughly reviewed by the person who generated them. The responsibility always lies with the person.

astrocolor-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["uv_build>=0.11.20,<0.12.0"]
+build-backend = "uv_build"
+
+[project]
+name = "astrocolor"
+version = "0.1.0"
+description = "Library to perform spectral reconstruction, calculate synthetic photometry and colors."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+authors = [
+    { name = "Askaniy Anpilogov", email = "aaskaniy@gmail.com" },
+]
+requires-python = ">=3.12"
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+dependencies = [
+    "numpy>=2.4.4",
+    "scipy>=1.17.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/Askaniy/AstroColor"
+Repository = "https://github.com/Askaniy/AstroColor"
+Issues = "https://github.com/Askaniy/AstroColor/issues"
+Changelog = "https://github.com/Askaniy/AstroColor/releases"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "src/astrocolor/tests"]

astrocolor-0.1.0/src/astrocolor/__init__.py

@@ -0,0 +1,39 @@
+from .spectral_objects import Spectrum, SpectralSet, SpectralCube
+from .photospectral_objects import Photospectrum, PhotospectralSet, PhotospectralCube
+from .spectral_reconstruction import (
+    ReconstructedSpectrum,
+    ReconstructedSpectralSet,
+    ReconstructedSpectralCube,
+    spectral_reconstruction,
+)
+from .filter_objects import Filter, FilterSet
+from .convolution import observe, scale_spectrum
+from .color import ColorSystem, ColorPoint, ColorLine, ColorImage, visible_range
+from .physical_models import sun_CALSPEC, vega_CALSPEC, BlackBodyModel
+
+
+# API namespace
+__all__ = (
+    'Spectrum',
+    'SpectralSet',
+    'SpectralCube',
+    'Photospectrum',
+    'PhotospectralSet',
+    'PhotospectralCube',
+    'ReconstructedSpectrum',
+    'ReconstructedSpectralSet',
+    'ReconstructedSpectralCube',
+    'spectral_reconstruction',
+    'Filter',
+    'FilterSet',
+    'observe',
+    'scale_spectrum',
+    'ColorSystem',
+    'ColorPoint',
+    'ColorLine',
+    'ColorImage',
+    'visible_range',
+    'sun_CALSPEC',
+    'vega_CALSPEC',
+    'BlackBodyModel'
+)

astrocolor-0.1.0/src/astrocolor/algebra.py

@@ -0,0 +1,101 @@
+import numpy as np
+import numpy.typing as npt
+
+
+
+def make_same_ndim(arr1: npt.ArrayLike, arr2: npt.ArrayLike):
+    """ Equalizes the arrays dimensions along spatial axes to make it possible to broadcast """
+    arr1 = np.asarray(arr1)
+    arr2 = np.asarray(arr2)
+    if (ndim_delta := arr2.ndim - arr1.ndim) != 0:
+        if ndim_delta > 0:
+            arr1 = arr1.reshape(arr1.shape + (1,)*ndim_delta)
+        else:
+            arr2 = arr2.reshape(arr2.shape + (1,)*(-ndim_delta))
+    return arr1, arr2
+
+
+# 1. Addition
+
+def add_value(mean_x, mean_y):
+    mean_x, mean_y = make_same_ndim(mean_x, mean_y)
+    return mean_x + mean_y
+
+def add_error(mean_x, cov_x, mean_y, cov_y):
+    if cov_x is None:
+        return cov_y
+    elif cov_y is None:
+        return cov_x
+    else:
+        cov_x, cov_y = make_same_ndim(cov_x, cov_y)
+        return cov_x + cov_y
+
+
+# 2. Subtraction
+
+def sub_value(mean_x, mean_y):
+    mean_x, mean_y = make_same_ndim(mean_x, mean_y)
+    return mean_x - mean_y
+
+def sub_error(mean_x, cov_x, mean_y, cov_y):
+    return add_error(mean_x, cov_x, mean_y, cov_y)
+
+
+# 3. Multiplication
+
+@staticmethod
+def mul_value(mean_x, mean_y):
+    try:
+        # Numeric and same-ndim numpy arrays cases
+        return mean_x * mean_y
+    except ValueError:
+        # Different ndim case
+        mean_x = np.asarray(mean_x)
+        mean_y = np.asarray(mean_y)
+        if mean_y.ndim > mean_x.ndim:
+            mean_x, mean_y = mean_y, mean_x
+        return (mean_x.T * mean_y).T
+
+def mul_error(mean_x, cov_x, mean_y, cov_y):
+    if cov_x is None and cov_y is None:
+        return None
+    else:
+        n = mean_x.shape[0]
+        cov_z = np.zeros((n, n)) # TODO: fix the case of x.ndim != y.ndim
+        if cov_x is not None:
+            diag_y = np.diag(mean_y)
+            cov_z += diag_y @ cov_x @ diag_y
+        if cov_y is not None:
+            diag_x = np.diag(mean_x)
+            cov_z += diag_x @ cov_y @ diag_x
+        return cov_z
+
+
+# 4. Division
+
+@staticmethod
+def div_value(mean_x, mean_y):
+    try:
+        # Numeric and same-ndim numpy arrays cases
+        return mean_x / mean_y
+    except ValueError:
+        # Different ndim case
+        mean_x = np.asarray(mean_x)
+        mean_y = np.asarray(mean_y)
+        if mean_y.ndim > mean_x.ndim:
+            mean_x, mean_y = mean_y, mean_x
+        return (mean_x.T / mean_y).T
+
+def div_error(mean_x, cov_x, mean_y, cov_y):
+    if cov_x is None and cov_y is None:
+        return None
+    else:
+        n = mean_x.shape[0]
+        cov_z = np.zeros((n, n)) # TODO: fix the case of x.ndim != y.ndim
+        if cov_x is not None:
+            cov_z += cov_x
+        if cov_y is not None:
+            diag_z = np.diag(div_value(mean_x, mean_y))
+            cov_z += diag_z @ cov_y @ diag_z
+        diag_y_inv = np.diag(1 / mean_y)
+        return diag_y_inv @ cov_z @ diag_y_inv