From f6644810560618fb0b2073bb160a962bbd3ed132 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 11:02:51 +0200 Subject: [PATCH 01/24] :sparkles: Implement WCS and 2 axis FoV recovery --- js/models/event_handler.js | 7 +++++++ js/widget.js | 9 +++++++++ src/ipyaladin/widget.py | 36 +++++++++++++++++++++++++++++++++++- 3 files changed, 51 insertions(+), 1 deletion(-) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index d3c3bb8c..3dc43bed 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -42,6 +42,7 @@ export default class EventHandler { } jsTargetLock.lock(); const raDec = [position.ra, position.dec]; + this.model.set("_wcs", this.aladin.getViewWCS()); this.model.set("_target", `${raDec[0]} ${raDec[1]}`); this.model.save_changes(); }); @@ -68,7 +69,13 @@ export default class EventHandler { } jsFovLock.lock(); // fov MUST be cast into float in order to be sent to the model + this.model.set("_wcs", this.aladin.getViewWCS()); this.model.set("_fov", parseFloat(fov.toFixed(5))); + const fov_xy = this.aladin.getFov(); + this.model.set("_fov_xy", { + x: fov_xy[0], + y: fov_xy[1], + }); this.model.save_changes(); }); diff --git a/js/widget.js b/js/widget.js index 7b261dde..98b05251 100644 --- a/js/widget.js +++ b/js/widget.js @@ -24,6 +24,15 @@ function initAladinLite(model, el) { const raDec = initOptions["target"].split(" "); aladin.gotoRaDec(raDec[0], raDec[1]); + // Set current FoV and WCS + const FoV = aladin.getFov(); + model.set("_fov_xy", { + x: FoV[0], + y: FoV[1], + }); + model.set("_wcs", aladin.getViewWCS()); + model.save_changes(); + el.appendChild(aladinDiv); return { aladin, aladinDiv }; } diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 735fee5a..8b296a18 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -9,7 +9,7 @@ import pathlib from pathlib import Path import typing -from typing import ClassVar, Union, Final, Optional +from typing import ClassVar, Union, Final, Optional, Tuple import warnings import anywidget @@ -19,6 +19,7 @@ from astropy.io import fits as astropy_fits from astropy.io.fits import HDUList import traitlets +from astropy.wcs import WCS try: from regions import ( @@ -126,6 +127,10 @@ class Aladin(anywidget.AnyWidget): grid_opacity = Float(0.5).tag(sync=True, init_option=True) grid_options = traitlets.Dict().tag(sync=True, init_option=True) + # Values + _wcs = traitlets.Dict().tag(sync=True) + _fov_xy = traitlets.Dict().tag(sync=True) + # content of the last click clicked_object = traitlets.Dict().tag(sync=True) # listener callback is on the python side and contains functions to link to events @@ -165,6 +170,35 @@ def _handle_custom_message(self, _: any, message: dict, __: any) -> None: elif event_type == "select" and "select" in self.listener_callback: self.listener_callback["select"](message_content) + @property + def wcs(self) -> WCS: + """The world coordinate system of the Aladin Lite widget. + + Returns + ------- + WCS + An astropy WCS object representing the world coordinate system. + + """ + if "RADECSYS" in self._wcs: # RADECSYS keyword is deprecated for astropy.WCS + self._wcs["RADESYS"] = self._wcs.pop("RADECSYS") + return WCS(self._wcs) + + @property + def fov_xy(self) -> Tuple[Angle, Angle]: + """The field of view of the Aladin Lite along the two axis. + + Returns + ------- + tuple[Angle, Angle] + A tuple of astropy.units.Angle objects representing the field of view. + + """ + return ( + Angle(self._fov_xy["x"], unit="deg"), + Angle(self._fov_xy["y"], unit="deg"), + ) + @property def fov(self) -> Angle: """The field of view of the Aladin Lite widget along the horizontal axis. From 90c6fda2898c69bd1e77e187a2e27d43dd9c2a89 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 11:28:04 +0200 Subject: [PATCH 02/24] :memo: Add new notebook example for wcs and ov recovery --- examples/11_Values_Recovery.ipynb | 236 ++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) create mode 100644 examples/11_Values_Recovery.ipynb diff --git a/examples/11_Values_Recovery.ipynb b/examples/11_Values_Recovery.ipynb new file mode 100644 index 00000000..1b309445 --- /dev/null +++ b/examples/11_Values_Recovery.ipynb @@ -0,0 +1,236 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 20, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:49.859887Z", + "start_time": "2024-07-15T09:19:49.856897Z" + }, + "collapsed": true + }, + "outputs": [], + "source": [ + "from ipyaladin import Aladin" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2e62d34eb8543145", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:50.731329Z", + "start_time": "2024-07-15T09:19:50.706131Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1bd7729f085f4d4e8874464da6aa7bec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Aladin(height=600, init_options=['_fov', '_target', 'background_color', 'coo_frame', 'full_screen', 'grid_colo…" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin = Aladin(fov=5, height=600, target=\"M31\")\n", + "aladin" + ] + }, + { + "cell_type": "markdown", + "id": "54a2d7bb2777de3b", + "metadata": {}, + "source": [ + "# Values Recovery\n", + "## Recover current values\n", + "Currently, ipyaladin allow you to recover some values from the Aladin Lite instance. These values are:\n", + "- The World Coordinate System (WCS)\n", + "- The field of view for the x and y axis\n", + "You can recover these values by calling the corresponding attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "84153657cb7cd837", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:53.288584Z", + "start_time": "2024-07-15T09:19:53.270738Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "WCS Keywords\n", + "\n", + "Number of WCS axes: 2\n", + "CTYPE : 'RA---SIN' 'DEC--SIN' \n", + "CRVAL : 10.684708330000005 41.26875 \n", + "CRPIX : 639.5 300.5 \n", + "PC1_1 PC1_2 : 1.0 0.0 \n", + "PC2_1 PC2_2 : 0.0 1.0 \n", + "CDELT : 0.003912363067292645 0.003912363067292645 \n", + "NAXIS : 1278 600" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.wcs # Recover the current WCS" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9595ae02388b245a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:54.416080Z", + "start_time": "2024-07-15T09:19:54.405967Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.fov_xy # Recover the current field of view for the x and y axis" + ] + }, + { + "cell_type": "markdown", + "id": "870935d9c4e2aaa", + "metadata": {}, + "source": [ + "## Recover values after changing\n", + "In case you are changing a value like the target or the field of view, you need to recover one of these values in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "dfdc3a54019d7e34", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:56.582921Z", + "start_time": "2024-07-15T09:19:56.566380Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "WCS Keywords\n", + "\n", + "Number of WCS axes: 2\n", + "CTYPE : 'RA---SIN' 'DEC--SIN' \n", + "CRVAL : 10.684708330000005 41.26875 \n", + "CRPIX : 639.5 300.5 \n", + "PC1_1 PC1_2 : 1.0 0.0 \n", + "PC2_1 PC2_2 : 0.0 1.0 \n", + "CDELT : 0.003912363067292645 0.003912363067292645 \n", + "NAXIS : 1278 600" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.target = \"M33\"\n", + "aladin.fov = 2\n", + "aladin.wcs # This will display the previous WCS" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "ad62fb2664e45a30", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-15T09:19:57.772224Z", + "start_time": "2024-07-15T09:19:57.763011Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "WCS Keywords\n", + "\n", + "Number of WCS axes: 2\n", + "CTYPE : 'RA---SIN' 'DEC--SIN' \n", + "CRVAL : 23.462069062180003 30.660175111980003 \n", + "CRPIX : 639.5 300.5 \n", + "PC1_1 PC1_2 : 1.0 0.0 \n", + "PC2_1 PC2_2 : 0.0 1.0 \n", + "CDELT : 0.001564945226917058 0.001564945226917058 \n", + "NAXIS : 1278 600" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.wcs # This will represent the new WCS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "281941943a948d7b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 4a15caa6075d440ad0138c1fdd2ad08c84b595fc Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 11:29:27 +0200 Subject: [PATCH 03/24] :memo: Update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 879a12e5..2c8ce4d1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,6 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Support for `astropy.coordinates.SkyCoord` for assigning and reading the `target` property (#80) - Support for `astropy.coordinates.Angle` for reading the `fov` property (#83) - Support for `regions.LineSkyRegion`, `regions.CircleSkyRegion`, `regions.EllipseSkyRegion`, `regions.PolygonSkyRegion`, `regions.RectangleSkyRegion`, `regions.Regions` with `add_graphic_overlay_from_region` (#88) +- Allow WCS and 2 axis FoV recovery from `wcs` and `fov_xy` properties (#96) ### Fixed From 5f0b7455d6f84caeb167a66c922387ebe9cfd6b7 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 12:23:18 +0200 Subject: [PATCH 04/24] :sparkles: Add support for cooFrameChanged event to update the WCS --- js/models/event_handler.js | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 3dc43bed..5f7697c7 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -97,6 +97,11 @@ export default class EventHandler { /* Aladin callbacks */ + this.aladin.on("cooFrameChanged", () => { + this.model.set("_wcs", this.aladin.getViewWCS()); + this.model.save_changes(); + }); + this.aladin.on("objectHovered", (object) => { if (object["data"] !== undefined) { this.model.send({ From 71c0d13f27133567534bed5b0988163a36becf92 Mon Sep 17 00:00:00 2001 From: Tom Czekaj <47594493+Xen0Xys@users.noreply.github.com> Date: Mon, 15 Jul 2024 13:35:20 +0200 Subject: [PATCH 05/24] :pencil2: Fix typo Co-authored-by: Manon Marchand --- src/ipyaladin/widget.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 8b296a18..e746ed66 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -186,7 +186,7 @@ def wcs(self) -> WCS: @property def fov_xy(self) -> Tuple[Angle, Angle]: - """The field of view of the Aladin Lite along the two axis. + """The field of view of the Aladin Lite along the two axes. Returns ------- From 610ceaf30cc3e99d59e320ef354a4dcb6801a2f2 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 13:43:15 +0200 Subject: [PATCH 06/24] :art: Add error raising when recovering the WSC in the same cell that an update --- examples/11_Values_Recovery.ipynb | 169 +++++------------------------- src/ipyaladin/widget.py | 13 +++ 2 files changed, 39 insertions(+), 143 deletions(-) diff --git a/examples/11_Values_Recovery.ipynb b/examples/11_Values_Recovery.ipynb index 1b309445..bc1647e0 100644 --- a/examples/11_Values_Recovery.ipynb +++ b/examples/11_Values_Recovery.ipynb @@ -2,51 +2,26 @@ "cells": [ { "cell_type": "code", - "execution_count": 20, "id": "initial_id", "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:49.859887Z", - "start_time": "2024-07-15T09:19:49.856897Z" - }, "collapsed": true }, - "outputs": [], "source": [ "from ipyaladin import Aladin" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 21, "id": "2e62d34eb8543145", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:50.731329Z", - "start_time": "2024-07-15T09:19:50.706131Z" - } - }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "1bd7729f085f4d4e8874464da6aa7bec", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Aladin(height=600, init_options=['_fov', '_target', 'background_color', 'coo_frame', 'full_screen', 'grid_colo…" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "aladin = Aladin(fov=5, height=600, target=\"M31\")\n", "aladin" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -63,64 +38,23 @@ }, { "cell_type": "code", - "execution_count": 22, "id": "84153657cb7cd837", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:53.288584Z", - "start_time": "2024-07-15T09:19:53.270738Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "WCS Keywords\n", - "\n", - "Number of WCS axes: 2\n", - "CTYPE : 'RA---SIN' 'DEC--SIN' \n", - "CRVAL : 10.684708330000005 41.26875 \n", - "CRPIX : 639.5 300.5 \n", - "PC1_1 PC1_2 : 1.0 0.0 \n", - "PC2_1 PC2_2 : 0.0 1.0 \n", - "CDELT : 0.003912363067292645 0.003912363067292645 \n", - "NAXIS : 1278 600" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "aladin.wcs # Recover the current WCS" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 23, "id": "9595ae02388b245a", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:54.416080Z", - "start_time": "2024-07-15T09:19:54.405967Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(, )" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "aladin.fov_xy # Recover the current field of view for the x and y axis" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -133,83 +67,32 @@ }, { "cell_type": "code", - "execution_count": 24, "id": "dfdc3a54019d7e34", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:56.582921Z", - "start_time": "2024-07-15T09:19:56.566380Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "WCS Keywords\n", - "\n", - "Number of WCS axes: 2\n", - "CTYPE : 'RA---SIN' 'DEC--SIN' \n", - "CRVAL : 10.684708330000005 41.26875 \n", - "CRPIX : 639.5 300.5 \n", - "PC1_1 PC1_2 : 1.0 0.0 \n", - "PC2_1 PC2_2 : 0.0 1.0 \n", - "CDELT : 0.003912363067292645 0.003912363067292645 \n", - "NAXIS : 1278 600" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "aladin.target = \"M33\"\n", - "aladin.fov = 2\n", - "aladin.wcs # This will display the previous WCS" - ] + "aladin.fov = 2" + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 25, "id": "ad62fb2664e45a30", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-15T09:19:57.772224Z", - "start_time": "2024-07-15T09:19:57.763011Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "WCS Keywords\n", - "\n", - "Number of WCS axes: 2\n", - "CTYPE : 'RA---SIN' 'DEC--SIN' \n", - "CRVAL : 23.462069062180003 30.660175111980003 \n", - "CRPIX : 639.5 300.5 \n", - "PC1_1 PC1_2 : 1.0 0.0 \n", - "PC2_1 PC2_2 : 0.0 1.0 \n", - "CDELT : 0.001564945226917058 0.001564945226917058 \n", - "NAXIS : 1278 600" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "aladin.wcs # This will represent the new WCS" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "id": "281941943a948d7b", "metadata": {}, + "source": [], "outputs": [], - "source": [] + "execution_count": null } ], "metadata": { diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index e746ed66..5be01f40 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -180,6 +180,11 @@ def wcs(self) -> WCS: An astropy WCS object representing the world coordinate system. """ + if self._wcs == {}: + raise ValueError( + "The world coordinate system is not available. " + "Please recover it from another cell." + ) if "RADECSYS" in self._wcs: # RADECSYS keyword is deprecated for astropy.WCS self._wcs["RADESYS"] = self._wcs.pop("RADECSYS") return WCS(self._wcs) @@ -194,6 +199,11 @@ def fov_xy(self) -> Tuple[Angle, Angle]: A tuple of astropy.units.Angle objects representing the field of view. """ + if self._fov_xy == {}: + raise ValueError( + "The field of view along the two axes is not available. " + "Please recover it from another cell." + ) return ( Angle(self._fov_xy["x"], unit="deg"), Angle(self._fov_xy["y"], unit="deg"), @@ -219,6 +229,8 @@ def fov(self, fov: Union[float, Angle]) -> None: if isinstance(fov, Angle): fov = fov.deg self._fov = fov + self._fov_xy = {} + self._wcs = {} self.send({"event_name": "change_fov", "fov": fov}) @property @@ -234,6 +246,7 @@ def target(self) -> SkyCoord: """ ra, dec = self._target.split(" ") + self._wcs = None return SkyCoord( ra=ra, dec=dec, From 72dedd237995529541f358723c55203fe7f678f6 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Mon, 15 Jul 2024 15:50:50 +0200 Subject: [PATCH 07/24] :ambulance: Fix wrong _wcs traitlets assignation --- src/ipyaladin/widget.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 5be01f40..1e1e0056 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -246,7 +246,6 @@ def target(self) -> SkyCoord: """ ra, dec = self._target.split(" ") - self._wcs = None return SkyCoord( ra=ra, dec=dec, @@ -263,6 +262,7 @@ def target(self, target: Union[str, SkyCoord]) -> None: "target must be a string or an astropy.coordinates.SkyCoord object" ) self._target = f"{target.icrs.ra.deg} {target.icrs.dec.deg}" + self._wcs = {} self.send( { "event_name": "goto_ra_dec", From 676911c9fe542db0ea62df41d56d45dd24796103 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Tue, 16 Jul 2024 09:55:53 +0200 Subject: [PATCH 08/24] :art: Rename example 11 --- ...1_Extracting_information_from_the_view.ipynb} | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) rename examples/{11_Values_Recovery.ipynb => 11_Extracting_information_from_the_view.ipynb} (85%) diff --git a/examples/11_Values_Recovery.ipynb b/examples/11_Extracting_information_from_the_view.ipynb similarity index 85% rename from examples/11_Values_Recovery.ipynb rename to examples/11_Extracting_information_from_the_view.ipynb index bc1647e0..67eda70c 100644 --- a/examples/11_Values_Recovery.ipynb +++ b/examples/11_Extracting_information_from_the_view.ipynb @@ -28,8 +28,8 @@ "id": "54a2d7bb2777de3b", "metadata": {}, "source": [ - "# Values Recovery\n", - "## Recover current values\n", + "# Extracting information from the view\n", + "## Extracting values\n", "Currently, ipyaladin allow you to recover some values from the Aladin Lite instance. These values are:\n", "- The World Coordinate System (WCS)\n", "- The field of view for the x and y axis\n", @@ -61,8 +61,8 @@ "id": "870935d9c4e2aaa", "metadata": {}, "source": [ - "## Recover values after changing\n", - "In case you are changing a value like the target or the field of view, you need to recover one of these values in the next cell." + "## Changing values\n", + "If you change a value that affects the value you want to extract, you need to extract this value in the next cell." ] }, { @@ -85,14 +85,6 @@ ], "outputs": [], "execution_count": null - }, - { - "cell_type": "code", - "id": "281941943a948d7b", - "metadata": {}, - "source": [], - "outputs": [], - "execution_count": null } ], "metadata": { From 70688fc4612684b65f282102d1e75e5c8e4867c4 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Tue, 16 Jul 2024 12:03:09 +0200 Subject: [PATCH 09/24] :arrow_up: Update Aladin Lite from 3.4.1-beta to 3.4.4-beta --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1588d45e..61e4388e 100644 --- a/README.md +++ b/README.md @@ -58,8 +58,8 @@ Correspondence table between ipyaladin versions and Aladin Lite versions: | ipyaladin | Aladin-Lite | | --------- | ----------- | -| 0.3.0 | 3.3.3-dev | | 0.4.0 | 3.4.4-beta | +| 0.3.0 | 3.3.3-dev | > [!TIP] > This can always be read like so From 6f3d3ae1e1711dee52c8b0c109a4c36ed300d34d Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Tue, 16 Jul 2024 12:03:47 +0200 Subject: [PATCH 10/24] :sparkles: Add missing events that impact WCS and FoV --- js/models/event_handler.js | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 5f7697c7..8812a887 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -102,6 +102,21 @@ export default class EventHandler { this.model.save_changes(); }); + this.aladin.on("projectionChanged", () => { + this.model.set("_wcs", this.aladin.getViewWCS()); + this.model.save_changes(); + }); + + this.aladin.on("resizeChanged", () => { + this.model.set("_wcs", this.aladin.getViewWCS()); + const fov_xy = this.aladin.getFov(); + this.model.set("_fov_xy", { + x: fov_xy[0], + y: fov_xy[1], + }); + this.model.save_changes(); + }); + this.aladin.on("objectHovered", (object) => { if (object["data"] !== undefined) { this.model.send({ From 4483b76760b0d66dfaf4c05ebeaff4b3f3d58d45 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Tue, 16 Jul 2024 11:39:26 +0200 Subject: [PATCH 11/24] maint: prepare release 0.4.0 fix: A.line was removed from public AL API in favor of A.vector --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2c8ce4d1..91017399 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Allow WCS and 2 axis FoV recovery from `wcs` and `fov_xy` properties (#96) - monochromatic FITS images can be added to the view with `ipyaladin.Aladin.add_fits`. The method accepts `astropy.io.fits.HDUList`, `pathlib.Path`, or `string` representing paths (#86) @@ -29,13 +30,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Support for `astropy.coordinates.SkyCoord` for assigning and reading the `target` property (#80) - Support for `astropy.coordinates.Angle` for reading the `fov` property (#83) - Support for `regions.LineSkyRegion`, `regions.CircleSkyRegion`, `regions.EllipseSkyRegion`, `regions.PolygonSkyRegion`, `regions.RectangleSkyRegion`, `regions.Regions` with `add_graphic_overlay_from_region` (#88) -- Allow WCS and 2 axis FoV recovery from `wcs` and `fov_xy` properties (#96) ### Fixed - `clicked_object` was not properly updated after a click - Fix asynchronous update for the `target` property (#80) -- some options were not accepted in snake_case anymore in `add_moc` and in `add_catalog_from_url` (#82) +- Allow WCS and 2 axis FoV recovery from `wcs` and `fov_xy` properties (#96) ### Changed From 48999a259d75b1c08354d210dfca51999693bb6b Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Tue, 16 Jul 2024 15:37:05 +0200 Subject: [PATCH 12/24] :sparkles: Add layerChanged listener for future AL version --- js/models/event_handler.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 8812a887..5b3c80cd 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -107,6 +107,12 @@ export default class EventHandler { this.model.save_changes(); }); + this.aladin.on("layerChanged", (_, layer) => { + if (layer !== "base") return; + this.model.set("_wcs", this.aladin.getViewWCS()); + this.model.save_changes(); + }); + this.aladin.on("resizeChanged", () => { this.model.set("_wcs", this.aladin.getViewWCS()); const fov_xy = this.aladin.getFov(); From 5f8e397d1084cff4e8e77446b886a940bdfd0517 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Tue, 16 Jul 2024 11:39:26 +0200 Subject: [PATCH 13/24] maint: prepare release 0.4.0 fix: A.line was removed from public AL API in favor of A.vector --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 91017399..5028afbb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -35,7 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `clicked_object` was not properly updated after a click - Fix asynchronous update for the `target` property (#80) -- Allow WCS and 2 axis FoV recovery from `wcs` and `fov_xy` properties (#96) +- some options were not accepted in snake_case anymore in `add_moc` and in `add_catalog_from_url` (#82) ### Changed From baeed5d2f63cf5a710bbeed1e06031703f859649 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Thu, 18 Jul 2024 10:40:40 +0200 Subject: [PATCH 14/24] :arrow_up: Bump Aladin Lite to 3.4.5-beta --- CHANGELOG.md | 6 +++++- README.md | 9 +++++---- js/aladin_lite.js | 2 +- js/models/event_handler.js | 16 ++++++++-------- js/widget.js | 6 +++--- 5 files changed, 22 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5028afbb..5989cd58 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - monochromatic FITS images can be added to the view with `ipyaladin.Aladin.add_fits`. The method accepts `astropy.io.fits.HDUList`, `pathlib.Path`, or `string` representing paths (#86) +### Changed + +- Upgrade Aladin Lite version to 3.4.5-beta (#96) + ## [0.4.0] ### Added @@ -41,7 +45,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Change the jslink target trait from `target` to `shared_target` (#80) - Change the jslink fov trait from `fov` to `shared_fov` (#83) -- Upgrade Aladin Lite version to 3.4.1-beta (#88) +- Upgrade Aladin Lite version to 3.4.4-beta (#88) - Add support for list of strings in `add_overlay_from_stcs` (#88) ### Deprecated diff --git a/README.md b/README.md index 61e4388e..bdf8388b 100644 --- a/README.md +++ b/README.md @@ -56,10 +56,11 @@ Ipyaladin brings [Aladin Lite](https://github.com/cds-astro/aladin-lite) into no Correspondence table between ipyaladin versions and Aladin Lite versions: -| ipyaladin | Aladin-Lite | -| --------- | ----------- | -| 0.4.0 | 3.4.4-beta | -| 0.3.0 | 3.3.3-dev | +| ipyaladin | Aladin-Lite | +| ---------- | ----------- | +| Unreleased | 3.4.5-beta | +| 0.4.0 | 3.4.4-beta | +| 0.3.0 | 3.3.3-dev | > [!TIP] > This can always be read like so diff --git a/js/aladin_lite.js b/js/aladin_lite.js index 379517f1..98addcb1 100644 --- a/js/aladin_lite.js +++ b/js/aladin_lite.js @@ -1,3 +1,3 @@ -import A from "https://esm.sh/aladin-lite@3.4.4-beta"; +import A from "https://esm.sh/aladin-lite@3.4.5-beta"; export default A; diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 5b3c80cd..49417d04 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -71,10 +71,10 @@ export default class EventHandler { // fov MUST be cast into float in order to be sent to the model this.model.set("_wcs", this.aladin.getViewWCS()); this.model.set("_fov", parseFloat(fov.toFixed(5))); - const fov_xy = this.aladin.getFov(); + const twoAxisFoV = this.aladin.getFov(); this.model.set("_fov_xy", { - x: fov_xy[0], - y: fov_xy[1], + x: twoAxisFoV[0], + y: twoAxisFoV[1], }); this.model.save_changes(); }); @@ -107,18 +107,18 @@ export default class EventHandler { this.model.save_changes(); }); - this.aladin.on("layerChanged", (_, layer) => { - if (layer !== "base") return; + this.aladin.on("layerChanged", (_, layerName, state) => { + if (layerName !== "base" || state !== "ADDED") return; this.model.set("_wcs", this.aladin.getViewWCS()); this.model.save_changes(); }); this.aladin.on("resizeChanged", () => { this.model.set("_wcs", this.aladin.getViewWCS()); - const fov_xy = this.aladin.getFov(); + const twoAxisFoV = this.aladin.getFov(); this.model.set("_fov_xy", { - x: fov_xy[0], - y: fov_xy[1], + x: twoAxisFoV[0], + y: twoAxisFoV[1], }); this.model.save_changes(); }); diff --git a/js/widget.js b/js/widget.js index 98b05251..3be29317 100644 --- a/js/widget.js +++ b/js/widget.js @@ -25,10 +25,10 @@ function initAladinLite(model, el) { aladin.gotoRaDec(raDec[0], raDec[1]); // Set current FoV and WCS - const FoV = aladin.getFov(); + const twoAxisFoV = aladin.getFov(); model.set("_fov_xy", { - x: FoV[0], - y: FoV[1], + x: twoAxisFoV[0], + y: twoAxisFoV[1], }); model.set("_wcs", aladin.getViewWCS()); model.save_changes(); From 3ce83855ab82af29053b3569cfd1f2145cdfd5b1 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Thu, 18 Jul 2024 11:46:39 +0200 Subject: [PATCH 15/24] :sparkles: Convert height to property to change the WCS on height updates --- js/models/event_handler.js | 16 ++++++++++++---- js/models/message_handler.js | 5 ++++- src/ipyaladin/widget.py | 24 +++++++++++++++++++++++- 3 files changed, 39 insertions(+), 6 deletions(-) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 49417d04..0406e99f 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -12,7 +12,7 @@ export default class EventHandler { this.aladin = aladin; this.aladinDiv = aladinDiv; this.model = model; - this.messageHandler = new MessageHandler(aladin); + this.messageHandler = new MessageHandler(aladin, model); } /** @@ -90,9 +90,17 @@ export default class EventHandler { }); /* Div control */ - this.model.on("change:height", () => { - let height = this.model.get("height"); + this.model.on("change:_height", () => { + let height = this.model.get("_height"); this.aladinDiv.style.height = `${height}px`; + // Update WCS and FoV + this.model.set("_wcs", this.aladin.getViewWCS()); + const twoAxisFoV = this.aladin.getFov(); + this.model.set("_fov_xy", { + x: twoAxisFoV[0], + y: twoAxisFoV[1], + }); + this.model.save_changes(); }); /* Aladin callbacks */ @@ -233,7 +241,7 @@ export default class EventHandler { unsubscribeAll() { this.model.off("change:_target"); this.model.off("change:_fov"); - this.model.off("change:height"); + this.model.off("change:_height"); this.model.off("change:coo_frame"); this.model.off("change:survey"); this.model.off("change:overlay_survey"); diff --git a/js/models/message_handler.js b/js/models/message_handler.js index b5387d7f..28294c7e 100644 --- a/js/models/message_handler.js +++ b/js/models/message_handler.js @@ -4,8 +4,9 @@ import A from "../aladin_lite"; let imageCount = 0; export default class MessageHandler { - constructor(aladin) { + constructor(aladin, model) { this.aladin = aladin; + this.model = model; } handleChangeFoV(msg) { @@ -29,6 +30,8 @@ export default class MessageHandler { URL.revokeObjectURL(url); }); this.aladin.setOverlayImageLayer(image, options.name); + // this.model.set("_wcs", this.aladin.getViewWCS()); + // this.model.save_changes(); } handleAddCatalogFromURL(msg) { diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 1e1e0056..4d919186 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -80,7 +80,7 @@ class Aladin(anywidget.AnyWidget): _css: Final = pathlib.Path(__file__).parent / "static" / "widget.css" # Options for the view initialization - height = Int(400).tag(sync=True, init_option=True) + _height = Int(400).tag(sync=True, init_option=True) _target = Unicode( "0 0", help="A private trait that stores the current target of the widget in a string." @@ -148,6 +148,7 @@ def _init_options(self) -> typing.List[str]: def __init__(self, *args: any, **kwargs: any) -> None: super().__init__(*args, **kwargs) + self.height = kwargs.get("height", 400) self.target = kwargs.get("target", "0 0") self.fov = kwargs.get("fov", 60.0) self.on_msg(self._handle_custom_message) @@ -170,6 +171,26 @@ def _handle_custom_message(self, _: any, message: dict, __: any) -> None: elif event_type == "select" and "select" in self.listener_callback: self.listener_callback["select"](message_content) + @property + def height(self) -> int: + """The height of the Aladin Lite widget. + + Returns + ------- + int + The height of the widget in pixels. + + """ + return self._height + + @height.setter + def height(self, height: int) -> None: + if self._height == height: + return + self._wcs = {} + self._fov_xy = {} + self._height = height + @property def wcs(self) -> WCS: """The world coordinate system of the Aladin Lite widget. @@ -313,6 +334,7 @@ def add_fits(self, fits: Union[str, Path, HDUList], **image_options: any) -> Non fits_bytes = io.BytesIO() fits.writeto(fits_bytes) + self._wcs = {} self.send( {"event_name": "add_fits", "options": image_options}, buffers=[fits_bytes.getvalue()], From 975c8e96d07fa4db86ffc86bd18e80bc541d8818 Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Thu, 18 Jul 2024 11:49:55 +0200 Subject: [PATCH 16/24] :goal_net: Add custom WidgetCommunicationError --- src/ipyaladin/errors/widget_communication_error.py | 6 ++++++ src/ipyaladin/widget.py | 6 ++++-- 2 files changed, 10 insertions(+), 2 deletions(-) create mode 100644 src/ipyaladin/errors/widget_communication_error.py diff --git a/src/ipyaladin/errors/widget_communication_error.py b/src/ipyaladin/errors/widget_communication_error.py new file mode 100644 index 00000000..a77b3e73 --- /dev/null +++ b/src/ipyaladin/errors/widget_communication_error.py @@ -0,0 +1,6 @@ +class WidgetCommunicationError(OSError): + """Error raised when there is a communication error with the widget.""" + + def __init__(self, message: str) -> None: + self.message = message + super(WidgetCommunicationError, self).__init__(message) diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 4d919186..91e9cf3e 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -21,6 +21,8 @@ import traitlets from astropy.wcs import WCS +from .errors.widget_communication_error import WidgetCommunicationError + try: from regions import ( CircleSkyRegion, @@ -202,7 +204,7 @@ def wcs(self) -> WCS: """ if self._wcs == {}: - raise ValueError( + raise WidgetCommunicationError( "The world coordinate system is not available. " "Please recover it from another cell." ) @@ -221,7 +223,7 @@ def fov_xy(self) -> Tuple[Angle, Angle]: """ if self._fov_xy == {}: - raise ValueError( + raise WidgetCommunicationError( "The field of view along the two axes is not available. " "Please recover it from another cell." ) From 972cab58945893db41918cbbbf4acc625ac6b613 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Thu, 18 Jul 2024 17:34:59 +0200 Subject: [PATCH 17/24] refactor: create a utils submodule --- src/ipyaladin/utils/__init__.py | 0 src/ipyaladin/{ => utils}/coordinate_parser.py | 0 .../widget_communication_error.py => utils/exceptions.py} | 0 src/ipyaladin/{ => utils}/region_converter.py | 0 src/ipyaladin/widget.py | 6 +++--- src/test/test_aladin.py | 2 +- src/test/test_coordinate_parser.py | 2 +- 7 files changed, 5 insertions(+), 5 deletions(-) create mode 100644 src/ipyaladin/utils/__init__.py rename src/ipyaladin/{ => utils}/coordinate_parser.py (100%) rename src/ipyaladin/{errors/widget_communication_error.py => utils/exceptions.py} (100%) rename src/ipyaladin/{ => utils}/region_converter.py (100%) diff --git a/src/ipyaladin/utils/__init__.py b/src/ipyaladin/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/ipyaladin/coordinate_parser.py b/src/ipyaladin/utils/coordinate_parser.py similarity index 100% rename from src/ipyaladin/coordinate_parser.py rename to src/ipyaladin/utils/coordinate_parser.py diff --git a/src/ipyaladin/errors/widget_communication_error.py b/src/ipyaladin/utils/exceptions.py similarity index 100% rename from src/ipyaladin/errors/widget_communication_error.py rename to src/ipyaladin/utils/exceptions.py diff --git a/src/ipyaladin/region_converter.py b/src/ipyaladin/utils/region_converter.py similarity index 100% rename from src/ipyaladin/region_converter.py rename to src/ipyaladin/utils/region_converter.py diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 91e9cf3e..23141a79 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -21,7 +21,7 @@ import traitlets from astropy.wcs import WCS -from .errors.widget_communication_error import WidgetCommunicationError +from .utils.exceptions import WidgetCommunicationError try: from regions import ( @@ -50,7 +50,7 @@ default, ) -from .coordinate_parser import parse_coordinate_string +from .utils.coordinate_parser import parse_coordinate_string SupportedRegion = Union[ typing.List[ @@ -534,7 +534,7 @@ def add_graphic_overlay_from_region( "See the documentation for the supported region types." ) - from .region_converter import RegionInfos + from .utils.region_converter import RegionInfos # Define behavior for each region type regions_infos.append(RegionInfos(region_element).to_clean_dict()) diff --git a/src/test/test_aladin.py b/src/test/test_aladin.py index 4ff155cf..14a42cac 100644 --- a/src/test/test_aladin.py +++ b/src/test/test_aladin.py @@ -4,7 +4,7 @@ from typing import Callable from ipyaladin import Aladin -from ipyaladin.coordinate_parser import parse_coordinate_string +from ipyaladin.utils.coordinate_parser import parse_coordinate_string from .test_coordinate_parser import test_is_coordinate_string_values diff --git a/src/test/test_coordinate_parser.py b/src/test/test_coordinate_parser.py index 9282f2b0..bcd5d3f1 100644 --- a/src/test/test_coordinate_parser.py +++ b/src/test/test_coordinate_parser.py @@ -1,5 +1,5 @@ from typing import Tuple -from ipyaladin.coordinate_parser import ( +from ipyaladin.utils.coordinate_parser import ( parse_coordinate_string, _split_coordinate_string, _is_hour_angle_string, From 0500082e52d32f4e374c2a4f363742d25a45e36f Mon Sep 17 00:00:00 2001 From: Xen0Xys Date: Fri, 19 Jul 2024 14:16:09 +0200 Subject: [PATCH 18/24] :sparkles: Add support for multiple Aladin Lite instances Data will be exported from the last created one --- js/models/event_handler.js | 76 ++++++++++++++++++++++++------------ js/models/message_handler.js | 2 - js/utils.js | 13 +++++- js/widget.js | 13 +++--- 4 files changed, 72 insertions(+), 32 deletions(-) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index 0406e99f..d0b4dbfb 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -1,5 +1,5 @@ import MessageHandler from "./message_handler"; -import { Lock } from "../utils"; +import { divNumber, Lock } from "../utils"; export default class EventHandler { /** @@ -15,6 +15,45 @@ export default class EventHandler { this.messageHandler = new MessageHandler(aladin, model); } + /** + * Checks if the current div is the last active div. + * @returns {boolean} + */ + isLastDiv() { + let maxDiv = divNumber; + for (let i = maxDiv; i >= 0; i--) { + const alDiv = document.getElementById(`aladin-lite-div-${i}`); + if (!alDiv) continue; + if (alDiv.style.display !== "none") { + maxDiv = i; + break; + } + } + return parseInt(this.aladinDiv.id.split("-").pop()) === maxDiv; + } + + /** + * Updates the WCS coordinates in the model. + * WARNING: This method don't call model.save_changes()! + */ + updateWCS() { + if (!this.isLastDiv()) return; + this.model.set("_wcs", this.aladin.getViewWCS()); + } + + /** + * Updates the 2-axis FoV in the model. + * WARNING: This method don't call model.save_changes()! + */ + update2AxisFoV() { + if (!this.isLastDiv()) return; + const twoAxisFoV = this.aladin.getFov(); + this.model.set("_fov_xy", { + x: twoAxisFoV[0], + y: twoAxisFoV[1], + }); + } + /** * Subscribes to all the events needed for the Aladin Lite widget. */ @@ -42,7 +81,7 @@ export default class EventHandler { } jsTargetLock.lock(); const raDec = [position.ra, position.dec]; - this.model.set("_wcs", this.aladin.getViewWCS()); + this.updateWCS(); this.model.set("_target", `${raDec[0]} ${raDec[1]}`); this.model.save_changes(); }); @@ -69,13 +108,9 @@ export default class EventHandler { } jsFovLock.lock(); // fov MUST be cast into float in order to be sent to the model - this.model.set("_wcs", this.aladin.getViewWCS()); + this.updateWCS(); + this.update2AxisFoV(); this.model.set("_fov", parseFloat(fov.toFixed(5))); - const twoAxisFoV = this.aladin.getFov(); - this.model.set("_fov_xy", { - x: twoAxisFoV[0], - y: twoAxisFoV[1], - }); this.model.save_changes(); }); @@ -93,41 +128,33 @@ export default class EventHandler { this.model.on("change:_height", () => { let height = this.model.get("_height"); this.aladinDiv.style.height = `${height}px`; - // Update WCS and FoV - this.model.set("_wcs", this.aladin.getViewWCS()); - const twoAxisFoV = this.aladin.getFov(); - this.model.set("_fov_xy", { - x: twoAxisFoV[0], - y: twoAxisFoV[1], - }); + // Update WCS and FoV only if this is the last div + this.updateWCS(); + this.update2AxisFoV(); this.model.save_changes(); }); /* Aladin callbacks */ this.aladin.on("cooFrameChanged", () => { - this.model.set("_wcs", this.aladin.getViewWCS()); + this.updateWCS(); this.model.save_changes(); }); this.aladin.on("projectionChanged", () => { - this.model.set("_wcs", this.aladin.getViewWCS()); + this.updateWCS(); this.model.save_changes(); }); this.aladin.on("layerChanged", (_, layerName, state) => { if (layerName !== "base" || state !== "ADDED") return; - this.model.set("_wcs", this.aladin.getViewWCS()); + this.updateWCS(); this.model.save_changes(); }); this.aladin.on("resizeChanged", () => { - this.model.set("_wcs", this.aladin.getViewWCS()); - const twoAxisFoV = this.aladin.getFov(); - this.model.set("_fov_xy", { - x: twoAxisFoV[0], - y: twoAxisFoV[1], - }); + this.updateWCS(); + this.update2AxisFoV(); this.model.save_changes(); }); @@ -163,6 +190,7 @@ export default class EventHandler { }); this.aladin.on("click", (clickContent) => { + console.log("Click", this.isLastDiv()); this.model.send({ event_type: "click", content: clickContent, diff --git a/js/models/message_handler.js b/js/models/message_handler.js index 28294c7e..76fd9a25 100644 --- a/js/models/message_handler.js +++ b/js/models/message_handler.js @@ -30,8 +30,6 @@ export default class MessageHandler { URL.revokeObjectURL(url); }); this.aladin.setOverlayImageLayer(image, options.name); - // this.model.set("_wcs", this.aladin.getViewWCS()); - // this.model.save_changes(); } handleAddCatalogFromURL(msg) { diff --git a/js/utils.js b/js/utils.js index 41cc3660..d2ac7295 100644 --- a/js/utils.js +++ b/js/utils.js @@ -41,4 +41,15 @@ class Lock { } } -export { snakeCaseToCamelCase, convertOptionNamesToCamelCase, Lock }; +let divNumber = -1; +function setDivNumber(num) { + divNumber = num; +} + +export { + snakeCaseToCamelCase, + convertOptionNamesToCamelCase, + Lock, + divNumber, + setDivNumber, +}; diff --git a/js/widget.js b/js/widget.js index 3be29317..778d1872 100644 --- a/js/widget.js +++ b/js/widget.js @@ -1,11 +1,15 @@ import "./widget.css"; import EventHandler from "./models/event_handler"; -import { snakeCaseToCamelCase } from "./utils"; +import { + divNumber, + getDivNumber, + setDivNumber, + snakeCaseToCamelCase, +} from "./utils"; import A from "./aladin_lite"; -let idxView = 0; - function initAladinLite(model, el) { + setDivNumber(divNumber + 1); let initOptions = {}; model.get("init_options").forEach((option_name) => { initOptions[snakeCaseToCamelCase(option_name)] = model.get(option_name); @@ -15,9 +19,8 @@ function initAladinLite(model, el) { aladinDiv.classList.add("aladin-widget"); aladinDiv.style.height = `${initOptions["height"]}px`; - aladinDiv.id = `aladin-lite-div-${idxView}`; + aladinDiv.id = `aladin-lite-div-${divNumber}`; let aladin = new A.aladin(aladinDiv, initOptions); - idxView += 1; // Set the target again after the initialization to be sure that the target is set // from icrs coordinates because of the use of gotoObject in the Aladin Lite API From 45662fda32cee6a707373bafaeb33051414a4117 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 12:45:18 +0200 Subject: [PATCH 19/24] maint: sort imports --- src/ipyaladin/widget.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 23141a79..790b6e65 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -8,20 +8,20 @@ import io import pathlib from pathlib import Path -import typing -from typing import ClassVar, Union, Final, Optional, Tuple +from typing import ClassVar, Dict, Final, List, Optional, Tuple, Union import warnings import anywidget +from astropy.coordinates import SkyCoord, Angle from astropy.table.table import QTable from astropy.table import Table -from astropy.coordinates import SkyCoord, Angle from astropy.io import fits as astropy_fits from astropy.io.fits import HDUList -import traitlets from astropy.wcs import WCS +import traitlets from .utils.exceptions import WidgetCommunicationError +from .utils.coordinate_parser import parse_coordinate_string try: from regions import ( @@ -50,10 +50,8 @@ default, ) -from .utils.coordinate_parser import parse_coordinate_string - SupportedRegion = Union[ - typing.List[ + List[ Union[ CircleSkyRegion, EllipseSkyRegion, @@ -136,7 +134,7 @@ class Aladin(anywidget.AnyWidget): # content of the last click clicked_object = traitlets.Dict().tag(sync=True) # listener callback is on the python side and contains functions to link to events - listener_callback: ClassVar[typing.Dict[str, callable]] = {} + listener_callback: ClassVar[Dict[str, callable]] = {} # overlay survey overlay_survey = Unicode("").tag(sync=True, init_option=True) @@ -145,7 +143,7 @@ class Aladin(anywidget.AnyWidget): init_options = traitlets.List(trait=Any()).tag(sync=True) @default("init_options") - def _init_options(self) -> typing.List[str]: + def _init_options(self) -> List[str]: return list(self.traits(init_option=True)) def __init__(self, *args: any, **kwargs: any) -> None: @@ -548,7 +546,7 @@ def add_graphic_overlay_from_region( ) def add_overlay_from_stcs( - self, stc_string: Union[typing.List[str], str], **overlay_options: any + self, stc_string: Union[List[str], str], **overlay_options: any ) -> None: """Add an overlay layer defined by an STC-S string. @@ -569,7 +567,7 @@ def add_overlay_from_stcs( self.add_graphic_overlay_from_stcs(stc_string, **overlay_options) def add_graphic_overlay_from_stcs( - self, stc_string: Union[typing.List[str], str], **overlay_options: any + self, stc_string: Union[List[str], str], **overlay_options: any ) -> None: """Add an overlay layer defined by an STC-S string. From 49c17db1035c505be1e342f9fda0dde19da64809 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 12:52:11 +0200 Subject: [PATCH 20/24] fix: avoid most getElementById calls --- js/models/event_handler.js | 10 +++++++--- js/widget.js | 7 +------ 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index d0b4dbfb..f6fe0253 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -1,5 +1,5 @@ import MessageHandler from "./message_handler"; -import { divNumber, Lock } from "../utils"; +import { divNumber, setDivNumber, Lock } from "../utils"; export default class EventHandler { /** @@ -20,6 +20,10 @@ export default class EventHandler { * @returns {boolean} */ isLastDiv() { + let currentDivNumber = parseInt(this.aladinDiv.id.split("-").pop()); + if (currentDivNumber === divNumber) { + return true; + } let maxDiv = divNumber; for (let i = maxDiv; i >= 0; i--) { const alDiv = document.getElementById(`aladin-lite-div-${i}`); @@ -29,7 +33,8 @@ export default class EventHandler { break; } } - return parseInt(this.aladinDiv.id.split("-").pop()) === maxDiv; + setDivNumber(maxDiv); + return currentDivNumber === maxDiv; } /** @@ -190,7 +195,6 @@ export default class EventHandler { }); this.aladin.on("click", (clickContent) => { - console.log("Click", this.isLastDiv()); this.model.send({ event_type: "click", content: clickContent, diff --git a/js/widget.js b/js/widget.js index 778d1872..b2e13fc0 100644 --- a/js/widget.js +++ b/js/widget.js @@ -1,11 +1,6 @@ import "./widget.css"; import EventHandler from "./models/event_handler"; -import { - divNumber, - getDivNumber, - setDivNumber, - snakeCaseToCamelCase, -} from "./utils"; +import { divNumber, setDivNumber, snakeCaseToCamelCase } from "./utils"; import A from "./aladin_lite"; function initAladinLite(model, el) { From a4ab722f05aac48e5b4d65913407aaf4fcaf2233 Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 12:52:55 +0200 Subject: [PATCH 21/24] fix: don't empty fov_xy if fov does not change --- src/ipyaladin/widget.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/ipyaladin/widget.py b/src/ipyaladin/widget.py index 790b6e65..9f528bd9 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -18,6 +18,7 @@ from astropy.io import fits as astropy_fits from astropy.io.fits import HDUList from astropy.wcs import WCS +import numpy as np import traitlets from .utils.exceptions import WidgetCommunicationError @@ -185,7 +186,7 @@ def height(self) -> int: @height.setter def height(self, height: int) -> None: - if self._height == height: + if np.isclose(self._height, height): return self._wcs = {} self._fov_xy = {} @@ -250,6 +251,8 @@ def fov(self, fov: Union[float, Angle]) -> None: if isinstance(fov, Angle): fov = fov.deg self._fov = fov + if np.isclose(fov, self._fov): + return self._fov_xy = {} self._wcs = {} self.send({"event_name": "change_fov", "fov": fov}) From d51920e2e23888d0ca1372b4a5a1695588ad60ca Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 12:56:31 +0200 Subject: [PATCH 22/24] docs: edit info extractions --- ...Extracting_information_from_the_view.ipynb | 309 +++++++++++++++--- 1 file changed, 267 insertions(+), 42 deletions(-) diff --git a/examples/11_Extracting_information_from_the_view.ipynb b/examples/11_Extracting_information_from_the_view.ipynb index 67eda70c..89e37514 100644 --- a/examples/11_Extracting_information_from_the_view.ipynb +++ b/examples/11_Extracting_information_from_the_view.ipynb @@ -1,109 +1,334 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "98601fdf-e2df-46c9-b039-710e45aabfdc", + "metadata": {}, + "source": [ + "# Retrieving data from the current widget's view\n", + "\n", + "So far, we've seen how to send information (tables, MOCs, ...) into the widget. The other way also works! Here are a list of methods to extract diverse information about the current view:" + ] + }, { "cell_type": "code", + "execution_count": 1, "id": "initial_id", - "metadata": { - "collapsed": true - }, + "metadata": {}, + "outputs": [], "source": [ "from ipyaladin import Aladin" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 2, "id": "2e62d34eb8543145", "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8609c7b19f7644acb71ce3a258199fd9", + "version_major": 2, + "version_minor": 1 + }, + "text/plain": [ + "Aladin(init_options=['_fov', '_height', '_target', 'background_color', 'coo_frame', 'full_screen', 'grid_color…" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "aladin = Aladin(fov=5, height=600, target=\"M31\")\n", "aladin" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", - "id": "54a2d7bb2777de3b", + "id": "ae0a5496-d621-49ef-a11a-3578c272ce92", "metadata": {}, "source": [ - "# Extracting information from the view\n", - "## Extracting values\n", - "Currently, ipyaladin allow you to recover some values from the Aladin Lite instance. These values are:\n", - "- The World Coordinate System (WCS)\n", - "- The field of view for the x and y axis\n", - "You can recover these values by calling the corresponding attribute." + "## Getting the current WCS\n", + "\n", + "The World Coordinates System (WCS) describes the field of view, the projection, and it's rotation. It is returned as an `astropy.coordinates.WCS` object." ] }, { "cell_type": "code", + "execution_count": 3, "id": "84153657cb7cd837", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WCS Keywords\n", + "\n", + "Number of WCS axes: 2\n", + "CTYPE : 'RA---SIN' 'DEC--SIN' \n", + "CRVAL : 10.6847083 41.26875 \n", + "CRPIX : 929.0 300.5 \n", + "PC1_1 PC1_2 : 1.0 0.0 \n", + "PC2_1 PC2_2 : 0.0 1.0 \n", + "CDELT : -0.00269251480883144 0.002692514808831448 \n", + "NAXIS : 1857 600" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "aladin.wcs # Recover the current WCS" - ], - "outputs": [], - "execution_count": null + ] }, { - "cell_type": "code", - "id": "9595ae02388b245a", + "cell_type": "markdown", + "id": "998def1f-3963-405b-8be2-6d4ef4012634", "metadata": {}, "source": [ - "aladin.fov_xy # Recover the current field of view for the x and y axis" - ], + "If you edit the view either by modifiing the widget through its interface, or programmatically: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a63f210b-3a64-4860-8e70-42a4c66378fa", + "metadata": {}, "outputs": [], - "execution_count": null + "source": [ + "aladin.height = 800\n", + "aladin.survey = \"CDS/P/PLANCK/R2/HFI/color\"\n", + "aladin.target = \"LMC\"\n", + "aladin.fov = 50" + ] }, { "cell_type": "markdown", - "id": "870935d9c4e2aaa", + "id": "9c2221f3-6ecc-46d6-9d53-5dbefa71326d", "metadata": {}, "source": [ - "## Changing values\n", - "If you change a value that affects the value you want to extract, you need to extract this value in the next cell." + "The wcs is updated and you can print its new value in the **next cell**:" ] }, { "cell_type": "code", - "id": "dfdc3a54019d7e34", + "execution_count": 5, + "id": "2ddc9637-b5c3-4412-8435-2302b6d86816", "metadata": {}, - "source": [ - "aladin.target = \"M33\"\n", - "aladin.fov = 2" + "outputs": [ + { + "data": { + "text/plain": [ + "WCS Keywords\n", + "\n", + "Number of WCS axes: 2\n", + "CTYPE : 'RA---SIN' 'DEC--SIN' \n", + "CRVAL : 80.89416999999995 -69.75611 \n", + "CRPIX : 929.0 400.5 \n", + "PC1_1 PC1_2 : 1.0 0.0 \n", + "PC2_1 PC2_2 : 0.0 1.0 \n", + "CDELT : -0.00269251480883144 0.002692514808831449 \n", + "NAXIS : 1857 800" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } ], - "outputs": [], - "execution_count": null + "source": [ + "aladin.wcs" + ] }, { - "cell_type": "code", - "id": "ad62fb2664e45a30", + "cell_type": "markdown", + "id": "f5add3a2-be30-488e-86df-426338b98f5d", "metadata": {}, "source": [ - "aladin.wcs # This will represent the new WCS" + "If you try to recover the value in the same cell, you'll get a `WidgetCommunicationError` error. This is because the calculation of the WCS is done by Aladin Lite *between* cell exceutions. \n", + "\n", + "## Getting the field of view\n", + "\n", + "The field of view is printed in the bottom left corner of the view. You can grab the two values with:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9595ae02388b245a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } ], - "outputs": [], - "execution_count": null + "source": [ + "aladin.fov_xy # Recover the current field of view for the x and y axis" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.11.8" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "8609c7b19f7644acb71ce3a258199fd9": { + "model_module": "anywidget", + "model_module_version": "0.9.10", + "model_name": "AnyModel", + "state": { + "_anywidget_id": "ipyaladin.widget.Aladin", + "_css": ".cell-output-ipywidget-background{background:transparent}.jp-OutputArea-output,.aladin-widget{background-color:transparent}.aladin-widget .aladin-measurement-div{max-height:100px}\n/*# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vanMvd2lkZ2V0LmNzcyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLmNlbGwtb3V0cHV0LWlweXdpZGdldC1iYWNrZ3JvdW5kIHtcbiAgYmFja2dyb3VuZDogdHJhbnNwYXJlbnQ7XG59XG4uanAtT3V0cHV0QXJlYS1vdXRwdXQge1xuICBiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbn1cbi5hbGFkaW4td2lkZ2V0IHtcbiAgYmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG59XG4uYWxhZGluLXdpZGdldCAuYWxhZGluLW1lYXN1cmVtZW50LWRpdiB7XG4gIG1heC1oZWlnaHQ6IDEwMHB4O1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsQ0FBQyxpQ0FDQyxXQUFZLFdBQ2QsQ0FDQSxDQUFDLHFCQUdELENBQUMsY0FGQyxpQkFBa0IsV0FDcEIsQ0FJQSxDQUhDLGNBR2MsQ0FBQyx1QkFDZCxXQUFZLEtBQ2QiLAogICJuYW1lcyI6IFtdCn0K */\n", + "_esm": "function f(s){s.charAt(0)===\"_\"&&(s=s.slice(1));let e=s.split(\"_\");for(let a=1;a{this.aladin.gotoRaDec(r,v),console.info(`FITS located at ra: ${r}, dec: ${v}`),URL.revokeObjectURL(o)});this.aladin.setOverlayImageLayer(d,i.name)}handleAddCatalogFromURL(e){let a=h(e.options||{});this.aladin.addCatalog(l.catalogFromURL(e.votable_URL,a))}handleAddMOCFromURL(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromURL(e.moc_URL,a))}handleAddMOCFromDict(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromJSON(e.moc_dict,a))}handleAddOverlay(e){let a=e.regions_infos,i=h(e.graphic_options||{});i.color||(i.color=\"red\");let n=l.graphicOverlay(i);this.aladin.addOverlay(n);for(let t of a){let o=t.infos;switch(t.region_type){case\"stcs\":n.addFootprints(l.footprintsFromSTCS(o.stcs,t.options));break;case\"circle\":n.add(l.circle(o.ra,o.dec,o.radius,t.options));break;case\"ellipse\":n.add(l.ellipse(o.ra,o.dec,o.a,o.b,o.theta,t.options));break;case\"line\":t.options.lineWidth=t.options.lineWidth||3,n.add(l.vector(o.ra1,o.dec1,o.ra2,o.dec2,t.options));break;case\"polygon\":n.add(l.polygon(o.vertices,t.options));break}}}handleChangeColormap(e){this.aladin.getBaseImageLayer().setColormap(e.colormap)}handleGetJPGThumbnail(){this.aladin.exportAsPNG()}handleTriggerRectangularSelection(){this.aladin.select()}handleAddTable(e,a){let i=h(e.options||{}),n=a[0].buffer,t=new TextDecoder(\"utf-8\"),o=new Blob([t.decode(n)]),d=URL.createObjectURL(o);l.catalogFromURL(d,Object.assign(i,{onClick:\"showTable\"}),r=>{this.aladin.addCatalog(r)},!1),URL.revokeObjectURL(d)}};var p=class{constructor(e,a,i){this.aladin=e,this.aladinDiv=a,this.model=i,this.messageHandler=new g(e,i)}isLastDiv(){let e=parseInt(this.aladinDiv.id.split(\"-\").pop());if(e===m)return!0;let a=m;for(let i=a;i>=0;i--){let n=document.getElementById(`aladin-lite-div-${i}`);if(n&&n.style.display!==\"none\"){a=i;break}}return u(a),e===a}updateWCS(){this.isLastDiv()&&this.model.set(\"_wcs\",this.aladin.getViewWCS())}update2AxisFoV(){if(!this.isLastDiv())return;let e=this.aladin.getFov();this.model.set(\"_fov_xy\",{x:e[0],y:e[1]})}subscribeAll(){let e=new c,a=new c;this.aladin.on(\"positionChanged\",t=>{if(a.locked){a.unlock();return}e.lock();let o=[t.ra,t.dec];this.updateWCS(),this.model.set(\"_target\",`${o[0]} ${o[1]}`),this.model.save_changes()}),this.model.on(\"change:_target\",()=>{if(e.locked){e.unlock();return}a.lock();let t=this.model.get(\"_target\"),[o,d]=t.split(\" \");this.aladin.gotoRaDec(o,d)});let i=new c,n=new c;this.aladin.on(\"zoomChanged\",t=>{if(n.locked){n.unlock();return}i.lock(),this.updateWCS(),this.update2AxisFoV(),this.model.set(\"_fov\",parseFloat(t.toFixed(5))),this.model.save_changes()}),this.model.on(\"change:_fov\",()=>{if(i.locked){i.unlock();return}n.lock();let t=this.model.get(\"_fov\");this.aladin.setFoV(t)}),this.model.on(\"change:_height\",()=>{let t=this.model.get(\"_height\");this.aladinDiv.style.height=`${t}px`,this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"cooFrameChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"projectionChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"layerChanged\",(t,o,d)=>{o!==\"base\"||d!==\"ADDED\"||(this.updateWCS(),this.model.save_changes())}),this.aladin.on(\"resizeChanged\",()=>{this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"objectHovered\",t=>{t.data!==void 0&&this.model.send({event_type:\"object_hovered\",content:{ra:t.ra,dec:t.dec}})}),this.aladin.on(\"objectClicked\",t=>{if(t){let o={ra:t.ra,dec:t.dec};t.data!==void 0&&(o.data=t.data),this.model.set(\"clicked_object\",o),this.model.send({event_type:\"object_clicked\",content:o}),this.model.save_changes()}}),this.aladin.on(\"click\",t=>{this.model.send({event_type:\"click\",content:t})}),this.aladin.on(\"select\",t=>{let o=[];t.forEach(d=>{d.forEach(r=>{o.push({ra:r.ra,dec:r.dec,data:r.data,x:r.x,y:r.y})})}),this.model.send({event_type:\"select\",content:o})}),this.model.on(\"change:coo_frame\",()=>{this.aladin.setFrame(this.model.get(\"coo_frame\"))}),this.model.on(\"change:survey\",()=>{this.aladin.setImageSurvey(this.model.get(\"survey\"))}),this.model.on(\"change:overlay_survey\",()=>{this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"))}),this.model.on(\"change:overlay_survey_opacity\",()=>{this.aladin.getOverlayImageLayer().setAlpha(this.model.get(\"overlay_survey_opacity\"))}),this.eventHandlers={change_fov:this.messageHandler.handleChangeFoV,goto_ra_dec:this.messageHandler.handleGotoRaDec,add_fits:this.messageHandler.handleAddFits,add_catalog_from_URL:this.messageHandler.handleAddCatalogFromURL,add_MOC_from_URL:this.messageHandler.handleAddMOCFromURL,add_MOC_from_dict:this.messageHandler.handleAddMOCFromDict,add_overlay:this.messageHandler.handleAddOverlay,change_colormap:this.messageHandler.handleChangeColormap,get_JPG_thumbnail:this.messageHandler.handleGetJPGThumbnail,trigger_rectangular_selection:this.messageHandler.handleTriggerRectangularSelection,add_table:this.messageHandler.handleAddTable},this.model.on(\"msg:custom\",(t,o)=>{let d=t.event_name,r=this.eventHandlers[d];if(r)r.call(this,t,o);else throw new Error(`Unknown event name: ${d}`)})}unsubscribeAll(){this.model.off(\"change:_target\"),this.model.off(\"change:_fov\"),this.model.off(\"change:_height\"),this.model.off(\"change:coo_frame\"),this.model.off(\"change:survey\"),this.model.off(\"change:overlay_survey\"),this.model.off(\"change:overlay_survey_opacity\"),this.model.off(\"change:trigger_event\"),this.model.off(\"msg:custom\")}};function C(s,e){u(m+1);let a={};s.get(\"init_options\").forEach(d=>{a[f(d)]=s.get(d)});let i=document.createElement(\"div\");i.classList.add(\"aladin-widget\"),i.style.height=`${a.height}px`,i.id=`aladin-lite-div-${m}`;let n=new l.aladin(i,a),t=a.target.split(\" \");n.gotoRaDec(t[0],t[1]);let o=n.getFov();return s.set(\"_fov_xy\",{x:o[0],y:o[1]}),s.set(\"_wcs\",n.getViewWCS()),s.save_changes(),e.appendChild(i),{aladin:n,aladinDiv:i}}async function b({model:s}){await l.init}function k({model:s,el:e}){let{aladin:a,aladinDiv:i}=C(s,e),n=new p(a,i,s);return n.subscribeAll(),()=>{n.unsubscribeAll()}}var j={initialize:b,render:k};export{j as default};\n//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../js/utils.js", "../../../js/aladin_lite.js", "../../../js/models/message_handler.js", "../../../js/models/event_handler.js", "../../../js/widget.js"],
  "sourcesContent": ["/**\n * Converts a string from camelCase to snake_case.\n * @param {string} snakeCaseStr - The string to convert.\n * @returns {string} The string converted to snake_case.\n */\nfunction snakeCaseToCamelCase(snakeCaseStr) {\n  if (snakeCaseStr.charAt(0) === \"_\") snakeCaseStr = snakeCaseStr.slice(1);\n  let temp = snakeCaseStr.split(\"_\");\n  for (let i = 1; i < temp.length; i++)\n    temp[i] = temp[i].charAt(0).toUpperCase() + temp[i].slice(1);\n  return temp.join(\"\");\n}\n\n/**\n * Converts option names in an object from snake_case to camelCase.\n * @param {Object} options - The options object with snake_case property names.\n * @returns {Object} An object with property names converted to camelCase.\n */\nfunction convertOptionNamesToCamelCase(options) {\n  const newOptions = {};\n  for (const optionName in options)\n    newOptions[snakeCaseToCamelCase(optionName)] = options[optionName];\n  return newOptions;\n}\n\nclass Lock {\n  locked = false;\n\n  /**\n   * Unlocks the object\n   */\n  unlock() {\n    this.locked = false;\n  }\n\n  /**\n   * Locks the object\n   */\n  lock() {\n    this.locked = true;\n  }\n}\n\nlet divNumber = -1;\nfunction setDivNumber(num) {\n  divNumber = num;\n}\n\nexport {\n  snakeCaseToCamelCase,\n  convertOptionNamesToCamelCase,\n  Lock,\n  divNumber,\n  setDivNumber,\n};\n", "import A from \"https://esm.sh/aladin-lite@3.4.5-beta\";\n\nexport default A;\n", "import { convertOptionNamesToCamelCase } from \"../utils\";\nimport A from \"../aladin_lite\";\n\nlet imageCount = 0;\n\nexport default class MessageHandler {\n  constructor(aladin, model) {\n    this.aladin = aladin;\n    this.model = model;\n  }\n\n  handleChangeFoV(msg) {\n    this.aladin.setFoV(msg[\"fov\"]);\n  }\n\n  handleGotoRaDec(msg) {\n    this.aladin.gotoRaDec(msg[\"ra\"], msg[\"dec\"]);\n  }\n\n  handleAddFits(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    if (!options.name)\n      options.name = `image_${String(++imageCount).padStart(3, \"0\")}`;\n    const buffer = buffers[0];\n    const blob = new Blob([buffer], { type: \"application/octet-stream\" });\n    const url = URL.createObjectURL(blob);\n    const image = this.aladin.createImageFITS(url, options, (ra, dec) => {\n      this.aladin.gotoRaDec(ra, dec);\n      console.info(`FITS located at ra: ${ra}, dec: ${dec}`);\n      URL.revokeObjectURL(url);\n    });\n    this.aladin.setOverlayImageLayer(image, options.name);\n  }\n\n  handleAddCatalogFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addCatalog(A.catalogFromURL(msg[\"votable_URL\"], options));\n  }\n\n  handleAddMOCFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromURL(msg[\"moc_URL\"], options));\n  }\n\n  handleAddMOCFromDict(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromJSON(msg[\"moc_dict\"], options));\n  }\n\n  handleAddOverlay(msg) {\n    const regions = msg[\"regions_infos\"];\n    const graphic_options = convertOptionNamesToCamelCase(\n      msg[\"graphic_options\"] || {},\n    );\n    if (!graphic_options[\"color\"]) graphic_options[\"color\"] = \"red\";\n    const overlay = A.graphicOverlay(graphic_options);\n    this.aladin.addOverlay(overlay);\n    for (const region of regions) {\n      const infos = region[\"infos\"];\n      switch (region[\"region_type\"]) {\n        case \"stcs\":\n          overlay.addFootprints(\n            A.footprintsFromSTCS(infos.stcs, region.options),\n          );\n          break;\n        case \"circle\":\n          overlay.add(\n            A.circle(infos.ra, infos.dec, infos.radius, region.options),\n          );\n          break;\n        case \"ellipse\":\n          overlay.add(\n            A.ellipse(\n              infos.ra,\n              infos.dec,\n              infos.a,\n              infos.b,\n              infos.theta,\n              region.options,\n            ),\n          );\n          break;\n        case \"line\":\n          // remove default lineWidth when we switch to AL > 3.4.4\n          region.options.lineWidth = region.options.lineWidth || 3;\n          overlay.add(\n            A.vector(\n              infos.ra1,\n              infos.dec1,\n              infos.ra2,\n              infos.dec2,\n              region.options,\n            ),\n          );\n          break;\n        case \"polygon\":\n          overlay.add(A.polygon(infos.vertices, region.options));\n          break;\n      }\n    }\n  }\n\n  handleChangeColormap(msg) {\n    this.aladin.getBaseImageLayer().setColormap(msg[\"colormap\"]);\n  }\n\n  handleGetJPGThumbnail() {\n    this.aladin.exportAsPNG();\n  }\n\n  handleTriggerRectangularSelection() {\n    this.aladin.select();\n  }\n\n  handleAddTable(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    const buffer = buffers[0].buffer;\n    const decoder = new TextDecoder(\"utf-8\");\n    const blob = new Blob([decoder.decode(buffer)]);\n    const url = URL.createObjectURL(blob);\n    A.catalogFromURL(\n      url,\n      Object.assign(options, { onClick: \"showTable\" }),\n      (catalog) => {\n        this.aladin.addCatalog(catalog);\n      },\n      false,\n    );\n    URL.revokeObjectURL(url);\n  }\n}\n", "import MessageHandler from \"./message_handler\";\nimport { divNumber, setDivNumber, Lock } from \"../utils\";\n\nexport default class EventHandler {\n  /**\n   * Constructor for the EventHandler class.\n   * @param aladin The Aladin instance\n   * @param aladinDiv The Aladin div\n   * @param model The model instance\n   */\n  constructor(aladin, aladinDiv, model) {\n    this.aladin = aladin;\n    this.aladinDiv = aladinDiv;\n    this.model = model;\n    this.messageHandler = new MessageHandler(aladin, model);\n  }\n\n  /**\n   * Checks if the current div is the last active div.\n   * @returns {boolean}\n   */\n  isLastDiv() {\n    let currentDivNumber = parseInt(this.aladinDiv.id.split(\"-\").pop())\n    if (currentDivNumber === divNumber){\n      return true\n    };\n    let maxDiv = divNumber;\n    for (let i = maxDiv; i >= 0; i--) {\n      const alDiv = document.getElementById(`aladin-lite-div-${i}`);\n      if (!alDiv) continue;\n      if (alDiv.style.display !== \"none\") {\n        maxDiv = i;\n        break;\n      }\n    }\n    setDivNumber(maxDiv);\n    return currentDivNumber === maxDiv;\n  }\n\n  /**\n   * Updates the WCS coordinates in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  updateWCS() {\n    if (!this.isLastDiv()) return;\n    this.model.set(\"_wcs\", this.aladin.getViewWCS());\n  }\n\n  /**\n   * Updates the 2-axis FoV in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  update2AxisFoV() {\n    if (!this.isLastDiv()) return;\n    const twoAxisFoV = this.aladin.getFov();\n    this.model.set(\"_fov_xy\", {\n      x: twoAxisFoV[0],\n      y: twoAxisFoV[1],\n    });\n  }\n\n  /**\n   * Subscribes to all the events needed for the Aladin Lite widget.\n   */\n  subscribeAll() {\n    /* ------------------- */\n    /* Listeners --------- */\n    /* ------------------- */\n\n    /* Position Control */\n    // there are two ways of changing the target, one from the javascript side, and\n    // one from the python side. We have to instantiate two listeners for these, but\n    // the gotoObject call should only happen once. The two booleans prevent the two\n    // listeners from triggering each other and creating a buggy loop. The same trick\n    // is also necessary for the field of view.\n\n    /* Target control */\n    const jsTargetLock = new Lock();\n    const pyTargetLock = new Lock();\n\n    // Event triggered when the user moves the map in Aladin Lite\n    this.aladin.on(\"positionChanged\", (position) => {\n      if (pyTargetLock.locked) {\n        pyTargetLock.unlock();\n        return;\n      }\n      jsTargetLock.lock();\n      const raDec = [position.ra, position.dec];\n      this.updateWCS();\n      this.model.set(\"_target\", `${raDec[0]} ${raDec[1]}`);\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_target\", () => {\n      if (jsTargetLock.locked) {\n        jsTargetLock.unlock();\n        return;\n      }\n      pyTargetLock.lock();\n      let target = this.model.get(\"_target\");\n      const [ra, dec] = target.split(\" \");\n      this.aladin.gotoRaDec(ra, dec);\n    });\n\n    /* Field of View control */\n    const jsFovLock = new Lock();\n    const pyFovLock = new Lock();\n\n    this.aladin.on(\"zoomChanged\", (fov) => {\n      if (pyFovLock.locked) {\n        pyFovLock.unlock();\n        return;\n      }\n      jsFovLock.lock();\n      // fov MUST be cast into float in order to be sent to the model\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.set(\"_fov\", parseFloat(fov.toFixed(5)));\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_fov\", () => {\n      if (jsFovLock.locked) {\n        jsFovLock.unlock();\n        return;\n      }\n      pyFovLock.lock();\n      let fov = this.model.get(\"_fov\");\n      this.aladin.setFoV(fov);\n    });\n\n    /* Div control */\n    this.model.on(\"change:_height\", () => {\n      let height = this.model.get(\"_height\");\n      this.aladinDiv.style.height = `${height}px`;\n      // Update WCS and FoV only if this is the last div\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    /* Aladin callbacks */\n\n    this.aladin.on(\"cooFrameChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"projectionChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"layerChanged\", (_, layerName, state) => {\n      if (layerName !== \"base\" || state !== \"ADDED\") return;\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"resizeChanged\", () => {\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"objectHovered\", (object) => {\n      if (object[\"data\"] !== undefined) {\n        this.model.send({\n          event_type: \"object_hovered\",\n          content: {\n            ra: object[\"ra\"],\n            dec: object[\"dec\"],\n          },\n        });\n      }\n    });\n\n    this.aladin.on(\"objectClicked\", (clicked) => {\n      if (clicked) {\n        let clickedContent = {\n          ra: clicked[\"ra\"],\n          dec: clicked[\"dec\"],\n        };\n        if (clicked[\"data\"] !== undefined) {\n          clickedContent[\"data\"] = clicked[\"data\"];\n        }\n        this.model.set(\"clicked_object\", clickedContent);\n        // send a custom message in case the user wants to define their own callbacks\n        this.model.send({\n          event_type: \"object_clicked\",\n          content: clickedContent,\n        });\n        this.model.save_changes();\n      }\n    });\n\n    this.aladin.on(\"click\", (clickContent) => {\n      this.model.send({\n        event_type: \"click\",\n        content: clickContent,\n      });\n    });\n\n    this.aladin.on(\"select\", (catalogs) => {\n      let objectsData = [];\n      // TODO: this flattens the selection. Each object from different\n      // catalogs are entered in the array. To change this, maybe change\n      // upstream what is returned upon selection?\n      catalogs.forEach((catalog) => {\n        catalog.forEach((object) => {\n          objectsData.push({\n            ra: object.ra,\n            dec: object.dec,\n            data: object.data,\n            x: object.x,\n            y: object.y,\n          });\n        });\n      });\n      this.model.send({\n        event_type: \"select\",\n        content: objectsData,\n      });\n    });\n\n    /* Aladin functionalities */\n\n    this.model.on(\"change:coo_frame\", () => {\n      this.aladin.setFrame(this.model.get(\"coo_frame\"));\n    });\n\n    this.model.on(\"change:survey\", () => {\n      this.aladin.setImageSurvey(this.model.get(\"survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey\", () => {\n      this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey_opacity\", () => {\n      this.aladin\n        .getOverlayImageLayer()\n        .setAlpha(this.model.get(\"overlay_survey_opacity\"));\n    });\n\n    this.eventHandlers = {\n      change_fov: this.messageHandler.handleChangeFoV,\n      goto_ra_dec: this.messageHandler.handleGotoRaDec,\n      add_fits: this.messageHandler.handleAddFits,\n      add_catalog_from_URL: this.messageHandler.handleAddCatalogFromURL,\n      add_MOC_from_URL: this.messageHandler.handleAddMOCFromURL,\n      add_MOC_from_dict: this.messageHandler.handleAddMOCFromDict,\n      add_overlay: this.messageHandler.handleAddOverlay,\n      change_colormap: this.messageHandler.handleChangeColormap,\n      get_JPG_thumbnail: this.messageHandler.handleGetJPGThumbnail,\n      trigger_rectangular_selection:\n        this.messageHandler.handleTriggerRectangularSelection,\n      add_table: this.messageHandler.handleAddTable,\n    };\n\n    this.model.on(\"msg:custom\", (msg, buffers) => {\n      const eventName = msg[\"event_name\"];\n      const handler = this.eventHandlers[eventName];\n      if (handler) handler.call(this, msg, buffers);\n      else throw new Error(`Unknown event name: ${eventName}`);\n    });\n  }\n\n  /**\n   * Unsubscribe from all the model events.\n   * There is no need to unsubscribe from the Aladin Lite events.\n   */\n  unsubscribeAll() {\n    this.model.off(\"change:_target\");\n    this.model.off(\"change:_fov\");\n    this.model.off(\"change:_height\");\n    this.model.off(\"change:coo_frame\");\n    this.model.off(\"change:survey\");\n    this.model.off(\"change:overlay_survey\");\n    this.model.off(\"change:overlay_survey_opacity\");\n    this.model.off(\"change:trigger_event\");\n    this.model.off(\"msg:custom\");\n  }\n}\n", "import \"./widget.css\";\nimport EventHandler from \"./models/event_handler\";\nimport {\n  divNumber,\n  setDivNumber,\n  snakeCaseToCamelCase,\n} from \"./utils\";\nimport A from \"./aladin_lite\";\n\nfunction initAladinLite(model, el) {\n  setDivNumber(divNumber + 1);\n  let initOptions = {};\n  model.get(\"init_options\").forEach((option_name) => {\n    initOptions[snakeCaseToCamelCase(option_name)] = model.get(option_name);\n  });\n\n  let aladinDiv = document.createElement(\"div\");\n  aladinDiv.classList.add(\"aladin-widget\");\n  aladinDiv.style.height = `${initOptions[\"height\"]}px`;\n\n  aladinDiv.id = `aladin-lite-div-${divNumber}`;\n  let aladin = new A.aladin(aladinDiv, initOptions);\n\n  // Set the target again after the initialization to be sure that the target is set\n  // from icrs coordinates because of the use of gotoObject in the Aladin Lite API\n  const raDec = initOptions[\"target\"].split(\" \");\n  aladin.gotoRaDec(raDec[0], raDec[1]);\n\n  // Set current FoV and WCS\n  const twoAxisFoV = aladin.getFov();\n  model.set(\"_fov_xy\", {\n    x: twoAxisFoV[0],\n    y: twoAxisFoV[1],\n  });\n  model.set(\"_wcs\", aladin.getViewWCS());\n  model.save_changes();\n\n  el.appendChild(aladinDiv);\n  return { aladin, aladinDiv };\n}\n\nasync function initialize({ model }) {\n  await A.init;\n}\n\nfunction render({ model, el }) {\n  /* ------------------- */\n  /* View -------------- */\n  /* ------------------- */\n\n  const { aladin, aladinDiv } = initAladinLite(model, el);\n\n  const eventHandler = new EventHandler(aladin, aladinDiv, model);\n  eventHandler.subscribeAll();\n\n  return () => {\n    // Need to unsubscribe the listeners\n    eventHandler.unsubscribeAll();\n  };\n}\n\nexport default { initialize, render };\n"],
  "mappings": "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",
  "names": ["snakeCaseToCamelCase", "snakeCaseStr", "temp", "i", "convertOptionNamesToCamelCase", "options", "newOptions", "optionName", "Lock", "divNumber", "setDivNumber", "num", "A", "aladin_lite_default", "imageCount", "MessageHandler", "aladin", "model", "msg", "buffers", "options", "convertOptionNamesToCamelCase", "buffer", "blob", "url", "image", "ra", "dec", "aladin_lite_default", "regions", "graphic_options", "overlay", "region", "infos", "decoder", "catalog", "EventHandler", "aladin", "aladinDiv", "model", "MessageHandler", "currentDivNumber", "divNumber", "maxDiv", "alDiv", "setDivNumber", "twoAxisFoV", "jsTargetLock", "Lock", "pyTargetLock", "position", "raDec", "target", "ra", "dec", "jsFovLock", "pyFovLock", "fov", "height", "_", "layerName", "state", "object", "clicked", "clickedContent", "clickContent", "catalogs", "objectsData", "catalog", "msg", "buffers", "eventName", "handler", "initAladinLite", "model", "el", "setDivNumber", "divNumber", "initOptions", "option_name", "snakeCaseToCamelCase", "aladinDiv", "aladin", "aladin_lite_default", "raDec", "twoAxisFoV", "initialize", "render", "eventHandler", "EventHandler", "widget_default"]
}
\n", + "_fov": 5.60143, + "_fov_xy": { + "x": 5.60143396583755, + "y": 5.60143396583755 + }, + "_height": 800, + "_model_module": "anywidget", + "_model_module_version": "0.9.10", + "_model_name": "AnyModel", + "_target": "10.684708299999999 41.268749999999976", + "_view_module": "anywidget", + "_view_module_version": "0.9.10", + "_view_name": "AnyView", + "_wcs": { + "CDELT1": -5.60143396583755, + "CDELT2": 5.60143396583755, + "CRPIX1": 1, + "CRPIX2": 1, + "CRVAL1": 10.684708299999997, + "CRVAL2": 41.26874999999998, + "CTYPE1": "RA---SIN", + "CTYPE2": "DEC--SIN", + "CUNIT1": "deg ", + "CUNIT2": "deg ", + "LONPOLE": 180.00000000000006, + "NAXIS": 2, + "NAXIS1": 1, + "NAXIS2": 1, + "RADESYS": "ICRS " + }, + "background_color": "rgb(60, 60, 60)", + "clicked_object": {}, + "coo_frame": "J2000", + "full_screen": false, + "grid_color": "rgb(178, 50, 178)", + "grid_opacity": 0.5, + "grid_options": { + "color": { + "b": 0.6980392156862745, + "g": 0.19607843137254902, + "r": 0.6980392156862745 + }, + "enabled": false, + "labelSize": 15, + "opacity": 0.5, + "showLabels": true, + "thickness": 2 + }, + "init_options": [ + "_fov", + "_height", + "_target", + "background_color", + "coo_frame", + "full_screen", + "grid_color", + "grid_opacity", + "grid_options", + "overlay_survey", + "overlay_survey_opacity", + "projection", + "reticle_color", + "reticle_size", + "samp", + "show_catalog", + "show_context_menu", + "show_coo_grid", + "show_coo_grid_control", + "show_coo_location", + "show_fov", + "show_frame", + "show_fullscreen_control", + "show_layers_control", + "show_overlay_stack_control", + "show_projection_control", + "show_reticle", + "show_settings_control", + "show_share_control", + "show_simbad_pointer_control", + "show_status_bar", + "show_zoom_control", + "survey" + ], + "layout": "IPY_MODEL_963ac6a600854d92a585c08214f76219", + "overlay_survey": "", + "overlay_survey_opacity": 0, + "projection": "SIN", + "reticle_color": "rgb(178, 50, 178)", + "reticle_size": 20, + "samp": false, + "show_catalog": true, + "show_context_menu": true, + "show_coo_grid": false, + "show_coo_grid_control": true, + "show_coo_location": true, + "show_fov": true, + "show_frame": true, + "show_fullscreen_control": true, + "show_layers_control": true, + "show_overlay_stack_control": true, + "show_projection_control": true, + "show_reticle": true, + "show_settings_control": true, + "show_share_control": false, + "show_simbad_pointer_control": true, + "show_status_bar": true, + "show_zoom_control": false, + "survey": "CDS/P/PLANCK/R2/HFI/color" + } + }, + "963ac6a600854d92a585c08214f76219": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } } }, "nbformat": 4, From 8121131e3b4a3d99bfb5a2bcdcadaace0e6b46fd Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 15:47:24 +0200 Subject: [PATCH 23/24] fix: only parse string once --- js/models/event_handler.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/js/models/event_handler.js b/js/models/event_handler.js index f6fe0253..4c1ccaea 100644 --- a/js/models/event_handler.js +++ b/js/models/event_handler.js @@ -13,6 +13,7 @@ export default class EventHandler { this.aladinDiv = aladinDiv; this.model = model; this.messageHandler = new MessageHandler(aladin, model); + this.currentDivNumber = parseInt(aladinDiv.id.split("-").pop()); } /** @@ -20,8 +21,7 @@ export default class EventHandler { * @returns {boolean} */ isLastDiv() { - let currentDivNumber = parseInt(this.aladinDiv.id.split("-").pop()); - if (currentDivNumber === divNumber) { + if (this.currentDivNumber === divNumber) { return true; } let maxDiv = divNumber; @@ -34,7 +34,7 @@ export default class EventHandler { } } setDivNumber(maxDiv); - return currentDivNumber === maxDiv; + return this.currentDivNumber === maxDiv; } /** From 0ad20d37dfd5f6d8cfde05675c56b8124869cffc Mon Sep 17 00:00:00 2001 From: MARCHAND MANON Date: Mon, 22 Jul 2024 15:48:16 +0200 Subject: [PATCH 24/24] docs: add paragraph on limitations --- ...Extracting_information_from_the_view.ipynb | 48 ++++++++++--------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/examples/11_Extracting_information_from_the_view.ipynb b/examples/11_Extracting_information_from_the_view.ipynb index 89e37514..39fc3ab4 100644 --- a/examples/11_Extracting_information_from_the_view.ipynb +++ b/examples/11_Extracting_information_from_the_view.ipynb @@ -7,7 +7,10 @@ "source": [ "# Retrieving data from the current widget's view\n", "\n", - "So far, we've seen how to send information (tables, MOCs, ...) into the widget. The other way also works! Here are a list of methods to extract diverse information about the current view:" + "So far, we've seen how to send information (tables, MOCs, ...) into the widget. The other way also works! This notebook contains a list of methods to extract diverse information about the current view. However, here are several information about retrieving data from the widget:\n", + "\n", + "- when the view is modified programmatically (*i.e.* not by clicking on the buttons), the update of its properties is done between cell execution. This means that you'll see a `WidgetCommunicationError` when you try to modify the view and retrieve information about it in the **same** cell. Simply switch the property-reading to the next cell and everything will work as intended!\n", + "- if you generate different views of the same `Aladin()` instances -- either by calling `display` multiple times, or by using the `Create new view for cell output` button in Jupyter, the information contained in `wcs` and `fov_xy` will always correspond to the **most recently** created view." ] }, { @@ -29,7 +32,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8609c7b19f7644acb71ce3a258199fd9", + "model_id": "68df3ccd903340b4aa8af8aad92c0c20", "version_major": 2, "version_minor": 1 }, @@ -71,11 +74,11 @@ "Number of WCS axes: 2\n", "CTYPE : 'RA---SIN' 'DEC--SIN' \n", "CRVAL : 10.6847083 41.26875 \n", - "CRPIX : 929.0 300.5 \n", + "CRPIX : 843.0 300.5 \n", "PC1_1 PC1_2 : 1.0 0.0 \n", "PC2_1 PC2_2 : 0.0 1.0 \n", - "CDELT : -0.00269251480883144 0.002692514808831448 \n", - "NAXIS : 1857 600" + "CDELT : -0.0029673590504451 0.002967359050445104 \n", + "NAXIS : 1685 600" ] }, "execution_count": 3, @@ -105,6 +108,7 @@ "aladin.height = 800\n", "aladin.survey = \"CDS/P/PLANCK/R2/HFI/color\"\n", "aladin.target = \"LMC\"\n", + "aladin.frame = \"Galactic\"\n", "aladin.fov = 50" ] }, @@ -130,11 +134,11 @@ "Number of WCS axes: 2\n", "CTYPE : 'RA---SIN' 'DEC--SIN' \n", "CRVAL : 80.89416999999995 -69.75611 \n", - "CRPIX : 929.0 400.5 \n", + "CRPIX : 843.0 400.5 \n", "PC1_1 PC1_2 : 1.0 0.0 \n", "PC2_1 PC2_2 : 0.0 1.0 \n", - "CDELT : -0.00269251480883144 0.002692514808831449 \n", - "NAXIS : 1857 800" + "CDELT : -0.0029673590504451 0.002967359050445104 \n", + "NAXIS : 1685 800" ] }, "execution_count": 5, @@ -151,7 +155,7 @@ "id": "f5add3a2-be30-488e-86df-426338b98f5d", "metadata": {}, "source": [ - "If you try to recover the value in the same cell, you'll get a `WidgetCommunicationError` error. This is because the calculation of the WCS is done by Aladin Lite *between* cell exceutions. \n", + "If you try to recover the value in the **same cell**, you'll get a `WidgetCommunicationError` error. This is because the calculation of the WCS is done by Aladin Lite *between* cell executions. \n", "\n", "## Getting the field of view\n", "\n", @@ -167,7 +171,7 @@ { "data": { "text/plain": [ - "(, )" + "(, )" ] }, "execution_count": 6, @@ -201,34 +205,34 @@ "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { - "8609c7b19f7644acb71ce3a258199fd9": { + "68df3ccd903340b4aa8af8aad92c0c20": { "model_module": "anywidget", "model_module_version": "0.9.10", "model_name": "AnyModel", "state": { "_anywidget_id": "ipyaladin.widget.Aladin", "_css": ".cell-output-ipywidget-background{background:transparent}.jp-OutputArea-output,.aladin-widget{background-color:transparent}.aladin-widget .aladin-measurement-div{max-height:100px}\n/*# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vanMvd2lkZ2V0LmNzcyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLmNlbGwtb3V0cHV0LWlweXdpZGdldC1iYWNrZ3JvdW5kIHtcbiAgYmFja2dyb3VuZDogdHJhbnNwYXJlbnQ7XG59XG4uanAtT3V0cHV0QXJlYS1vdXRwdXQge1xuICBiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbn1cbi5hbGFkaW4td2lkZ2V0IHtcbiAgYmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG59XG4uYWxhZGluLXdpZGdldCAuYWxhZGluLW1lYXN1cmVtZW50LWRpdiB7XG4gIG1heC1oZWlnaHQ6IDEwMHB4O1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsQ0FBQyxpQ0FDQyxXQUFZLFdBQ2QsQ0FDQSxDQUFDLHFCQUdELENBQUMsY0FGQyxpQkFBa0IsV0FDcEIsQ0FJQSxDQUhDLGNBR2MsQ0FBQyx1QkFDZCxXQUFZLEtBQ2QiLAogICJuYW1lcyI6IFtdCn0K */\n", - "_esm": "function f(s){s.charAt(0)===\"_\"&&(s=s.slice(1));let e=s.split(\"_\");for(let a=1;a{this.aladin.gotoRaDec(r,v),console.info(`FITS located at ra: ${r}, dec: ${v}`),URL.revokeObjectURL(o)});this.aladin.setOverlayImageLayer(d,i.name)}handleAddCatalogFromURL(e){let a=h(e.options||{});this.aladin.addCatalog(l.catalogFromURL(e.votable_URL,a))}handleAddMOCFromURL(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromURL(e.moc_URL,a))}handleAddMOCFromDict(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromJSON(e.moc_dict,a))}handleAddOverlay(e){let a=e.regions_infos,i=h(e.graphic_options||{});i.color||(i.color=\"red\");let n=l.graphicOverlay(i);this.aladin.addOverlay(n);for(let t of a){let o=t.infos;switch(t.region_type){case\"stcs\":n.addFootprints(l.footprintsFromSTCS(o.stcs,t.options));break;case\"circle\":n.add(l.circle(o.ra,o.dec,o.radius,t.options));break;case\"ellipse\":n.add(l.ellipse(o.ra,o.dec,o.a,o.b,o.theta,t.options));break;case\"line\":t.options.lineWidth=t.options.lineWidth||3,n.add(l.vector(o.ra1,o.dec1,o.ra2,o.dec2,t.options));break;case\"polygon\":n.add(l.polygon(o.vertices,t.options));break}}}handleChangeColormap(e){this.aladin.getBaseImageLayer().setColormap(e.colormap)}handleGetJPGThumbnail(){this.aladin.exportAsPNG()}handleTriggerRectangularSelection(){this.aladin.select()}handleAddTable(e,a){let i=h(e.options||{}),n=a[0].buffer,t=new TextDecoder(\"utf-8\"),o=new Blob([t.decode(n)]),d=URL.createObjectURL(o);l.catalogFromURL(d,Object.assign(i,{onClick:\"showTable\"}),r=>{this.aladin.addCatalog(r)},!1),URL.revokeObjectURL(d)}};var p=class{constructor(e,a,i){this.aladin=e,this.aladinDiv=a,this.model=i,this.messageHandler=new g(e,i)}isLastDiv(){let e=parseInt(this.aladinDiv.id.split(\"-\").pop());if(e===m)return!0;let a=m;for(let i=a;i>=0;i--){let n=document.getElementById(`aladin-lite-div-${i}`);if(n&&n.style.display!==\"none\"){a=i;break}}return u(a),e===a}updateWCS(){this.isLastDiv()&&this.model.set(\"_wcs\",this.aladin.getViewWCS())}update2AxisFoV(){if(!this.isLastDiv())return;let e=this.aladin.getFov();this.model.set(\"_fov_xy\",{x:e[0],y:e[1]})}subscribeAll(){let e=new c,a=new c;this.aladin.on(\"positionChanged\",t=>{if(a.locked){a.unlock();return}e.lock();let o=[t.ra,t.dec];this.updateWCS(),this.model.set(\"_target\",`${o[0]} ${o[1]}`),this.model.save_changes()}),this.model.on(\"change:_target\",()=>{if(e.locked){e.unlock();return}a.lock();let t=this.model.get(\"_target\"),[o,d]=t.split(\" \");this.aladin.gotoRaDec(o,d)});let i=new c,n=new c;this.aladin.on(\"zoomChanged\",t=>{if(n.locked){n.unlock();return}i.lock(),this.updateWCS(),this.update2AxisFoV(),this.model.set(\"_fov\",parseFloat(t.toFixed(5))),this.model.save_changes()}),this.model.on(\"change:_fov\",()=>{if(i.locked){i.unlock();return}n.lock();let t=this.model.get(\"_fov\");this.aladin.setFoV(t)}),this.model.on(\"change:_height\",()=>{let t=this.model.get(\"_height\");this.aladinDiv.style.height=`${t}px`,this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"cooFrameChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"projectionChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"layerChanged\",(t,o,d)=>{o!==\"base\"||d!==\"ADDED\"||(this.updateWCS(),this.model.save_changes())}),this.aladin.on(\"resizeChanged\",()=>{this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"objectHovered\",t=>{t.data!==void 0&&this.model.send({event_type:\"object_hovered\",content:{ra:t.ra,dec:t.dec}})}),this.aladin.on(\"objectClicked\",t=>{if(t){let o={ra:t.ra,dec:t.dec};t.data!==void 0&&(o.data=t.data),this.model.set(\"clicked_object\",o),this.model.send({event_type:\"object_clicked\",content:o}),this.model.save_changes()}}),this.aladin.on(\"click\",t=>{this.model.send({event_type:\"click\",content:t})}),this.aladin.on(\"select\",t=>{let o=[];t.forEach(d=>{d.forEach(r=>{o.push({ra:r.ra,dec:r.dec,data:r.data,x:r.x,y:r.y})})}),this.model.send({event_type:\"select\",content:o})}),this.model.on(\"change:coo_frame\",()=>{this.aladin.setFrame(this.model.get(\"coo_frame\"))}),this.model.on(\"change:survey\",()=>{this.aladin.setImageSurvey(this.model.get(\"survey\"))}),this.model.on(\"change:overlay_survey\",()=>{this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"))}),this.model.on(\"change:overlay_survey_opacity\",()=>{this.aladin.getOverlayImageLayer().setAlpha(this.model.get(\"overlay_survey_opacity\"))}),this.eventHandlers={change_fov:this.messageHandler.handleChangeFoV,goto_ra_dec:this.messageHandler.handleGotoRaDec,add_fits:this.messageHandler.handleAddFits,add_catalog_from_URL:this.messageHandler.handleAddCatalogFromURL,add_MOC_from_URL:this.messageHandler.handleAddMOCFromURL,add_MOC_from_dict:this.messageHandler.handleAddMOCFromDict,add_overlay:this.messageHandler.handleAddOverlay,change_colormap:this.messageHandler.handleChangeColormap,get_JPG_thumbnail:this.messageHandler.handleGetJPGThumbnail,trigger_rectangular_selection:this.messageHandler.handleTriggerRectangularSelection,add_table:this.messageHandler.handleAddTable},this.model.on(\"msg:custom\",(t,o)=>{let d=t.event_name,r=this.eventHandlers[d];if(r)r.call(this,t,o);else throw new Error(`Unknown event name: ${d}`)})}unsubscribeAll(){this.model.off(\"change:_target\"),this.model.off(\"change:_fov\"),this.model.off(\"change:_height\"),this.model.off(\"change:coo_frame\"),this.model.off(\"change:survey\"),this.model.off(\"change:overlay_survey\"),this.model.off(\"change:overlay_survey_opacity\"),this.model.off(\"change:trigger_event\"),this.model.off(\"msg:custom\")}};function C(s,e){u(m+1);let a={};s.get(\"init_options\").forEach(d=>{a[f(d)]=s.get(d)});let i=document.createElement(\"div\");i.classList.add(\"aladin-widget\"),i.style.height=`${a.height}px`,i.id=`aladin-lite-div-${m}`;let n=new l.aladin(i,a),t=a.target.split(\" \");n.gotoRaDec(t[0],t[1]);let o=n.getFov();return s.set(\"_fov_xy\",{x:o[0],y:o[1]}),s.set(\"_wcs\",n.getViewWCS()),s.save_changes(),e.appendChild(i),{aladin:n,aladinDiv:i}}async function b({model:s}){await l.init}function k({model:s,el:e}){let{aladin:a,aladinDiv:i}=C(s,e),n=new p(a,i,s);return n.subscribeAll(),()=>{n.unsubscribeAll()}}var j={initialize:b,render:k};export{j as default};\n//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../js/utils.js", "../../../js/aladin_lite.js", "../../../js/models/message_handler.js", "../../../js/models/event_handler.js", "../../../js/widget.js"],
  "sourcesContent": ["/**\n * Converts a string from camelCase to snake_case.\n * @param {string} snakeCaseStr - The string to convert.\n * @returns {string} The string converted to snake_case.\n */\nfunction snakeCaseToCamelCase(snakeCaseStr) {\n  if (snakeCaseStr.charAt(0) === \"_\") snakeCaseStr = snakeCaseStr.slice(1);\n  let temp = snakeCaseStr.split(\"_\");\n  for (let i = 1; i < temp.length; i++)\n    temp[i] = temp[i].charAt(0).toUpperCase() + temp[i].slice(1);\n  return temp.join(\"\");\n}\n\n/**\n * Converts option names in an object from snake_case to camelCase.\n * @param {Object} options - The options object with snake_case property names.\n * @returns {Object} An object with property names converted to camelCase.\n */\nfunction convertOptionNamesToCamelCase(options) {\n  const newOptions = {};\n  for (const optionName in options)\n    newOptions[snakeCaseToCamelCase(optionName)] = options[optionName];\n  return newOptions;\n}\n\nclass Lock {\n  locked = false;\n\n  /**\n   * Unlocks the object\n   */\n  unlock() {\n    this.locked = false;\n  }\n\n  /**\n   * Locks the object\n   */\n  lock() {\n    this.locked = true;\n  }\n}\n\nlet divNumber = -1;\nfunction setDivNumber(num) {\n  divNumber = num;\n}\n\nexport {\n  snakeCaseToCamelCase,\n  convertOptionNamesToCamelCase,\n  Lock,\n  divNumber,\n  setDivNumber,\n};\n", "import A from \"https://esm.sh/aladin-lite@3.4.5-beta\";\n\nexport default A;\n", "import { convertOptionNamesToCamelCase } from \"../utils\";\nimport A from \"../aladin_lite\";\n\nlet imageCount = 0;\n\nexport default class MessageHandler {\n  constructor(aladin, model) {\n    this.aladin = aladin;\n    this.model = model;\n  }\n\n  handleChangeFoV(msg) {\n    this.aladin.setFoV(msg[\"fov\"]);\n  }\n\n  handleGotoRaDec(msg) {\n    this.aladin.gotoRaDec(msg[\"ra\"], msg[\"dec\"]);\n  }\n\n  handleAddFits(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    if (!options.name)\n      options.name = `image_${String(++imageCount).padStart(3, \"0\")}`;\n    const buffer = buffers[0];\n    const blob = new Blob([buffer], { type: \"application/octet-stream\" });\n    const url = URL.createObjectURL(blob);\n    const image = this.aladin.createImageFITS(url, options, (ra, dec) => {\n      this.aladin.gotoRaDec(ra, dec);\n      console.info(`FITS located at ra: ${ra}, dec: ${dec}`);\n      URL.revokeObjectURL(url);\n    });\n    this.aladin.setOverlayImageLayer(image, options.name);\n  }\n\n  handleAddCatalogFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addCatalog(A.catalogFromURL(msg[\"votable_URL\"], options));\n  }\n\n  handleAddMOCFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromURL(msg[\"moc_URL\"], options));\n  }\n\n  handleAddMOCFromDict(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromJSON(msg[\"moc_dict\"], options));\n  }\n\n  handleAddOverlay(msg) {\n    const regions = msg[\"regions_infos\"];\n    const graphic_options = convertOptionNamesToCamelCase(\n      msg[\"graphic_options\"] || {},\n    );\n    if (!graphic_options[\"color\"]) graphic_options[\"color\"] = \"red\";\n    const overlay = A.graphicOverlay(graphic_options);\n    this.aladin.addOverlay(overlay);\n    for (const region of regions) {\n      const infos = region[\"infos\"];\n      switch (region[\"region_type\"]) {\n        case \"stcs\":\n          overlay.addFootprints(\n            A.footprintsFromSTCS(infos.stcs, region.options),\n          );\n          break;\n        case \"circle\":\n          overlay.add(\n            A.circle(infos.ra, infos.dec, infos.radius, region.options),\n          );\n          break;\n        case \"ellipse\":\n          overlay.add(\n            A.ellipse(\n              infos.ra,\n              infos.dec,\n              infos.a,\n              infos.b,\n              infos.theta,\n              region.options,\n            ),\n          );\n          break;\n        case \"line\":\n          // remove default lineWidth when we switch to AL > 3.4.4\n          region.options.lineWidth = region.options.lineWidth || 3;\n          overlay.add(\n            A.vector(\n              infos.ra1,\n              infos.dec1,\n              infos.ra2,\n              infos.dec2,\n              region.options,\n            ),\n          );\n          break;\n        case \"polygon\":\n          overlay.add(A.polygon(infos.vertices, region.options));\n          break;\n      }\n    }\n  }\n\n  handleChangeColormap(msg) {\n    this.aladin.getBaseImageLayer().setColormap(msg[\"colormap\"]);\n  }\n\n  handleGetJPGThumbnail() {\n    this.aladin.exportAsPNG();\n  }\n\n  handleTriggerRectangularSelection() {\n    this.aladin.select();\n  }\n\n  handleAddTable(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    const buffer = buffers[0].buffer;\n    const decoder = new TextDecoder(\"utf-8\");\n    const blob = new Blob([decoder.decode(buffer)]);\n    const url = URL.createObjectURL(blob);\n    A.catalogFromURL(\n      url,\n      Object.assign(options, { onClick: \"showTable\" }),\n      (catalog) => {\n        this.aladin.addCatalog(catalog);\n      },\n      false,\n    );\n    URL.revokeObjectURL(url);\n  }\n}\n", "import MessageHandler from \"./message_handler\";\nimport { divNumber, setDivNumber, Lock } from \"../utils\";\n\nexport default class EventHandler {\n  /**\n   * Constructor for the EventHandler class.\n   * @param aladin The Aladin instance\n   * @param aladinDiv The Aladin div\n   * @param model The model instance\n   */\n  constructor(aladin, aladinDiv, model) {\n    this.aladin = aladin;\n    this.aladinDiv = aladinDiv;\n    this.model = model;\n    this.messageHandler = new MessageHandler(aladin, model);\n  }\n\n  /**\n   * Checks if the current div is the last active div.\n   * @returns {boolean}\n   */\n  isLastDiv() {\n    let currentDivNumber = parseInt(this.aladinDiv.id.split(\"-\").pop())\n    if (currentDivNumber === divNumber){\n      return true\n    };\n    let maxDiv = divNumber;\n    for (let i = maxDiv; i >= 0; i--) {\n      const alDiv = document.getElementById(`aladin-lite-div-${i}`);\n      if (!alDiv) continue;\n      if (alDiv.style.display !== \"none\") {\n        maxDiv = i;\n        break;\n      }\n    }\n    setDivNumber(maxDiv);\n    return currentDivNumber === maxDiv;\n  }\n\n  /**\n   * Updates the WCS coordinates in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  updateWCS() {\n    if (!this.isLastDiv()) return;\n    this.model.set(\"_wcs\", this.aladin.getViewWCS());\n  }\n\n  /**\n   * Updates the 2-axis FoV in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  update2AxisFoV() {\n    if (!this.isLastDiv()) return;\n    const twoAxisFoV = this.aladin.getFov();\n    this.model.set(\"_fov_xy\", {\n      x: twoAxisFoV[0],\n      y: twoAxisFoV[1],\n    });\n  }\n\n  /**\n   * Subscribes to all the events needed for the Aladin Lite widget.\n   */\n  subscribeAll() {\n    /* ------------------- */\n    /* Listeners --------- */\n    /* ------------------- */\n\n    /* Position Control */\n    // there are two ways of changing the target, one from the javascript side, and\n    // one from the python side. We have to instantiate two listeners for these, but\n    // the gotoObject call should only happen once. The two booleans prevent the two\n    // listeners from triggering each other and creating a buggy loop. The same trick\n    // is also necessary for the field of view.\n\n    /* Target control */\n    const jsTargetLock = new Lock();\n    const pyTargetLock = new Lock();\n\n    // Event triggered when the user moves the map in Aladin Lite\n    this.aladin.on(\"positionChanged\", (position) => {\n      if (pyTargetLock.locked) {\n        pyTargetLock.unlock();\n        return;\n      }\n      jsTargetLock.lock();\n      const raDec = [position.ra, position.dec];\n      this.updateWCS();\n      this.model.set(\"_target\", `${raDec[0]} ${raDec[1]}`);\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_target\", () => {\n      if (jsTargetLock.locked) {\n        jsTargetLock.unlock();\n        return;\n      }\n      pyTargetLock.lock();\n      let target = this.model.get(\"_target\");\n      const [ra, dec] = target.split(\" \");\n      this.aladin.gotoRaDec(ra, dec);\n    });\n\n    /* Field of View control */\n    const jsFovLock = new Lock();\n    const pyFovLock = new Lock();\n\n    this.aladin.on(\"zoomChanged\", (fov) => {\n      if (pyFovLock.locked) {\n        pyFovLock.unlock();\n        return;\n      }\n      jsFovLock.lock();\n      // fov MUST be cast into float in order to be sent to the model\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.set(\"_fov\", parseFloat(fov.toFixed(5)));\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_fov\", () => {\n      if (jsFovLock.locked) {\n        jsFovLock.unlock();\n        return;\n      }\n      pyFovLock.lock();\n      let fov = this.model.get(\"_fov\");\n      this.aladin.setFoV(fov);\n    });\n\n    /* Div control */\n    this.model.on(\"change:_height\", () => {\n      let height = this.model.get(\"_height\");\n      this.aladinDiv.style.height = `${height}px`;\n      // Update WCS and FoV only if this is the last div\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    /* Aladin callbacks */\n\n    this.aladin.on(\"cooFrameChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"projectionChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"layerChanged\", (_, layerName, state) => {\n      if (layerName !== \"base\" || state !== \"ADDED\") return;\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"resizeChanged\", () => {\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"objectHovered\", (object) => {\n      if (object[\"data\"] !== undefined) {\n        this.model.send({\n          event_type: \"object_hovered\",\n          content: {\n            ra: object[\"ra\"],\n            dec: object[\"dec\"],\n          },\n        });\n      }\n    });\n\n    this.aladin.on(\"objectClicked\", (clicked) => {\n      if (clicked) {\n        let clickedContent = {\n          ra: clicked[\"ra\"],\n          dec: clicked[\"dec\"],\n        };\n        if (clicked[\"data\"] !== undefined) {\n          clickedContent[\"data\"] = clicked[\"data\"];\n        }\n        this.model.set(\"clicked_object\", clickedContent);\n        // send a custom message in case the user wants to define their own callbacks\n        this.model.send({\n          event_type: \"object_clicked\",\n          content: clickedContent,\n        });\n        this.model.save_changes();\n      }\n    });\n\n    this.aladin.on(\"click\", (clickContent) => {\n      this.model.send({\n        event_type: \"click\",\n        content: clickContent,\n      });\n    });\n\n    this.aladin.on(\"select\", (catalogs) => {\n      let objectsData = [];\n      // TODO: this flattens the selection. Each object from different\n      // catalogs are entered in the array. To change this, maybe change\n      // upstream what is returned upon selection?\n      catalogs.forEach((catalog) => {\n        catalog.forEach((object) => {\n          objectsData.push({\n            ra: object.ra,\n            dec: object.dec,\n            data: object.data,\n            x: object.x,\n            y: object.y,\n          });\n        });\n      });\n      this.model.send({\n        event_type: \"select\",\n        content: objectsData,\n      });\n    });\n\n    /* Aladin functionalities */\n\n    this.model.on(\"change:coo_frame\", () => {\n      this.aladin.setFrame(this.model.get(\"coo_frame\"));\n    });\n\n    this.model.on(\"change:survey\", () => {\n      this.aladin.setImageSurvey(this.model.get(\"survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey\", () => {\n      this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey_opacity\", () => {\n      this.aladin\n        .getOverlayImageLayer()\n        .setAlpha(this.model.get(\"overlay_survey_opacity\"));\n    });\n\n    this.eventHandlers = {\n      change_fov: this.messageHandler.handleChangeFoV,\n      goto_ra_dec: this.messageHandler.handleGotoRaDec,\n      add_fits: this.messageHandler.handleAddFits,\n      add_catalog_from_URL: this.messageHandler.handleAddCatalogFromURL,\n      add_MOC_from_URL: this.messageHandler.handleAddMOCFromURL,\n      add_MOC_from_dict: this.messageHandler.handleAddMOCFromDict,\n      add_overlay: this.messageHandler.handleAddOverlay,\n      change_colormap: this.messageHandler.handleChangeColormap,\n      get_JPG_thumbnail: this.messageHandler.handleGetJPGThumbnail,\n      trigger_rectangular_selection:\n        this.messageHandler.handleTriggerRectangularSelection,\n      add_table: this.messageHandler.handleAddTable,\n    };\n\n    this.model.on(\"msg:custom\", (msg, buffers) => {\n      const eventName = msg[\"event_name\"];\n      const handler = this.eventHandlers[eventName];\n      if (handler) handler.call(this, msg, buffers);\n      else throw new Error(`Unknown event name: ${eventName}`);\n    });\n  }\n\n  /**\n   * Unsubscribe from all the model events.\n   * There is no need to unsubscribe from the Aladin Lite events.\n   */\n  unsubscribeAll() {\n    this.model.off(\"change:_target\");\n    this.model.off(\"change:_fov\");\n    this.model.off(\"change:_height\");\n    this.model.off(\"change:coo_frame\");\n    this.model.off(\"change:survey\");\n    this.model.off(\"change:overlay_survey\");\n    this.model.off(\"change:overlay_survey_opacity\");\n    this.model.off(\"change:trigger_event\");\n    this.model.off(\"msg:custom\");\n  }\n}\n", "import \"./widget.css\";\nimport EventHandler from \"./models/event_handler\";\nimport {\n  divNumber,\n  setDivNumber,\n  snakeCaseToCamelCase,\n} from \"./utils\";\nimport A from \"./aladin_lite\";\n\nfunction initAladinLite(model, el) {\n  setDivNumber(divNumber + 1);\n  let initOptions = {};\n  model.get(\"init_options\").forEach((option_name) => {\n    initOptions[snakeCaseToCamelCase(option_name)] = model.get(option_name);\n  });\n\n  let aladinDiv = document.createElement(\"div\");\n  aladinDiv.classList.add(\"aladin-widget\");\n  aladinDiv.style.height = `${initOptions[\"height\"]}px`;\n\n  aladinDiv.id = `aladin-lite-div-${divNumber}`;\n  let aladin = new A.aladin(aladinDiv, initOptions);\n\n  // Set the target again after the initialization to be sure that the target is set\n  // from icrs coordinates because of the use of gotoObject in the Aladin Lite API\n  const raDec = initOptions[\"target\"].split(\" \");\n  aladin.gotoRaDec(raDec[0], raDec[1]);\n\n  // Set current FoV and WCS\n  const twoAxisFoV = aladin.getFov();\n  model.set(\"_fov_xy\", {\n    x: twoAxisFoV[0],\n    y: twoAxisFoV[1],\n  });\n  model.set(\"_wcs\", aladin.getViewWCS());\n  model.save_changes();\n\n  el.appendChild(aladinDiv);\n  return { aladin, aladinDiv };\n}\n\nasync function initialize({ model }) {\n  await A.init;\n}\n\nfunction render({ model, el }) {\n  /* ------------------- */\n  /* View -------------- */\n  /* ------------------- */\n\n  const { aladin, aladinDiv } = initAladinLite(model, el);\n\n  const eventHandler = new EventHandler(aladin, aladinDiv, model);\n  eventHandler.subscribeAll();\n\n  return () => {\n    // Need to unsubscribe the listeners\n    eventHandler.unsubscribeAll();\n  };\n}\n\nexport default { initialize, render };\n"],
  "mappings": "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",
  "names": ["snakeCaseToCamelCase", "snakeCaseStr", "temp", "i", "convertOptionNamesToCamelCase", "options", "newOptions", "optionName", "Lock", "divNumber", "setDivNumber", "num", "A", "aladin_lite_default", "imageCount", "MessageHandler", "aladin", "model", "msg", "buffers", "options", "convertOptionNamesToCamelCase", "buffer", "blob", "url", "image", "ra", "dec", "aladin_lite_default", "regions", "graphic_options", "overlay", "region", "infos", "decoder", "catalog", "EventHandler", "aladin", "aladinDiv", "model", "MessageHandler", "currentDivNumber", "divNumber", "maxDiv", "alDiv", "setDivNumber", "twoAxisFoV", "jsTargetLock", "Lock", "pyTargetLock", "position", "raDec", "target", "ra", "dec", "jsFovLock", "pyFovLock", "fov", "height", "_", "layerName", "state", "object", "clicked", "clickedContent", "clickContent", "catalogs", "objectsData", "catalog", "msg", "buffers", "eventName", "handler", "initAladinLite", "model", "el", "setDivNumber", "divNumber", "initOptions", "option_name", "snakeCaseToCamelCase", "aladinDiv", "aladin", "aladin_lite_default", "raDec", "twoAxisFoV", "initialize", "render", "eventHandler", "EventHandler", "widget_default"]
}
\n", - "_fov": 5.60143, + "_esm": "function f(n){n.charAt(0)===\"_\"&&(n=n.slice(1));let e=n.split(\"_\");for(let a=1;a{this.aladin.gotoRaDec(r,v),console.info(`FITS located at ra: ${r}, dec: ${v}`),URL.revokeObjectURL(o)});this.aladin.setOverlayImageLayer(d,i.name)}handleAddCatalogFromURL(e){let a=h(e.options||{});this.aladin.addCatalog(l.catalogFromURL(e.votable_URL,a))}handleAddMOCFromURL(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromURL(e.moc_URL,a))}handleAddMOCFromDict(e){let a=h(e.options||{});this.aladin.addMOC(l.MOCFromJSON(e.moc_dict,a))}handleAddOverlay(e){let a=e.regions_infos,i=h(e.graphic_options||{});i.color||(i.color=\"red\");let s=l.graphicOverlay(i);this.aladin.addOverlay(s);for(let t of a){let o=t.infos;switch(t.region_type){case\"stcs\":s.addFootprints(l.footprintsFromSTCS(o.stcs,t.options));break;case\"circle\":s.add(l.circle(o.ra,o.dec,o.radius,t.options));break;case\"ellipse\":s.add(l.ellipse(o.ra,o.dec,o.a,o.b,o.theta,t.options));break;case\"line\":t.options.lineWidth=t.options.lineWidth||3,s.add(l.vector(o.ra1,o.dec1,o.ra2,o.dec2,t.options));break;case\"polygon\":s.add(l.polygon(o.vertices,t.options));break}}}handleChangeColormap(e){this.aladin.getBaseImageLayer().setColormap(e.colormap)}handleGetJPGThumbnail(){this.aladin.exportAsPNG()}handleTriggerRectangularSelection(){this.aladin.select()}handleAddTable(e,a){let i=h(e.options||{}),s=a[0].buffer,t=new TextDecoder(\"utf-8\"),o=new Blob([t.decode(s)]),d=URL.createObjectURL(o);l.catalogFromURL(d,Object.assign(i,{onClick:\"showTable\"}),r=>{this.aladin.addCatalog(r)},!1),URL.revokeObjectURL(d)}};var p=class{constructor(e,a,i){this.aladin=e,this.aladinDiv=a,this.model=i,this.messageHandler=new g(e,i),this.currentDivNumber=parseInt(a.id.split(\"-\").pop())}isLastDiv(){if(this.currentDivNumber===m)return!0;let e=m;for(let a=e;a>=0;a--){let i=document.getElementById(`aladin-lite-div-${a}`);if(i&&i.style.display!==\"none\"){e=a;break}}return u(e),this.currentDivNumber===e}updateWCS(){this.isLastDiv()&&this.model.set(\"_wcs\",this.aladin.getViewWCS())}update2AxisFoV(){if(!this.isLastDiv())return;let e=this.aladin.getFov();this.model.set(\"_fov_xy\",{x:e[0],y:e[1]})}subscribeAll(){let e=new c,a=new c;this.aladin.on(\"positionChanged\",t=>{if(a.locked){a.unlock();return}e.lock();let o=[t.ra,t.dec];this.updateWCS(),this.model.set(\"_target\",`${o[0]} ${o[1]}`),this.model.save_changes()}),this.model.on(\"change:_target\",()=>{if(e.locked){e.unlock();return}a.lock();let t=this.model.get(\"_target\"),[o,d]=t.split(\" \");this.aladin.gotoRaDec(o,d)});let i=new c,s=new c;this.aladin.on(\"zoomChanged\",t=>{if(s.locked){s.unlock();return}i.lock(),this.updateWCS(),this.update2AxisFoV(),this.model.set(\"_fov\",parseFloat(t.toFixed(5))),this.model.save_changes()}),this.model.on(\"change:_fov\",()=>{if(i.locked){i.unlock();return}s.lock();let t=this.model.get(\"_fov\");this.aladin.setFoV(t)}),this.model.on(\"change:_height\",()=>{let t=this.model.get(\"_height\");this.aladinDiv.style.height=`${t}px`,this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"cooFrameChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"projectionChanged\",()=>{this.updateWCS(),this.model.save_changes()}),this.aladin.on(\"layerChanged\",(t,o,d)=>{o!==\"base\"||d!==\"ADDED\"||(this.updateWCS(),this.model.save_changes())}),this.aladin.on(\"resizeChanged\",()=>{this.updateWCS(),this.update2AxisFoV(),this.model.save_changes()}),this.aladin.on(\"objectHovered\",t=>{t.data!==void 0&&this.model.send({event_type:\"object_hovered\",content:{ra:t.ra,dec:t.dec}})}),this.aladin.on(\"objectClicked\",t=>{if(t){let o={ra:t.ra,dec:t.dec};t.data!==void 0&&(o.data=t.data),this.model.set(\"clicked_object\",o),this.model.send({event_type:\"object_clicked\",content:o}),this.model.save_changes()}}),this.aladin.on(\"click\",t=>{this.model.send({event_type:\"click\",content:t})}),this.aladin.on(\"select\",t=>{let o=[];t.forEach(d=>{d.forEach(r=>{o.push({ra:r.ra,dec:r.dec,data:r.data,x:r.x,y:r.y})})}),this.model.send({event_type:\"select\",content:o})}),this.model.on(\"change:coo_frame\",()=>{this.aladin.setFrame(this.model.get(\"coo_frame\"))}),this.model.on(\"change:survey\",()=>{this.aladin.setImageSurvey(this.model.get(\"survey\"))}),this.model.on(\"change:overlay_survey\",()=>{this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"))}),this.model.on(\"change:overlay_survey_opacity\",()=>{this.aladin.getOverlayImageLayer().setAlpha(this.model.get(\"overlay_survey_opacity\"))}),this.eventHandlers={change_fov:this.messageHandler.handleChangeFoV,goto_ra_dec:this.messageHandler.handleGotoRaDec,add_fits:this.messageHandler.handleAddFits,add_catalog_from_URL:this.messageHandler.handleAddCatalogFromURL,add_MOC_from_URL:this.messageHandler.handleAddMOCFromURL,add_MOC_from_dict:this.messageHandler.handleAddMOCFromDict,add_overlay:this.messageHandler.handleAddOverlay,change_colormap:this.messageHandler.handleChangeColormap,get_JPG_thumbnail:this.messageHandler.handleGetJPGThumbnail,trigger_rectangular_selection:this.messageHandler.handleTriggerRectangularSelection,add_table:this.messageHandler.handleAddTable},this.model.on(\"msg:custom\",(t,o)=>{let d=t.event_name,r=this.eventHandlers[d];if(r)r.call(this,t,o);else throw new Error(`Unknown event name: ${d}`)})}unsubscribeAll(){this.model.off(\"change:_target\"),this.model.off(\"change:_fov\"),this.model.off(\"change:_height\"),this.model.off(\"change:coo_frame\"),this.model.off(\"change:survey\"),this.model.off(\"change:overlay_survey\"),this.model.off(\"change:overlay_survey_opacity\"),this.model.off(\"change:trigger_event\"),this.model.off(\"msg:custom\")}};function b(n,e){u(m+1);let a={};n.get(\"init_options\").forEach(d=>{a[f(d)]=n.get(d)});let i=document.createElement(\"div\");i.classList.add(\"aladin-widget\"),i.style.height=`${a.height}px`,i.id=`aladin-lite-div-${m}`;let s=new l.aladin(i,a),t=a.target.split(\" \");s.gotoRaDec(t[0],t[1]);let o=s.getFov();return n.set(\"_fov_xy\",{x:o[0],y:o[1]}),n.set(\"_wcs\",s.getViewWCS()),n.save_changes(),e.appendChild(i),{aladin:s,aladinDiv:i}}async function C({model:n}){await l.init}function k({model:n,el:e}){let{aladin:a,aladinDiv:i}=b(n,e),s=new p(a,i,n);return s.subscribeAll(),()=>{s.unsubscribeAll()}}var j={initialize:C,render:k};export{j as default};\n//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../js/utils.js", "../../../js/aladin_lite.js", "../../../js/models/message_handler.js", "../../../js/models/event_handler.js", "../../../js/widget.js"],
  "sourcesContent": ["/**\n * Converts a string from camelCase to snake_case.\n * @param {string} snakeCaseStr - The string to convert.\n * @returns {string} The string converted to snake_case.\n */\nfunction snakeCaseToCamelCase(snakeCaseStr) {\n  if (snakeCaseStr.charAt(0) === \"_\") snakeCaseStr = snakeCaseStr.slice(1);\n  let temp = snakeCaseStr.split(\"_\");\n  for (let i = 1; i < temp.length; i++)\n    temp[i] = temp[i].charAt(0).toUpperCase() + temp[i].slice(1);\n  return temp.join(\"\");\n}\n\n/**\n * Converts option names in an object from snake_case to camelCase.\n * @param {Object} options - The options object with snake_case property names.\n * @returns {Object} An object with property names converted to camelCase.\n */\nfunction convertOptionNamesToCamelCase(options) {\n  const newOptions = {};\n  for (const optionName in options)\n    newOptions[snakeCaseToCamelCase(optionName)] = options[optionName];\n  return newOptions;\n}\n\nclass Lock {\n  locked = false;\n\n  /**\n   * Unlocks the object\n   */\n  unlock() {\n    this.locked = false;\n  }\n\n  /**\n   * Locks the object\n   */\n  lock() {\n    this.locked = true;\n  }\n}\n\nlet divNumber = -1;\nfunction setDivNumber(num) {\n  divNumber = num;\n}\n\nexport {\n  snakeCaseToCamelCase,\n  convertOptionNamesToCamelCase,\n  Lock,\n  divNumber,\n  setDivNumber,\n};\n", "import A from \"https://esm.sh/aladin-lite@3.4.5-beta\";\n\nexport default A;\n", "import { convertOptionNamesToCamelCase } from \"../utils\";\nimport A from \"../aladin_lite\";\n\nlet imageCount = 0;\n\nexport default class MessageHandler {\n  constructor(aladin, model) {\n    this.aladin = aladin;\n    this.model = model;\n  }\n\n  handleChangeFoV(msg) {\n    this.aladin.setFoV(msg[\"fov\"]);\n  }\n\n  handleGotoRaDec(msg) {\n    this.aladin.gotoRaDec(msg[\"ra\"], msg[\"dec\"]);\n  }\n\n  handleAddFits(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    if (!options.name)\n      options.name = `image_${String(++imageCount).padStart(3, \"0\")}`;\n    const buffer = buffers[0];\n    const blob = new Blob([buffer], { type: \"application/octet-stream\" });\n    const url = URL.createObjectURL(blob);\n    const image = this.aladin.createImageFITS(url, options, (ra, dec) => {\n      this.aladin.gotoRaDec(ra, dec);\n      console.info(`FITS located at ra: ${ra}, dec: ${dec}`);\n      URL.revokeObjectURL(url);\n    });\n    this.aladin.setOverlayImageLayer(image, options.name);\n  }\n\n  handleAddCatalogFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addCatalog(A.catalogFromURL(msg[\"votable_URL\"], options));\n  }\n\n  handleAddMOCFromURL(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromURL(msg[\"moc_URL\"], options));\n  }\n\n  handleAddMOCFromDict(msg) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    this.aladin.addMOC(A.MOCFromJSON(msg[\"moc_dict\"], options));\n  }\n\n  handleAddOverlay(msg) {\n    const regions = msg[\"regions_infos\"];\n    const graphic_options = convertOptionNamesToCamelCase(\n      msg[\"graphic_options\"] || {},\n    );\n    if (!graphic_options[\"color\"]) graphic_options[\"color\"] = \"red\";\n    const overlay = A.graphicOverlay(graphic_options);\n    this.aladin.addOverlay(overlay);\n    for (const region of regions) {\n      const infos = region[\"infos\"];\n      switch (region[\"region_type\"]) {\n        case \"stcs\":\n          overlay.addFootprints(\n            A.footprintsFromSTCS(infos.stcs, region.options),\n          );\n          break;\n        case \"circle\":\n          overlay.add(\n            A.circle(infos.ra, infos.dec, infos.radius, region.options),\n          );\n          break;\n        case \"ellipse\":\n          overlay.add(\n            A.ellipse(\n              infos.ra,\n              infos.dec,\n              infos.a,\n              infos.b,\n              infos.theta,\n              region.options,\n            ),\n          );\n          break;\n        case \"line\":\n          // remove default lineWidth when we switch to AL > 3.4.4\n          region.options.lineWidth = region.options.lineWidth || 3;\n          overlay.add(\n            A.vector(\n              infos.ra1,\n              infos.dec1,\n              infos.ra2,\n              infos.dec2,\n              region.options,\n            ),\n          );\n          break;\n        case \"polygon\":\n          overlay.add(A.polygon(infos.vertices, region.options));\n          break;\n      }\n    }\n  }\n\n  handleChangeColormap(msg) {\n    this.aladin.getBaseImageLayer().setColormap(msg[\"colormap\"]);\n  }\n\n  handleGetJPGThumbnail() {\n    this.aladin.exportAsPNG();\n  }\n\n  handleTriggerRectangularSelection() {\n    this.aladin.select();\n  }\n\n  handleAddTable(msg, buffers) {\n    const options = convertOptionNamesToCamelCase(msg[\"options\"] || {});\n    const buffer = buffers[0].buffer;\n    const decoder = new TextDecoder(\"utf-8\");\n    const blob = new Blob([decoder.decode(buffer)]);\n    const url = URL.createObjectURL(blob);\n    A.catalogFromURL(\n      url,\n      Object.assign(options, { onClick: \"showTable\" }),\n      (catalog) => {\n        this.aladin.addCatalog(catalog);\n      },\n      false,\n    );\n    URL.revokeObjectURL(url);\n  }\n}\n", "import MessageHandler from \"./message_handler\";\nimport { divNumber, setDivNumber, Lock } from \"../utils\";\n\nexport default class EventHandler {\n  /**\n   * Constructor for the EventHandler class.\n   * @param aladin The Aladin instance\n   * @param aladinDiv The Aladin div\n   * @param model The model instance\n   */\n  constructor(aladin, aladinDiv, model) {\n    this.aladin = aladin;\n    this.aladinDiv = aladinDiv;\n    this.model = model;\n    this.messageHandler = new MessageHandler(aladin, model);\n    this.currentDivNumber = parseInt(aladinDiv.id.split(\"-\").pop());\n  }\n\n  /**\n   * Checks if the current div is the last active div.\n   * @returns {boolean}\n   */\n  isLastDiv() {\n    if (this.currentDivNumber === divNumber) {\n      return true;\n    }\n    let maxDiv = divNumber;\n    for (let i = maxDiv; i >= 0; i--) {\n      const alDiv = document.getElementById(`aladin-lite-div-${i}`);\n      if (!alDiv) continue;\n      if (alDiv.style.display !== \"none\") {\n        maxDiv = i;\n        break;\n      }\n    }\n    setDivNumber(maxDiv);\n    return this.currentDivNumber === maxDiv;\n  }\n\n  /**\n   * Updates the WCS coordinates in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  updateWCS() {\n    if (!this.isLastDiv()) return;\n    this.model.set(\"_wcs\", this.aladin.getViewWCS());\n  }\n\n  /**\n   * Updates the 2-axis FoV in the model.\n   * WARNING: This method don't call model.save_changes()!\n   */\n  update2AxisFoV() {\n    if (!this.isLastDiv()) return;\n    const twoAxisFoV = this.aladin.getFov();\n    this.model.set(\"_fov_xy\", {\n      x: twoAxisFoV[0],\n      y: twoAxisFoV[1],\n    });\n  }\n\n  /**\n   * Subscribes to all the events needed for the Aladin Lite widget.\n   */\n  subscribeAll() {\n    /* ------------------- */\n    /* Listeners --------- */\n    /* ------------------- */\n\n    /* Position Control */\n    // there are two ways of changing the target, one from the javascript side, and\n    // one from the python side. We have to instantiate two listeners for these, but\n    // the gotoObject call should only happen once. The two booleans prevent the two\n    // listeners from triggering each other and creating a buggy loop. The same trick\n    // is also necessary for the field of view.\n\n    /* Target control */\n    const jsTargetLock = new Lock();\n    const pyTargetLock = new Lock();\n\n    // Event triggered when the user moves the map in Aladin Lite\n    this.aladin.on(\"positionChanged\", (position) => {\n      if (pyTargetLock.locked) {\n        pyTargetLock.unlock();\n        return;\n      }\n      jsTargetLock.lock();\n      const raDec = [position.ra, position.dec];\n      this.updateWCS();\n      this.model.set(\"_target\", `${raDec[0]} ${raDec[1]}`);\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_target\", () => {\n      if (jsTargetLock.locked) {\n        jsTargetLock.unlock();\n        return;\n      }\n      pyTargetLock.lock();\n      let target = this.model.get(\"_target\");\n      const [ra, dec] = target.split(\" \");\n      this.aladin.gotoRaDec(ra, dec);\n    });\n\n    /* Field of View control */\n    const jsFovLock = new Lock();\n    const pyFovLock = new Lock();\n\n    this.aladin.on(\"zoomChanged\", (fov) => {\n      if (pyFovLock.locked) {\n        pyFovLock.unlock();\n        return;\n      }\n      jsFovLock.lock();\n      // fov MUST be cast into float in order to be sent to the model\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.set(\"_fov\", parseFloat(fov.toFixed(5)));\n      this.model.save_changes();\n    });\n\n    this.model.on(\"change:_fov\", () => {\n      if (jsFovLock.locked) {\n        jsFovLock.unlock();\n        return;\n      }\n      pyFovLock.lock();\n      let fov = this.model.get(\"_fov\");\n      this.aladin.setFoV(fov);\n    });\n\n    /* Div control */\n    this.model.on(\"change:_height\", () => {\n      let height = this.model.get(\"_height\");\n      this.aladinDiv.style.height = `${height}px`;\n      // Update WCS and FoV only if this is the last div\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    /* Aladin callbacks */\n\n    this.aladin.on(\"cooFrameChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"projectionChanged\", () => {\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"layerChanged\", (_, layerName, state) => {\n      if (layerName !== \"base\" || state !== \"ADDED\") return;\n      this.updateWCS();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"resizeChanged\", () => {\n      this.updateWCS();\n      this.update2AxisFoV();\n      this.model.save_changes();\n    });\n\n    this.aladin.on(\"objectHovered\", (object) => {\n      if (object[\"data\"] !== undefined) {\n        this.model.send({\n          event_type: \"object_hovered\",\n          content: {\n            ra: object[\"ra\"],\n            dec: object[\"dec\"],\n          },\n        });\n      }\n    });\n\n    this.aladin.on(\"objectClicked\", (clicked) => {\n      if (clicked) {\n        let clickedContent = {\n          ra: clicked[\"ra\"],\n          dec: clicked[\"dec\"],\n        };\n        if (clicked[\"data\"] !== undefined) {\n          clickedContent[\"data\"] = clicked[\"data\"];\n        }\n        this.model.set(\"clicked_object\", clickedContent);\n        // send a custom message in case the user wants to define their own callbacks\n        this.model.send({\n          event_type: \"object_clicked\",\n          content: clickedContent,\n        });\n        this.model.save_changes();\n      }\n    });\n\n    this.aladin.on(\"click\", (clickContent) => {\n      this.model.send({\n        event_type: \"click\",\n        content: clickContent,\n      });\n    });\n\n    this.aladin.on(\"select\", (catalogs) => {\n      let objectsData = [];\n      // TODO: this flattens the selection. Each object from different\n      // catalogs are entered in the array. To change this, maybe change\n      // upstream what is returned upon selection?\n      catalogs.forEach((catalog) => {\n        catalog.forEach((object) => {\n          objectsData.push({\n            ra: object.ra,\n            dec: object.dec,\n            data: object.data,\n            x: object.x,\n            y: object.y,\n          });\n        });\n      });\n      this.model.send({\n        event_type: \"select\",\n        content: objectsData,\n      });\n    });\n\n    /* Aladin functionalities */\n\n    this.model.on(\"change:coo_frame\", () => {\n      this.aladin.setFrame(this.model.get(\"coo_frame\"));\n    });\n\n    this.model.on(\"change:survey\", () => {\n      this.aladin.setImageSurvey(this.model.get(\"survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey\", () => {\n      this.aladin.setOverlayImageLayer(this.model.get(\"overlay_survey\"));\n    });\n\n    this.model.on(\"change:overlay_survey_opacity\", () => {\n      this.aladin\n        .getOverlayImageLayer()\n        .setAlpha(this.model.get(\"overlay_survey_opacity\"));\n    });\n\n    this.eventHandlers = {\n      change_fov: this.messageHandler.handleChangeFoV,\n      goto_ra_dec: this.messageHandler.handleGotoRaDec,\n      add_fits: this.messageHandler.handleAddFits,\n      add_catalog_from_URL: this.messageHandler.handleAddCatalogFromURL,\n      add_MOC_from_URL: this.messageHandler.handleAddMOCFromURL,\n      add_MOC_from_dict: this.messageHandler.handleAddMOCFromDict,\n      add_overlay: this.messageHandler.handleAddOverlay,\n      change_colormap: this.messageHandler.handleChangeColormap,\n      get_JPG_thumbnail: this.messageHandler.handleGetJPGThumbnail,\n      trigger_rectangular_selection:\n        this.messageHandler.handleTriggerRectangularSelection,\n      add_table: this.messageHandler.handleAddTable,\n    };\n\n    this.model.on(\"msg:custom\", (msg, buffers) => {\n      const eventName = msg[\"event_name\"];\n      const handler = this.eventHandlers[eventName];\n      if (handler) handler.call(this, msg, buffers);\n      else throw new Error(`Unknown event name: ${eventName}`);\n    });\n  }\n\n  /**\n   * Unsubscribe from all the model events.\n   * There is no need to unsubscribe from the Aladin Lite events.\n   */\n  unsubscribeAll() {\n    this.model.off(\"change:_target\");\n    this.model.off(\"change:_fov\");\n    this.model.off(\"change:_height\");\n    this.model.off(\"change:coo_frame\");\n    this.model.off(\"change:survey\");\n    this.model.off(\"change:overlay_survey\");\n    this.model.off(\"change:overlay_survey_opacity\");\n    this.model.off(\"change:trigger_event\");\n    this.model.off(\"msg:custom\");\n  }\n}\n", "import \"./widget.css\";\nimport EventHandler from \"./models/event_handler\";\nimport { divNumber, setDivNumber, snakeCaseToCamelCase } from \"./utils\";\nimport A from \"./aladin_lite\";\n\nfunction initAladinLite(model, el) {\n  setDivNumber(divNumber + 1);\n  let initOptions = {};\n  model.get(\"init_options\").forEach((option_name) => {\n    initOptions[snakeCaseToCamelCase(option_name)] = model.get(option_name);\n  });\n\n  let aladinDiv = document.createElement(\"div\");\n  aladinDiv.classList.add(\"aladin-widget\");\n  aladinDiv.style.height = `${initOptions[\"height\"]}px`;\n\n  aladinDiv.id = `aladin-lite-div-${divNumber}`;\n  let aladin = new A.aladin(aladinDiv, initOptions);\n\n  // Set the target again after the initialization to be sure that the target is set\n  // from icrs coordinates because of the use of gotoObject in the Aladin Lite API\n  const raDec = initOptions[\"target\"].split(\" \");\n  aladin.gotoRaDec(raDec[0], raDec[1]);\n\n  // Set current FoV and WCS\n  const twoAxisFoV = aladin.getFov();\n  model.set(\"_fov_xy\", {\n    x: twoAxisFoV[0],\n    y: twoAxisFoV[1],\n  });\n  model.set(\"_wcs\", aladin.getViewWCS());\n  model.save_changes();\n\n  el.appendChild(aladinDiv);\n  return { aladin, aladinDiv };\n}\n\nasync function initialize({ model }) {\n  await A.init;\n}\n\nfunction render({ model, el }) {\n  /* ------------------- */\n  /* View -------------- */\n  /* ------------------- */\n\n  const { aladin, aladinDiv } = initAladinLite(model, el);\n\n  const eventHandler = new EventHandler(aladin, aladinDiv, model);\n  eventHandler.subscribeAll();\n\n  return () => {\n    // Need to unsubscribe the listeners\n    eventHandler.unsubscribeAll();\n  };\n}\n\nexport default { initialize, render };\n"],
  "mappings": "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",
  "names": ["snakeCaseToCamelCase", "snakeCaseStr", "temp", "i", "convertOptionNamesToCamelCase", "options", "newOptions", "optionName", "Lock", "divNumber", "setDivNumber", "num", "A", "aladin_lite_default", "imageCount", "MessageHandler", "aladin", "model", "msg", "buffers", "options", "convertOptionNamesToCamelCase", "buffer", "blob", "url", "image", "ra", "dec", "aladin_lite_default", "regions", "graphic_options", "overlay", "region", "infos", "decoder", "catalog", "EventHandler", "aladin", "aladinDiv", "model", "MessageHandler", "divNumber", "maxDiv", "i", "alDiv", "setDivNumber", "twoAxisFoV", "jsTargetLock", "Lock", "pyTargetLock", "position", "raDec", "target", "ra", "dec", "jsFovLock", "pyFovLock", "fov", "height", "_", "layerName", "state", "object", "clicked", "clickedContent", "clickContent", "catalogs", "objectsData", "catalog", "msg", "buffers", "eventName", "handler", "initAladinLite", "model", "el", "setDivNumber", "divNumber", "initOptions", "option_name", "snakeCaseToCamelCase", "aladinDiv", "aladin", "aladin_lite_default", "raDec", "twoAxisFoV", "initialize", "render", "eventHandler", "EventHandler", "widget_default"]
}
\n", + "_fov": 50, "_fov_xy": { - "x": 5.60143396583755, - "y": 5.60143396583755 + "x": 5, + "y": 5 }, "_height": 800, "_model_module": "anywidget", "_model_module_version": "0.9.10", "_model_name": "AnyModel", - "_target": "10.684708299999999 41.268749999999976", + "_target": "80.89416999999995 -69.75611", "_view_module": "anywidget", "_view_module_version": "0.9.10", "_view_name": "AnyView", "_wcs": { - "CDELT1": -5.60143396583755, - "CDELT2": 5.60143396583755, + "CDELT1": -5, + "CDELT2": 5, "CRPIX1": 1, "CRPIX2": 1, - "CRVAL1": 10.684708299999997, - "CRVAL2": 41.26874999999998, + "CRVAL1": 80.89416999999995, + "CRVAL2": -69.75611, "CTYPE1": "RA---SIN", "CTYPE2": "DEC--SIN", "CUNIT1": "deg ", @@ -292,7 +296,7 @@ "show_zoom_control", "survey" ], - "layout": "IPY_MODEL_963ac6a600854d92a585c08214f76219", + "layout": "IPY_MODEL_8b1f9d5607de4bd4a8cc50de5de97650", "overlay_survey": "", "overlay_survey_opacity": 0, "projection": "SIN", @@ -319,7 +323,7 @@ "survey": "CDS/P/PLANCK/R2/HFI/color" } }, - "963ac6a600854d92a585c08214f76219": { + "8b1f9d5607de4bd4a8cc50de5de97650": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel",