Subdivision tuning

Cells are all subdivided at the same level.
One subdivision is added if:
* the cell is on a pole
* the cell is at a frontier of a base cells (and in collignon zona)

codemeta.json

@@ -8,8 +8,8 @@
     "dateModified": "2023-01-31",
     "issueTracker": "https://github.com/cds-astro/aladin-lite/issues",
     "name": "Aladin Lite",
-    "version": "3.6.5",
-    "softwareVersion": "3.6.5",
+    "version": "3.6.4",
+    "softwareVersion": "3.6.4",
     "description": "An astronomical HiPS visualizer in the browser.",
     "identifier": "10.5281/zenodo.7638833",
     "applicationCategory": "Astronomy, Visualization",

examples/al-footprints.html

@@ -11,7 +11,7 @@
     let aladin;
     A.init.then(() => {
         // Start up Aladin Lite
-        aladin = A.aladin('#aladin-lite-div', {target: 'M 1', fov: 0.2, showContextMenu: true, fullScreen: true});
+        aladin = A.aladin('#aladin-lite-div', {survey: "CDS/P/DSS2/color", target: 'M 1', fov: 0.2, showContextMenu: true, fullScreen: true});
         var overlay = A.graphicOverlay({color: '#ee2345', lineWidth: 3, lineDash: [2, 2]});
         aladin.addOverlay(overlay);
         overlay.addFootprints([

examples/al-image-with-AVM-tags.html

@@ -7,7 +7,7 @@
     <script type="module">
         import A from '../src/js/A.js';
         A.init.then(() => {
-            let aladin = A.aladin('#aladin-lite-div', {fov: 30, target: "280 +0", projection: "AIT", showShareControl:true, showSettingsControl: true, showContextMenu:true});
+            let aladin = A.aladin('#aladin-lite-div', {fov: 30, survey: "CDS/P/DSS2/color", target: "280 +0", projection: "AIT", showShareControl:true, showSettingsControl: true, showContextMenu:true});
             
             aladin.setOverlayImageLayer(A.image(
                 "https://www.virtualastronomy.org/images/sig05-013.jpg",

src/core/al-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "al-api"
-version = "3.6.5"
+version = "3.6.4"
 authors = ["baumannmatthieu0@gmail.com", "matthieu.baumann@astro.unistra.fr"]
 edition = "2018"
 

src/core/al-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "al-core"
-version = "3.6.5"
+version = "3.6.4"
 authors = ["baumannmatthieu0@gmail.com", "matthieu.baumann@astro.unistra.fr"]
 edition = "2018"
 

src/core/src/downloader/request/allsky.rs

@@ -185,24 +185,14 @@ impl From<query::Allsky> for AllskyRequest {
                                 .collect())
                         }
                         InMemData::F32(data) => {
-                            let data = unsafe {
-                                std::slice::from_raw_parts(
-                                    data.as_ptr() as *const u8,
-                                    data.len() * 4,
-                                )
-                            };
+                            let data = unsafe { std::slice::from_raw_parts(data.as_ptr() as *const u8, data.len() * 4) };
                             Ok(handle_allsky_fits(&data, tile_size, texture_size)?
                                 .map(|image| ImageType::RawRgba8u { image })
                                 .collect())
                         }
                         InMemData::F64(data) => {
                             let data = data.iter().map(|v| *v as f32).collect::<Vec<_>>();
-                            let data = unsafe {
-                                std::slice::from_raw_parts(
-                                    data.as_ptr() as *const u8,
-                                    data.len() * 4,
-                                )
-                            };
+                            let data = unsafe { std::slice::from_raw_parts(data.as_ptr() as *const u8, data.len() * 4) };
 
                             Ok(handle_allsky_fits(&data, tile_size, texture_size)?
                                 .map(|image| ImageType::RawRgba8u { image })
@@ -238,77 +228,71 @@ fn handle_allsky_file<F: ImageFormat>(
     let num_allsky_tiles_per_tile = (tile_size / allsky_tile_size) * (tile_size / allsky_tile_size);
 
     let mut src_idx = 0;
-    let tiles = (0..num_tiles).map(move |_| {
-        let mut base_tile =
+    let tiles = (0..num_tiles)
+        .map(move |_| {
+            let mut base_tile =
             ImageBuffer::<F>::allocate(&<F as ImageFormat>::P::BLACK, tile_size, tile_size);
-        for idx_tile in 0..num_allsky_tiles_per_tile {
-            let (x, y) = crate::utils::unmortonize(idx_tile as u64);
-            let dx = x * (allsky_tile_size as u32);
-            let dy = y * (allsky_tile_size as u32);
+            for idx_tile in 0..num_allsky_tiles_per_tile {
+                let (x, y) = crate::utils::unmortonize(idx_tile as u64);
+                let dx = x * (allsky_tile_size as u32);
+                let dy = y * (allsky_tile_size as u32);
 
-            let sx = (src_idx % 27) * allsky_tile_size;
-            let sy = (src_idx / 27) * allsky_tile_size;
-            let s = ImageBufferView {
-                x: sx as i32,
-                y: sy as i32,
-                w: allsky_tile_size as i32,
-                h: allsky_tile_size as i32,
-            };
-            let d = ImageBufferView {
-                x: dx as i32,
-                y: dy as i32,
-                w: allsky_tile_size as i32,
-                h: allsky_tile_size as i32,
-            };
+                let sx = (src_idx % 27) * allsky_tile_size;
+                let sy = (src_idx / 27) * allsky_tile_size;
+                let s = ImageBufferView {
+                    x: sx as i32,
+                    y: sy as i32,
+                    w: allsky_tile_size as i32,
+                    h: allsky_tile_size as i32,
+                };
+                let d = ImageBufferView {
+                    x: dx as i32,
+                    y: dy as i32,
+                    w: allsky_tile_size as i32,
+                    h: allsky_tile_size as i32,
+                };
 
-            base_tile.tex_sub(&allsky, &s, &d);
+                base_tile.tex_sub(&allsky, &s, &d);
 
-            src_idx += 1;
-        }
+                src_idx += 1;
+            }
 
-        base_tile
-    });
+            base_tile
+        });
 
     Ok(tiles)
 }
 
 fn handle_allsky_fits<F: ImageFormat>(
     allsky_data: &[<<F as ImageFormat>::P as Pixel>::Item],
-
     tile_size: i32,
     texture_size: i32,
-) -> Result<impl Iterator<Item = ImageBuffer<F>>, JsValue> {
+) -> Result<impl Iterator<Item=ImageBuffer<F>>, JsValue> {
     let allsky_tile_size = std::cmp::min(tile_size, 64);
     let width_allsky_px = 27 * allsky_tile_size;
     let height_allsky_px = 29 * allsky_tile_size;
     // The fits image layout stores rows in reverse
     let reversed_rows_data = allsky_data
-        .chunks(width_allsky_px as usize * F::NUM_CHANNELS)
+        .chunks(width_allsky_px as usize)
         .rev()
         .flatten()
         .copied()
         .collect::<Vec<_>>();
+
     let allsky = ImageBuffer::<F>::new(reversed_rows_data, width_allsky_px, height_allsky_px);
 
-    let allsky_tiles_iter =
-        handle_allsky_file::<F>(allsky, allsky_tile_size, texture_size, tile_size)?.map(
-            move |image| {
-                // The GPU does a specific transformation on the UV for FITS tiles
-                // We must revert this to be compatible with this GPU transformation
-                let new_image_data = image
-                    .get_data()
-                    .chunks((tile_size * tile_size) as usize * F::NUM_CHANNELS)
-                    .flat_map(|c| {
-                        c.chunks(tile_size as usize * F::NUM_CHANNELS)
-                            .rev()
-                            .flatten()
-                    })
-                    .cloned()
-                    .collect();
+    let allsky_tiles_iter = handle_allsky_file::<F>(allsky, allsky_tile_size, texture_size, tile_size)?
+        .map(move |image| {
+            // The GPU does a specific transformation on the UV
+            // for FITS tiles
+            // We must revert this to be compatible with this GPU transformation
+            let mut new_image_data = Vec::with_capacity(tile_size as usize);
+            for c in image.get_data().chunks((tile_size * tile_size) as usize) {
+                new_image_data.extend(c.chunks(tile_size as usize).rev().flatten());
+            }
 
-                ImageBuffer::<F>::new(new_image_data, tile_size, tile_size)
-            },
-        );
+            ImageBuffer::<F>::new(new_image_data, tile_size, tile_size)
+        });
 
     Ok(allsky_tiles_iter)
 }

src/core/src/tile_fetcher.rs

@@ -2,10 +2,10 @@ use crate::downloader::{query, Downloader};
 use crate::time::{DeltaTime, Time};
 use crate::Abort;
 
-use al_api::moc::MOCOptions;
 use std::cell::RefCell;
 use std::collections::{HashMap, VecDeque};
 use std::rc::Rc;
+use al_api::moc::MOCOptions;
 
 const MAX_NUM_TILE_FETCHING: usize = 8;
 const MAX_QUERY_QUEUE_LENGTH: usize = 100;
@@ -214,7 +214,7 @@ impl TileFetcherQueue {
 
         let tile_size = cfg.get_tile_size();
         //Request the allsky for the small tile size or if base tiles are not available
-        if tile_size <= 256 || cfg.get_min_depth_tile() > 0 {
+        if tile_size <= 128 || cfg.get_min_depth_tile() > 0 {
             // Request the allsky
             downloader.borrow_mut().fetch(query::Allsky::new(
                 cfg,

src/js/Aladin.js

@@ -413,8 +413,6 @@ export let Aladin = (function () {
             // Merge what is already in the cache for that HiPS with new properties
             // coming from the MOCServer
             this.hipsFavorites.push(hipsObj);
-            // Favorites are also directly pushed to the cache
-            this.hipsCache.append(hipsObj.id, hipsObj)
         }
 
         this._setupUI(options);
@@ -434,7 +432,11 @@ export let Aladin = (function () {
                 });
             } else if (options.survey === HiPS.DEFAULT_SURVEY_ID) {
                 // DSS is cached inside HiPS class, no need to provide any further information
-                this.setBaseImageLayer(HiPS.DEFAULT_SURVEY_ID);
+                const survey = this.createImageSurvey(
+                    HiPS.DEFAULT_SURVEY_ID
+                );
+
+                this.setBaseImageLayer(survey);
             } else {
                 this.setBaseImageLayer(options.survey);
             }
@@ -1574,8 +1576,10 @@ export let Aladin = (function () {
         let hipsOptions = { id, name, maxOrder, url, cooFrame, ...options };
         let hips = new HiPS(id, url || id, hipsOptions)
 
-        // A HiPS can be refered by its unique ID thus we add it to the cache (cf excample/al-cfht.html that refers to HiPS object just by their unique ID)
-        if (this instanceof Aladin) {
+        // This allows to retrieve the survey's options when it will be
+        // added later to the view.
+        if (this instanceof Aladin && !this.hipsCache.contains(hips.id)) {
+            // Add it to the cache as soon as possible if we have a reference to the aladin object
             this.hipsCache.append(hips.id, hipsOptions)
         }
 
@@ -1932,14 +1936,12 @@ export let Aladin = (function () {
         let imageLayer;
 
         let hipsCache = this.hipsCache;
-
         // 1. User gives an ID
         if (typeof urlOrHiPSOrFITS === "string") {
             const idOrUrl = urlOrHiPSOrFITS;
             // many cases here
             // 1/ It has been already added to the cache
             let cachedOptions = hipsCache.get(idOrUrl)
-
             if (cachedOptions) {
                 imageLayer = A.HiPS(idOrUrl, cachedOptions);
             } else {
@@ -1959,7 +1961,7 @@ export let Aladin = (function () {
                 if (!cachedLayerOptions) {
                     hipsCache.append(imageLayer.id, imageLayer.options)
                 } else {
-                    // Set the options from what is in the cache
+                    // set the options from what is in the cache
                     imageLayer.setOptions(cachedLayerOptions);
                 }
             }

src/js/gui/Box/StackBox.js

@@ -528,7 +528,15 @@ export class OverlayStackBox extends Box {
                                 position: self.position,
                             });*/
                             self.aladin.addNewImageLayer(
-                                'P/DSS2/color'
+                                A.imageHiPS('P/DSS2/color', {
+                                    errorCallback: (e) => {
+                                        aladin.addStatusBarMessage({
+                                            duration: 2000,
+                                            type: 'info',
+                                            message: 'DSS2 colored HiPS could not plot',
+                                        })
+                                    }
+                                })
                             );
                         },
                     },
@@ -932,7 +940,6 @@ export class OverlayStackBox extends Box {
                 options.push(value)
             }
 
-
             let HiPSSelector = Input.select({
                 value,
                 options,