space-ska 1.0__tar.gz

space_ska-1.0/LICENSE

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

space_ska-1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: space-ska
+Version: 1.0
+Summary: Spectral-Kit for Asteroids
+License: MIT
+Author: Benoit Carry
+Author-email: benoit.carry@oca.eu
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: docs
+Requires-Dist: astropy (>=6.0.1,<7.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.1,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Description-Content-Type: text/markdown
+
+# ska - Spectral-Kit for Asteroids
+
+Suites of tools to compute colors from spectra or reflectance spectra using the
+[SVO Filter Service](http://svo2.cab.inta-csic.es/theory/fps/index.php?mode=voservice)
+in different photometric system: Vega, AB, ST.
+
+

space_ska-1.0/README.md

@@ -0,0 +1,6 @@
+# ska - Spectral-Kit for Asteroids
+
+Suites of tools to compute colors from spectra or reflectance spectra using the
+[SVO Filter Service](http://svo2.cab.inta-csic.es/theory/fps/index.php?mode=voservice)
+in different photometric system: Vega, AB, ST.
+

space_ska-1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[tool.poetry]
+name = "space-ska"
+version = "1.0"
+description = "Spectral-Kit for Asteroids"
+authors = ["Benoit Carry <benoit.carry@oca.eu>", "Max Mahlke"]
+license = "MIT"
+readme = "README.md"
+packages = [{'include' = 'ska'}]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+requests = "^2.31.0"
+pandas = "^2.2.1"
+click = "^8.1.7"
+rich = "^13.7.1"
+astropy = "^6.0.1"
+numpy = "^1.26.4"
+
+
+[tool.poetry.extras]
+docs = [
+  "furo",
+  "sphinx",
+  "sphinx-copybutton",
+  "sphinx-hoverxref",
+  "sphinx-redactor-theme",
+  "spinx_design"
+]
+
+[tool.poetry.scripts]
+ska = "ska.cli:cli_ska"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

space_ska-1.0/ska/__init__.py

@@ -0,0 +1,25 @@
+"""Spectral-Kit for Asteroids."""
+
+import os
+
+from .filter import Filter  # noqa
+from .spectrum import Spectrum  # noqa
+from . import svo  # noqa
+from .cache import download_sun_vega  # noqa
+
+__version__ = "1.0.0"
+
+# Cache location
+PATH_CACHE = os.path.join(os.path.expanduser("~"), ".cache/ska")
+os.makedirs(PATH_CACHE, exist_ok=True)
+
+# SKA Auxiliary data
+PATH_VEGA = os.path.join(PATH_CACHE, "spectrum_vega.csv")
+PATH_SUN = os.path.join(PATH_CACHE, "spectrum_sun.csv")
+PATH_FILTER_LIST = os.path.join(PATH_CACHE, "svo_filters.txt")
+
+if not os.path.isfile(PATH_FILTER_LIST):
+    svo.download_filter_list()
+
+if not os.path.isfile(PATH_VEGA) or not os.path.isfile(PATH_SUN):
+    download_sun_vega()

space_ska-1.0/ska/cache.py

@@ -0,0 +1,88 @@
+"""Cache management for ska"""
+
+import os
+import glob
+import requests
+
+import ska
+
+
+# ------
+# Functions for cache management
+def clear():
+    """Remove the cached filters and the acceptable list"""
+
+    filter_ids, filter_files = take_inventory()
+
+    # Remove cached filters
+    for f in filter_files:
+        os.unlink(os.path.join(ska.PATH_CACHE, f))
+
+    # Remove list of SVO Filters
+    os.unlink(os.path.join(ska.PATH_CACHE, "svo_filters.txt"))
+
+
+def take_inventory():
+    """Create lists of the cached filter VOTables.
+
+    Returns
+    -------
+    list of str
+        The path to the cached VOTables.
+    """
+
+    # Get all XML in cache
+    cached_xmls = set(
+        file_ for file_ in glob.glob(os.path.join(ska.PATH_CACHE, "*.xml"))
+    )
+    cached_ids = set(
+        os.path.basename(FILT).replace("_", "/")[:-4] for FILT in cached_xmls
+    )
+
+    return cached_ids, cached_xmls
+
+
+def update_filter_list():
+    # TBD doc / handle issue
+    ska.svo.download_filter_list()
+
+
+def update_filters(ids, force=False):
+    """Update the cached filters (VOTable files).
+
+    Parameters
+    ----------
+    ids : list
+        List of SVO IDs corresponding to the filters to update.
+    """
+
+    # Download filters
+    for f in ids:
+        ska.svo.download_filter(f, force=force)
+
+
+# Get Vega and Sun
+def download_sun_vega():
+    """Download the spectra of the Sun and Vega"""
+
+    try:
+
+        # Get Solar Spectrum
+        r = requests.get(
+            "https://raw.githubusercontent.com/bcarry/ska/main/data/hst_sun.csv"
+        )
+        with open(ska.PATH_SUN, "w") as file:
+            file.write(r.text)
+
+        # Get Vega Spectrum
+        r = requests.get(
+            "https://raw.githubusercontent.com/bcarry/ska/main/data/lte096-4.0-0.5a%2B0.0.BT-NextGen.7.dat.csv"
+        )
+
+        with open(ska.PATH_VEGA, "w") as file:
+            file.write(r.text)
+
+        return True
+
+    except:
+        return False

space_ska-1.0/ska/cli.py

@@ -0,0 +1,214 @@
+import os
+import sys
+
+import click
+import rich
+
+import ska
+
+
+@click.group()
+@click.version_option(version=ska.__version__, message="%(version)s")
+def cli_ska():
+    """CLI for Spectral-Kit for Asteroids."""
+    pass
+
+
+# --------------------------------------------------------------------------------
+# Status
+@cli_ska.command()
+@click.option(
+    "--clear",
+    "-c",
+    help="Clear cached filters and update the filter list.",
+    is_flag=True,
+)
+@click.option(
+    "--update", "-u", help="Update cached filters and filter list.", is_flag=True
+)
+def status(clear, update):
+    """Echo the status of the cached filters."""
+    from rich import prompt
+
+    from ska import cache
+
+    # ------
+    # Check filter list
+    if not os.path.isfile(ska.PATH_FILTER_LIST):
+        ska.svo.download_filter_list()
+
+    # ------
+    # Echo inventory
+    cached_ids, cached_xmls = cache.take_inventory()
+
+    rich.print(
+        f"""\nContents of {ska.PATH_CACHE}:
+
+        {len(cached_xmls)} filters\n"""
+    )
+
+    # Update or clear
+    if cached_xmls:
+        if not clear and not update:
+            decision = prompt.Prompt.ask(
+                "Update or clear the cached filters and filter list?\n"
+                "[blue][0][/blue] No "
+                "[blue][1][/blue] Clear cache "
+                "[blue][2][/blue] Update data ",
+                choices=["0", "1", "2"],
+                show_choices=False,
+                default="0",
+            )
+        else:
+            decision = "none"
+
+        if clear or decision == "1":
+            rich.print("\nClearing the cached filters and filter list..")
+            cache.clear()
+
+        elif update or decision == "2":
+            rich.print(cached_ids)
+            rich.print("\nDownload filters from SVO Filter Service..")
+            cache.update_filters(cached_ids, force=True)
+
+
+# --------------------------------------------------------------------------------
+# Fuzzy search among filters ID
+@cli_ska.command()
+def id():
+    """Fuzzy-search SVO filter index."""
+
+    import shutil
+    import subprocess
+
+    PATH_EXECUTABLE = shutil.which("fzf")
+
+    if PATH_EXECUTABLE is None:
+        rich.print(
+            "Interactive selection is not possible as the fzf tool is not installed.\n"
+        )
+        sys.exit()
+
+    FZF_OPTIONS = []
+
+    # Open fzf subprocess
+    process = subprocess.Popen(
+        [shutil.which("fzf"), *FZF_OPTIONS],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=None,
+    )
+
+    FILTERS = ska.svo.load_filter_list()
+    for filter in FILTERS:
+        line = filter.encode(sys.getdefaultencoding()) + b"\n"
+        process.stdin.write(line)
+        process.stdin.flush()
+
+    # Run process and wait for user selection
+    process.stdin.close()
+    process.wait()
+
+    # Extract selected line
+    try:
+        choice = [line for line in process.stdout][0].decode()
+        filt = ska.Filter(choice.strip())
+        filt.display_summary()
+
+    except IndexError:  # no choice was made, c-c c-c
+        sys.exit()
+    return choice
+
+
+# --------------------------------------------------------------------------------
+# Color computation
+@cli_ska.command()
+@click.argument("file")
+@click.argument("filter1")
+@click.argument("filter2")
+@click.option(
+    "--phot_sys", default="Vega", help="Photometric system: Vega (default) | ST | AB"
+)
+@click.option(
+    "--reflectance",
+    "-r",
+    is_flag=True,
+    default=False,
+    help="Multiply the input reflectance by Solar spectrum.",
+)
+def color(file, filter1, filter2, phot_sys, reflectance):
+    """Compute the color between two filters"""
+
+    import pandas as pd
+
+    # TBD: interactive selection filters with fzf
+
+    # Load filters
+    f_1 = ska.Filter(filter1)
+    f_2 = ska.Filter(filter2)
+
+    # Read spectrum
+    spectrum = ska.Spectrum(file)
+
+    # Compute color
+    if reflectance:
+        color = spectrum.reflectance_to_color(f_1, f_2, phot_sys=phot_sys)
+        # color = skatools.reflectance_to_color(spectrum, f_1, f_2, phot_sys=phot_sys)
+    else:
+        color = spectrum.compute_color(f_1, f_2, phot_sys=phot_sys)
+        # color = skatools.compute_color(spectrum, f_1, f_2, phot_sys=phot_sys)
+    click.echo(f"{color:4.2f}")
+
+
+# --------------------------------------------------------------------------------
+# Solar Colors
+@cli_ska.command()
+@click.argument("filter1")
+@click.argument("filter2")
+@click.option(
+    "--phot_sys",
+    default="Vega",
+    help="Photometric system ([green]Vega[/green] | ST | AB)",
+)
+def solarcolor(filter1, filter2, phot_sys):
+    """Compute the color of the Sun between two filters"""
+
+    # Load filters
+    f_1 = ska.Filter(filter1)
+    f_2 = ska.Filter(filter2)
+
+    # Compute color
+    color = f_1.solar_color(f_2, phot_sys=phot_sys)
+    click.echo(f"{color:4.2f}")
+
+
+# --------------------------------------------------------------------------------
+# Filter basic information
+@cli_ska.command()
+@click.argument("filter")
+def filter(filter):
+    """Display the basic properties of the filter"""
+
+    f = ska.Filter(filter)
+    f.display_summary()
+
+
+# --------------------------------------------------------------------------------
+# Plot filter transmission
+@cli_ska.command()
+@click.argument("filter")
+@click.option("--figure", default=None, help="Name of the figure")
+@click.option(
+    "--black", default=False, is_flag=True, help="Figure with a dark background"
+)
+def plot(filter, figure, black):
+    """Display the basic properties of the filter"""
+
+    f = ska.Filter(filter)
+
+    import matplotlib.pyplot as plt
+
+    fig, ax = f.plot_transmission(figure, black=black)
+
+    if not "figure" in locals():
+        plt.show()

space_ska-1.0/ska/filter.py

@@ -0,0 +1,248 @@
+import os
+import sys
+from astropy.io.votable import parse
+import numpy as np
+import pandas as pd
+
+import rich
+
+import ska
+
+
+class Filter:
+    # --------------------------------------------------------------------------------
+    def __init__(self, id):
+        """Load a filter.
+
+        Parameters
+        ----------
+        id : str
+            The filter unique ID (see SVO filter service)
+        """
+
+        # Test validity of filters
+        FILTERS = ska.svo.load_filter_list()
+        if id not in FILTERS:
+            rich.print(
+                f"[red]Unknown filter ID {id}[/red]. Use [green]ska filter[/green] command to list available filters"
+            )
+            sys.exit(1)
+            # raise ValueError(f"Unknown filter ID {id}. Use [green]ska filter[/green] to list available filters")
+
+        self.id = id
+        self.path = os.path.join(ska.PATH_CACHE, f"{self.id.replace('/','_')}.xml")
+
+        # Download if not cached
+        if not os.path.isfile(self.path):
+            ska.svo.download_filter(self.id)
+
+        # Parse filter response
+        self.VOFilter = parse(self.path)
+        data = pd.DataFrame(data=self.VOFilter.get_first_table().array.data)
+
+        # Select non-zero transmission and convert to micron
+        data = data[data.Transmission >= 1e-5]
+        data.Wavelength /= 1e4  # to micron
+
+        # Store attributes
+        self.id = id
+        self.wave = data.Wavelength
+        self.trans = data.Transmission
+        self.central_wavelength = (
+            self.VOFilter.get_field_by_id("WavelengthCen").value / 1e4
+        )
+        self.FWHM = self.VOFilter.get_field_by_id("FWHM").value / 1e4
+        self.pivot_wavelength = (
+            self.VOFilter.get_field_by_id("WavelengthPivot").value / 1e4
+        )
+
+        try:
+            self.facility = self.VOFilter.get_field_by_id("Facility").value
+        except:
+            self.facility = None
+
+        try:
+            self.instrument = self.VOFilter.get_field_by_id("Instrument").value
+        except:
+            self.instrument = None
+
+        try:
+            self.band = self.VOFilter.get_field_by_id("Band").value
+        except:
+            self.band = None
+
+    # --------------------------------------------------------------------------------
+    def display_summary(self):
+        import rich
+
+        rich.print(f"\n[bright_cyan]Filter ID :[/bright_cyan] {self.id}")
+
+        if self.facility is not None:
+            rich.print(f"[bright_cyan]Facility  :[/bright_cyan] {self.facility:s}")
+
+        if self.instrument is not None:
+            rich.print(f"[bright_cyan]Instrument:[/bright_cyan] {self.instrument:s}")
+
+        if self.band is not None:
+            rich.print(f"[bright_cyan]Band      :[/bright_cyan] {self.band:s}")
+
+        rich.print(
+            f"[bright_cyan]Central λ :[/bright_cyan] [green]{self.central_wavelength:.3f}[/green] [bright_cyan](micron)[/bright_cyan]"
+        )
+        rich.print(
+            f"[bright_cyan]FWHM      :[/bright_cyan] [green]{self.FWHM:.3f}[/green] [bright_cyan](micron)[/bright_cyan]"
+        )
+        rich.print(
+            f"[bright_cyan]Pivot λ   :[/bright_cyan] [green]{self.pivot_wavelength:.3f}[/green] [bright_cyan](micron)[/bright_cyan]"
+        )
+
+    # --------------------------------------------------------------------------------
+    def compute_flux(self, spectrum):
+        """Computes the flux of a spectrum in a given band.
+
+        Parameters
+        ----------
+        spectrum : pd.DataFrame
+            Wavelength: in Angstrom
+            Flux: Flux density (erg/cm2/s/ang)
+
+        Returns
+        -------
+        float
+            The computed mean flux density
+        """
+
+        # Wavelength range to integrate over
+        lambda_int = np.arange(self.wave.min(), self.wave.max(), 0.0005)
+
+        # Detector type
+        # Photon counter
+        if self.VOFilter.get_field_by_id("DetectorType") == 1:
+            factor = lambda_int
+        # Energy counter
+        else:
+            factor = lambda_int * 0 + 1
+
+        # Interpolate over the transmission range
+        interpol_transmission = np.interp(lambda_int, self.wave, self.trans)
+
+        interpol_spectrum = np.interp(lambda_int, spectrum.Wavelength, spectrum.Flux)
+
+        # Compute the flux by integrating over wavelength.
+        nom = np.trapz(
+            interpol_spectrum * interpol_transmission * factor,
+            lambda_int,
+        )
+        denom = np.trapz(interpol_transmission * factor, lambda_int)
+        flux = nom / denom
+        return flux
+
+    # --------------------------------------------------------------------------------
+    def solar_color(self, filter, phot_sys="Vega", vega=None):
+        """Compute the color of the Sun between current and provided filter
+
+        Parameters
+        ==========
+        filter: str
+            The filter unique ID (see SVO filter service)
+
+        phot_sys : str
+            Photometric system in which to report the color (default=AB)
+
+        vega : ska.Spectrum
+
+        Returns
+        =======
+        float
+            The solar color
+        """
+        if not isinstance(filter, ska.Filter):
+            filter = ska.Filter(filter)
+
+        # Extract Solar Fluxes
+        sun_1 = self.VOFilter.get_field_by_id("Fsun").value
+        sun_2 = filter.VOFilter.get_field_by_id("Fsun").value
+
+        # Convert to magnitude
+        mag_1 = -2.5 * np.log10(sun_1)
+        mag_2 = -2.5 * np.log10(sun_2)
+        colorST = mag_1 - mag_2
+
+        # Solar color in ST photometric system
+        if phot_sys == "ST":
+            return colorST
+
+        # Solar color in Vega photometric system
+        elif phot_sys == "Vega":
+            # Read Vega spectrum if not provided
+            if not "vega" in locals():
+                vega = ska.Spectrum(ska.PATH_VEGA)
+            else:
+                if not isinstance(vega, ska.Spectrum):
+                    vega = ska.Spectrum(ska.PATH_VEGA)
+
+            # Compute color of Vega
+            vega_ST = vega.compute_color(self, filter, phot_sys="ST")
+            return colorST - vega_ST
+
+        # Solar color in ST photometric system
+        else:
+            pivot_1 = self.VOFilter.get_field_by_id("WavelengthPivot").value
+            pivot_2 = filter.VOFilter.get_field_by_id("WavelengthPivot").value
+            return colorST - 5 * np.log10(pivot_1 / pivot_2)
+
+    # --------------------------------------------------------------------------------
+    def plot_transmission(self, figure=None, black=False):
+        """Create a plot of the transmission.
+
+        Parameters
+        ----------
+        figure : str
+            Path to save a figure
+
+        Returns
+        -------
+        figure, axe
+            Matplotlib figure and axe
+        """
+
+        # Define figure
+        import matplotlib.pyplot as plt
+
+        if black:
+            plt.style.use("dark_background")
+        else:
+            plt.style.use("default")
+        fig, ax = plt.subplots()
+
+        # Plot transmission
+        ax.plot(self.wave, self.trans, label=self.id)
+
+        # Central wavelength and FWHM
+        ax.axvline(
+            self.central_wavelength,
+            color="gray",
+            linestyle="--",
+            label=r"$\lambda_c$ = {:.2f} $\mu$m".format(self.central_wavelength),
+        )
+        ax.plot(
+            self.central_wavelength + self.FWHM / 2 * np.array([-1, 1]),
+            [self.trans.max() / 2, self.trans.max() / 2],
+            linestyle="dotted",
+            color="gray",
+            label=r"FWHM = {:.2f} $\mu$m".format(self.FWHM),
+        )
+
+        # Add labels
+        ax.set_xlabel("Wavelength (micron)")
+        ax.set_ylabel("Transmission")
+        ax.legend(loc="lower right")
+        ax.set_ylim(bottom=0)
+        fig.tight_layout()
+
+        # Save to file
+        if figure is not None:
+            # fig.savefig(figure, dpi=180, facecolor="w", edgecolor="w")
+            fig.savefig(figure, dpi=180)
+
+        return fig, ax

space_ska-1.0/ska/spectrum.py

@@ -0,0 +1,243 @@
+import os
+import sys
+
+import numpy as np
+import pandas as pd
+
+import rich
+import ska
+
+
+class Spectrum:
+    # --------------------------------------------------------------------------------
+    def __init__(self, input=None):
+        """ """
+
+        # Store attributes
+        self.Wavelength = None
+        self.Flux = None
+        self.Reflectance = False
+
+        if "input" in locals():
+
+            # Initialize from a file
+            if isinstance(input, str):
+                self.from_csv(input)
+
+            # Initialize from a numpy.ndarray
+            if isinstance(input, np.ndarray):
+                self.from_numpy(input)
+
+            # Initialize from a pandas.DataFrame
+            if isinstance(input, pd.DataFrame):
+                self.from_dataframe(input)
+
+    # --------------------------------------------------------------------------------
+    def copy(self):
+        from copy import deepcopy
+
+        return deepcopy(self)
+
+    # --------------------------------------------------------------------------------
+    def from_csv(self, file):
+        if not os.path.isfile(file):
+            rich.print(f"[red]Spectrum file {file} not found.[/red].")
+            sys.exit(1)
+
+        # Read spectrum
+        try:
+            spectrum = pd.read_csv(file)
+        except:
+            rich.print(f"[red]Cannot read spectrum file {file}.[/red].")
+            sys.exit(1)
+
+        self.from_dataframe(spectrum)
+
+    # --------------------------------------------------------------------------------
+    def from_numpy(self, arr, reflectance=False):
+        if not isinstance(arr, np.ndarray):
+            rich.print(f"[red]Input is not a numpy array.[/red]")
+            sys.exit(1)
+
+        if arr.shape[1] < 2:
+            rich.print(f"[red]Input array has less than 2 columns.[/red]")
+            sys.exit(1)
+
+        # Store attributes
+        order = np.argsort(arr[:, 0])
+        self.Wavelength = arr[order, 0]
+        self.Flux = arr[order, 1]
+        self.Reflectance = reflectance
+
+    # --------------------------------------------------------------------------------
+    def from_dataframe(self, df):
+
+        # Test Wavelength column
+        check_wave = True
+        if not "Wavelength" in df.columns:
+            check_wave = False
+            rich.print(f"[red]Column 'Wavelength' missing from input.[/red]")
+
+        # Test Flux or Reflectance column
+        check_flux = True
+        check_refl = True
+        if not "Flux" in df.columns:
+            check_flux = False
+        if not "Reflectance" in df.columns:
+            check_refl = False
+
+        if not (check_flux | check_refl):
+            rich.print(f"[red]Column 'Flux' or 'Reflectance' missing from input.[/red]")
+            sys.exit(1)
+
+        if not (check_wave & (check_flux | check_refl)):
+            sys.exit(1)
+
+        # Store attributes
+        order = np.argsort(df.Wavelength)
+        self.Wavelength = np.array(df.loc[order, "Wavelength"].values)
+        if check_flux:
+            self.Flux = np.array(df.loc[order, "Flux"].values)
+        if check_refl:
+            self.Flux = np.array(df.loc[order, "Reflectance"].values)
+            self.Reflectance = True
+
+    # --------------------------------------------------------------------------------
+    def compute_color(self, filter1, filter2, phot_sys="Vega", vega=None):
+        """Computes filter_1-filter_2 color of spectrum in the requested system.
+
+        Parameters
+        ==========
+        filter_1: ska.Filter
+
+        filter_2: ska.Filter
+
+        phot_sys : str
+            Photometric system in which to report the color (default=Vega)
+
+        vega : ska.Spectrum
+            The spectrum of Vega
+
+        Returns
+        =======
+        float
+            The requested color
+        """
+
+        # Compute fluxes in each filter
+        flux1 = filter1.compute_flux(self)
+        flux2 = filter2.compute_flux(self)
+
+        # Magnitude in AB photometric system
+        if phot_sys == "AB":
+            # Get Pivot wavelength for both filters
+            pivot_1 = filter1.VOFilter.get_field_by_id("WavelengthPivot").value
+            pivot_2 = filter2.VOFilter.get_field_by_id("WavelengthPivot").value
+
+            # Compute and return the color
+            return -2.5 * np.log10(flux1 / flux2) - 5 * np.log10(pivot_1 / pivot_2)
+
+        # Magnitude in Vega photometric system
+        elif phot_sys == "Vega":
+            # Read Vega spectrum if not provided
+            if vega is None:
+                vega = ska.Spectrum(ska.PATH_VEGA)
+
+            # Compute fluxes of Vega in each filter
+            flux1_vega = filter1.compute_flux(vega)
+            flux2_vega = filter2.compute_flux(vega)
+
+            # Compute and return the color
+            return -2.5 * (np.log10(flux1 / flux1_vega) - np.log10(flux2 / flux2_vega))
+
+        # Magnitude in ST photometric system
+        elif phot_sys == "ST":
+            return -2.5 * np.log10(flux1 / flux2)
+
+    # --------------------------------------------------------------------------------
+    def reflectance_to_flux(self, sun=None):
+        """Convert reflectance to flux by multiply by Solar spectrum.
+
+        Parameters
+        ==========
+        sun : ska.Spectrum
+            Spectrum of the Sun
+
+        Returns
+        =======
+        ska.Spectrum
+            A copy of the input Spectrum, in flux units
+        """
+
+        # Test if the input is a reflectance spectrum
+        if not self.Reflectance:
+            rich.print(f"[red]Input spectrum is not a reflectance spectrum.[/red]")
+
+        # Read spectrum of the Sun if not provided
+        if not isinstance(sun, ska.Spectrum):
+            sun = ska.Spectrum(ska.PATH_SUN)
+
+        # Interpolate spectrum of the Sun
+        interpol_spectrum = np.interp(self.Wavelength, sun.Wavelength, sun.Flux)
+
+        # Mulitply reflectance by Solar spectrum
+        spectrum = self.copy()
+        spectrum.Flux = self.Flux * interpol_spectrum
+        spectrum.Reflectance = False
+        return spectrum
+
+    # --------------------------------------------------------------------------------
+    def reflectance_to_color(
+        self, filter1, filter2, phot_sys="Vega", vega=None, sun=None
+    ):
+        """Computes filter_1-filter_2 color for a reflectance spectrum.
+
+        Parameters
+        ==========
+        filter_1: ska.Filter
+
+        filter_2: ska.Filter
+
+        phot_sys : str
+            Photometric system in which to report the color (default=Vega)
+
+        vega : ska.Spectrum
+            Spectrum of Vega
+
+        sun : ska.Spectrum
+            Spectrum of the Sun
+
+        Returns
+        =======
+        float
+            The requested color
+        """
+
+        # Integration grid is built from the transmission curve
+        lambda_min = np.min([filter1.wave.min(), filter2.wave.min()])
+        lambda_max = np.max([filter1.wave.max(), filter2.wave.max()])
+
+        # Wavelength range to integrate over
+        lambda_int = np.arange(lambda_min, lambda_max, 0.0005)
+
+        # Read spectrum of the Sun if not provided
+        if not isinstance(sun, ska.Spectrum):
+            sun = ska.Spectrum(ska.PATH_SUN)
+
+        # Interpolate spectrum of the Sun
+        interpol_spectrum = np.interp(lambda_int, sun.Wavelength, sun.Flux)
+        interp_sun = pd.DataFrame({"Wavelength": lambda_int, "Flux": interpol_spectrum})
+        interp_sun = interp_sun.astype("float")
+
+        # Interpolate reflectance spectrum
+        interpol_spectrum = np.interp(lambda_int, self.Wavelength, self.Flux)
+        interp_spectrum = ska.Spectrum(
+            pd.DataFrame(
+                {"Wavelength": lambda_int, "Flux": interpol_spectrum * interp_sun.Flux}
+            )
+        )
+
+        # Compute color of the reflectance*Sun spectrum
+        return interp_spectrum.compute_color(
+            filter1, filter2, phot_sys=phot_sys, vega=vega
+        )

space_ska-1.0/ska/svo.py

@@ -0,0 +1,118 @@
+import io
+import os
+import sys
+import requests
+from astropy.io.votable import parse
+import rich
+
+import ska
+
+
+def download_filter_list():
+    """Retrieve the list of filter IDs from SVO Filter Service
+    http://svo2.cab.inta-csic.es/theory/fps/
+
+    Returns
+    =======
+    list
+        The list of filter IDS
+    """
+
+    try:
+
+        # Main SVO filter list
+        r = requests.get(
+            "https://svo.cab.inta-csic.es/files/svo/Public/HowTo/FPS/FPS_info.xml"
+        )
+        SVOFilters = parse(io.BytesIO(r.content))
+        main_id = SVOFilters.get_first_table().to_table().to_pandas().filterID.to_list()
+
+        # Secondary SVO filter list
+        r = requests.get(
+            "https://svo.cab.inta-csic.es/files/svo/Public/HowTo/FPS/others.xml"
+        )
+        SVOFilters = parse(io.BytesIO(r.content))
+        other_id = SVOFilters.get_first_table().to_table().to_pandas()["__ID"].to_list()
+
+        # Merge and Write to disk
+        filter_id = main_id + other_id
+        with open(ska.PATH_FILTER_LIST, "w") as file:
+            for f in filter_id:
+                file.write(f"{f}\n")
+        return True
+
+    except:
+        # raise Exception("Error downloading filter list")
+        rich.print(f"[red]Error downloading filter {id} VOTable[/red].")
+        return False
+
+
+def load_filter_list():
+    """Read all filter IDs from a cache list
+
+    Returns
+    =======
+    list
+        The list of filter IDS
+
+    """
+    if not os.path.isfile(ska.PATH_FILTER_LIST):
+        download_filter_list()
+
+    with open(ska.PATH_FILTER_LIST, "r") as file:
+        FILTERS = [filt.strip() for filt in file]
+    return FILTERS
+
+
+def download_filter(id, force=False):
+    """Download a filter VOTable from SVO Filter Service
+    http://svo2.cab.inta-csic.es/theory/fps/index.php?mode=voservice
+
+    Parameters
+    ==========
+    id : str
+        The unique SVO filter identifier to be downloaded
+
+    force : bool
+        If True, the filter VOTable will be downloaded even if it is already cached
+
+    Returns
+    =======
+    str
+        The path to the filter VOTable file
+    """
+
+    # Test if the filter ID is valid
+    FILTERS = load_filter_list()
+    if id not in FILTERS:
+        rich.print(
+            f"[red]Unknown filter ID {id}[/red]. Use [green]ska filter[/green] to list available filters"
+        )
+        sys.exit(1)
+        # raise ValueError(f"Unknown filter ID {id}. Use ska filter to list available filters")
+
+    # SVO Base URL for queries
+    url = f"http://svo2.cab.inta-csic.es/theory/fps3/fps.php?"
+
+    # Output name for the filter VOTable
+    out = os.path.join(ska.PATH_CACHE, id.replace("/", "_") + ".xml")
+
+    # Download VOTable
+    if (not os.path.isfile(out)) or force:
+        try:
+            # Request the filter VOTable
+            r = requests.get(url, params={"ID": id})
+            SVOFilter = parse(io.BytesIO(r.content))
+            filter_info = SVOFilter.get_first_table()
+
+            # Write it to disk
+            # os.makedirs(ska.PATH_CACHE, exist_ok=True)
+            SVOFilter.to_xml(out)
+
+        except:
+            rich.print(f"[red]Error downloading filter {id} VOTable[/red].")
+            sys.exit(1)
+            # raise Exception("Error downloading filter VOTable")
+
+    # Return path to filter VOTable
+    return out