diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..e4995c3 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,8 @@ +# This is a comment. +# Each line is a file pattern followed by one or more owners. + +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence, +# these owners will be requested for +# review when someone opens a pull request. +* @ceb8 @scfleming diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..1a218f5 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,15 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates + +version: 2 +updates: + - package-ecosystem: "github-actions" # See documentation for possible values + directory: ".github/workflows" # Location of package manifests + schedule: + interval: "monthly" + groups: + actions: + patterns: + - "*" diff --git a/.github/workflows/black.yml b/.github/workflows/black.yml new file mode 100644 index 0000000..81e6a94 --- /dev/null +++ b/.github/workflows/black.yml @@ -0,0 +1,10 @@ +name: Lint + +on: [push, pull_request] + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: psf/black@stable diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 94b6d5a..085dd5c 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -4,8 +4,11 @@ on: push: branches: - main + - py311 tags: pull_request: + branches: + - main jobs: tests: @@ -16,47 +19,106 @@ jobs: matrix: include: - - name: Python 3.8.13 with minimal dependencies - os: ubuntu-latest - python: 3.8.13 - toxenv: py38-test + - name: Python 3.9.xx with minimal dependencies + os: ubuntu-latest + python: 3.9.21 + toxenv: py39-test + + - name: Python 3.9.xx with all optional dependencies + os: ubuntu-latest + python: 3.9.21 + toxenv: py39-test-alldeps + toxargs: -v --develop + toxposargs: -W error::ResourceWarning + + - name: Python 3.9.xx with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.9.21 + toxenv: py39-test-alldeps-numpy124-cov - - name: Python 3.8.13 with all optional dependencies + - name: Python 3.10.xx with minimal dependencies os: ubuntu-latest - python: 3.8.13 - toxenv: py38-test-alldeps - toxargs: -v --develop - toxposargs: --open-files - -# - name: Python 3.9.0 with all optional dependencies (Windows) -# os: windows-latest -# python: 3.9.0 -# toxenv: py38-test-alldeps - -# - name: Python 3.8.13 with all optional dependencies (MacOS X) -# os: macos-latest -# python: 3.8.13 -# toxenv: py38-test-alldeps + python: 3.10.16 + toxenv: py310-test + + - name: Python 3.10.xx with all optional dependencies + os: ubuntu-latest + python: 3.10.16 + toxenv: py310-test-alldeps + toxargs: -v --develop + toxposargs: -W error::ResourceWarning + + - name: Python 3.10.xx with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.10.16 + toxenv: py310-test-alldeps-numpy124-cov + + - name: Python 3.10.xx with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.10.16 + toxenv: py310-test-alldeps-numpy210-cov + + - name: Python 3.11.xx with minimal dependencies + os: ubuntu-latest + python: 3.11.11 + toxenv: py311-test + + - name: Python 3.11.xx with all optional dependencies + os: ubuntu-latest + python: 3.11.11 + toxenv: py311-test-alldeps + toxargs: -v --develop + toxposargs: -W error::ResourceWarning + + - name: Python 3.11.xx with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.11.11 + toxenv: py311-test-alldeps-numpy124-cov + + - name: Python 3.11.xx with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.11.11 + toxenv: py311-test-alldeps-numpy210-cov + + - name: Python 3.12.xx with minimal dependencies + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test + + - name: Python 3.12.xx with all optional dependencies + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test-alldeps + toxargs: -v --develop + toxposargs: -W error::ResourceWarning + + - name: Python 3.12.xx with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test-alldeps-numpy210-cov steps: - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0 with: python-version: ${{ matrix.python }} - name: Install language-pack-de and tzdata if: startsWith(matrix.os, 'ubuntu') run: sudo apt-get install language-pack-de tzdata + - name: Install pyo dependencies + if: startsWith(matrix.os, 'ubuntu') + run: sudo apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev - name: Install Python dependencies run: python -m pip install --upgrade tox codecov sphinx_rtd_theme - name: Run tests run: tox ${{ matrix.toxargs }} -e ${{ matrix.toxenv }} -- ${{ matrix.toxposargs }} - name: Upload coverage to codecov if: ${{ contains(matrix.toxenv,'-cov') }} - uses: codecov/codecov-action@v2 + uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673 # v4.5.0 with: file: ./coverage.xml @@ -68,23 +130,26 @@ jobs: matrix: include: - - name: Code style checks + - name: (Allowed Failure) Python 3.11 with dev version of key dependencies os: ubuntu-latest - python: 3.x - toxenv: codestyle + python: 3.11 + toxenv: py311-test-devdeps steps: - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0 with: python-version: ${{ matrix.python }} - name: Install language-pack-de and tzdata if: startsWith(matrix.os, 'ubuntu') run: sudo apt-get install language-pack-de tzdata + - name: Install pyo dependencies + if: startsWith(matrix.os, 'ubuntu') + run: sudo apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev - name: Install Python dependencies run: python -m pip install --upgrade tox codecov sphinx_rtd_theme - name: Run tests diff --git a/.gitignore b/.gitignore index 9b73111..c91ac51 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ __pycache__ *.c # Other generated files +notebooks/miles_stellar_spectra */version.py */cython_version.py htmlcov diff --git a/.readthedocs.yml b/.readthedocs.yml index 91be621..b65ecd4 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -1,15 +1,23 @@ version: 2 build: - image: latest + os: "ubuntu-24.04" + tools: + python: "3.11" + apt_packages: + - portaudio19-dev + - libsndfile1-dev + - libportmidi-dev + - liblo-dev python: - version: 3.7 install: - method: pip path: . extra_requirements: - docs - all + - requirements: docs/requirements.txt -formats: [] +sphinx: + configuration: docs/conf.py diff --git a/CHANGES.rst b/CHANGES.rst index e2c090a..353bc48 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,7 +1,10 @@ -0.2 (unreleased) +0.11 (2025-01-31) ---------------- -- No changes yet +- Fixes installation via pypi, confirmed to work with modern Python + (e.g., 3.11, 3.12), updated installation instructions and tips, + infrastructure improvements in CI, fixes automated documentation + builds, added __version__. 0.1 (2020-11-25) ---------------- diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..fd76fd3 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,20 @@ +cff-version: 1.1.0 +message: "Please cite the following works when using this software: https://ui.adsabs.harvard.edu/abs/2024ascl.soft08005B" +authors: +- family-names: Brasseur + given-names: C. E. +- family-names: Fleming + given-names: S. +- family-names: Kotler + given-names: J. +- family-names: Meredith + given-names: K. +title: "Astronify: Astronomical data sonification" +version: 0.11 +date-released: 2025-01-31 +identifiers: + - type: "ascl-id" + value: "2408.005" + - type: "bibcode" + value: "2024ascl.soft08005B" +abstract: "Astronify contains tools for sonifying astronomical data, specifically data series. Data series sonification takes a data table and maps one column to time, and one column to pitch. This technique is commonly used to sonify light curves, where observation time is scaled to listening time and flux is mapped to pitch. While Astronify’s sonification uses the columns “time” and “flux” by default, any two columns can be supplied and a sonification created." diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst new file mode 100644 index 0000000..e480ed7 --- /dev/null +++ b/DEVELOPER_DOC.rst @@ -0,0 +1,104 @@ +Developer Documentation +----------------------- + +This documentation is intended for code maintainers and developers as a guide, especially when preparing to merge and release a new version of the code. + +Installation +^^^^^^^^^^^^ + +.. code-block:: bash + + $ git clone https://github.com/spacetelescope/astronify.git + $ cd astronify + $ pip install . + +For active development, install in develop mode + +.. code-block:: bash + + $ pip install -e . + + +Testing +^^^^^^^ +Testing is run with `tox `_ (``pip install tox``). +Tests can be found in ``tests/`` sub-directories. + +.. code-block:: bash + + $ tox -e test + +Tests can also be run directly with pytest: + +.. code-block:: bash + + $ pip install -e .[test] + $ pytest + + +Documentation +^^^^^^^^^^^^^ + +Documentation files are found in ``docs/``. + +We build the documentation with `tox `_ (``pip install tox``): + +.. code-block:: bash + + $ tox -e build_docs + +You can also build the documentation with Sphinx directly using: + +.. code-block:: bash + + $ cd docs + $ sphinx-build -M html . _build/ + +The built docs will be in ``docs/_build/html/``, to view them go to ``file://docs/_build/html/index.html`` in the browser of your choice. + + +Release Protocol +^^^^^^^^^^^^^^^^ + +TO-BE-FINALIZED + +- Update the ``ci_workflows.yml`` under ``.github/workflows/`` to + remove any inactive branches and add your new development branch, + under the ``push`` section towards the top of the file. + +- Update the __init__.py file under the "astronify/" folder to update + the __version__ variable to match the upcoming release version. This + should be specified as a string. + +- Update the version information and release date in the CITATION.cff + file, located in the top-level directory to match the upcoming release version. + +- Update the "CHANGES.rst" file to add the new version, release date, + and summary of what's changing in this version. + +- Make a final commit to the branch, doing things like double checking + Python versions, release dates, spell check documentation files, + etc. Commit the final release with: + +.. code-block:: bash + + $ git commit -m "Preparing release " + +- Tag the commit with the version, using the "v' in front of the tag, + even if the version in the __init__.py file does not. + +.. code-block:: bash + + $ git tag -a v -m "Release version " + +- Make sure the `build` package is up-to-date: + +.. code-block:: bash + + $ python -m build --sdist --outdir dist . + +- Twine upload. + +.. code-block:: bash + + twine upload dist/ diff --git a/README.rst b/README.rst index d41f6c1..4df06cc 100644 --- a/README.rst +++ b/README.rst @@ -16,6 +16,10 @@ Sonification of astronomical data. .. image:: https://readthedocs.org/projects/astronify/badge/?version=latest :target: https://astronify.readthedocs.io/en/latest/?badge=latest :alt: Documentation Status + +.. image:: https://img.shields.io/badge/ascl-2408.005-blue.svg?colorB=262255 + :target: https://ascl.net/2408.005 + :alt: ascl:2408.005 Tools for sonifying astronomical data. @@ -33,74 +37,19 @@ Project Status :target: https://codecov.io/gh/spacetelescope/astronify :alt: Astronify's Codecov coverage status -Developer Documentation ------------------------ - -Installation -^^^^^^^^^^^^ - -.. code-block:: bash - - $ git clone https://github.com/spacetelescope/astronify.git - $ cd astronify - $ pip install . - -For active development, install in develop mode - -.. code-block:: bash - - $ pip install -e . - - -Testing -^^^^^^^ -Testing is run with `tox `_ (``pip install tox``). -Tests can be found in ``tests/`` sub-directories. - -.. code-block:: bash - - $ tox -e test - -Tests can also be run directly with pytest: - -.. code-block:: bash - - $ pip install -e .[test] - $ pytest - - - -Documentation -^^^^^^^^^^^^^ - -Documentation files are found in ``docs/``. - -We build the documentation with `tox `_ (``pip install tox``): - -.. code-block:: bash - - $ tox -e build_docs - -You can also build the documentation with Sphinx directly using: - -.. code-block:: bash - - $ pip install -e .[docs] - $ cd docs - $ make html - -The built docs will be in ``docs/_build/html/``, to view them go to ``file:///path/to/astronify/repo/docs/_build/html/index.html`` in the browser of your choice. - - -Release Protocol -^^^^^^^^^^^^^^^^ - -Follow the `Astropy template release instructions `_. +Getting Started +--------------- +Install instructions: https://astronify.readthedocs.io/en/latest/astronify/install.html +Tutorials: https://astronify.readthedocs.io/en/latest/astronify/tutorials.html Contributing ------------ +If you are a maintainer of the code, refer to the developer +documentation (DEVELOPER_DOC.rst file) for guidelines on how to release a +new version. + We love contributions! Astronify is open source, built on open source, and we'd love to have you hang out in our community. diff --git a/astronify/__init__.py b/astronify/__init__.py index 4419fcb..eb1eef6 100644 --- a/astronify/__init__.py +++ b/astronify/__init__.py @@ -4,12 +4,12 @@ # Packages may add whatever they like to this file, but # should keep this content at the top. # ---------------------------------------------------------------------------- -from ._astropy_init import * # noqa -# ---------------------------------------------------------------------------- - +from ._astropy_init import * # noqa -from . import series # noqa -from . import simulator # noqa +# ---------------------------------------------------------------------------- +from . import series # noqa +from . import simulator # noqa from . import utils # noqa -__all__ = ['series', 'simulator', 'utils'] # noqa +__all__ = ["series", "simulator", "utils"] # noqa +__version__ = "0.11" diff --git a/astronify/_astropy_init.py b/astronify/_astropy_init.py index fa37a63..8c1ddc7 100644 --- a/astronify/_astropy_init.py +++ b/astronify/_astropy_init.py @@ -1,18 +1,19 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst -__all__ = ['__version__'] +__all__ = ["__version__"] # this indicates whether or not we are in the package's setup.py try: _ASTROPY_SETUP_ except NameError: import builtins + builtins._ASTROPY_SETUP_ = False try: from .version import version as __version__ except ImportError: - __version__ = '' + __version__ = "" if not _ASTROPY_SETUP_: # noqa @@ -20,6 +21,7 @@ # Create the test function for self test from astropy.tests.runner import TestRunner + test = TestRunner.make_test_runner_in(os.path.dirname(__file__)) test.__test__ = False - __all__ += ['test'] + __all__ += ["test"] diff --git a/astronify/conftest.py b/astronify/conftest.py index 672b273..c23b24e 100644 --- a/astronify/conftest.py +++ b/astronify/conftest.py @@ -8,13 +8,15 @@ from astropy.version import version as astropy_version # For Astropy 3.0 and later, we can use the standalone pytest plugin -if astropy_version < '3.0': +if astropy_version < "3.0": from astropy.tests.pytest_plugins import * # noqa + del pytest_report_header ASTROPY_HEADER = True else: try: from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS + ASTROPY_HEADER = True except ImportError: ASTROPY_HEADER = False @@ -28,13 +30,15 @@ def pytest_configure(config): # Customize the following lines to add/remove entries from the list of # packages for which version numbers are displayed when running the tests. - PYTEST_HEADER_MODULES.pop('Pandas', None) - PYTEST_HEADER_MODULES['scikit-image'] = 'skimage' + PYTEST_HEADER_MODULES.pop("Pandas", None) + PYTEST_HEADER_MODULES["scikit-image"] = "skimage" from . import __version__ + packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = __version__ + # Uncomment the last two lines in this block to treat all DeprecationWarnings as # exceptions. For Astropy v2.0 or later, there are 2 additional keywords, # as follow (although default should work for most cases). diff --git a/astronify/series/series.py b/astronify/series/series.py index 98e737f..b49ba6c 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -11,23 +11,25 @@ from inspect import signature, Parameter import numpy as np - +from scipy import stats from astropy.table import Table, MaskedColumn from astropy.time import Time +import matplotlib.pyplot as plt + import pyo from ..utils.pitch_mapping import data_to_pitch from ..utils.exceptions import InputWarning -__all__ = ['PitchMap', 'SoniSeries'] +__all__ = ["PitchMap", "SoniSeries"] -class PitchMap(): +class PitchMap: def __init__(self, pitch_func=data_to_pitch, **pitch_args): """ - Class that encapsulates the data value to pitch function + Class that encapsulates the data value to pitch function and associated arguments. Parameters @@ -36,22 +38,23 @@ def __init__(self, pitch_func=data_to_pitch, **pitch_args): Optional. Defaults to `~astronify.utils.data_to_pitch`. If supplying a function it should take a data array as the first parameter, and all other parameters should be optional. - **pitch_args + **pitch_args Default parameters and values for the pitch function. Should include all necessary arguments other than the data values. """ # Setting up the default arguments if (not pitch_args) and (pitch_func == data_to_pitch): - pitch_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "median", - "stretch": "linear"} - + pitch_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "median", + "stretch": "linear", + } + self.pitch_map_func = pitch_func self.pitch_map_args = pitch_args - def _check_func_args(self): """ Make sure the pitch mapping function and argument dictionary match. @@ -62,11 +65,15 @@ def _check_func_args(self): if hasattr(self, "pitch_map_func") and hasattr(self, "pitch_map_args"): # Only check parameters if there is no kwargs argument - param_types = [x.kind for x in signature(self.pitch_map_func).parameters.values()] + param_types = [ + x.kind for x in signature(self.pitch_map_func).parameters.values() + ] if Parameter.VAR_KEYWORD not in param_types: for arg_name in list(self.pitch_map_args): if arg_name not in signature(self.pitch_map_func).parameters: - wstr = "{} is not accepted by the pitch mapping function and will be ignored".format(arg_name) + wstr = "{} is not accepted by the pitch mapping function and will be ignored".format( + arg_name + ) warnings.warn(wstr, InputWarning) del self.pitch_map_args[arg_name] @@ -80,7 +87,7 @@ def __call__(self, data): @property def pitch_map_func(self): """ - The pitch mapping function. + The pitch mapping function. """ return self._pitch_map_func @@ -100,15 +107,16 @@ def pitch_map_args(self): @pitch_map_args.setter def pitch_map_args(self, new_args): - assert isinstance(new_args, dict), "Pitch mapping function args must be in a dictionary." + assert isinstance( + new_args, dict + ), "Pitch mapping function args must be in a dictionary." self._pitch_map_args = new_args self._check_func_args() - -class SoniSeries(): +class SoniSeries: - def __init__(self, data, time_col="time", val_col="flux"): + def __init__(self, data, time_col="time", val_col="flux", preview_type="scan"): """ Class that encapsulates a sonified data series. @@ -120,17 +128,26 @@ def __init__(self, data, time_col="time", val_col="flux"): Optional, default "time". The data column to be mapped to time. val_col : str Optional, default "flux". The data column to be mapped to pitch. + preview_type : str + Optional, default "scan". The mode of preview/gist sonification to + make, choice of "ensemble" or "scan". Ensemble means each section + is assigned a different pitch, played separately, then all sections + are played together at the end. Scan means each section is assigned + to the same pitch value, played separately, and no combined sound + is made at the end. """ self.time_col = time_col self.val_col = val_col self.data = data + self.preview_type = preview_type # Default specs self.note_duration = 0.5 # note duration in seconds self.note_spacing = 0.01 # spacing between notes in seconds - self.gain = 0.05 # default gain in the generated sine wave. pyo multiplier, -1 to 1. + # default gain in the generated sine wave. pyo multiplier, -1 to 1. + self.gain = 0.05 self.pitch_mapper = PitchMap(data_to_pitch) - + self.preview_object = SeriesPreviews(self) self._init_pyo() def _init_pyo(self): @@ -139,24 +156,12 @@ def _init_pyo(self): @property def data(self): - """ The data table (~astropy.table.Table). """ + """The data table (~astropy.table.Table).""" return self._data @data.setter def data(self, data_table): - - if not isinstance(data_table, Table): - raise TypeError('Data must be an astropy.table.Table object.') - - for c in list(data_table.columns): - data_table.rename_column(c, c.lower()) - - - if self.time_col not in data_table.columns: - raise AttributeError(f"Input Table must contain time column '{self.time_col}'") - - if self.val_col not in data_table.columns: - raise AttributeError(f"Input Table must contain a value column '{self.val_col}'") + assert isinstance(data_table, Table), "Data must be a Table." # Removing any masked values as they interfere with the sonification if isinstance(data_table[self.val_col], MaskedColumn): @@ -172,32 +177,32 @@ def data(self, data_table): float_col = "asf_time" data_table[float_col] = data_table[self.time_col].jd self.time_col = float_col - + self._data = data_table @property def time_col(self): - """ The data column mappend to time when sonifying. """ + """The data column mappend to time when sonifying.""" return self._time_col @time_col.setter def time_col(self, value): - assert isinstance(value, str), 'Time column name must be a string.' + assert isinstance(value, str), "Time column name must be a string." self._time_col = value @property def val_col(self): - """ The data column mappend to putch when sonifying. """ + """The data column mappend to putch when sonifying.""" return self._val_col @val_col.setter def val_col(self, value): - assert isinstance(value, str), 'Value column name must be a string.' + assert isinstance(value, str), "Value column name must be a string." self._val_col = value @property def pitch_mapper(self): - """ The pitch mapping object that takes data values to pitch values (Hz). """ + """The pitch mapping object that takes data values to pitch values (Hz).""" return self._pitch_mapper @pitch_mapper.setter @@ -206,7 +211,7 @@ def pitch_mapper(self, value): @property def gain(self): - """ Adjustable gain for output. """ + """Adjustable gain for output.""" return self._gain @gain.setter @@ -215,7 +220,7 @@ def gain(self, value): @property def note_duration(self): - """ How long each individual note will be in seconds.""" + """How long each individual note will be in seconds.""" return self._note_duration @note_duration.setter @@ -225,20 +230,20 @@ def note_duration(self, value): @property def note_spacing(self): - """ The spacing of the notes on average (will adjust based on time) in seconds. """ + """The spacing of the notes on average (will adjust based on time) in seconds.""" return self._note_spacing @note_spacing.setter def note_spacing(self, value): # Add in min value check self._note_spacing = value - + def sonify(self): """ - Perform the sonification, two columns will be added to the data table: asf_pitch, and asf_onsets. + Perform the sonification, two columns will be added to the data table: asf_pitch, and asf_onsets. The asf_pitch column will contain the sonified data in Hz. The asf_onsets column will contain the start time for each note in seconds from the first note. - Metadata will also be added to the table giving information about the duration and spacing + Metadata will also be added to the table giving information about the duration and spacing of the sonified pitches, as well as an adjustable gain. """ data = self.data @@ -247,9 +252,14 @@ def sonify(self): data.meta["asf_exposure_time"] = exptime data.meta["asf_note_duration"] = self.note_duration data.meta["asf_spacing"] = self.note_spacing - + data["asf_pitch"] = self.pitch_mapper(data[self.val_col]) - data["asf_onsets"] = [x for x in (data[self.time_col] - data[self.time_col][0])/exptime*self.note_spacing] + data["asf_onsets"] = [ + x + for x in (data[self.time_col] - data[self.time_col][0]) + / exptime + * self.note_spacing + ] def play(self): """ @@ -270,23 +280,30 @@ def play(self): # TODO: This doesn't seem like the best way to do this, but I don't know # how to make it better - env = pyo.Linseg(list=[(0, 0), (0.01, 1), (duration - 0.1, 1), - (duration - 0.05, 0.5), (duration - 0.005, 0)], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) - - self.streams = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), - dur=duration) + env = pyo.Linseg( + list=[ + (0, 0), + (0.01, 1), + (duration - 0.1, 1), + (duration - 0.05, 0.5), + (duration - 0.005, 0), + ], + mul=[self.gain for i in range(len(pitches))], + ).play(delay=list(delays), dur=duration) + + self.streams = pyo.Sine(list(pitches), 0, env).out( + delay=list(delays), dur=duration + ) def stop(self): """ Stop playing the data sonification. """ - self.streams.stop() + self.streams.stop() def write(self, filepath): """ - Save data sonification to the given file. + Save data sonification to the given file. Currently the only output option is a wav file. Parameters @@ -306,16 +323,286 @@ def write(self, filepath): self.server.reinit(audio="offline") self.server.boot() - self.server.recordOptions(dur=delays[-1]+duration, filename=filepath) - - env = pyo.Linseg(list=[(0, 0), (0.1, 1), (duration - 0.1, 1), - (duration - 0.05, 0.5), (duration - 0.005, 0)], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) - sine = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), dur=duration) # noqa: F841 + self.server.recordOptions(dur=delays[-1] + duration, filename=filepath) + + env = pyo.Linseg( + list=[ + (0, 0), + (0.1, 1), + (duration - 0.1, 1), + (duration - 0.05, 0.5), + (duration - 0.005, 0), + ], + mul=[self.gain for i in range(len(pitches))], + ).play(delay=list(delays), dur=duration) + sine = pyo.Sine(list(pitches), 0, env).out( + delay=list(delays), dur=duration + ) # noqa: F841 self.server.start() # Clean up self.server.shutdown() self.server.reinit(audio="portaudio") + +class SeriesPreviews: + """ + Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. + """ + + def __init__(self, soniseries): + # Allows access to SoniSeries class methods and variables + self._soniseries = soniseries + # Define the frequencies to use for each section. + self.pitch_values = [500] * 5 + if self._soniseries.preview_type == "ensemble": + self.pitch_values = [300, 400, 500, 600, 700] + # TODO: Make robust + self.n_pitch_values = len(self.pitch_values) + # Amplitudes will be stored as a % between 0-1. + self.amplitudes = np.zeros(self.n_pitch_values) + # Tremolo values will be stored as a number, typically ranging from some small number + # (avoid 0.0, e.g., 0.1) through ~10. + self.tremolo_vals = np.zeros(self.n_pitch_values) + + def area_of_pieces(self, ydata_bins, xdata_bins): + """ + Given pieces of a series of 1D data, calculate the area-under-the-curve of each piece + such that the total area of all the pieces equals the total area of the entire curve. + """ + area_vals = [] + for idx, (ydata_bin, xdata_bin) in enumerate(zip(ydata_bins, xdata_bins)): + if idx < len(ydata_bins) - 1: + # Then you need to include the first (x,y) point from the NEXT bin as well + # when calculating the trapezoidal area so the pieces all add up to the total. + list(ydata_bin).append(ydata_bins[idx + 1][0]) + list(xdata_bin).append(xdata_bins[idx + 1][0]) + + # Taking the absolute value so that emission lines and absorption lines + # have the same amplitude + area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) + return area_vals + + def plot_preview(self, xdata_bin_ranges): + plt.plot( + self._soniseries.data[self._soniseries.time_col], + self._soniseries.data[self._soniseries.val_col], + color="k", + ) + + plt.axvspan( + xdata_bin_ranges[0][0], + xdata_bin_ranges[0][1], + color="royalblue", + alpha=0.5, + lw=0, + ) + + plt.axvspan( + xdata_bin_ranges[1][0], + xdata_bin_ranges[1][1], + color="green", + alpha=0.5, + lw=0, + ) + + plt.axvspan( + xdata_bin_ranges[2][0], + xdata_bin_ranges[2][1], + color="yellow", + alpha=0.5, + lw=0, + ) + + plt.axvspan( + xdata_bin_ranges[3][0], + xdata_bin_ranges[3][1], + color="orange", + alpha=0.5, + lw=0, + ) + + plt.axvspan( + xdata_bin_ranges[4][0], + xdata_bin_ranges[4][1], + color="red", + alpha=0.5, + lw=0, + ) + + plt.show() + + def sonify_preview(self, plotting=True, verbose=False): + """ + Make a "preview-style" sonification. The data is split into even pieces. Each piece + gets assigned a specific frequency. The amplitude is defined by the area under the curve + in this piece, normalized by the total area under the curve. The tremolo is defined + by the standard deviation of data in this piece, normalized by the maximum standard + deviation across all pieces. + """ + # Get a copy of the 'y' and 'x' data. + ydata = np.asarray(self._soniseries.data[self._soniseries.val_col]) + xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) + + # Normalize the y-data by the maximum to constrain values from 0-1. + ydata_norm = ydata / max(ydata) + + # Split the data into `n_pitch_values` equal-sized pieces. + bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) + # Split the y-values into pieces. + ydata_bins = [ + ydata_norm[i : i + bin_size] for i in range(0, len(ydata_norm), bin_size) + ] + # Split the x-values into pieces. + xdata_bins = [xdata[i : i + bin_size] for i in range(0, len(xdata), bin_size)] + + # Calculate the total area under the curve, used to normalize the areas in each piece. + total_area = np.trapz(ydata_norm, xdata) + + # Loop through each piece and calculate the standard deviation of the y-data + # and the area under the curve in each piece. + std_vals, xdata_bin_ranges = [], [] + for xdata_bin, ydata_bin in zip(xdata_bins, ydata_bins): + + xdata_bin_ranges.append((min(xdata_bin), max(xdata_bin))) + # Calculate standard deviation error and add to the list. + _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) + std_vals.append(std_err) + + # Plot the spectra and ranges if in troubleshooting mode + if plotting: + self.plot_preview(xdata_bin_ranges) + + # Calculate the area under the curve for each piece. + area_vals = self.area_of_pieces(ydata_bins, xdata_bins) + + # Normalize the standard deviations in each piece by this factor. + std_dev_norm = max(std_vals) + + # Set the amplitude of each pitch to the area under the curve normalized by the total + # area. + self.amplitudes = np.asarray(area_vals) / total_area + + if std_dev_norm == 0.0: + std_dev_norm = 1.0 + + # Set the tremolo values based on the standard deviation of the piece normalized by the + # `std_dev_norm` factor. + + # TODO: Might be worth trying a different way of calculating the tremolo values other + # than the normalized standard dev. Maybe using RMS vals? + # To more accurately represent all forms of data. + + # The final calculated tremolo values are multiplied by a factor of 10 for auditory + # purposes + self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm) * 10 + + # Constraint added to keep tremolo values at or below 15, otherwise oscillations are + # more difficult to hear + # self.tremolo_vals[self.tremolo_vals > 15] = 15 + + if verbose: + print("Total Expected area = {0:0f}".format(total_area)) + print(" ") + print("Area Values = ", np.asarray(area_vals)) + print(" ") + # print("Total Calculated area = {0:0f}".format(np.sum(str(area_vals).split(" ")))) + print(" ") + print("Amplitudes = ", self.amplitudes) + print(" ") + print("Standard Dev. Error Vals = ", np.asarray(std_vals)) + print(" ") + print("Standard Dev. Error MAX = ", std_dev_norm) + print(" ") + print("Tremolo Vals (x10) = ", self.tremolo_vals) + + def play_preview(self): + """Play the sound of a "preview-style" sonification. + + The assigned pitch for each section of the spectra will begin + to play, with the calculated amplitude and frequency, one + at a time until all pitches are playing together for the full + audio preview of the spectra. + """ + + if self._soniseries.server.getIsBooted(): + self._soniseries.server.shutdown() + + self._soniseries.server.boot() + self._soniseries.server.start() + + # TODO: Generalize the self.delays list + # `step` must go into `stop` 5 times, since we have 5 pitches + self.delays = [0.0, 2.0, 4.0, 6.0, 8.0] + + # `total_duration` is in seconds + self.total_duration = 8.0 + + self.amplitudes = [amp / max(self.amplitudes) for amp in self.amplitudes] + + a = pyo.Phasor(self.pitch_values[0], mul=np.pi * 2) + b = pyo.Phasor(self.pitch_values[1], mul=np.pi * 2) + c = pyo.Phasor(self.pitch_values[2], mul=np.pi * 2) + d = pyo.Phasor(self.pitch_values[3], mul=np.pi * 2) + e = pyo.Phasor(self.pitch_values[4], mul=np.pi * 2) + + # TODO: Make everything below iterable to it's cleaner and takes up less lines + lfo1 = ( + pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) + if self.tremolo_vals[0] > 0 + else pyo.Cos(a, mul=float(self.amplitudes[0])) + ) + lfo2 = ( + pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) + if self.tremolo_vals[1] > 0 + else pyo.Cos(b, mul=float(self.amplitudes[1])) + ) + lfo3 = ( + pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) + if self.tremolo_vals[2] > 0 + else pyo.Cos(c, mul=float(self.amplitudes[2])) + ) + lfo4 = ( + pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) + if self.tremolo_vals[3] > 0 + else pyo.Cos(d, mul=float(self.amplitudes[3])) + ) + lfo5 = ( + pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) + if self.tremolo_vals[4] > 0 + else pyo.Cos(e, mul=float(self.amplitudes[4])) + ) + + self.stream1 = pyo.Sine( + freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 + ).out(delay=self.delays[0], dur=2.0) + self.stream2 = pyo.Sine( + freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 + ).out(delay=self.delays[1], dur=2.0) + self.stream3 = pyo.Sine( + freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 + ).out(delay=self.delays[2], dur=2.0) + self.stream4 = pyo.Sine( + freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 + ).out(delay=self.delays[3], dur=2.0) + self.stream5 = pyo.Sine( + freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 + ).out(delay=self.delays[4], dur=2.0) + + # All together, if in ensemble mode. + if self._soniseries.preview_type == "ensemble": + self.stream6 = pyo.Sine( + freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 + ).out(delay=10, dur=4) + self.stream7 = pyo.Sine( + freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 + ).out(delay=10, dur=4) + self.stream8 = pyo.Sine( + freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 + ).out(delay=10, dur=4) + self.stream9 = pyo.Sine( + freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 + ).out(delay=10, dur=4) + self.stream10 = pyo.Sine( + freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 + ).out(delay=10, dur=4) diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index 0c4462f..6e8e8bd 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -13,29 +13,33 @@ def test_pitchmap(): """ Testing the PitchMap class. """ - + # Defaults my_pitchmapper = PitchMap() assert isinstance(my_pitchmapper.pitch_map_args, dict) assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() - assert my_pitchmapper.pitch_map_args["zero_point"] == 'median' + assert my_pitchmapper.pitch_map_args["zero_point"] == "median" # Change args - my_pitchmapper.pitch_map_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "mean", - "stretch": "linear", - "invert": True} + my_pitchmapper.pitch_map_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "mean", + "stretch": "linear", + "invert": True, + } assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() - assert my_pitchmapper.pitch_map_args["zero_point"] == 'mean' + assert my_pitchmapper.pitch_map_args["zero_point"] == "mean" with pytest.warns(InputWarning): # setting with bad arg - my_pitchmapper.pitch_map_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "mean", - "stretch": "linear", - "penguin": True} - + my_pitchmapper.pitch_map_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "mean", + "stretch": "linear", + "penguin": True, + } + assert "penguin" not in my_pitchmapper.pitch_map_args.keys() # Running function @@ -44,56 +48,44 @@ def test_pitchmap(): # Changing function def my_map_func(data): # dummy function data = np.array(data) - return data/2 + return data / 2 - with pytest.warns(InputWarning): # because of different args + with pytest.warns(InputWarning): # because of different args my_pitchmapper.pitch_map_func = my_map_func assert (my_pitchmapper([1, 1]) == [0.5, 0.5]).all() class TestSoniSeries(object): - - @classmethod - def setup_class(cls): - - cls.data = Table({"time": [0, 1, 2, 3, 4, 5, 6], - "Flux": [1, 2, 1, 2, 5, 3, np.nan]}) - - cls.soni_obj = SoniSeries(cls.data) - - def test_soniseries_initializes(self): - SoniSeries(self.data) - - def test_conversion_to_lowercase(self): - assert list(self.soni_obj.data.columns)[1] == "flux" - - def test_assert_time_exists(self): - - new_data = Table({"foo": [0, 1, 2, 3, 4, 5, 6], - "Flux": [1, 2, 1, 2, 5, 3, np.nan]}) - - with pytest.raises(AttributeError): - SoniSeries(new_data) - - def test_assert_flux_exists(self): - - new_data = Table({"time": [0, 1, 2, 3, 4, 5, 6], - "bar": [1, 2, 1, 2, 5, 3, np.nan]}) - - with pytest.raises(AttributeError): - SoniSeries(new_data) - - def test_default_parameters(self): - assert self.soni_obj.note_duration == 0.5 - assert self.soni_obj.note_spacing == 0.01 - assert self.soni_obj.gain == 0.05 + data = Table({"time": [0, 1, 2, 3, 4, 5, 6], "flux": [1, 2, 1, 2, 5, 3, np.nan]}) + + # defaults + soni_obj = SoniSeries(data) + assert soni_obj.note_duration == 0.5 + assert soni_obj.note_spacing == 0.01 + assert soni_obj.gain == 0.05 + assert isinstance(soni_obj.server, Server) + assert len(soni_obj.data) == len(data) - 1 # nan row should be removed + assert ~np.isnan(soni_obj.data["flux"]).any() + assert soni_obj.data["flux"].dtype == np.float64 + + soni_obj.sonify() + assert "asf_pitch" in soni_obj.data.colnames + assert "asf_onsets" in soni_obj.data.colnames + assert soni_obj.data.meta["asf_exposure_time"] == 1 + assert soni_obj.data.meta["asf_note_duration"] == soni_obj.note_duration + assert soni_obj.data.meta["asf_spacing"] == soni_obj.note_spacing + + onset_spacing = soni_obj.data["asf_onsets"][1:] - soni_obj.data["asf_onsets"][:-1] + assert (np.isclose(onset_spacing, soni_obj.note_spacing)).all() def test_server_class(self): assert isinstance(self.soni_obj.server, Server) def test_nans_removed(self): - assert len(self.soni_obj.data) == len(self.data) - 1 # nan row should be removed + assert ( + len(self.soni_obj.data) == len(self.data) - 1 + ) # nan row should be removed assert ~np.isnan(self.soni_obj.data["flux"]).any() def test_flux_type_correct(self): @@ -107,12 +99,16 @@ def test_sonify_new_columns_exist(self): assert "asf_onsets" in self.soni_obj.data.colnames def test_sonify_metadata(self): - assert self.soni_obj.data.meta['asf_exposure_time'] == 1 - assert self.soni_obj.data.meta['asf_note_duration'] == self.soni_obj.note_duration - assert self.soni_obj.data.meta['asf_spacing'] == self.soni_obj.note_spacing + assert self.soni_obj.data.meta["asf_exposure_time"] == 1 + assert ( + self.soni_obj.data.meta["asf_note_duration"] == self.soni_obj.note_duration + ) + assert self.soni_obj.data.meta["asf_spacing"] == self.soni_obj.note_spacing def test_onset_spacing(self): - onset_spacing = self.soni_obj.data['asf_onsets'][1:]-self.soni_obj.data['asf_onsets'][:-1] + onset_spacing = ( + self.soni_obj.data["asf_onsets"][1:] - self.soni_obj.data["asf_onsets"][:-1] + ) assert (np.isclose(onset_spacing, self.soni_obj.note_spacing)).all() def test_pitch_min_max(self): @@ -123,5 +119,3 @@ def test_pitch_min_max(self): # TODO: change args and test # TODO: test write - - diff --git a/astronify/simulator/add_flare_signal.py b/astronify/simulator/add_flare_signal.py index 9e688a9..da37fd3 100644 --- a/astronify/simulator/add_flare_signal.py +++ b/astronify/simulator/add_flare_signal.py @@ -52,7 +52,7 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # Where "n" = 6 in Davenport et al., where the decay phase is defined from # t_1/2 = [0,6], but we will choose to extend to the end of the light curve # so that the decay gets as close to zero as possible. - n_t12 = int((fluxes_to_add.shape[0] + 1 - flare_time)/flare_halfwidth) + n_t12 = int((fluxes_to_add.shape[0] + 1 - flare_time) / flare_halfwidth) # Create the normalized part of the rise time. # In the Davenport et al. flare template, the rise part of the flare @@ -71,12 +71,17 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # [flare_time-flare_halfwidth+1 : flare_time] # Generate indices in "t_1/2" units. - t12_rise_indices = np.linspace(-1., 0., flare_halfwidth) + t12_rise_indices = np.linspace(-1.0, 0.0, flare_halfwidth) # Compute fluxes for the rise part. - rise_fluxes = (1. + 1.941*t12_rise_indices - 0.175*t12_rise_indices**2. - - 2.246*t12_rise_indices**3. - 1.125*t12_rise_indices**4.) + rise_fluxes = ( + 1.0 + + 1.941 * t12_rise_indices + - 0.175 * t12_rise_indices**2.0 + - 2.246 * t12_rise_indices**3.0 + - 1.125 * t12_rise_indices**4.0 + ) # Insert these fluxes into the correct location in our light curve. - fluxes_to_add[flare_time-flare_halfwidth+1:flare_time+1] = rise_fluxes + fluxes_to_add[flare_time - flare_halfwidth + 1 : flare_time + 1] = rise_fluxes # Create the normalized part of the decay time. # In Davenport et al., they define their Eqn. 4 from t_1/2 = [0, 6]. @@ -91,16 +96,17 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # [flare_time : flare_time + n*flare_halfwidth-1 # Generate indices in "t_1/2" units. - t12_decay_indices = np.linspace(0., n_t12, n_t12*flare_halfwidth) - + t12_decay_indices = np.linspace(0.0, n_t12, n_t12 * flare_halfwidth) + # Compute fluxes for the decay part. - decay_fluxes = (0.6890*np.exp(-1.600*t12_decay_indices) + - 0.3030*np.exp(-0.2783*t12_decay_indices)) - + decay_fluxes = 0.6890 * np.exp(-1.600 * t12_decay_indices) + 0.3030 * np.exp( + -0.2783 * t12_decay_indices + ) + # Insert these fluxes into the correct location in our light curve. # Note: the above index range is correct, but in Python you need to go one # extra when slicing, hence 6*flare_halfwidth-1+1 = 6*flare_halfwidth... - fluxes_to_add[flare_time: flare_time+n_t12*flare_halfwidth] = decay_fluxes + fluxes_to_add[flare_time : flare_time + n_t12 * flare_halfwidth] = decay_fluxes # Scale the fluxes to add (which are normalized at this point) by 'flare_amp' fluxes_to_add *= flare_amp diff --git a/astronify/simulator/add_sine_signal.py b/astronify/simulator/add_sine_signal.py index 42e4530..ed09bef 100644 --- a/astronify/simulator/add_sine_signal.py +++ b/astronify/simulator/add_sine_signal.py @@ -27,7 +27,7 @@ def add_sine_signal(times, fluxes, sine_amp, sine_period): """ # Generate sinusoidal signal. - sine_signal = Sine1D(amplitude=sine_amp, frequency=1./sine_period) + sine_signal = Sine1D(amplitude=sine_amp, frequency=1.0 / sine_period) fluxes += sine_signal(times) diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 81c98aa..cebc682 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -8,8 +8,9 @@ import numpy as np -def add_transit_signal(fluxes, transit_depth, transit_period, transit_start, - transit_width): +def add_transit_signal( + fluxes, transit_depth, transit_period, transit_start, transit_width +): """ :param fluxes: Array of fluxes to add the transit signal to. :type fluxes: numpy.ndarray @@ -39,16 +40,15 @@ def add_transit_signal(fluxes, transit_depth, transit_period, transit_start, transit_indexes = np.zeros(n_fluxes) # Get the set of start indexes. - start_indexes = np.arange(transit_start, n_fluxes+1, transit_period, - dtype=np.int) + start_indexes = np.arange(transit_start, n_fluxes + 1, transit_period, dtype=int) # Set transit indexes to 1. for st_ind in start_indexes: if st_ind + transit_width < fluxes.size: - transit_indexes[st_ind:st_ind+transit_width+1] = 1 + transit_indexes[st_ind : st_ind + transit_width + 1] = 1 else: transit_indexes[st_ind:] = 1 # Set the flux values of the transit indexes to the transit depth. - fluxes[np.where(transit_indexes == 1)] *= (1.-(transit_depth/100.)) + fluxes[np.where(transit_indexes == 1)] *= 1.0 - (transit_depth / 100.0) return fluxes diff --git a/astronify/simulator/check_flare_params.py b/astronify/simulator/check_flare_params.py index d6ca06b..e719411 100644 --- a/astronify/simulator/check_flare_params.py +++ b/astronify/simulator/check_flare_params.py @@ -24,23 +24,29 @@ def check_flare_params(n_fluxes, flare_time, flare_amp): # Flare time index must be less than total numbr of fluxes. if flare_time > n_fluxes: - raise argparse.ArgumentTypeError("The flare time at peak flux must be" - " less than the total number of fluxes" - " in the simulated light curve." - " Number of fluxes = " + str(n_fluxes) + - ", flare time requested is " + - str(flare_time) + ".") + raise argparse.ArgumentTypeError( + "The flare time at peak flux must be" + " less than the total number of fluxes" + " in the simulated light curve." + " Number of fluxes = " + + str(n_fluxes) + + ", flare time requested is " + + str(flare_time) + + "." + ) # Flare time index must be greater than or equal to zero. if flare_time < 0: - raise argparse.ArgumentTypeError("The flare time at peak flux must be" - " greater than or equal to zero, flare" - " time requested is " + - str(flare_time) + ".") + raise argparse.ArgumentTypeError( + "The flare time at peak flux must be" + " greater than or equal to zero, flare" + " time requested is " + str(flare_time) + "." + ) # The flare amplitude must be greater than zero. - if flare_amp <= 0.: - raise argparse.ArgumentTypeError("Flare amplitude must be greater than" - " zero. Requested" - " flare amplitude = " + - str(flare_amp) + ".") + if flare_amp <= 0.0: + raise argparse.ArgumentTypeError( + "Flare amplitude must be greater than" + " zero. Requested" + " flare amplitude = " + str(flare_amp) + "." + ) diff --git a/astronify/simulator/check_transit_params.py b/astronify/simulator/check_transit_params.py index c19a7cf..61d19d5 100644 --- a/astronify/simulator/check_transit_params.py +++ b/astronify/simulator/check_transit_params.py @@ -30,25 +30,30 @@ def check_transit_params(n_fluxes, transit_period, transit_start, transit_width) # Start index must be less than total numbr of fluxes. if transit_start > n_fluxes: - raise argparse.ArgumentTypeError("The transit start must be less than" - " the total number of fluxes in the" - " simulated light curve." - " Number of fluxes = " + str(n_fluxes) + - ", start index requested is " + - str(transit_start) + ".") + raise argparse.ArgumentTypeError( + "The transit start must be less than" + " the total number of fluxes in the" + " simulated light curve." + " Number of fluxes = " + + str(n_fluxes) + + ", start index requested is " + + str(transit_start) + + "." + ) # The start index must be greater than or equal to zero. if transit_start < 0: - raise argparse.ArgumentTypeError("The transit start must be greater than" - " or equal to zero, start" - " index requested is " + - str(transit_start) + ".") + raise argparse.ArgumentTypeError( + "The transit start must be greater than" + " or equal to zero, start" + " index requested is " + str(transit_start) + "." + ) # The transit period must be greater than the transit duration (width). if transit_width >= transit_period: - raise argparse.ArgumentTypeError("Transit duration must be less than" - " the transit period. Requested" - " transit duration = " + - str(transit_width) + ", requested" - " transit period = " + - str(transit_period) + ".") + raise argparse.ArgumentTypeError( + "Transit duration must be less than" + " the transit period. Requested" + " transit duration = " + str(transit_width) + ", requested" + " transit period = " + str(transit_period) + "." + ) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 35d9183..91a679c 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -22,23 +22,26 @@ from .sim_lc_setup_args import sim_lc_setup_args -__all__ = ["simulated_lc", 'SimLcConfig'] - - -def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, - lc_length=SimLcConfig.sim_lc_length, - lc_noise=SimLcConfig.sim_lc_noise, - visualize=SimLcConfig.sim_lc_visualize, - lc_yoffset=SimLcConfig.sim_lc_yoffset, - transit_depth=SimLcConfig.sim_lc_transit_depth, - transit_period=SimLcConfig.sim_lc_transit_period, - transit_start=SimLcConfig.sim_lc_transit_start, - transit_width=SimLcConfig.sim_lc_transit_width, - sine_amp=SimLcConfig.sim_lc_sine_amp, - sine_period=SimLcConfig.sim_lc_sine_period, - flare_time=SimLcConfig.sim_lc_flare_time, - flare_amp=SimLcConfig.sim_lc_flare_amp, - flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth): +__all__ = ["simulated_lc", "SimLcConfig"] + + +def simulated_lc( + lc_type, + lc_ofile=SimLcConfig.sim_lc_ofile, + lc_length=SimLcConfig.sim_lc_length, + lc_noise=SimLcConfig.sim_lc_noise, + visualize=SimLcConfig.sim_lc_visualize, + lc_yoffset=SimLcConfig.sim_lc_yoffset, + transit_depth=SimLcConfig.sim_lc_transit_depth, + transit_period=SimLcConfig.sim_lc_transit_period, + transit_start=SimLcConfig.sim_lc_transit_start, + transit_width=SimLcConfig.sim_lc_transit_width, + sine_amp=SimLcConfig.sim_lc_sine_amp, + sine_period=SimLcConfig.sim_lc_sine_period, + flare_time=SimLcConfig.sim_lc_flare_time, + flare_amp=SimLcConfig.sim_lc_flare_amp, + flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth, +): """ Create light curve with specified parameters as a `~astropy.table.Table`, and optionally writes a FITS file with the same information. @@ -100,7 +103,7 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, corresponds to "t_1/2" in the Davenport et al. flare template. Returns - -------- + ------- response : `~astropy.table.Table` The time and flux columns. """ @@ -117,11 +120,11 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, fluxes = add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth) elif lc_type == "sine": fluxes = add_sine_signal(times, fluxes, sine_amp, sine_period) - elif lc_type == 'transit': - check_transit_params(fluxes.size, transit_period, transit_start, - transit_width) - fluxes = add_transit_signal(fluxes, transit_depth, transit_period, - transit_start, transit_width) + elif lc_type == "transit": + check_transit_params(fluxes.size, transit_period, transit_start, transit_width) + fluxes = add_transit_signal( + fluxes, transit_depth, transit_period, transit_start, transit_width + ) # Add noise based on standard deviation. fluxes_with_noise = add_lc_noise(fluxes, lc_noise) @@ -129,7 +132,7 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # Visualize the light curve, if desired. if visualize: _, ax1 = plt.subplots(1) - ax1.plot(times, fluxes_with_noise, 'bo') + ax1.plot(times, fluxes_with_noise, "bo") plt.show() if lc_ofile: @@ -139,15 +142,22 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, hdr.append(("LCTYPE", lc_type, "Type of signal.")) hdr.append(("LCLENGTH", lc_length, "Number of fluxes.")) hdr.append(("LCYOFF", lc_yoffset, "Baseline flux value (unitless).")) - hdr.append(("LCNOISE", lc_noise, "Std. dev. of normal dist. used to" - " apply noise.")) + hdr.append( + ("LCNOISE", lc_noise, "Std. dev. of normal dist. used to apply noise.") + ) # Record the flare parameters used if adding a flare. if lc_type == "flare": - hdr.append(("FLARETIM", flare_time, "Index corresponding to the peak" - " of the flare.")) + hdr.append( + ( + "FLARETIM", + flare_time, + "Index corresponding to the peak of the flare.", + ) + ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) - hdr.append(("FLAREWID", flare_halfwidth, "Flare half-width" - " (number of indices).")) + hdr.append( + ("FLAREWID", flare_halfwidth, "Flare half-width (number of indices).") + ) # Record the sinusoidal parameters if adding a sinusoid. if lc_type == "sine": hdr.append(("SINEAMP", sine_amp, "Amplitude of sine.")) @@ -161,9 +171,9 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # This builds the primary header, no data, just keywords. primary_hdu = fits.PrimaryHDU(header=hdr) # This sets up the binary table and creates the first extension header. - col1 = fits.Column(name="time", array=times, format='D') - col2 = fits.Column(name="flux", array=fluxes_with_noise, format='D') - col3 = fits.Column(name="flux_pure", array=fluxes, format='D') + col1 = fits.Column(name="time", array=times, format="D") + col2 = fits.Column(name="flux", array=fluxes_with_noise, format="D") + col3 = fits.Column(name="flux_pure", array=fluxes, format="D") hdu1 = fits.BinTableHDU.from_columns([col1, col2, col3]) # If the output directory doesn't exist, create it. if not os.path.isdir(os.path.abspath(os.path.dirname(lc_ofile))): @@ -175,17 +185,29 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # Return the times and fluxes as an astropy Table so it can be directly # used later in a script. - return Table([times, fluxes_with_noise, fluxes], - names=("time", "flux", "flux_pure")) + return Table( + [times, fluxes_with_noise, fluxes], names=("time", "flux", "flux_pure") + ) if __name__ == "__main__": # Get command-line arguments. INPUT_ARGS = sim_lc_setup_args().parse_args() - simulated_lc(INPUT_ARGS.lc_type, INPUT_ARGS.lc_ofile, INPUT_ARGS.lc_length, - INPUT_ARGS.lc_noise, INPUT_ARGS.visualize, INPUT_ARGS.lc_yoffset, - INPUT_ARGS.transit_depth, INPUT_ARGS.transit_period, - INPUT_ARGS.transit_start, INPUT_ARGS.transit_width, - INPUT_ARGS.sine_amp, INPUT_ARGS.sine_period, INPUT_ARGS.flare_time, - INPUT_ARGS.flare_amp, INPUT_ARGS.flare_halfwidth) + simulated_lc( + INPUT_ARGS.lc_type, + INPUT_ARGS.lc_ofile, + INPUT_ARGS.lc_length, + INPUT_ARGS.lc_noise, + INPUT_ARGS.visualize, + INPUT_ARGS.lc_yoffset, + INPUT_ARGS.transit_depth, + INPUT_ARGS.transit_period, + INPUT_ARGS.transit_start, + INPUT_ARGS.transit_width, + INPUT_ARGS.sine_amp, + INPUT_ARGS.sine_period, + INPUT_ARGS.flare_time, + INPUT_ARGS.flare_amp, + INPUT_ARGS.flare_halfwidth, + ) diff --git a/astronify/simulator/sim_lc_config.py b/astronify/simulator/sim_lc_config.py index 7def0cb..d766de3 100644 --- a/astronify/simulator/sim_lc_config.py +++ b/astronify/simulator/sim_lc_config.py @@ -1,4 +1,3 @@ - class SimLcConfig: """ Class that holds the default configuration parameters @@ -8,21 +7,21 @@ class SimLcConfig: # General Parameters sim_lc_ofile = "" sim_lc_length = 500 - sim_lc_noise = 0. + sim_lc_noise = 0.0 sim_lc_visualize = False - sim_lc_yoffset = 100. - + sim_lc_yoffset = 100.0 + # Transit Parameters - sim_lc_transit_depth = 10. - sim_lc_transit_period = 50. + sim_lc_transit_depth = 10.0 + sim_lc_transit_period = 50.0 sim_lc_transit_start = 10 sim_lc_transit_width = 5 - + # Sinusoidal Parameters - sim_lc_sine_amp = 10. - sim_lc_sine_period = 50. + sim_lc_sine_amp = 10.0 + sim_lc_sine_period = 50.0 # Flare Parameters sim_lc_flare_time = 10 - sim_lc_flare_amp = 100. + sim_lc_flare_amp = 100.0 sim_lc_flare_halfwidth = 5 diff --git a/astronify/simulator/sim_lc_setup_args.py b/astronify/simulator/sim_lc_setup_args.py index 4483860..0455bf7 100644 --- a/astronify/simulator/sim_lc_setup_args.py +++ b/astronify/simulator/sim_lc_setup_args.py @@ -19,102 +19,173 @@ def sim_lc_setup_args(): parser = argparse.ArgumentParser( description="Create simulated light curves, as FITS files, for use with" " the Astronify sonification software. Types include flat, transit, sine" - " and flare.") - - parser.add_argument("lc_type", action="store", type=str, help="Type of light" - " curve to create.", choices=["flat", "transit", - "sine", "flare"]) - - parser.add_argument("-o", dest="lc_ofile", action="store", type=str, - help="Name of output FITS file to create.", - default=sim_lc_config.sim_lc_ofile) - - parser.add_argument("-l", action="store", type=int, - default=sim_lc_config.sim_lc_length, - dest="lc_length", help="Total number of flux" - " measurements in the light curve. Default =" - " %(default)s.") - - parser.add_argument("-n", action="store", type=float, - default=sim_lc_config.sim_lc_noise, - dest="lc_noise", help="Amount of noise to add to the" - " measurements in the light curve, specified by the" - " standard deviation of the normal distribution to draw" - " from. Set to zero for no noise. Default =" - " %(default)s.") - - parser.add_argument("-v", action="store_true", dest="visualize", - default=sim_lc_config.sim_lc_vizualize, - help="If True, a plot of the light curve" - " that is generated will be plot on the screen. Default" - " = %(default)s.") - - parser.add_argument("-y", action="store", type=float, - default=sim_lc_config.sim_lc_yoffset, - dest="lc_yoffset", help="Baseline (unitless) flux height" - " of the light curve. Used to test sonification of" - " sources with different total brightness. Default =" - " %(default)s.") + " and flare." + ) + + parser.add_argument( + "lc_type", + action="store", + type=str, + help="Type of light curve to create.", + choices=["flat", "transit", "sine", "flare"], + ) + + parser.add_argument( + "-o", + dest="lc_ofile", + action="store", + type=str, + help="Name of output FITS file to create.", + default=sim_lc_config.sim_lc_ofile, + ) + + parser.add_argument( + "-l", + action="store", + type=int, + default=sim_lc_config.sim_lc_length, + dest="lc_length", + help="Total number of flux" + " measurements in the light curve. Default =" + " %(default)s.", + ) + + parser.add_argument( + "-n", + action="store", + type=float, + default=sim_lc_config.sim_lc_noise, + dest="lc_noise", + help="Amount of noise to add to the" + " measurements in the light curve, specified by the" + " standard deviation of the normal distribution to draw" + " from. Set to zero for no noise. Default =" + " %(default)s.", + ) + + parser.add_argument( + "-v", + action="store_true", + dest="visualize", + default=sim_lc_config.sim_lc_vizualize, + help="If True, a plot of the light curve" + " that is generated will be plot on the screen. Default" + " = %(default)s.", + ) + + parser.add_argument( + "-y", + action="store", + type=float, + default=sim_lc_config.sim_lc_yoffset, + dest="lc_yoffset", + help="Baseline (unitless) flux height" + " of the light curve. Used to test sonification of" + " sources with different total brightness. Default =" + " %(default)s.", + ) # Transit-related parameters here. - transit_group = parser.add_argument_group("transit", "Parameters for transit" - " signals.") - transit_group.add_argument("--transit_depth", type=float, - default=sim_lc_config.sim_lc_transit_depth, - dest="transit_depth", help="Depth of the transit" - " signal specified as a percent, e.g., set to" - " 10.0 for a 10%% depth transit. Default =" - " %(default)s.") - transit_group.add_argument("--transit_period", type=int, - default=sim_lc_config.sim_lc_transit_period, - dest="transit_period", help="Period of the" - " transit signal, specified as the number of" - " fluxes (bins) between the start of each event." - " Default = %(default)s.") - transit_group.add_argument("--transit_start", type=int, - default=sim_lc_config.sim_lc_transit_start, - dest="transit_start", help="Start of the first" - " transit, specified as the index of the" - " flux (bin) to use as the start of the first" - " transit event. Default = %(default)s.") - transit_group.add_argument("--transit_width", type=int, - default=sim_lc_config.sim_lc_transit_width, - dest="transit_width", help="Width of the" - " transit signal, specified as the number of" - " fluxes (bins) between the start and end of each" - " event. Default = %(default)s.") + transit_group = parser.add_argument_group( + "transit", "Parameters for transit signals." + ) + + transit_group.add_argument( + "--transit_depth", + type=float, + default=sim_lc_config.sim_lc_transit_depth, + dest="transit_depth", + help="Depth of the transit" + " signal specified as a percent, e.g., set to" + " 10.0 for a 10%% depth transit. Default =" + " %(default)s.", + ) + + transit_group.add_argument( + "--transit_period", + type=int, + default=sim_lc_config.sim_lc_transit_period, + dest="transit_period", + help="Period of the" + " transit signal, specified as the number of" + " fluxes (bins) between the start of each event." + " Default = %(default)s.", + ) + + transit_group.add_argument( + "--transit_start", + type=int, + default=sim_lc_config.sim_lc_transit_start, + dest="transit_start", + help="Start of the first" + " transit, specified as the index of the" + " flux (bin) to use as the start of the first" + " transit event. Default = %(default)s.", + ) + + transit_group.add_argument( + "--transit_width", + type=int, + default=sim_lc_config.sim_lc_transit_width, + dest="transit_width", + help="Width of the" + " transit signal, specified as the number of" + " fluxes (bins) between the start and end of each" + " event. Default = %(default)s.", + ) # Sinusoidal-related parameters here. - sine_group = parser.add_argument_group("sinusoidal", "Parameters for" - " sinusoidal signals.") - sine_group.add_argument("--sine_amp", type=float, - default=sim_lc_config.sim_lc_sine_amp, - dest="sine_amp", help="Amplitude of the" - " sinusoidal signal to add. Default =" - " %(default)s.") - sine_group.add_argument("--sine_period", type=float, - default=sim_lc_config.sim_lc_sine_period, - dest="sine_period", help="Period of the" - " sinusoidal signal, specified in the (unitless)" - " time axis (flux bins). Default = %(default)s.") + sine_group = parser.add_argument_group( + "sinusoidal", "Parameters for sinusoidal signals." + ) + + sine_group.add_argument( + "--sine_amp", + type=float, + default=sim_lc_config.sim_lc_sine_amp, + dest="sine_amp", + help="Amplitude of the sinusoidal signal to add. Default = %(default)s.", + ) + + sine_group.add_argument( + "--sine_period", + type=float, + default=sim_lc_config.sim_lc_sine_period, + dest="sine_period", + help="Period of the sinusoidal signal, specified in the (unitless)" + " time axis (flux bins). Default = %(default)s.", + ) # Flare-related parameters here. - flare_group = parser.add_argument_group("flare", "Parameters for" - " adding flares.") - flare_group.add_argument("--flare_time", type=int, - default=sim_lc_config.sim_lc_flare_time, - dest="flare_time", help="Time corresponding to" - " the maximum flux of the flare, specified" - " as the index of the flux (bin) to use as" - " the peak time. Default = %(default)s.") - flare_group.add_argument("--flare_amp", type=float, - default=sim_lc_config.sim_lc_flare_amp, - dest="flare_amp", help="Amplitude (maximum flux)" - " of the flare to add. Default = %(default)s.") - flare_group.add_argument("--flare_halfwidth", type=int, - default="flare_halfwidth", help="The flare" - " half-width (measured in indices) that" - " corresponds to 't_1/2' in the Davenport et al." - " flare template.") + flare_group = parser.add_argument_group("flare", "Parameters for adding flares.") + + flare_group.add_argument( + "--flare_time", + type=int, + default=sim_lc_config.sim_lc_flare_time, + dest="flare_time", + help="Time corresponding to" + " the maximum flux of the flare, specified" + " as the index of the flux (bin) to use as" + " the peak time. Default = %(default)s.", + ) + + flare_group.add_argument( + "--flare_amp", + type=float, + default=sim_lc_config.sim_lc_flare_amp, + dest="flare_amp", + help="Amplitude (maximum flux) of the flare to add. Default = %(default)s.", + ) + + flare_group.add_argument( + "--flare_halfwidth", + type=int, + default="flare_halfwidth", + help="The flare" + " half-width (measured in indices) that" + " corresponds to 't_1/2' in the Davenport et al." + " flare template.", + ) return parser diff --git a/astronify/utils/__init__.py b/astronify/utils/__init__.py index a84c02a..eb0f7e9 100644 --- a/astronify/utils/__init__.py +++ b/astronify/utils/__init__.py @@ -6,4 +6,4 @@ from .pitch_mapping import * # noqa: F403 -__all__ = ['data_to_pitch'] # noqa: F405 +__all__ = ["data_to_pitch"] # noqa: F405 diff --git a/astronify/utils/exceptions.py b/astronify/utils/exceptions.py index 9a4845b..e6a81d9 100644 --- a/astronify/utils/exceptions.py +++ b/astronify/utils/exceptions.py @@ -9,9 +9,10 @@ class InvalidInputError(Exception): """ - Exception to be issued when user input is incorrect in a + Exception to be issued when user input is incorrect in a way that prevents the function from running. """ + pass @@ -20,4 +21,5 @@ class InputWarning(AstropyWarning): Warning to be issued when user input is incorrect in some way but doesn't prevent the function from running. """ + pass diff --git a/astronify/utils/pitch_mapping.py b/astronify/utils/pitch_mapping.py index d8f29bb..45ce6d5 100644 --- a/astronify/utils/pitch_mapping.py +++ b/astronify/utils/pitch_mapping.py @@ -10,17 +10,32 @@ import numpy as np -from astropy.visualization import (SqrtStretch, LogStretch, AsinhStretch, SinhStretch, - LinearStretch, MinMaxInterval, ManualInterval, - AsymmetricPercentileInterval) +from astropy.visualization import ( + SqrtStretch, + LogStretch, + AsinhStretch, + SinhStretch, + LinearStretch, + MinMaxInterval, + ManualInterval, + AsymmetricPercentileInterval, +) from .exceptions import InputWarning, InvalidInputError -__all__ = ['data_to_pitch'] +__all__ = ["data_to_pitch"] -def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_point="median", - stretch='linear', minmax_percent=None, minmax_value=None, invert=False): +def data_to_pitch( + data_array, + pitch_range=[100, 10000], + center_pitch=440, + zero_point="median", + stretch="linear", + minmax_percent=None, + minmax_value=None, + invert=False, +): """ Map data array to audible pitches in the given range, and apply stretch and scaling as required. @@ -68,26 +83,29 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p # The center pitch cannot be >= max() pitch range, or <= min() of pitch range. # If it is, fall back to using the mean of the pitch range provided. if center_pitch <= pitch_range[0] or center_pitch >= pitch_range[1]: - warnings.warn("Given center pitch is outside the pitch range, defaulting to the mean.", - InputWarning) + warnings.warn( + "Given center pitch is outside the pitch range, defaulting to the mean.", + InputWarning, + ) center_pitch = np.mean(pitch_range) - if (data_array == zero_point).all(): # All values are the same, no more calculation needed + if (data_array == zero_point).all(): + # All values are the same, no more calculation needed return np.full(len(data_array), center_pitch) # Normalizing the data_array and adding the zero point (so it can go through the same transform) data_array = np.append(np.array(data_array), zero_point) # Setting up the transform with the stretch - if stretch == 'asinh': + if stretch == "asinh": transform = AsinhStretch() - elif stretch == 'sinh': + elif stretch == "sinh": transform = SinhStretch() - elif stretch == 'sqrt': + elif stretch == "sqrt": transform = SqrtStretch() - elif stretch == 'log': + elif stretch == "log": transform = LogStretch() - elif stretch == 'linear': + elif stretch == "linear": transform = LinearStretch() else: raise InvalidInputError("Stretch {} is not supported!".format(stretch)) @@ -97,8 +115,10 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p transform += AsymmetricPercentileInterval(*minmax_percent) if minmax_value is not None: - warnings.warn("Both minmax_percent and minmax_value are set, minmax_value will be ignored.", - InputWarning) + warnings.warn( + "Both minmax_percent and minmax_value are set, minmax_value will be ignored.", + InputWarning, + ) elif minmax_value is not None: transform += ManualInterval(*minmax_value) else: # Default, scale the entire image range to [0,1] @@ -121,12 +141,17 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p # change user's choice here. May want to consider providing info back to the user about the # distribution of pitches actually used based on their sonification options in some way. if zero_point == 0.0: - zero_point = 1E-6 - - if ((1/zero_point)*(center_pitch - pitch_range[0]) + pitch_range[0]) <= pitch_range[1]: - pitch_array = (pitch_array/zero_point)*(center_pitch - pitch_range[0]) + pitch_range[0] + zero_point = 1e-6 + + if ( + (1 / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0] + ) <= pitch_range[1]: + pitch_array = (pitch_array / zero_point) * ( + center_pitch - pitch_range[0] + ) + pitch_range[0] else: - pitch_array = (((pitch_array-zero_point)/(1-zero_point))*(pitch_range[1] - center_pitch) + - center_pitch) + pitch_array = ((pitch_array - zero_point) / (1 - zero_point)) * ( + pitch_range[1] - center_pitch + ) + center_pitch return pitch_array diff --git a/astronify/utils/tests/test_pitch_mapping.py b/astronify/utils/tests/test_pitch_mapping.py index e03e4ce..95b953e 100644 --- a/astronify/utils/tests/test_pitch_mapping.py +++ b/astronify/utils/tests/test_pitch_mapping.py @@ -15,104 +15,153 @@ def test_data_to_pitch(): center_pitch = 450 # basic linear stretch - data_arr = np.array([[1, 0, .25, .75]]) - pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] - - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() - # invert - pitch_arr = pitch_range[1] - data_arr*(pitch_range[1]-pitch_range[0]) - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', invert=True)).all() + data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) + pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + + assert ( + pitch_arr + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear") + ).all() - # linear stretch where input image must be scaled - data_arr = np.array([10, 20, 12.5, 17.5]) - pitch_arr = ((data_arr - data_arr.min())/(data_arr.max()-data_arr.min()) * - (pitch_range[1]-pitch_range[0])) + pitch_range[0] - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() + # invert + pitch_arr = pitch_range[1] - data_arr * (pitch_range[1] - pitch_range[0]) + assert ( + pitch_arr + == data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", invert=True + ) + ).all() + + # linear stretch where input image must be scaled + data_arr = np.array([10.0, 20.0, 12.5, 17.5]) + pitch_arr = ( + (data_arr - data_arr.min()) + / (data_arr.max() - data_arr.min()) + * (pitch_range[1] - pitch_range[0]) + ) + pitch_range[0] + assert ( + pitch_arr + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear") + ).all() # linear stretch with non-equal lower/upper pitch ranges - data_arr = np.array([[1, 0, .25, .75]]) - pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) + pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] pitch_range = [300, 500] - assert (pitch_arr == data_to_pitch(data_arr, [300, 500], - center_pitch, stretch='linear')).all() + assert ( + pitch_arr == data_to_pitch(data_arr, [300, 500], center_pitch, stretch="linear") + ).all() pitch_range = [400, 600] - assert (pitch_arr == data_to_pitch(data_arr, [400, 600], - center_pitch, stretch='linear')).all() + assert ( + pitch_arr == data_to_pitch(data_arr, [400, 600], center_pitch, stretch="linear") + ).all() pitch_range = [400, 500] - + # min_max val minval, maxval = 0, 1 data_arr = np.array([1, 0, -1, 2]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_value=[minval, maxval]) + pitch_arr = data_to_pitch( + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[minval, maxval], + ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval - manual_pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() minval, maxval = 0, 1 - data_arr = np.array([1, 0, .25, .75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_value=[minval, maxval]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) + pitch_arr = data_to_pitch( + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[minval, maxval], + ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval - manual_pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # min_max percent - data_arr = np.array([1.1, -0.1, 1, 0, .25, .75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_percent=[20, 80]) - assert (np.isclose(pitch_arr, np.array([500, 400, 500, 400, - 422.22222222, 477.77777778]))).all() + data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80] + ) + assert ( + np.isclose( + pitch_arr, np.array([500, 400, 500, 400, 422.22222222, 477.77777778]) + ) + ).all() # asinh - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.21271901209248895 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='asinh') - manual_pitch_arr = np.arcsinh(data_arr*10)/np.arcsinh(10)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="asinh" + ) + manual_pitch_arr = ( + np.arcsinh(data_arr * 10) / np.arcsinh(10) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # sinh - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.7713965391706435 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='sinh') - manual_pitch_arr = np.sinh(data_arr*3)/np.sinh(3)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="sinh" + ) + manual_pitch_arr = ( + np.sinh(data_arr * 3) / np.sinh(3) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # sqrt - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.25 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='sqrt') - manual_pitch_arr = np.sqrt(data_arr)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="sqrt" + ) + manual_pitch_arr = ( + np.sqrt(data_arr) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # log - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.030638584039112748 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='log') - manual_pitch_arr = np.log(1000*data_arr+1)/np.log(1001)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="log" + ) + manual_pitch_arr = ( + np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # Bad stretch with pytest.raises(InvalidInputError): - data_arr = np.array([1, 0, .25, .75]) - data_to_pitch(data_arr, stretch='lin') + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) + data_to_pitch(data_arr, stretch="lin") # Giving both minmax percent and cut - data_arr = np.array([1.1, -0.1, 1, 0, .25, .75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear', minmax_percent=[20, 80]) + data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80] + ) with pytest.warns(InputWarning): - test_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear', - minmax_value=[0, 1], minmax_percent=[20, 80]) + test_arr = data_to_pitch( + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[0, 1], + minmax_percent=[20, 80], + ) assert (pitch_arr == test_arr).all() - - - - - - diff --git a/docs/_templates/layout.html b/docs/_templates/layout.html index 62a5c54..999cb20 100644 --- a/docs/_templates/layout.html +++ b/docs/_templates/layout.html @@ -2,7 +2,7 @@ {% block sidebartitle %} - + {{ _('Logo') }} {% if theme_display_version %} diff --git a/docs/astronify/index.rst b/docs/astronify/index.rst index 9419563..8361904 100644 --- a/docs/astronify/index.rst +++ b/docs/astronify/index.rst @@ -99,8 +99,8 @@ taking into account any requested clipping, and the requested stretch is applied if the invert argument is set, the array is inverted by subtracting all values from 1. The scaled zero point is then removed from the array which is scaled to the pitch range -such that the scaled zero point become the center pitch value and the entire pitch range -fell within the input pitch range. In practice this means one of two things: +such that the scaled zero point becomes the center pitch value and the entire pitch range +falls within the input pitch range. In practice this means one of two things: The array is scaled such that the 0 corresponds to the minimum of the input pitch range and the scaled zero point corresponds to the center pitch value. Or, the scaled zero point corresponds to the center pitch value and 1 corresponds to the maximum of the input pitch range. Whichever diff --git a/docs/astronify/install.rst b/docs/astronify/install.rst index 68e582e..8e4e78a 100644 --- a/docs/astronify/install.rst +++ b/docs/astronify/install.rst @@ -3,8 +3,8 @@ Installation ************ -Installing astrocut -=================== +Installing astronify +==================== Using pip --------- @@ -13,6 +13,41 @@ The easiest way to install Astronify is using pip:: pip install astronify +Errors installing dependent packages +------------------------------------ + +You may experience difficulties installing Astronify without some +libraries pre-installed. If you run into problems, we recommend +installing the following dependencies of `pyo` prior to running the +`pip install astronify` step. + +Mac +~~~ +We recommend installing `homebrew` (https://brew.sh) and then running:: + + brew install portaudio portmidi libsndfile liblo + +Still having issues? +^^^^^^^^^^^^^^^^^^^^ +If you are still unable to install `astronify` (or `pyo`) via `pip`, +it's possible `pip` is looking for them in the wrong spot, depending on +how you've installed other packages in your envionrment. If so, try +adding the following flags to your shell of choice, open a new +terminal, and then run `pip install astronify` again:: + + # Example for .cshrc + setenv CFLAGS '-I/opt/homebrew/include/' + setenv LDFLAGS '-L/opt/homebrew/lib/' + + # Example for .bashrc + export CFLAGS="-I/opt/homebrew/include/" + export LDFLAGS="-L/opt/homebrew/lib/" + +Linux +~~~~~ +We recommend installing the following with apt-get:: + + apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev From source ----------- diff --git a/docs/conf.py b/docs/conf.py index ef97c78..5f9d614 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -33,23 +33,26 @@ try: from sphinx_astropy.conf.v1 import * # noqa except ImportError: - print('ERROR: the documentation requires the sphinx-astropy package to be installed') + print( + "ERROR: the documentation requires the sphinx-astropy package to be installed" + ) sys.exit(1) # Get configuration information from setup.cfg from configparser import ConfigParser + conf = ConfigParser() -conf.read([os.path.join(os.path.dirname(__file__), '..', 'setup.cfg')]) -setup_cfg = dict(conf.items('metadata')) +conf.read([os.path.join(os.path.dirname(__file__), "..", "setup.cfg")]) +setup_cfg = dict(conf.items("metadata")) # -- General configuration ---------------------------------------------------- # By default, highlight as Python 3. -highlight_language = 'python3' +highlight_language = "python3" # If your documentation needs a minimal Sphinx version, state it here. -#needs_sphinx = '1.2' +# needs_sphinx = '5.0' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. @@ -57,7 +60,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. -#exclude_patterns.append('_templates') +# exclude_patterns.append('_templates') # This is added to the end of RST files - a good place to put substitutions to # be used globally. @@ -67,20 +70,19 @@ # -- Project information ------------------------------------------------------ # This does not *have* to match the package name, but typically does -project = setup_cfg['name'] -author = setup_cfg['author'] -copyright = '{0}, {1}'.format( - datetime.datetime.now().year, setup_cfg['author']) +project = setup_cfg["name"] +author = setup_cfg["author"] +copyright = "{0}, {1}".format(datetime.datetime.now().year, setup_cfg["author"]) # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. -import_module(setup_cfg['name']) -package = sys.modules[setup_cfg['name']] +import_module(setup_cfg["name"]) +package = sys.modules[setup_cfg["name"]] # The short X.Y version. -version = package.__version__.split('-', 1)[0] +version = package.__version__.split("-", 1)[0] # The full version, including alpha/beta/rc tags. release = package.__version__ @@ -97,7 +99,7 @@ # Add any paths that contain custom themes here, relative to this directory. # To use a different custom theme, add the directory containing the theme. -#html_theme_path = ["_themes",] +# html_theme_path = ["_themes",] # Custome template path, adding custom css and home link templates_path = ["_templates"] @@ -105,75 +107,76 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. To override the custom theme, set this to the # name of a builtin theme or the name of a custom theme in html_theme_path. -html_theme = 'sphinx_rtd_theme' +html_theme = "sphinx_rtd_theme" + def setup_style(app): app.add_stylesheet("astronify.css") -master_doc='contents' -html_extra_path=['index.html', 'CreateWithLight.html'] +master_doc = "contents" +html_extra_path = ["index.html", "CreateWithLight.html"] # Custom sidebar templates, maps document names to template names. -html_sidebars = { '**': ['globaltoc.html', 'localtoc.html', 'searchbox.html'] } +html_sidebars = {"**": ["globaltoc.html", "localtoc.html", "searchbox.html"]} # The name of an image file (relative to this directory) to place at the top # of the sidebar. -html_logo = '_static/ASTRONIFY_Ball_white.svg' +html_logo = "_static/ASTRONIFY_Ball_white.svg" # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. -html_favicon = '_static/astronify-favicon.png' +html_favicon = "_static/astronify-favicon.png" # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. -#html_last_updated_fmt = '' +# html_last_updated_fmt = '' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". -html_title = '{0} v{1}'.format(project, release) +html_title = "{0} v{1}".format(project, release) # Output file base name for HTML help builder. -htmlhelp_basename = project + 'doc' +htmlhelp_basename = project + "doc" # Static files to copy after template files -html_static_path = ['_static'] -#html_style = 'astronify.css' +html_static_path = ["_static"] +# html_style = 'astronify.css' -html_css_files = ['astronify.css'] +html_css_files = ["astronify.css"] # -- Options for LaTeX output ------------------------------------------------- # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). -latex_documents = [('index', project + '.tex', project + u' Documentation', - author, 'manual')] +latex_documents = [ + ("index", project + ".tex", project + " Documentation", author, "manual") +] # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [('index', project.lower(), project + u' Documentation', - [author], 1)] +man_pages = [("index", project.lower(), project + " Documentation", [author], 1)] # -- Options for the edit_on_github extension --------------------------------- -if setup_cfg.get('edit_on_github').lower() == 'true': +if setup_cfg.get("edit_on_github").lower() == "true": - extensions += ['sphinx_astropy.ext.edit_on_github'] + extensions += ["sphinx_astropy.ext.edit_on_github"] - edit_on_github_project = setup_cfg['github_project'] + edit_on_github_project = setup_cfg["github_project"] edit_on_github_branch = "main" edit_on_github_source_root = "" edit_on_github_doc_root = "docs" # -- Resolving issue number to links in changelog ----------------------------- -github_issues_url = 'https://github.com/{0}/issues/'.format(setup_cfg['github_project']) +github_issues_url = "https://github.com/{0}/issues/".format(setup_cfg["github_project"]) # -- Turn on nitpicky mode for sphinx (to warn about references not found) ---- # diff --git a/docs/index.html b/docs/index.html index a8b57f9..054ded1 100644 --- a/docs/index.html +++ b/docs/index.html @@ -66,7 +66,9 @@

Email Us at astronify@stsci.edu


Media

- Video lecture: How Sonification Deepens our Understanding of the Cosmos and Makes Astronomy More Accessible + Video: Hearing the Light - Astronomy Data Sonification + + Video: How Sonification Deepens our Understanding of the Cosmos and Makes Astronomy More Accessible Podcast: Out of the Blocks- Space Sonification

diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..6c5d5d4 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1 @@ +sphinx-rtd-theme diff --git a/notebooks/OBAFGKM_demo.ipynb b/notebooks/OBAFGKM_demo.ipynb new file mode 100644 index 0000000..02feb49 --- /dev/null +++ b/notebooks/OBAFGKM_demo.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4aa6cea2", + "metadata": {}, + "source": [ + "## Astronify's Spectrum preview mode with OBAFGKM samples\n", + "Based on data from the MILES library service developed by the Spanish Virtual Observatory in the framework of the IAU Comission G5 Working Group : Spectral Stellar Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6a5a4813", + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.io import fits,ascii\n", + "import numpy as np\n", + "import os\n", + "import requests\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from astropy.table import QTable, Table, Column\n", + "from astronify.series import SoniSeries" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "808908c9", + "metadata": {}, + "outputs": [], + "source": [ + "# File names to save each file when downloaded for the Miles exmaple spectra.\n", + "ostar_filename = \"1-Type_O_Stelib_HD269698.fits\"\n", + "bstar_filename = \"2-Type_B_HD003369_s0020.fits\"\n", + "astar_filename = \"3-Type_A_HD031295_s0166.fits\"\n", + "fstar_filename = \"4-Type_F_HD222451_s0889.fits\"\n", + "gstar_filename = \"5-Type_G_HD114606_s0462.fits\"\n", + "kstar_filename = \"6-Type_K_HD233832_s0410.fits\"\n", + "mstar_filename = \"7-Type_M_HD036395_s0183.fits\"\n", + "\n", + "all_filenames = np.asarray([ostar_filename, bstar_filename, astar_filename, fstar_filename,\n", + " gstar_filename, kstar_filename, mstar_filename])\n", + "n_stars = len(all_filenames)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0280bcc1", + "metadata": {}, + "outputs": [], + "source": [ + "# These \"share\" URLs are used to download the sample files.\n", + "ostar_link = \"https://stsci.box.com/shared/static/v7eecpzpxfnb3fxywy0amve4ofcoz0ns\"\n", + "bstar_link = \"https://stsci.box.com/shared/static/vpoby26z4f7cm9mavlo7fziikb1s3v9n\"\n", + "astar_link = \"https://stsci.box.com/shared/static/wmmwy5im68lnhjcw63iyc8rz3n65f1cr\"\n", + "fstar_link = \"https://stsci.box.com/shared/static/ro5ix00yh19iid9wxlzgi41bjfbremtz\"\n", + "gstar_link = \"https://stsci.box.com/shared/static/yv13duxb5qqtjdfgmsirh8rbyw3r68s2\"\n", + "kstar_link = \"https://stsci.box.com/shared/static/zbqy0bzesz7z8mqu0h0nqzffbnc4h0xg\"\n", + "mstar_link = \"https://stsci.box.com/shared/static/ztq2x6vsx7ickq0zmmimb7qhguu8vz3a\"\n", + "\n", + "all_urls = np.asarray([ostar_link, bstar_link, astar_link, fstar_link, gstar_link,\n", + " kstar_link, mstar_link])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9f205b59", + "metadata": {}, + "outputs": [], + "source": [ + "# Download each sample spectrum to the local working directory.\n", + "odir = \"miles_stellar_spectra\"\n", + "if not os.path.isdir(odir):\n", + " os.makedirs(odir)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "13223d56", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 1-Type_O_Stelib_HD269698.fits via https://stsci.box.com/shared/static/v7eecpzpxfnb3fxywy0amve4ofcoz0ns...\n", + "Downloading 2-Type_B_HD003369_s0020.fits via https://stsci.box.com/shared/static/vpoby26z4f7cm9mavlo7fziikb1s3v9n...\n", + "Downloading 3-Type_A_HD031295_s0166.fits via https://stsci.box.com/shared/static/wmmwy5im68lnhjcw63iyc8rz3n65f1cr...\n", + "Downloading 4-Type_F_HD222451_s0889.fits via https://stsci.box.com/shared/static/ro5ix00yh19iid9wxlzgi41bjfbremtz...\n", + "Downloading 5-Type_G_HD114606_s0462.fits via https://stsci.box.com/shared/static/yv13duxb5qqtjdfgmsirh8rbyw3r68s2...\n", + "Downloading 6-Type_K_HD233832_s0410.fits via https://stsci.box.com/shared/static/zbqy0bzesz7z8mqu0h0nqzffbnc4h0xg...\n", + "Downloading 7-Type_M_HD036395_s0183.fits via https://stsci.box.com/shared/static/ztq2x6vsx7ickq0zmmimb7qhguu8vz3a...\n" + ] + } + ], + "source": [ + "# Download the sample spectra.\n", + "for file, url in zip(all_filenames, all_urls):\n", + " print(\"Downloading \" + file + \" via \" + url + \"...\")\n", + " response = requests.get(url)\n", + " open(odir + os.path.sep + file, \"wb\").write(response.content)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e71b17db", + "metadata": {}, + "outputs": [], + "source": [ + "# Read in the wavelengths and fluxes of each spectrum.\n", + "# We'll store them as a list of dict objects contiaining the wavelengths and fluxes of\n", + "# the seven sample spectra.\n", + "all_spectra = []\n", + "for ii, file in enumerate(all_filenames):\n", + " file = odir + os.path.sep + file\n", + " if os.path.isfile(file):\n", + " with fits.open(file) as hdulist:\n", + " # Read in flux from the data table.\n", + " flux = np.array(hdulist[0].data)\n", + " # Normalize the flux by the maximum value.\n", + " flux_norm = np.reshape(flux/(np.nanmax(flux)), (hdulist[0].header['NAXIS1']))\n", + " # Setup list of wavelengths.\n", + " wave = np.ones(hdulist[0].header[\"NAXIS1\"], dtype=float)\n", + " # Compute the wavelength values from the WCS header keywords.\n", + " for i in range(hdulist[0].header[\"NAXIS1\"]):\n", + " wave[i] = hdulist[0].header[\"CRVAL1\"] + i*hdulist[0].header[\"CDELT1\"]\n", + " hdulist.close()\n", + " # Add this star's wavelength and fluxes to the dict object.\n", + " this_spec = dict()\n", + " this_spec[\"wls\"] = wave\n", + " this_spec[\"fls\"] = flux_norm\n", + " all_spectra.append(this_spec)\n", + " else:\n", + " raise IOError(\"Could not find expected input file: \" + file)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "445c543e", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# Construct the Sonification object.\n", + "soni_table = Table([all_spectra[0][\"wls\"], all_spectra[0][\"fls\"]],\n", + " names=[\"wavelengths\", \"flux\"])\n", + "\n", + "# In an \"ensemble\" preview, each section is a different pitch frequency. Each section\n", + "# gets played separately, then at the end all sections get played together.\n", + "data_soni_ensemble = SoniSeries(soni_table, time_col=\"wavelengths\", val_col=\"flux\",\n", + " preview_type=\"ensemble\")\n", + "ensemble_prev = data_soni_ensemble.preview_object\n", + "ensemble_prev.sonify_preview()\n", + "ensemble_prev.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "243081cd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# In a \"scan\" preview, each section has the same frequency. Each section gets\n", + "# played separately, and then there is no combined sound made.\n", + "data_soni_scan = SoniSeries(soni_table, time_col=\"wavelengths\", val_col=\"flux\",\n", + " preview_type=\"scan\")\n", + "scan_prev = data_soni_scan.preview_object\n", + "scan_prev.sonify_preview()\n", + "scan_prev.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82914e78", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "data_soni = SoniSeries(spectrum_B)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9de2f2aa", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "data_soni = SoniSeries(spectrum_A)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a71a37ec", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "data_soni = SoniSeries(spectrum_F)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50dd60d9", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "data_soni = SoniSeries(spectrum_G, flatten=True)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df882d08", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "data_soni = SoniSeries(spectrum_K)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e18f174b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'spectrum_M' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m data_soni \u001b[38;5;241m=\u001b[39m SoniSeries(\u001b[43mspectrum_M\u001b[49m, flatten\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 2\u001b[0m data_soni_preview \u001b[38;5;241m=\u001b[39m data_soni\u001b[38;5;241m.\u001b[39mpreview_object\n\u001b[1;32m 3\u001b[0m data_soni_preview\u001b[38;5;241m.\u001b[39msonify_preview()\n", + "\u001b[0;31mNameError\u001b[0m: name 'spectrum_M' is not defined" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_M, flatten=True)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f153ae5d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a1d4370", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb new file mode 100644 index 0000000..3d41883 --- /dev/null +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -0,0 +1,964 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6acbafed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WxPython is not found for the current python version.\n", + "Pyo will use a minimal GUI toolkit written with Tkinter (if available).\n", + "This toolkit has limited functionnalities and is no more\n", + "maintained or updated. If you want to use all of pyo's\n", + "GUI features, you should install WxPython, available here:\n", + "http://www.wxpython.org/\n", + "\n" + ] + } + ], + "source": [ + "from astronify.series import SoniSeries\n", + "from astropy.table import Table\n", + "from astropy.io import fits\n", + "\n", + "import numpy as np\n", + "\n", + "from pyo import *" + ] + }, + { + "cell_type": "markdown", + "id": "5e3b44e8", + "metadata": {}, + "source": [ + "### dummy data for testing SeriesPreview" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bd74c81", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 1.30, 0.3, 0.50, 0.5, 0.4, 10.3, 0.2, 0.3, 0.1, 0.4, 0.3, 1.2, 0.3, 1.1]})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bda1d4fd", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7c025809", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "df70bb84", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1]})" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7e9924e9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f6e45c77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dbWxj55Uf8P/RGyWRlMQ3jYeS7JkktmPJSOxgkKY1kCYbp/Cm2TgLZIFN26ybNeD9kLRJkCLNZoF29ksRtLtJd9HFFt4k9QAN0gZJNjHS7K4Nb4IgRTa749RvehnbsWdEihqJlES9v5E8/cD7cCiNJFLkvbz3iv8fIIikyMtjWXP06HnOeR5RVRARkf90uB0AERE1hgmciMinmMCJiHyKCZyIyKeYwImIfKqrlW8Wj8f1woULjb04k7E1Fsclk/Zfc9tn34M+B74HAHZ3/fN9CASc+R5k1v3zPUiGnfkeLK0WHbmuU2KDnQ2/9vnnn8+pauLw4y1N4BcuXMDVq1cbe/Hly7bG4jgn4n3JgWs66R2XHbnsm286c10nXLx42ZHrXv6JM9d1wuX3XXbkuk/9MO/IdZ3yrz881PBrReTGUY9zCoWIyKeYwImIfIoJnIjIp5jAiYh8igmciMinmMCJiHyqZgIXkV4R+XsReVFEJkXkD63HoyLyrIi8Zn2OOB8uEREZ9YzAdwH8mqq+E8ADAB4RkfcA+CKA51T1bgDPWfeJiBz3wgsv4LWpv3M7DNfVTOBatmHd7bY+FMCjAK5Yj18B8FFHIiQiOuQLX/gCrvzZ59wOw3V1zYGLSKeIvABgEcCzqvoLAOdUdR4ArM/DzoVJRHTLjRs3sJSdczsM19WVwFW1qKoPABgF8G4Rub/eNxCRJ0TkqohczWazjcZJRAQAUFWk02nsbK9je2vN7XBcdaoqFFXNA/gJgEcALIjIeQCwPi8e85onVfWSql5KJG7bi4WI6FTy+Ty2trYAAMs5/2zq5YR6qlASIjJk3e4D8DCAGQBPA3jMetpjAH7gVJBEREYqlarcXs619zRKPbsRngdwRUQ6UU7431bVH4rIzwF8W0QeBzAL4LccjJOICACQTqcrt1fafAReM4Gr6ksAHjzi8SUAH3AiKCKi41Qn8OUlJnAiIt9IpVLo6OhAfyiC5TavRGECJyJfSafTOH/+PLr7hrHCETgRkX+k02mMjY1hT+JYmHvd7XBcxc2siMhXUqkURkdHEY0l274KhQmciHzDNPGMjo4iEk9ie6u9m3k4hUJEvrG6uorNzU2MjY1hu2sAALCyNI++/gGXI3MHR+BE5BumiWd0dBTReBIA2roShSNwIvINUwM+OjqKG2tBAO1dC84ETkS+YRL42NgYIgsBAO3djckpFCLyDdPEc8cdd6CruwcDQ8NtXYnCBE5EvpFOp3HHHXegu7sbABCNJ7HCBE5E5H2miceIxkfaeg6cCZyIfMM08RiReHs38zCBE5EvqOrtCTyWxPbmGra31l2MzD1M4ETkC9VNPEY0PgIAyC/NuxWWq5jAicgXqmvAjUozT5tOozCBE5EvHJXAI9YIvF0XMpnAicgXTBt99RRKJHYeQPs28zCBE5EvpNNpiAjOnz9feay7O4CBoQSnUIiIvOxwE48RaeN9wZnAicgXUqnUgekTIxofYQInIvIyc5DDYZF4knPgRERedlwCj8aS2Npcxc72hgtRuYsJnIg8b3V1Fevr60dPoSTKpYTtOAqvmcBFZExEfiwi0yIyKSKfsR6/LCJzIvKC9fEh58MlonZ0VA24EYm1by14PQc6FAB8XlV/KSJhAM+LyLPW176qqn/kXHhERCcncNON2Y4j8JoJXFXnAcxbt9dFZBrAiNOBEREZRzXxGKaZpx0rUU41By4iFwA8COAX1kOfFpGXROQbIhI55jVPiMhVEbmazWabCpaI2pNp4kkmk7d9rbunF+HBOBP4SUQkBOC7AD6rqmsA/hzAWwE8gPII/Y+Pep2qPqmql1T1UiKRsCFkImo3xzXxGNH4CFbacA68rgQuIt0oJ+9vqur3AEBVF1S1qKolAH8B4N3OhUlE7ezwPuCHtevBDvVUoQiArwOYVtWvVD1+vuppvwngFfvDIyI6vgbciMbas5mnniqUhwB8AsDLIvKC9diXAHxcRB4AoACuA/g9RyIkoraXTqfx8MMPH/v1aHwEmxt57O5sItAbbGFk7qqnCuVnAOSIL/3I/nCIiA5aW1vD2tpazSkUAFjOZXB+9O5WheY6dmISkaedVANumKPV2m0hkwmciDzNJPCjasANk8CX22wenAmciDzNNPGcOIXSps08TOBE5GknNfEY3T29CA3EsMIETkTkHel0GufOnUNPT8+Jz4vGR9qulJAJnIg8rVYTjxFtw2YeJnAi8rRaTTxGJJZsuy1lmcCJyNPS6fSJFShGNDGCzfUV7O5stSAqb2ACJyLPWl9fx+rqan1TKDFrX/A2GoUzgRORZ9XTxGNE2rAWnAmciDyrniYeox27MZnAiciz6mniMSrNPNm0ozF5CRM4EXmWGYGf1MRj9AT6EApHOQInIvKCVCqFc+fOIRAI1PX8aGKEc+BERF5Qbw24EYm1VzMPEzgRedZpE3g03l4n8zCBE5FnpVKpuipQjGh8BBvry9jb3XYwKu9gAiciTzpNE49RqQVvk4VMJnAi8qS5ufJc9mnnwAG0zTQKEzgReZKpAT/VFErCauZpk4VMJnAi8qTTtNEbkWh7nczDBE5EnmQS+MjISN2vCfT2IxiOtE0tOBM4EXlSKpXC8PBw3U08RjQ+0jbdmEzgRORJp60BN6Jt1MxTM4GLyJiI/FhEpkVkUkQ+Yz0eFZFnReQ163PE+XDt9dMbNzCVzbodBhEdod6DHA5rp3b6ekbgBQCfV9X7ALwHwKdEZBzAFwE8p6p3A3jOuu8r/+K738UXnn3W7TCI6Aj1noV5WCSWxMbaEvb3dhyI6vT2drdx/fUXsLNjfzw1E7iqzqvqL63b6wCmAYwAeBTAFetpVwB81PboHJTf2cHc+jomOQIn8pyNjQ3k8/nGErjHDnaYffNl/OHn3o9nnnnG9mufag5cRC4AeBDALwCcU9V5oJzkAQwf85onROSqiFzNeihZmqmT6/k8Nvb2XI6GiKqZJp6GplA8drDD3I0ZAMDExITt1647gYtICMB3AXxWVdfqfZ2qPqmql1T1UiKRaCRGR1TPfc/kci5GQkSHneYgh8Oi8XI3plcOdsikrqGnpw8XL160/dp1JXAR6UY5eX9TVb9nPbwgIuetr58HsGh7dA6aXFw88jYRua+RJh7DtNN7ZT+UudkZnB+7Bx0d9hf91VOFIgC+DmBaVb9S9aWnATxm3X4MwA9sj85BU7kc3nHuHHo6O1mJQuQxjTTxGKaZxyv7oWRmZzBy59sduXZXHc95CMAnALwsIi9Yj30JwJcBfFtEHgcwC+C3HInQIVPZLN534QJUFVOcQiHylFQqhUQigd7e3oZe75Va8K2NVawsZZAcu9eR69dM4Kr6MwByzJc/YG84rbG6s4P02homEgkUSiX8Iu2NuTIiKmu0iceIxJOeqEKZS5UXMEfucmYE3padmNPWiHs8kcB4PI7r+Tw2WYlC5BmNNvEYXmmnz8xeAwAk77zPkeu3ZQI3c97jiQTGEwkogGtLS+4GRUQVjTbxGJH4CNZXc64382RmZ9AT6Ed8+E5Hrt+WCXxycRG9XV24ODSEieHhymNE5L7NzU2srKw0lcCj5mCHpXm7wmrI3OwMkg5VoABtmsCncjm8PR5HZ0cH3hqJoLujg5UoRB7RTBOPYQ52cHsevJzAnVnABNo0gU8uLmLcairq7uzEPbEYW+qJPKKZJh6jUguec69AYWtjFfnleSQdKiEE2jCBr+3uImVVoBgTw8McgRN5RDNNPIbpxnSzFrxSgcIEbp+ZqgoUYzwexxsrK9je33crLCKy2JHAA71BBENDrnZjZmZNAnemAgVowwRuFisPj8AV3BOFyAtSqRTi8XjDTTxGuRbcvWaeOasCJTbc+Fx+LW2XwKeyWQQ6O3Excuv8CTMa5zQKkfuabeIxIrGku1MoDlegAO2YwHM53BuPo6vqm/q2aBRdrEQh8oRmm3gMt5t5MrMzji5gAm2YwCcXFw9MnwBADytRiDyj2SYeIxofwVo+i/39XRuiOp3NjTzyyzcdXcAE2iyBb+zt4cbq6oEFTGM8keAInMhlW1tbWF5etmcKJe5eM8+tBUwmcNtMV7XQHzYej+NXKyvYKRRaHRYRWexo4jEqJ/O4sJA514IKFKDNErgZYR+eQgHKlSglVVxjJQqRa+xo4jGilWYedxJ4T6Af0UTz/x0nabsE3tPZibdGo7d9jZUoRO6zowbcMFMobrTTZ6wWeicrUIA2S+CT2SzujcUOVKAYd0ej6BThQiaRi+wcgff2hdAfHHSlEiWTuub4/DfQZgl8Kps9cv4bAAJdXbg7FuMInMhF6XQasVgMfX19tlwvEk9iOdvaKZRKBYpDhzhUa5sEvrm3h+v5/LEJHGAlCpHb7KoBN9yoBZ+7MQ0AjteAA22UwGdyOSiOXsA0JhIJvL68jF1WohC5wq4acCMaH2n5HHilAmWMCdw2UyeUEBrjiQSKqniVp/MQucKuNnojEktiLb/Y0maezOwMAr1BxytQgDZK4JPZLLo7OvC2IypQDFaiELlne3sbS0tL9k6hWAc75Jdu2nbNWjKpay2pQAHaKIFPZbO4JxZDd2fnsc+5NxZDBytRiFxhZwmhcetotdYtZM7NzrSkAgVoswR+0vQJUK5EeVs0yhE4kQucSOCmFnypRZUoG+srWF1ZaMkCJtAmCXxrfx9vrKycuIBpjCcSHIETucAkcDunUCKVEXhrFjIzs6YCxblzMKvVTOAi8g0RWRSRV6oeuywicyLygvXxIWfDbM41qwKl1ggcKFeivLa0hL1i0fnAiKjCNPGMjIzYds2+/jD6ggMt2xd8rkWbWBn1jMCfAvDIEY9/VVUfsD5+ZG9Y9qqnAsUwlSivsRKFqKXS6TSi0Sj6+/ttvW401rqTeTKz19DbF0Is4dwpPNVqJnBV/SmA5RbE4pjJbBZdHR24Oxar+VwzzcJpFKLWsruJx2hlLfictQeKiLTk/ZqZA/+0iLxkTbFEjnuSiDwhIldF5GrWpaQ4lc3i7mgUPSdUoBj3WJUoXMgkai27m3iMSAu7MedacApPtUYT+J8DeCuABwDMA/jj456oqk+q6iVVvZSoYwrDCZPZLCaGh+t6bl93N94SiTCBE7WY3U08RiRebuYp7O/Zfu1qG2vLWMsvIjnWmgVMoMEErqoLqlpU1RKAvwDwbnvDss+2VYEyHo/X/ZoJVqIQtdTOzg5yuZxjUyiqivyys808c1YFSqsWMIEGE7iInK+6+5sAXjnuuW57dWkJJdW6FjCN8UQCry4tYZ+VKEQt4UQNuNGqgx0yqWsAWpvAu2o9QUS+BeB9AOIikgbwHwG8T0QeAKAArgP4PQdjbIoZSdc7hQKUE3ihVMJry8unSvxE1BgnE/itgx2cTeBzszPo7Qu3ZA8Uo2YCV9WPH/Hw1x2IxRFT2Sw6RXD3CXugHDZRtScKEziR85xo4jEqZ2M6vJBZXsBsXQUK0AadmFPZLN4WjSLQVfN3VcW98TgE3NSKqFWcaOIx+vrD6OsPO15KaI5Ra6Uzn8BPU4Fi9FuVKFzIJGqNdDqNSCSCYDDoyPUjsRFHp1DWV5ewls+2dP4bOOMJfLdQwOvLy6eqQDF4Og9R6zjVxGNEEyOOttNnUq1toTfOdAK/ZlWgnHYEDpQT+LVcDoVSyYHIiKiaU008RsThdnqzB0orm3iAM57AT7MHymETiQT2SyW8vuzrXQSIfMGpJh4j6nAzT6UCJW7/HP5JznwC7xDBPXXsgXIYT+chao2dnR1ks1lnp1BMM8+KM808GRcqUIAznsAnrQqU3lNUoBhvt+bNJxcX7Q6LiKrMzZWnNhydQjG14A4d7NDKU3iqnekE3kwdd7CnBxeHhjCVy9kcFRFVc7KJx4g6eLDD2moO66s5JnA77RWLeG1pqaEKFIOVKETOc7KJxzCHGztRC56ZLbfQt3oBEzjDCfzVpSUUG6xAMSYSCcywEoXIUU428Rh9/QPo7Qs7UomScWETK+PMJvBmKlCM8UQCe8Ui3lhZsSssIjoknU5jaGgIoVDI0feJxpOO1ILPzc6grz9cOX+zlc5sAp9cXESHCO5toALFYCUKkfOcbuIxnDrYoXwKz9tbXoECnOEEPpXL4S2RCPq6uxu+xn3meDVWohA5xukmHiMad6aZJ5O65sr8N3CWE7gNOwmGenpw1+AgK1GIHNSqEXg0PoLVlQUUCvu2XdPNChTgjCbwvWIRry4tVbaFbcZ4IsEROJFDdnd3sbi42JIReCSWhKpi1caTeTKz7uyBYpzJBP768jIKpZIte3mbSpQiK1GIbNeKJh4j6sDBDuYYteSdrd1G1jiTCdyOChRjPJHAbrGIN/P5pq9FRAe1ogbcMPuULNu4kDl3w70KFOCMJvDJxUUIbrXDN8PUkXMahch+pga8JVMo1gjczlJCs4DpRgUKcEYT+FQuh4uRCPqbqEAx7rN+CbCUkMh+rWijN8rNPCGbp1BmMHLnfbZd77TOZAKfXFy0ZQETAMKBAMYGBliJQuSAVjXxAICIIBq372CHtXwWG2tLri1gAmcwge9bFSh2HkY8MTzMKRQiB7SqBtyIxJK2zYFXDnFo8TmY1c5cAv/Vygr2bapAMcbjcUyzEoXIdk4f5HBYJJ60bUtZU4EychdH4LYxI2W7plCAciXKTqGA66xEIbJVq5p4jHIzz01bmnkys9fQFxzAUPS8DZE15swlcLPYaEcFimEqUbiQSWSf3d1dLCwstHQEHo1bzTwrC01fK2Md4uBWBQpQRwIXkW+IyKKIvFL1WFREnhWR16zPEWfDrN9ULocLQ0MI9vTYdk1WohDZL5Mpz0W3eg4caL6ZR1Vdr0AB6huBPwXgkUOPfRHAc6p6N4DnrPueYGcFijHY24vRgQFMMoET2aaVTTyGOdih2UqUtXwWG+vLri5gAnUkcFX9KYDDR7M/CuCKdfsKgI/aHFdDCqUSrtlcgWLwdB4ie7WyiceIxqwE3mQlypzLe6AYjc6Bn1PVeQCwPh977I2IPCEiV0XkatbhBPir5WXsFYu2j8CBW5UoJVXbr03UjlrZxGP0BQcQ6A02XYmSSVklhD5N4HVT1SdV9ZKqXko4kFir2bkHymETw8PY2t/HDVaiENkinU5jcHAQ4XC4Ze9pmnmarQXPzM6gPziIoegdNkXWmEYT+IKInAcA67MnulxMAr/PoSmU6vcgoua0uonHiNhwtNqcBypQgMYT+NMAHrNuPwbgB/aE05zJbBZ3DQ4iZGMFisEETmSvVjfxGNFYcyfzmAoUt6dPgPrKCL8F4OcA7hWRtIg8DuDLAD4oIq8B+KB133V2nMJznKHeXiTDYVaiENmk1U08RjQ+gvzKTRSLhYZev5ZfxOb6iicSeFetJ6jqx4/50gdsjqUpxVIJM7kcHn7LWxx7D1aiENljb2+v5U08RiSehJZKWF1ZqOwRfhpzs9cAuF+BApyhTsw3Vlaw61AFijEej2Mqm2UlClGTMpkMVNW1BA403szj9jFq1c5MAneyAsWYGB7G5v4+Uqurjr0HUTtwo4nHMKPuRhcy52anEQwNYTByzs6wGnJmEvhkCxI4FzKJ7OFGE49ROVqt4QQ+g+TYva5XoABnKIFPZbMYGxhAOBBw7D1MAudCJlFz3GjiMfqDg+gJ9Dc0haKqyHikAgU4YwncydE3AET7+nBHKMQROFGT0uk0BgYGMDAw0PL3buZknrX8IjY38q5vYmWciQReLJUwncs5uoBpsBKFqHluNfEY0XgSy0unH4FX9kBx8RCHamcigV/P57FTKDg+AgfKB0VMZbNQVqIQNcytGnAjGh9paApl7oZ3KlCAM5LAzYjYHLzgpPFEAut7e0ivrTn+XkRnlVtdmEYknsTq8sKpm3lMBcrAkPO5ph5nIoGbRcX7bDyF5zhcyCRqzt7eHm7evOluAo8lUSoVsZY/3TZOZgHTCxUowBlJ4FPZLEbCYQz29jr+XhMsJSRqyvz8PFTV3SkU62CH02wrq6rIpK55ZvoEOCMJfDKbbcn0CQDE+vsxHAwygRM1yM0SQiNqjlY7xbayqysLnqpAAc5AAi+pYjqbxXgLpk+MiUSCUyhEDXKziceIxE8/AjcVKF6pAQfOQAK/kc9ju0UVKMY4K1GIGuZmG70RDA2hJ9B/qqPVbh2j5u45mNV8n8AnW1iBYownEljb3UVmfb1l70l0VqTTaYTDYVeaeIxyM0/yVO30mdkZBMMRz1SgAGcggbdiE6vDJliJQtQwt5t4jEgsieVcuu7nZzxyCk+1M5HAk+EwhlpQgWJwUyuixrndxGOcpp3enMLjpQoU4Awk8MkW7IFyWCIYRLy/H5OLnjgKlMhXPDMCjyeRX76JUrFY87n55ZvY2lz11AIm4PME7kYFijGRSGAql2v5+xL52f7+vutNPEY0Xm7mWc0v1HyuOcQhOcYEbpvZ1VVs7u+3dAHTYCUK0el5oYnHOM2+4HMeOoWnmq8TuBsLmMZEIoH8zg7mNzZa/t5EfuWFGnDDHK1Wzzx4JnUNoXAUA0OtzzUnYQJvEBcyiU7PC12YRjRmRuC1m3nmZqc9V4EC+DyBT2azuCMUQrSvr+XvzQROdHpeaOIxguEIenr6ak6hmAoUry1gAj5P4K04hec4w8EgYn19rEQhOoVUKoVQKORqE48hIojEk1ipcbBDfnke25trSHqoA9PwbQJXVUxlsy05hecoIlJeyGQlClHdzD7gXpmKiMSTNadQbh3i4J1NrIymEriIXBeRl0XkBRG5aldQ9UitrWFjb8+1EThQnkaZXFxkJQpRnbzSxGPU08yTSV0D4L0KFMCeEfj7VfUBVb1kw7Xq5uYCpjGRSGBlZwcLm5uuxUDkJ15p4jGisdrNPHOzMwgNxDxXgQL4eArFzD27NYUCcCGT6DT29/cxPz/vqQQeiSdRLBawesLJPKYCxYuaTeAK4BkReV5EnjjqCSLyhIhcFZGrWRsT3VQ2W15I7O+37ZqnZRqIuJBJVNvNmzc908RjmGae47aVVdXyMWpj3lvABJpP4A+p6rsA/DqAT4nIew8/QVWfVNVLqnopYeNoeSqXc3X6BADOBYOI9PZyBE5UBy818Ri1ujFXljLY3lrHyF1ncASuqhnr8yKAvwTwbjuCquN9Xa1AMViJQlQ/LzXxGBFztNoxlSiZWbOA6b0KFKCJBC4iQREJm9sA/hmAV+wK7CRz6+tY2911fQQOWMersRKFqCYvNfEYoYEount6sXJMAvfiMWrVmhmBnwPwMxF5EcDfA/g/qvrX9oR1MjNl4fYIHCgvZC5tbyO7teV2KESelkqlEAwGMTg46HYoFSKCSCx57Bz43OwMwoNxDAy2fsfTenQ1+kJVfQPAO22MpW5m0dALI3ATw+TiIoYvXnQ5GiLv8loTjxGNJ4893NjLC5iAT8sIp7JZxPv7kQgG3Q6lUonChUyik3mticeIxkewfMQIXFWRSXnvFJ5qvkzgkx5YwDTOh0IYDASYwIlq8FoTjxGJJ5FfmkepVDrweKUChQncPqYCxQvTJ0B5Dm1ieJgHHBOdoFAoYH5+3rMj8GKxgLVDzTy3FjC9WYEC+DCBz29sYNUjFSjGeDzOETjRCW7evIlSqeTJEXg0bkoJD06jZDx6Ck813yVwL7TQHzaeSCC7tYUs90QhOpIXm3iMSOzobkxTgRIejLkRVl18l8C9sInVYVzIJDqZF2vAjUo35qFKlLlZby9gAj5N4LG+Pgx7oALF4KZWRCfzYhemERqIoqs7cOBgh/IeKNc828Bj+C6BT1oLmF6qJR0JhzHAShSiY6VSKfT392NoaMjtUG4jIuVa8Ko58OXcHHa2vV2BAvgsgXutAsUwe6KwEoXoaKYG3EsDr2rR+MiB/VD8sIAJ+CyB39zYwMrOjqcWMA1WohAdz3RhelUkljxwMk+lhHCMCdw2XlzANCaGh7GwuYkl7olCdBuvNvEYkXgSK8u3mnnmZmcwMJTwdAUK4NMEbqo+vIQLmURH83ITjxGLj6BY2Mf6avnfbybl/QVMwGcJfDKbRaS3F+c8VIFiMIETHW1hYQHFYtHzI3Cg3MxjKlC8Pv8NNLEboRumPFiBYowNDCDU08OFTKJDvNzEY1SaeXIZDAzGfVGBAvgogasqJrNZfOw+b+5LUDmdhwmc6AAvN/EY0YQ5Wm0OXd09AODpbWQN3yTwxc1NLG9ve3IB0xhPJPA3r7/udhhEnuKHEXh4IIaurh4sL81hf38XgHePUavmmzlwL1egGBOJBOY3NrCyve12KESekU6n0dfXh0gk4nYoxxKRciVKLoNM6hoGhoYRGoi6HVZNvhmBT3q4AsWoXsh8yOVYiLzC6008hmnmKezv+WL+G/DZCHwwEMD5UMjtUI5VOV6N8+BEFV6vATci1tFqmZQ/KlAAnyXwieFhT/8Wv3NwEMHubi5kElXxehemEY0lkVucxc72BpJ3en8BE/BRAp/MZjEe9+bJ0EaHCO5jJQpRRalYQiaT8XQFimEqUQDv74Fi+CKBZ7NZ5La2PL2AaUxwUyuiio3lDc838RimFhzw9jFq1XyxiDk1NQXA2wuYxngigSsvvoh8Pn/qrTNVFRsbG1hdXUU+n8fq6uqB2+uv/l9HYu7oEPT2dKE30IVAdyd6A13o7elCwHqs8rWezspt8/VAT6enp7XIXWvZNQDeLiE0zNFqg5FzCIW9WzFTrakELiKPAPgTAJ0AvqaqX7YlqkMmJycBeLuE0DAxfv/738fo6OiBBHxUUq7+vLa2hmKx6PJ/wekFejrLyf5Acu9E79CP0Nvbi97eXgQCgSNv17p/1Ney2TwCgS4EAl3o6elET08XOjrc/yVSLJawu1uofOztFSFyHYODgxgYGEBnZ6drsWlJsb2+jY3lDWwsb2BzZRMbK+XPmyub2FjewNbqFqRD0NXTdZuFzXwAAAePSURBVOuju/y5s6fzwH3z0dndefD5hz7SU95v4jHMyTx+mT4BmkjgItIJ4M8AfBBAGsA/iMjTqjplV3DG1NQUBgIBjITDdl/adu84dw4A8MlPfvLIrw8ODlY+hoaGMDo6ivvvv79y/6TPoet/ig4HRrvFUgm7e0Xs7BWws1v+2N23bu8Vyl+zbh/+2s5u4cBrze3t3X3sBmLY3d3FxsYGcrkcdnZ2sLu7i52dnQMfZge4ZphEHgiYz12Vz9XJ/rj7nZ0d2NsrYm/PJODq2wXs7ZUT8sEEXThwv1jUIyL708qtcDh82//Tev6/m9t9fX0H/trRkmJrbauSgI9LzOa+lm6Pr6OrA6FICKFoCP2D/dCSorBfwM7GDgp7BRT2CijuFyu3zcdpiAjuvPPOU73GDaGBGHr7whi7eL/bodStmRH4uwG8rqpvAICI/C8AjwKwPYE//vjj+KcLC774U/3OwUH87e/8DjY+9rHb/jGGw2F0dDSx7LDYY1+gh4Sd2B/sHZfrelqhUDgyuR91f3t7G+n0/74tmR5MqMUD9/f2Ctje3sPq6tEJeGengFJJ0d3dUZXcD/4CMMl+YKC36pdD54HnH/WLIRr9yG1/dZnb8/PzmJ6ertyv9ddXV1dX5edpYWUBm/mjk3JndyeCkSBCkRDC8TDO33O+cj8YCSIULSfsYCSI3lDvqf9dqSpKhdKthL5/MLkfTviffv+nPd3EY3R0dOBL//mvEIt7f7rHaCaBjwBIVd1PA/hHzYVztAcffBAPTkw4cWlHvP/iReA3fsPtMHyjq6sLoVAIoTpr/N9881XbYyiV1JFpmIsXf7eu56kqtra2jp1eO/wLYDo/fSsZH0rMgWDA0cGOiKCzuxOd3Z0IBAM1n//e977XsVjsNnbBP3kGaC6BH/UTcttwQESeAPAEAF/8GUXtye05dBFBMBhEMBhEMpms+fzLP7nsfFDkec2UEaYBVK9MjALIHH6Sqj6pqpdU9VLCB4uQRER+0UwC/wcAd4vIRRHpAfDbAJ62JywiIqql4SkUVS2IyKcB/A3KZYTfUNVJ2yIjIqITNVUHrqo/AvAjm2IhIqJT8EUrPRER3Y4JnIjIp5jAiYh8igmciMinRPWo/RscejORLIAbDb48DiBnYzhO81O8fooV8Fe8fooV8Fe8fooVaC7eu1T1tkaalibwZojIVVW95HYc9fJTvH6KFfBXvH6KFfBXvH6KFXAmXk6hEBH5FBM4EZFP+SmBP+l2AKfkp3j9FCvgr3j9FCvgr3j9FCvgQLy+mQMnIqKD/DQCJyKiKkzgREQ+5YsELiKPiMg1EXldRL7odjzHEZExEfmxiEyLyKSIfMbtmGoRkU4R+X8i8kO3Y6lFRIZE5DsiMmN9j/+x2zGdREQ+Z/0cvCIi3xKRXrdjMkTkGyKyKCKvVD0WFZFnReQ167NnzkE7Jt7/Yv0svCQifykiQ27GaBwVa9XX/p2IqIjE7XgvzyfwqsOTfx3AOICPi8i4u1EdqwDg86p6H4D3APiUh2M1PgNg2u0g6vQnAP5aVd8O4J3wcNwiMgLg3wK4pKr3o7zl8m+7G9UBTwF45NBjXwTwnKreDeA5675XPIXb430WwP2q+g4ArwL4/VYHdYyncHusEJExlA+Bn7XrjTyfwFF1eLKq7gEwhyd7jqrOq+ovrdvrKCeYEXejOp6IjAL45wC+5nYstYjIAID3Avg6AKjqnqrm3Y2qpi4AfSLSBaAfR5xY5RZV/SmA5UMPPwrginX7CoCPtjSoExwVr6o+o6oF6+7foXwqmOuO+d4CwFcBfAFHHD3ZKD8k8KMOT/ZsUjRE5AKABwH8wt1ITvRfUf6BKrkdSB3eAiAL4H9YUz5fE5Gg20EdR1XnAPwRyqOteQCrqvqMu1HVdE5V54HyYATAsMvxnMbvAvgrt4M4joh8BMCcqr5o53X9kMDrOjzZS0QkBOC7AD6rqmtux3MUEfkwgEVVfd7tWOrUBeBdAP5cVR8EsAlv/Yl/gDV//CiAiwCSAIIi8q/cjepsEpE/QHn68ptux3IUEekH8AcA/oPd1/ZDAq/r8GSvEJFulJP3N1X1e27Hc4KHAHxERK6jPC31ayLyP90N6URpAGlVNX/RfAflhO5VDwN4U1WzqroP4HsA/onLMdWyICLnAcD6vOhyPDWJyGMAPgzgX6p3m1reivIv8hetf2+jAH4pInc0e2E/JHDfHJ4sIoLyHO20qn7F7XhOoqq/r6qjqnoB5e/p36qqZ0eIqnoTQEpE7rUe+gCAKRdDqmUWwHtEpN/6ufgAPLzoankawGPW7ccA/MDFWGoSkUcA/HsAH1HVLbfjOY6qvqyqw6p6wfr3lgbwLutnuimeT+DWIoU5PHkawLc9fHjyQwA+gfJo9gXr40NuB3WG/BsA3xSRlwA8AOA/uRzPsay/FL4D4JcAXkb535pnWr9F5FsAfg7gXhFJi8jjAL4M4IMi8hrK1RJfdjPGasfE+98AhAE8a/1b+++uBmk5JlZn3su7f3UQEdFJPD8CJyKiozGBExH5FBM4EZFPMYETEfkUEzgRkU8xgRMR+RQTOBGRT/1/d1LkjIay02gAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "35e668f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 10.3 -10.3 10.3 10.5 10.5 10.4 10.3 10.2 10.3 10.1 10.4 10.3\n", + " 40.2 10.3 30.1]\n" + ] + } + ], + "source": [ + "y = np.asarray([0.3, -20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1])+10\n", + "print(y)\n", + " \n", + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e49103f1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5158727c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# TODO: We have a negative area in the first fluctuation (\"absorption\" line)\n", + "\n", + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ca540bf1", + "metadata": {}, + "outputs": [], + "source": [ + "x = list(range(0, 15, 1))\n", + "y = np.ones(15)\n", + "\n", + "data_table = Table({\"time\": x,\n", + " \"flux\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fab274ab", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c2e12110", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cdfa7243", + "metadata": {}, + "outputs": [], + "source": [ + "x = np.asarray(range(0, 15, 1))\n", + "y = (x*-1)+15\n", + "\n", + "data_table = Table({\"time\": x,\n", + " \"flux\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "28df65ea", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a9cd036a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.33333335" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum([1.86666667, 1.46666667, 1.06666667, 0.66666667, 0.26666667])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6557b47e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d8fd9ec4", + "metadata": {}, + "outputs": [], + "source": [ + "amps = [0.02040816, 0.08163265, 0.14285714, 0.20408163, 0.26530612]\n", + "\n", + "lfo1 = Sine(10, 0, float(1/np.abs(np.log(amps[0]))), 0)\n", + "#lfo1 = Sine(10, 0, amps[0]*10, 0)\n", + "lfo2 = Sine(10, 0, amps[1], 0)\n", + "lfo3 = Sine(10, 0, amps[2], 0)\n", + "lfo4 = Sine(10, 0, amps[3], 0)\n", + "lfo5 = Sine(10, 0, float(1/np.abs(np.log(amps[4]))), 0)\n", + "#lfo5 = Sine(10, 0, amps[4]*10, 0)\n", + "\n", + "streams1 = Sine(freq=300, mul=lfo1).out(delay=0, dur=2.0)\n", + "streams2 = Sine(freq=300, mul=lfo5).out(delay=2.5, dur=4.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "91ece8f7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.2569491606212147, 0.7536527950141229)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "float(1/np.abs(np.log(amps[0]))), float(1/np.abs(np.log(amps[4])))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "488bcc85", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.20408160000000003, 2.6530612)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "amps[0]*10, amps[4]*10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57cf766a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74339612", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a0973367", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 0.30, 0.3, 0.30, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 040.4, 0.3]})" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ebec7606", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAe60lEQVR4nO3dfWxcd53v8ffXD0mcxPHMOE7stpR0u13uIroUZPXC7WrFJfSqC4jCokpwC5QLKPwB3HIF3S2txO1W6qoSBYouiFWB3oa7EVeUsmrLwy7dLBVC6sK6UJqWcDdoS0sa23HmwQ95tD3f+8ec40zssTMen5lzzsznJVmeOZ75zldp8/HJ7/x+52fujoiIpE9X3A2IiEhjFOAiIimlABcRSSkFuIhISinARURSqqeVH7Zz507fs2dPY28+dizSXlIhG3cDrXe2A08p8ufi7qD1Npd3x91Cyw0OdDf83qeffvqEuw8tP97SAN+zZw9jY2ONvfmuuyLtJRX+Iu4GWu+F/rg7aL39L8bdQevtmftk3C203Affnmn4vWZW8/+SDjzfERFpDwpwEZGUUoCLiKSUAlxEJKUU4CIiKaUAF5HUeurJh/n0h67mv70jx6c/dDVPPflw3C21VEunEYqIROWpJx/moS/fyrmzpwHITx3loS/fCsAb33RTnK21TN1n4GbWbWa/NLPvBc9zZvaEmR0JvnfgshMRicsj37x7KbxD586e5pFv3h1TR623niGUW4HDVc9vBw66+1XAweC5iEhL5E+8vK7j7aiuADezy4C3AV+vOnwjsD94vB94Z7StiYisbnDnpes63o7qPQO/H/hLoFx1bLe7jwME33fVeqOZ7TOzMTMbm5qa2lCzIiKhd3/gs2za1HfBsU2b+3j3Bz4bU0etd9EAN7O3A8fd/elGPsDdH3D3UXcfHRpacS8WEZGGvPFNN/Gu99259Dy381I++PEvdcwFTKhvFsp1wDvM7K3AFmCHmf0dMGlmI+4+bmYjwPFmNioistwVV12z9Piv/uZxdo1cEWM3rXfRM3B3/4y7X+bue4D3AP/s7u8DHgNuCV52C/Bo07oUEamhmB+vetx5t5zeyEKee4HrzewIcH3wXESkZUqFiZqPO8W6FvK4+5PAk8HjPLA3+pZEROpTKkzQ1dVNubzYkQGupfQiklrF/DF27n4lmzb1XTCc0im0lF5EUqtUmCA7OBI87rwA1xm4iKRWqTBBJjdMNjdMKa8hFBGRVHB3SvkJMrkRMoPDFDtwDFxDKCKSSqdOTnPu3Gmyg8OAU8r/EHfHzOJurWUU4CKSSqXgomUmGAM/d+40p0/OsHX7QJxttZQCXERSKZw2mM0NgzsAxcJ4RwW4xsBFJJXCaYOZ3AiZ3DBw/qy8U+gMXERSKZw2GIY30HEXMnUGLiKpVCxMsG17hk2b+xjI7gY6by64AlxEUimcAw6wectWtm4b6Ljl9ApwEUmlUn6cTG5k6XkmN9Jxy+kV4CKSSsXC+NIyeoDs4IjOwEVEkq5cLjNdmLzgAmYmN9xxs1AU4CKSOrPTU5TLi2QGqwJ8cJjp4iTlcnmNd7YXBbiIpE4xuHHVhWPgwywuLjA7fSKutlqunk2Nt5jZz83sV2b2vJn9dXD8LjN72cyeCb7e2vx2RUTOTxe8cAz8kuBnnTMOXs9CnrPAm919zsx6gZ+a2Q+Dn33R3e9rXnsiIiuFIb18DLzys3FeeeWfxNJXq100wN3dgbngaW/w5c1sSkRkLcX8OGbGjsyupWNhgHfSVMK6xsDNrNvMngGOA0+4+8+CH33czJ41swfNLLvKe/eZ2ZiZjU1NTUXUtoh0slJhgh2ZXfT09C4dG8juxsw6agilrgB390V3vwa4DLjWzF4DfBW4ErgGGAc+v8p7H3D3UXcfHRoaiqhtEelkpcL4BcMnAD09vfQPDCnAV+PuJSq70t/g7pNBsJeBrwHXNqE/EZEVqpfRV+u0ueD1zEIZMrNM8LgPeAvwGzMbqXrZu4DnmtOiiMiFivmVZ+BQuTd4sYNuaFXPLJQRYL+ZdVMJ/G+7+/fM7P+Y2TVULmj+Dvho89oUEalYmD/H7PSJpWmD1TKDI7zw21/G0FU86pmF8izwuhrH39+UjkRE1jBdnASoPYQyOMJMaYqFhfkLLnC2K63EFJFUCYdIqpfRh7JBqE93yIVMBbiIpEopH+6FObLiZ+EGx50yE0UBLiKpsrQKc3BlgIeh3ilbqynARSRVioVxunt62d6fW/Gz6uX0nUABLiKpUsqPk8nupqtrZXxt3zFId09vxyynV4CLSKqUChM1h08Aurq6yGR3awxcRCSJSoWJmhcwQ5lc52ytpgAXkVQp5o/VnAMeqiynV4CLiCTKmdNznD41u3aADw5TLBxrYVfxUYCLSGqUglWY2VXGwKEylfD0yRnOnjnZqrZiowAXkdQIh0ZWu4hZ/bNSYbIlPcVJAS4iqVHMV4ZGLjYGXnlt+08lVICLSGrU2gtzuezSGbgCXEQkMUqFCTZv2Ubf1h2rvub8asz2n4miABeR1Ai3UjOzVV/Tt3UHmzZvVYADmNkWM/u5mf3KzJ43s78OjufM7AkzOxJ8r7mpsYhIVFbbiaeamZHJDS+Nl7ezes7AzwJvdvfXUtnA+AYzewNwO3DQ3a8CDgbPRUSaplSYWHMKYSg72BmrMS8a4F4xFzztDb4cuBHYHxzfD7yzKR2KiADuvupmxstlcsMK8JCZdZvZM8Bx4Al3/xmw293HAYLvu5rXpoh0upNzJebPnSGzxn1QQpncCMX8OO7egs7iU1eAu/uiu18DXAZca2avqfcDzGyfmY2Z2djU1FSjfYpIhyutsZXactnBEebPneHUyelmtxWrdc1CcfcS8CRwAzBpZiMAwffjq7znAXcfdffRoaGhDbYrIp1qra3UlgtDvtTmi3nqmYUyZGaZ4HEf8BbgN8BjwC3By24BHm1WkyIia22ltly2Q+aC99TxmhFgv5l1Uwn8b7v798zsKeDbZvZh4CXgpib2KSIdbmkZfXb3RV8bjpO3+3L6iwa4uz8LvK7G8TywtxlNiYgsVypMsK0/y6bNfRd9bafsjamVmCKSCvVOIQTYtLmPbdszbb87vQJcRFKhsgrz4uPfoU6YC64AF5FUqOyFWd8ZOAR7Y7b5GLgCXEQSr7y4yHRxsq4ZKKHs4AhFjYGLiMRrduYE5fLiOs/Ah5kuTFIul5vYWbwU4CKSeOF0wHWNgQ8OUy4vMjvdvivAFeAiknjrWUYfyuYuAaCYb98LmQpwEUm8MITruZVsaGk5fRuPgyvARSTxSvlxzIwdmfpvetoJW6spwEUk8YqFCXZkdtHdXc/dPyp2ZHZhZm29nF4BLiKJVyqMr2v4BKCnp5cdmV06AxcRidN6ltFXq6zG1Bm4iEhs6tnMuJbK5sYKcBGRWMzPn2VuJr+uOeChdt/cWAEuIok2XZwE1jeFMJTJjTA7fYKF+XNRt5UICnARSbSlnXgaHEKB878E2k09W6q9wsx+bGaHzex5M7s1OH6Xmb1sZs8EX29tfrsi0mmWltGvYxVmKHxPu97Uqp5JlQvAp9z9F2bWDzxtZk8EP/uiu9/XvPZEpNOFmxk3OgZeXaPd1LOl2jgwHjyeNbPDwKXNbkxEBCpzwLt7eunfMbju94ah364XMtc1Bm5me6jsj/mz4NDHzexZM3vQzLKrvGefmY2Z2djUVPveFUxEmiOcQmhm637v9v4c3T29bTuEUneAm9l24BHgk+4+A3wVuBK4hsoZ+udrvc/dH3D3UXcfHRoaiqBlEekkjS7iAejq6iKT3d22O/PUFeBm1kslvA+4+3cB3H3S3RfdvQx8Dbi2eW2KSKcqFSbIDl7S8PszbTwXvJ5ZKAZ8Azjs7l+oOl59ReFdwHPRtycina5UaGwVZiiba98Ar2cWynXA+4FDZvZMcOwO4L1mdg3gwO+AjzalQxHpWGdOz3H61OyGAjyTG+b5Z34cYVfJUc8slJ8Cta4e/CD6dkREzgvPnNezF+ZymcERTp+a5czpObb0bY+qtUTQSkwRSaylVZgbGAMPw7/UhqsxFeAikljF/DFg42fg0J6LeRTgIpJY58/ANzYGDud/GbQTBbiIJFYpP8GWvu30bd3RcI2l5fRtOBNFAS4iiVXcwCKe0Ja+fjZv2aYAFxFppVL+2IYD3MzadmceBbiIJNZGltFXq+zMowAXEWkJd6dYmGhoJ57lKpsbawhFRKQlTs6VWJg/29B9wJcLA9zdI+gsORTgIpJI4bS/KIZQMrkR5s+d4eRcacO1kkQBLiKJtJG9MJc7P5WwvcbBFeAikkhL90HZwDL6UPhLoN1WYyrARSSRljYzzu3ecK1Mmy7mUYCLSCKV8uNs68/Su2nLhmtlspVfAu22nF4BLiKJVIpoCiHAps19bOvP6gxcRKQVKot4oglwaM+54PVsqfYKM/uxmR02s+fN7NbgeM7MnjCzI8H3mrvSi4g0ItyNPiqZ3EjbLaev5wx8AfiUu/8x8AbgY2b2auB24KC7XwUcDJ6LiGxYeXGR6dJkpAGebcPNjS8a4O4+7u6/CB7PAoeBS4Ebgf3By/YD72xWkyLSWWamp/ByObIxcKgMoUwXJykvLkZWM27rGgM3sz3A64CfAbvdfRwqIQ/sWuU9+8xszMzGpqamNtatiHSE81MIowvwbG6YcnmR2ZkTkdWMW90BbmbbgUeAT7r7TL3vc/cH3H3U3UeHhoYa6VFEOky4YjLqMXCgrcbB6wpwM+ulEt4H3P27weFJMxsJfj4CHG9OiyLSac6vwowwwNtwOX09s1AM+AZw2N2/UPWjx4Bbgse3AI9G356IdKJSfgLr6mJHpubIbEPCXwbFNlpO31PHa64D3g8cMrNngmN3APcC3zazDwMvATc1p0UR6TTFwjgDmV10d9cTUfXZkdmFdXVRaqMhlIv+6bj7TwFb5cd7o21HRKSyjD7K8W+A7u4eBjK7KLbRVEKtxBSRxCkVJpbGrKNUWY3ZPmfgCnARSZxifpxsxGfg0H7L6RXgIpIo8/NnmZstRDoHPNRuu9MrwEUkUaYLk0C0c8BD2cFLmJvJMz9/NvLacVCAi0iiFIMx6iiX0YfCXwrTxcnIa8dBAS4iiVLKR78KM7S0tVqbjIMrwEUkUYpLmxk34Qx8aTFPe4yDK8BFJFFKhXF6ejaxfUcu8trZXGWD5HbZ3FgBLiKJUspPkMkNU7mLR7S278jR3dPbNnPBFeAikijFwvjSUEfUzKytphIqwEUkUSpn4NGPf4faaWceBbiIJEqUu9HXkskpwEVEInf61CxnTs82ZQphqJ3uh6IAF5HEKC1NIWxugFd+Ucw17TNaRQEuIolRauIc8FB2aWee9A+j1LMjz4NmdtzMnqs6dpeZvWxmzwRfb21umyLSCUpNXEYfCn85dESAAw8BN9Q4/kV3vyb4+kG0bYlIJyo2cRl9KLxNbTF/rGmf0SoXDXB3/wlQaEEvItLhSoUJtvRtp29rf9M+I9NJQyhr+LiZPRsMsWRXe5GZ7TOzMTMbm5qa2sDHiUi7a/YccIC+rf1s6dveFsvpGw3wrwJXAtcA48DnV3uhuz/g7qPuPjo0NNTgx4lIJygWjjVtFWa1TG64LfbGbCjA3X3S3RfdvQx8Dbg22rZEpBOF90FptkxumFInjIHXYmbV/8Z5F/Dcaq8VEamHu1dWYbYiwNtkOX3PxV5gZt8C3gTsNLOjwP8E3mRm1wAO/A74aBN7FJEOcHK2yMLCOTKDlzT9s7LBEIq7N+Wuh61y0QB39/fWOPyNJvQiIh0snNbXkjPw3AgL82c5OVdie/+qczASTysxRSQRWrGMPpRpk7ngCnARSYRmbqW2XLssp1eAi0giLJ2Bt2QaoQJcRCQypfwxtvfn6O3d3PTPyuR2A+nf3FgBLiKJUCxMtOTsG6B30xa29+coKcBFRDaulJ8g24Lx71BmcFhDKCIiUSgVxpduNNUK7bC1mgJcRGK3uLjAdOl4S6YQhtphd3oFuIjEbqY0hZfLLQ3w7OAI06VJyouLLfvMqCnARSR24VBGM3fiWS6TG8bLZWam03ubawW4iMTu/E48rR0Dr/7sNFKAi0jswr0wWz2EUv3ZaaQAF5HYlQoTWFcXA5ldLfvM8JdFmmeiKMBFJHbF/DgDmd10dXe37DN3ZIawrq5Ub62mABeR2JUKrdmJp1p3dw8DmV0UNYQiItK4yiKe1gY4BIt52vkiZrDr/HEze67qWM7MnjCzI8H39N4RXURi1+pl9KG0L6ev5wz8IeCGZcduBw66+1XAweC5iMi6zZ87w9xsoaXL6EPZlO9Of9EAd/efAIVlh28E9geP9wPvjLgvEekQpcIk0NophKFMboS5mTzz82db/tlRaHQMfLe7jwME31ed+2Nm+8xszMzGpqbSu+JJRJojnIfdir0wlwvP+qeDXyJp0/SLmO7+gLuPuvvo0NBQsz9ORFJmaRVmTEMoQGpnojQa4JNmNgIQfD8eXUsi0kmW7oMSx0XMcDFPSmeiNBrgjwG3BI9vAR6Nph0R6TSlwjg9vZvZ1t/6yWzZwUsAUnshs55phN8CngJeZWZHzezDwL3A9WZ2BLg+eC4ism7FwgTZ3DBm1vLP3tafpadnU2rvh9JzsRe4+3tX+dHeiHsRkQ5Uyo/HMgMFwMzI5IZTu5xeKzFFJFaVZfStH/8OZQaHO+4ipohIJEot3I2+lmzuEp2Bi4is1+lTs5w5PdfSnXiWS/NyegW4iMSmlG/9Rg7LZXLDnDk9y+lTs7H10CgFuIjEJpy+F+cY+PmdedJ3Fq4AF5HYxLGV2nLhLw8FuIjIOhQTMoQC6dwbUwEuIrEpFSbY0tdP39b+2HoIAzyNu9MrwEUkNnFspbZc39Z+tvT1awhFRGQ9SoXxWKcQhtK6GlMBLiKxKca4jL5aZS64hlBEROri7rGvwgxlcsMaAxcRqdfcTIHFhflY54CHsoMjlAoTuHvcrayLAlxEYlEsHANIyBj4CAsL5zg5W4y7lXVRgItILMKLhkkYA1/aWi1/LOZO1kcBLiKxiHMrteUyKV1Of9ENHdZiZr8DZoFFYMHdR6NoSkTaXxiWA7ndMXdy/pdI2rZW21CAB/6zu5+IoI6IdJBi/hjbdwzS27s57laWfomk7QxcQygiEotSsBdmEvT2bmZ7f45Sh42BO/AjM3vazPbVeoGZ7TOzMTMbm5qa2uDHiUi7SMIy+mrZwZHUDaFsNMCvc/fXA38OfMzM/mz5C9z9AXcfdffRoaGhDX6ciLSLYn6czOAlcbexJI3L6TcU4O5+LPh+HPh74NoomhKR9ra4uMBM6XhihlCgMhMlbcvpGw5wM9tmZv3hY+C/AM9F1ZiItK+Z0nHcPRHL6EPZ3AjTpeMsLi7E3UrdNnIGvhv4qZn9Cvg58H13/4do2hKRdlZM0CKeUGZwGC+XmSml51pdw9MI3f3fgddG2IuIdIhwM+NswsbAIZgdk4Dl/fXQNEIRabkk7IW5XHhTrTTdlVABLiItVyxM0NXVzY6B5MxMO787vQJcRGRVpcIEA9nddHV3x93Kkh0DQ1hXV6pWYyrARaTlkrITT7Wu7m4GMrsV4CIiaykVkhfgkL6deRTgItJySVtGH8qmbDGPAlxEWmr+7DwnZ4uJnKqXtuX0CnARaam5/BxwfhOFJMkMjjA3W2D+3Jm4W6mLAlxEWmo2Pwskaw546PxUwsmYO6mPAlxEWmr2RHID/PxqzHSMgyvARaSlZk7MAMlaRh+qXk6fBgpwEWmp2fwsPb2b2bY9E3crK2RTtpxeAS4iLTV3Yo5sbhgzi7uVFbb1Z+np3awhFBGRWmZOzCRyBgqAmZHNDadma7UodqVvqgMHDnDnnXfy0osvcvnAAPfs3cvNV1/deL1Dh7jz4EFemp6OpF4zai7Vu3uay4cHuOcTe7n5bRuo9/1D3Pm/DvLSRDT1mlGzut7IyAC33baXG29svN6jjx7ic587yPh4MutV1zw2Ps3ArgH2fmQvV7+l8ZqH/ukQB79+kOnjyawX1vz9c7+nvPgin/7Q1bz7A5/ljW+6aUM1o/TUkw9TzI/zL08+zJHnn0pcf8ttKMDN7AbgS0A38HV3vzeSrgIHDhxg3759nDp1CoAXp6fZ9/jjAA0F5IFDh9j3+OOcmp+PpF4zaq6oNz7NvruDeg0E5IHvH2Lf3Y9z6kw09ZpRc3m9Y8emueOOSr1GQvLRRw9xxx2Pc/p0MuvVqjk9Oc3j91VqNhKSh/7pEI/f9zjzZ5NZr7pmebEMQH7qKA99+VaARITkU08+zENfvpWFhXNA8vqrxdy9sTeadQP/BlwPHAX+FXivu/96tfeMjo762NhY3Z+xZ88eXnzxxRXHe7q6+KPBwXX3/G/5PAvlcmT1mlFz1Xo9XfzR5Q3UeynPwkJ09ZpRc616V1yx/novvJDsemvV7OruYvCy9dfMH80vBWMS661Vc3DoMu578FBDNaP06Q9dTX7q6IrjUfX3wbc3ftHWzJ5299HlxzdyBn4t8NtgZx7M7P8CNwKrBvh6vfTSSzWPL5TLvLqBHe5/PVV7q6RG6zWj5qr1Fsq8+soG6v17tPWaUXOten/4h+uvd+RIsuutVbO8WGZoz/prTr2Y7Hpr1cyfeLmhelFbrY+k9FfLRgL8UuD3Vc+PAv9x+YvMbB+wD+Dyyy9f1wdcfvnlNc/AXzkwwMM3rf+fNHvuv58Xp6cjq9eMmqvWGxng4fsaqHfD/bw4Hl29ZtRcrd4llwzwla+sv96f/un9HDuW3Hpr1RzYPcBNd62/5v3vuZ/pyeTWW6vm4M5LG6oXtcGdl9Y+A09If7VsZBZKrTlAK8Zj3P0Bdx9199GhdZ6R3nPPPWzduvWCY1t7e7ln79511Vmqt3cvW3t7I6vXjJo1623p5Z5PNFjvE3vZuiW6es2oWateX18vt93WWL3bbttLX19y661Ws3dzL3s/0ljNvR/ZS+/m5NZbreamzX28+wOfbbhmlN79gc+yaXPfBceS1F8tGzkDPwq8our5ZcCxjbVzoZtvvhkgslko4fuinDESdc0L6s1sfIZH+L4oZ4xEXXN5vY3O8gjfF9WskajrLa8ZxSyU8H1RzRqJut7KmjMM7rw0UbM8wj4e+ebd5E+8nLj+atnIRcweKhcx9wIvU7mI+V/d/fnV3rPei5gXuOuuxt6XZn8RdwOt90J/3B203v6Vo4Rtb8/cJ+NuoeUSdRHT3RfM7OPAP1KZRvjgWuEtIiLR2tA8cHf/AfCDiHoREZF10FJ6EZGUUoCLiKSUAlxEJKUanoXS0IeZTQGNXnPfCZyIsJ1mSHqPSe8Pkt9j0vsD9RiFpPX3SndfsZCmpQG+EWY2VmsaTZIkvcek9wfJ7zHp/YF6jELS+wtpCEVEJKUU4CIiKZWmAH8g7gbqkPQek94fJL/HpPcH6jEKSe8PSNEYuIiIXChNZ+AiIlJFAS4iklKpCHAzu8HM/p+Z/dbMbo+7n2pm9goz+7GZHTaz583s1rh7Wo2ZdZvZL83se3H3spyZZczsO2b2m+DP8o1x97Scmf2P4L/xc2b2LTPbkoCeHjSz42b2XNWxnJk9YWZHgu/ZhPX3ueC/87Nm9vdm1vht+prUY9XPPm1mbmY74+jtYhIf4MHem18B/hx4NfBeM3t1vF1dYAH4lLv/MfAG4GMJ66/arcDhuJtYxZeAf3D3/wC8loT1aWaXAv8dGHX311C5A+d74u0KgIeAG5Ydux046O5XAQeD53F5iJX9PQG8xt3/hMotqT/T6qaWeYiVPWJmr6Cy52/tvR0TIPEBTtXem+5+Dgj33kwEdx93918Ej2epBE/i9mAys8uAtwFfj7uX5cxsB/BnwDcA3P2cu5fi7aqmHqAvuBf+ViLewKQR7v4ToLDs8I3A/uDxfuCdLW2qSq3+3P1H7r4QPP0XKpvBxGaVP0OALwJ/SY2dxpIiDQFea+/NxAUkgJntAV4H/CzeTmq6n8r/jCu3BY/fHwBTwP8Ohni+bmbb4m6qmru/DNxH5WxsHJh29x/F29Wqdrv7OFROMIBdMfezlg8BP4y7ieXM7B3Ay+7+q7h7WUsaAryuvTfjZmbbgUeAT7r7TNz9VDOztwPH3f3puHtZRQ/weuCr7v464CTx/rN/hWAc+UbgCuASYJuZvS/ertLNzO6kMgR5IO5eqpnZVuBOILmbYQbSEOBN33tzo8ysl0p4H3D378bdTw3XAe8ws99RGYJ6s5n9XbwtXeAocNTdw3+5fIdKoCfJW4AX3H3K3eeB7wL/KeaeVjNpZiMAwffjMfezgpndArwduNmTtxjlSiq/qH8V/J25DPiFmQ3H2lUNaQjwfwWuMrMrzGwTlQtHj8Xc0xIzMypjt4fd/Qtx91OLu3/G3S9z9z1U/vz+2d0Tc/bo7hPA783sVcGhvcCvY2yplpeAN5jZ1uC/+V4SdqG1ymPALcHjW4BHY+xlBTO7Afgr4B3ufirufpZz90Puvsvd9wR/Z44Crw/+P02UxAd4cLEj3HvzMPDthO29eR3wfipntc8EX2+Nu6kU+gRwwMyeBa4B/ibmfi4Q/OvgO8AvgENU/u7EvtzazL4FPAW8ysyOmtmHgXuB683sCJVZFPcmrL8vA/3AE8Hfl7+Nq781ekwFLaUXEUmpxJ+Bi4hIbQpwEZGUUoCLiKSUAlxEJKUU4CIiKaUAFxFJKQW4iEhK/X+c3C9SDxKakgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a3236c14", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "# TODO: Normalize range of sound so that it's comfortable to the human ears\n", + "# The sound in blue range is way too loud because the flat ranges are all 0.1 and \n", + "# blue is the only one with a Sine wave for the amp\n", + "\n", + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "markdown", + "id": "7f6999ce", + "metadata": {}, + "source": [ + "### troubleshooting functionality above" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "9e7906f0", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "a = Phasor([1000], mul=np.pi*2)\n", + "b = Cos(a, mul=.3).out(dur=2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e8ecdaf6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope: 1.0 \n", + "Intercept: 0.0\n" + ] + }, + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats\n", + "\n", + "x = np.arange(0, 10)\n", + "y = x\n", + "\n", + "slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n", + "\n", + "print('Slope: ',slope,'\\nIntercept: ',intercept)\n", + "std_err" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "644f4ca5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "< Instance of Sine class >" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lfo = Sine(10, 0, 0.91873589, 0)\n", + "Sine(freq=900, mul=lfo).out(dur=4.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "9bfd4f96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "< Instance of Sine class >" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lfo = LFO(freq=0, type=3, mul=0.2, add=0) # tri\n", + "Sine(freq=900, mul=lfo).out(dur=4.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "2db3eb27", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "13ec8825", + "metadata": {}, + "outputs": [], + "source": [ + "tremolo_vals = [0.37796447, 0.37796447, 0.37796447, 1., 0.65465367]\n", + "amplitudes = [0.15909091, 0.21590909, 0.11363636, 0.13636364, 0.10227273]\n", + "pitches = [300, 400, 500, 600, 700]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "f07eeffe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "s = Server().boot()\n", + "s.start()\n", + "\n", + "# TODO: probably iterate to create a list of LFOs \n", + "# based on the frequencies calculated\n", + "\n", + "factor = 10\n", + "\n", + "lfo1 = Sine(tremolo_vals[0]*factor, 0, amplitudes[0], 0)\n", + "lfo2 = Sine(tremolo_vals[1]*factor, 0, amplitudes[1], 0)\n", + "lfo3 = Sine(tremolo_vals[2]*factor, 0, amplitudes[2], 0)\n", + "lfo4 = Sine(tremolo_vals[3]*factor, 0, amplitudes[3], 0)\n", + "lfo5 = Sine(tremolo_vals[4]*factor, 0, amplitudes[4], 0)\n", + "\n", + "sine1 = Sine(freq=pitches[0], mul=lfo1).out(dur=4.0)\n", + " \n", + "sine2 = Sine(freq=pitches[1], mul=lfo2).out(delay=0.5, dur=3.5)\n", + "\n", + "sine3 = Sine(freq=pitches[2], mul=lfo3).out(delay=1.0, dur=3.0)\n", + "\n", + "sine4 = Sine(freq=pitches[3], mul=lfo4).out(delay=1.5, dur=2.5)\n", + "\n", + "sine5 = Sine(freq=pitches[4], mul=lfo5).out(delay=2.0, dur=2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a39bca37", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.5, 1. , 1.5, 2. ])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(0,2.5, 0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "5c932d82", + "metadata": {}, + "outputs": [], + "source": [ + "s.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d364183c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.cfg b/setup.cfg index 6707843..c8c6c43 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,11 +1,12 @@ [metadata] name = astronify -author = Clara Brasseur, Scott Fleming, Jennifer Kotler, Kate Meredith, Jenny Medina +author = Clara Brasseur, Scott Fleming, Jennifer Kotler, Kate Meredith, Pey-Lian Lim author_email = astronify@stsci.edu license = BSD 3-Clause license_file = licenses/LICENSE.rst url = https://github.com/spacetelescope/astronify description = Sonification of astronomical data. +version = attr: astronify.__version__ long_description = file: README.rst long_description_content_type = text/x-rst edit_on_github = False @@ -14,12 +15,15 @@ github_project = spacetelscope/astronify [options] zip_safe = False packages = find: -python_requires = >=3.8.13 +python_requires = >=3.9 setup_requires = setuptools_scm install_requires = astropy + scipy + matplotlib pyo - thinkx + requests + notebook [options.entry_points] console_scripts = diff --git a/setup.py b/setup.py index 155033f..40b1e12 100755 --- a/setup.py +++ b/setup.py @@ -34,7 +34,7 @@ http://docs.astropy.org/en/latest/development/testguide.html#running-tests """ -if 'test' in sys.argv: +if "test" in sys.argv: print(TEST_HELP) sys.exit(1) @@ -59,7 +59,7 @@ http://docs.astropy.org/en/latest/install.html#builddocs """ -if 'build_docs' in sys.argv or 'build_sphinx' in sys.argv: +if "build_docs" in sys.argv or "build_sphinx" in sys.argv: print(DOCS_HELP) sys.exit(1) @@ -74,5 +74,9 @@ version = '{version}' """.lstrip() -setup(use_scm_version={'write_to': os.path.join('astronify', 'version.py'), - 'write_to_template': VERSION_TEMPLATE}) +setup( + use_scm_version={ + "write_to": os.path.join("astronify", "version.py"), + "write_to_template": VERSION_TEMPLATE, + } +) diff --git a/tox.ini b/tox.ini index c3bae4d..beea845 100644 --- a/tox.ini +++ b/tox.ini @@ -1,21 +1,25 @@ [tox] envlist = - py{38}-test{,-alldeps,-devdeps}{,-cov} - py{38}-test-numpy{116,117,118} - py{38}-test-astropy{30,40,lts} + py{39,310,311}-test{,-alldeps,-devdeps}{,-cov} + py{39,310,311}-test-numpy{124,125,126,200,210} + py{39,310,311}-test-astropy{50,60,lts} build_docs linkcheck codestyle requires = setuptools >= 30.3.0 pip >= 19.3.1 - sphinx_rtd_theme >= 0.5.2 + sphinx < 6 + sphinx_rtd_theme >= 2.0.0 + docutils < 0.19 isolated_build = true [testenv] +setenv = + devdeps: PIP_EXTRA_INDEX_URL = https://pypi.anaconda.org/astropy/simple https://pypi.anaconda.org/scientific-python-nightly-wheels/simple # Pass through the following environment variables which may be needed for the CI -passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI,TRAVIS +passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI # Run the tests in a temporary directory to make sure that we don't import # this package from the source tree @@ -35,26 +39,31 @@ description = devdeps: with the latest developer version of key dependencies oldestdeps: with the oldest supported version of key dependencies cov: and test coverage - numpy116: with numpy 1.16.* - numpy117: with numpy 1.17.* - numpy118: with numpy 1.18.* - astropy30: with astropy 3.0.* - astropy40: with astropy 4.0.* + numpy124: with numpy 1.24.* + numpy125: with numpy 1.26.* + numpy126: with numpy 1.26.* + numpy200: with numpy 2.0.* + numpy210: with numpy 2.1.* + astropy50: with astropy 5.0.* + astropy60: with astropy 6.0.* astropylts: with the latest astropy LTS # The following provides some specific pinnings for key packages deps = - numpy116: numpy==1.16.* - numpy117: numpy==1.17.* - numpy118: numpy==1.18.* + numpy124: numpy==1.24.* + numpy125: numpy==1.25.* + numpy126: numpy==1.26.* + numpy200: numpy==2.0.* + numpy210: numpy==2.1.* - astropy30: astropy==3.0.* - astropy40: astropy==4.0.* - astropylts: astropy==4.0.* + astropy50: astropy==5.0.* + astropy60: astropy==6.0.* + astropylts: astropy==6.0.* - devdeps: git+https://github.com/numpy/numpy.git#egg=numpy - devdeps: git+https://github.com/astropy/astropy.git#egg=astropy + devdeps: numpy>=0.0.dev0 + devdeps: astropy>=0.0.dev0 + devdeps: git+https://github.com/psf/requests.git # The following indicates which extras_require from setup.cfg will be installed extras = @@ -73,7 +82,6 @@ description = invoke sphinx-build to build the HTML docs extras = docs deps= sphinx_rtd_theme commands = - pip freeze sphinx-build -b html . _build/html [testenv:linkcheck] @@ -81,12 +89,4 @@ changedir = docs description = check the links in the HTML docs extras = docs commands = - pip freeze sphinx-build -b linkcheck . _build/html - -[testenv:codestyle] -skip_install = true -changedir = . -description = check code style, e.g. with flake8 -deps = flake8 -commands = flake8 astronify --count --show-source --statistics --ignore=W291,W293,W391,E303,E266,E226,W504 --max-line-length=120 --exclude=astronify/conftest.py