package bump

package.json

@@ -1,7 +1,7 @@
 {
   "name": "deepscatter",
   "type": "module",
-  "version": "2.15.1-RC-1",
+  "version": "2.15.2",
   "description": "Fast, animated zoomable scatterplots scaling to billions of points",
   "files": [
     "dist"

release_notes.md

@@ -1,3 +1,8 @@
+
+# 2.15.1
+
+* Adds a method to `Dataset` called visit_full that returns a promise which iterates over all the tiles in the dataset including those that have not yet loaded. (Their load is triggered.)
+
 # 2.15.0
 
 This would be a bugfix release except that it's possible this might accidentally break code taking advantage of undocumented behavior involving the domain for categorical scales. If you've ever set a scale to have domain [-2047, 2047], the console will now throw a warning and autochange the extent to provide more sensible support for dictionary fields. 

src/Dataset.ts

@@ -307,6 +307,52 @@ export abstract class Dataset<T extends Tile> {
     }
   }
 
+ /**
+   * Invoke a function on all tiles in the dataset that have been downloaded.
+   * The general architecture here is taken from the
+   * d3 quadtree functions. That's why, for example, it doesn't
+   * recurse.
+
+   * @param callback The function to invoke on each tile.
+   * @param after Whether to execute the visit in bottom-up order. Default false.
+   * @param filter 
+   */
+
+  async visit_full(
+    callback: (tile: T) => Promise<void>,
+    after = false,
+    starting_tile : T | null = null,
+    filter: (t: T) => boolean = (x) => true,
+    updateFunction: (tile: T, completed, total) => Promise<void>
+  ) {
+
+      // Visit all children with a callback function.
+      // In general recursing quadtrees isn't that fast, but
+      // we rarely have more than ten tiles deep and the
+      // code is much cleaner this way than an async queue.
+
+      let seen = 0;
+      const start = starting_tile || this.root_tile;
+      await start.download();
+      const total = JSON.parse(start.record_batch.schema.metadata.get("total_points"))
+
+      async function resolve(tile: T) {
+        await tile.download();
+        if (after) {
+          await Promise.all(tile.children.map(resolve))
+          await callback(tile);
+          seen += tile.record_batch.numRows
+          void updateFunction(tile, seen, total)
+        } else {
+          await callback(tile);
+          seen += tile.record_batch.numRows
+          void updateFunction(tile, seen, total)
+          await Promise.all(tile.children.map(resolve))
+        }
+      }
+      await resolve(start);
+    }
+
   async schema() {
     await this.ready;
     if (this._schema) {

src/deepscatter.ts

@@ -206,12 +206,12 @@ class Scatterplot<T extends Tile> {
       }
     }
     const selection = new DataSelection<T>(this, params);
-    await selection.ready;
     this.selection_history.push({
       selection,
       name: selection.name,
       flushed: false,
     });
+    await selection.ready;
     return selection;
   }
 

src/tile.ts

@@ -74,7 +74,7 @@ export abstract class Tile {
     return this._children;
   }
 
-  download() {
+  download() : Promise<void> {
     throw new Error('Not implemented');
   }
 
@@ -253,7 +253,7 @@ export abstract class Tile {
   }
 
   async schema() {
-    this.download();
+    await this.download();
     await this.promise;
     return this._schema;
   }

vietnam2.html

@@ -55,7 +55,7 @@ <h1>Vietnam</h1>
 
   const prefs = {
     source_url: 'https://bmschmidt.github.io/vietnam_war/',
-    max_points: 100000,
+    max_points: 1000,
     alpha: 10.12, // Target saturation for the full page.
     zoom_balance: 0.12, // Rate at which points increase size. https://observablehq.com/@bmschmidt/zoom-strategies-for-huge-scatterplots-with-three-js
     point_size: 2, // Default point size before application of size scaling
@@ -184,7 +184,7 @@ <h1>Vietnam</h1>
       scatterplot
         .plotAPI({
           alpha: 3.5,
-          max_points: 10000,
+          max_points: 1000,
           point_size: 5,
           duration: 0.1,
           encoding: {