diff --git a/CHANGELOG.md b/CHANGELOG.md index 879a12e5..5989cd58 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,9 +18,14 @@ 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) +### Changed + +- Upgrade Aladin Lite version to 3.4.5-beta (#96) + ## [0.4.0] ### Added @@ -40,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 1588d45e..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.3.0 | 3.3.3-dev | -| 0.4.0 | 3.4.4-beta | +| 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/examples/11_Extracting_information_from_the_view.ipynb b/examples/11_Extracting_information_from_the_view.ipynb new file mode 100644 index 00000000..39fc3ab4 --- /dev/null +++ b/examples/11_Extracting_information_from_the_view.ipynb @@ -0,0 +1,340 @@ +{ + "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! 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." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "initial_id", + "metadata": {}, + "outputs": [], + "source": [ + "from ipyaladin import Aladin" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e62d34eb8543145", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68df3ccd903340b4aa8af8aad92c0c20", + "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" + ] + }, + { + "cell_type": "markdown", + "id": "ae0a5496-d621-49ef-a11a-3578c272ce92", + "metadata": {}, + "source": [ + "## 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 : 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.0029673590504451 0.002967359050445104 \n", + "NAXIS : 1685 600" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.wcs # Recover the current WCS" + ] + }, + { + "cell_type": "markdown", + "id": "998def1f-3963-405b-8be2-6d4ef4012634", + "metadata": {}, + "source": [ + "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": [], + "source": [ + "aladin.height = 800\n", + "aladin.survey = \"CDS/P/PLANCK/R2/HFI/color\"\n", + "aladin.target = \"LMC\"\n", + "aladin.frame = \"Galactic\"\n", + "aladin.fov = 50" + ] + }, + { + "cell_type": "markdown", + "id": "9c2221f3-6ecc-46d6-9d53-5dbefa71326d", + "metadata": {}, + "source": [ + "The wcs is updated and you can print its new value in the **next cell**:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2ddc9637-b5c3-4412-8435-2302b6d86816", + "metadata": {}, + "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 : 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.0029673590504451 0.002967359050445104 \n", + "NAXIS : 1685 800" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aladin.wcs" + ] + }, + { + "cell_type": "markdown", + "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 executions. \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" + } + ], + "source": [ + "aladin.fov_xy # Recover the current field of view for the x and y axis" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "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(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, + "y": 5 + }, + "_height": 800, + "_model_module": "anywidget", + "_model_module_version": "0.9.10", + "_model_name": "AnyModel", + "_target": "80.89416999999995 -69.75611", + "_view_module": "anywidget", + "_view_module_version": "0.9.10", + "_view_name": "AnyView", + "_wcs": { + "CDELT1": -5, + "CDELT2": 5, + "CRPIX1": 1, + "CRPIX2": 1, + "CRVAL1": 80.89416999999995, + "CRVAL2": -69.75611, + "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_8b1f9d5607de4bd4a8cc50de5de97650", + "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" + } + }, + "8b1f9d5607de4bd4a8cc50de5de97650": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} 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 d3c3bb8c..4c1ccaea 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, setDivNumber, Lock } from "../utils"; export default class EventHandler { /** @@ -12,7 +12,51 @@ export default class EventHandler { this.aladin = aladin; this.aladinDiv = aladinDiv; this.model = model; - this.messageHandler = new MessageHandler(aladin); + this.messageHandler = new MessageHandler(aladin, model); + this.currentDivNumber = parseInt(aladinDiv.id.split("-").pop()); + } + + /** + * Checks if the current div is the last active div. + * @returns {boolean} + */ + isLastDiv() { + if (this.currentDivNumber === divNumber) { + return true; + } + 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; + } + } + setDivNumber(maxDiv); + return this.currentDivNumber === 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], + }); } /** @@ -42,6 +86,7 @@ export default class EventHandler { } jsTargetLock.lock(); const raDec = [position.ra, position.dec]; + this.updateWCS(); this.model.set("_target", `${raDec[0]} ${raDec[1]}`); this.model.save_changes(); }); @@ -68,6 +113,8 @@ export default class EventHandler { } jsFovLock.lock(); // fov MUST be cast into float in order to be sent to the model + this.updateWCS(); + this.update2AxisFoV(); this.model.set("_fov", parseFloat(fov.toFixed(5))); this.model.save_changes(); }); @@ -83,13 +130,39 @@ 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 only if this is the last div + this.updateWCS(); + this.update2AxisFoV(); + this.model.save_changes(); }); /* Aladin callbacks */ + this.aladin.on("cooFrameChanged", () => { + this.updateWCS(); + this.model.save_changes(); + }); + + this.aladin.on("projectionChanged", () => { + this.updateWCS(); + this.model.save_changes(); + }); + + this.aladin.on("layerChanged", (_, layerName, state) => { + if (layerName !== "base" || state !== "ADDED") return; + this.updateWCS(); + this.model.save_changes(); + }); + + this.aladin.on("resizeChanged", () => { + this.updateWCS(); + this.update2AxisFoV(); + this.model.save_changes(); + }); + this.aladin.on("objectHovered", (object) => { if (object["data"] !== undefined) { this.model.send({ @@ -200,7 +273,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..76fd9a25 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) { 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 7b261dde..b2e13fc0 100644 --- a/js/widget.js +++ b/js/widget.js @@ -1,11 +1,10 @@ import "./widget.css"; import EventHandler from "./models/event_handler"; -import { snakeCaseToCamelCase } from "./utils"; +import { divNumber, 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,15 +14,23 @@ 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 const raDec = initOptions["target"].split(" "); aladin.gotoRaDec(raDec[0], raDec[1]); + // Set current FoV and WCS + const twoAxisFoV = aladin.getFov(); + model.set("_fov_xy", { + x: twoAxisFoV[0], + y: twoAxisFoV[1], + }); + model.set("_wcs", aladin.getViewWCS()); + model.save_changes(); + el.appendChild(aladinDiv); return { aladin, aladinDiv }; } 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/utils/exceptions.py b/src/ipyaladin/utils/exceptions.py new file mode 100644 index 00000000..a77b3e73 --- /dev/null +++ b/src/ipyaladin/utils/exceptions.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/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 735fee5a..9f528bd9 100644 --- a/src/ipyaladin/widget.py +++ b/src/ipyaladin/widget.py @@ -8,18 +8,22 @@ import io import pathlib from pathlib import Path -import typing -from typing import ClassVar, Union, Final, Optional +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 +from astropy.wcs import WCS +import numpy as np import traitlets +from .utils.exceptions import WidgetCommunicationError +from .utils.coordinate_parser import parse_coordinate_string + try: from regions import ( CircleSkyRegion, @@ -47,10 +51,8 @@ default, ) -from .coordinate_parser import parse_coordinate_string - SupportedRegion = Union[ - typing.List[ + List[ Union[ CircleSkyRegion, EllipseSkyRegion, @@ -79,7 +81,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." @@ -126,10 +128,14 @@ 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 - listener_callback: ClassVar[typing.Dict[str, callable]] = {} + listener_callback: ClassVar[Dict[str, callable]] = {} # overlay survey overlay_survey = Unicode("").tag(sync=True, init_option=True) @@ -138,11 +144,12 @@ 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: 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) @@ -165,6 +172,65 @@ 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 np.isclose(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. + + Returns + ------- + WCS + An astropy WCS object representing the world coordinate system. + + """ + if self._wcs == {}: + raise WidgetCommunicationError( + "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) + + @property + def fov_xy(self) -> Tuple[Angle, Angle]: + """The field of view of the Aladin Lite along the two axes. + + Returns + ------- + tuple[Angle, Angle] + A tuple of astropy.units.Angle objects representing the field of view. + + """ + if self._fov_xy == {}: + raise WidgetCommunicationError( + "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"), + ) + @property def fov(self) -> Angle: """The field of view of the Aladin Lite widget along the horizontal axis. @@ -185,6 +251,10 @@ 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}) @property @@ -216,6 +286,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", @@ -266,6 +337,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()], @@ -463,7 +535,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()) @@ -477,7 +549,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. @@ -498,7 +570,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. 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,