Misc

[thorwhalen]

Miscellaneous stuff.

[thorwhalen]

When JS corrupts notebooks

So, this is something that came up with some efforts to do JS stuff in a notebook by one of the developers of my team in the past. I think it also came up with third party tools that used JS components in notebooks.

And it's happening to us now.

The particular flavor here (in VsCode): Everything but the input cells get a grey background, and you can't see any output.
See that even just asking to render 123, or print "Hello" doesn't show up.

The particularity with this one is:

(1) I don't even have to execute any specific JS thing in a notebook to trigger the corruption. Executing anything will trigger it.

(2) All notebooks become corrupted -- not just the one where the execution happened.

--> The problem source was a big pickle that, when unpickled, corrupted the notebook. I deleted it without looking into what content was causing the corruption, to avoid rabbit-holing further

[thorwhalen]

Random graph generator

Viewing artificial graphs can be a good way to gauge our graph visualization tools, exhibit features as well as pinpoint bugs.
Offering this capability to users can be a good marketing route as well.

We can offer different kinds of graph generators. Right now I want to mention the advantages of random graphs.

Random graphs are not just cool tools for geeking out on graph theory; they're also a fantastic way to show off and refine our graph visualization software. Think about it: random graphs are like the wild cards of the graph world, modeling everything from social networks to brain wiring. This makes them super relatable and a great way to test how versatile and user-friendly our software is.

Here's the kicker: random graphs are unpredictable. This means every time you generate one, you get a new puzzle for your software to solve. This unpredictability is perfect for spotting any sneaky bugs and showcasing the flexibility of our tools. Plus, watching a graph evolve as you tweak the parameters – like witnessing a network suddenly connect at a critical point – is not just insightful, it's also pretty mesmerizing.

Now, imagine we let users play around with these parameters themselves. It's not just a testbed for our tools; it's an interactive playground for anyone curious about networks. Users get to see firsthand how complex, real-world networks can emerge from simple rules. And the best part? As they share their cool graph findings, they're also spreading the word about our software. It's like hitting two birds with one stone: we get invaluable user feedback and some organic marketing too.

In short, using random graphs to showcase our software isn't just smart testing; it's a clever way to engage users and get them talking about our tools.

[thorwhalen]

Easily create data images and videos

Being able to easily take a "visualization snapshot" (typically referred to as "screenshot" or "static visualization export") and its extension to "camera path animation" capabilities is invaluable for data scientists and analysts because these tools empower them to vividly narrate their data stories. A snapshot captures a single, telling moment in a dataset, crystallizing complex information into an easily digestible image. Extending this to camera path animation elevates the storytelling by providing a dynamic, engaging journey through the data. It allows for illustrating changes, trends, and patterns over time or across different dimensions, making the data narrative not just informative but also visually compelling. These visual aids are crucial in making complex data accessible and understandable to a broader audience, thereby enhancing communication, driving insights, and supporting decision-making processes.

Camera path Animation

The process of "camera path animation" (or "view interpolation") involves defining a series of camera positions and views (akin to setting up a sequence of plotting areas or viewports) and then creating a smooth transition between these views to generate a dynamic video or GIF. This technique is especially popular in 3D modeling, GIS (Geographic Information Systems), and advanced data visualization contexts.

We're looking to set up a "camera path" for your visualizations, where the 'camera' smoothly moves through a series of predefined views, zooming in and out, panning around – kind of like taking your audience on a guided tour of your data. You want two ways to control this camera:

1. Explicit Path Definition: Here, we'll lay out a specific sequence of camera views. We're in the driver's seat, choosing exactly where to look, when to zoom, and how to pan. We'll also set the pace, deciding how quickly the camera moves from one view to the next.

2. Automated Path with Customizable Transitions: This is where things get slick. You specify keyframes as a series of views (each defined by a viewport rectangle) how long to linger on each ('wait' times). Then you let the system handle the transitions. But you're not just handing over the keys – you get to tweak the transition styles (like fade, slide, or cross dissolve) and their durations, adding a professional touch to the animation. For live presentations, we should replace wait times with transition triggers (like a key press) to tell the system when to transition to the next data view.

Best practice in designing this functionality involves ensuring smooth, natural transitions between views. Linear interpolation is standard for simpler transitions, but you might also use easing functions for more dynamic effects -- like slow in, fast out and/or zoom out, zoom in. The key is to keep the audience oriented – too much jumping around can be disorienting. Also, giving users control over transition styles and durations is crucial, as it allows for customization based on the content and context of the visualization.

Lastly, integrating this feature into visualization tools typically involves a combination of camera control APIs (for 3D environments) or viewport manipulation functions (for 2D or map-based visualizations). And remember, the final output's quality hinges not just on the path but on the rendering capabilities of your tool – so make sure it's up to snuff to produce that crisp, smooth final product!