That's fine, this may give us some more idea of structure in the data but

remember the size of these elements corresponds to some property there.

So for example in a computer,

this will correspond to the file size.

So I can say, "Hey this might be a really big file.

Let me check out why it's taken up all this memory in this drive."

In the stock market,

it may correspond to the price of the stock.

With that, that might mean that zero value might be really important.

What if a stock value drops to zero?

What if I'm in a sports game and have a score of zero?

How do I encode that value into a node,

if I'm mapping areas how do I map to zero?

Because I want to show something because that might be important but

if I give it width in my misinterpreting this.

So thinking about how we map to zero,

one way to overcome this is to distort the classic treemap visualization.

So distorted tree map can show another attribute than a classic tree map,

so node area is no longer proportional to the attribute being visualized.

So instead we can scale this and make zero be important.

There's a lot of different implementation strategies.

For example, we use a regular treemap but we could add some epsilon to zero value items.

We could use an exponential mapping so two to the value.

So if the value is zero,

we get a size of one for the area or we can

assign some minimal screen space size to zero nodes.

But again, this can lead to sort of weird aspect ratios and other issues.

The final solution for contexts treemap was to calculate the total.

So in this particular paper,

which was from Johns Stasko's group on fund explore,

they calculated the total value,

created an additional total with respect to the context,

and split the context screen real estate among all the empty nodes.

The empty nodes were given the same level of importance.

And we can see an example here of a fund explorer.

Looking at where some of the zero node values are and trying

to again think about how we might interpret this sort of treemap.

Now, of course people also started thinking about,

"Well, I don't have to just do vertical and horizontal splits.

Why can't I lay out treemaps with other methods?"

So we had circular packing.

But what about voronoi treemaps?

So we can take our data and voronoi tessellation to the data,

and try to organize our elements into these voronoi diagrams.

But of course again, it gets tricky to extract and understand the hierarchy there.

But they look really pretty.

And so you can take a look at this work from Balzer or Deussen and Lewerentz in

2005 and see how they did voronoi treemaps for software visualization.

Take a look at their algorithm for that.

Essentially for a voronoi diagram,

we're going to let our partitions be a set of n distinct points,

and then the voronoi diagram of P is the subdivision of the plane into n cells,

one for each site and we're trying to capture this hierarchy.

So point Q is going to lie in the cell corresponding to a site.

The main algorithm for computing the voronoi diagram is Fortune's algorithm.

This would be something you would do more in a computer graphics class if you're

interested in learning more about voronoi tessellations and those sorts of things.

Take a look at Fortune's algorithm during the computer graphics class.

Mostly we mentioned the voronoi tessellation here just to give you

an idea of that treemaps don't have to just be square of phi,

we can do other sorts of elements.

The voronoi properties, essentially a point q lies in a voronoi edge

between different sites if and only if the largest empty circle

centered at q touches only p_i and p_j.

So we can start thinking about how to do these voronoi tessellations,

and how to do our splits to create this hierarchical clustering.

So there's more summaries of voronoi properties.

And by laying out these different voronoi elements,

we can try to maximize our screen space

and capture some different aesthetics that we don't have before.

What's nice is that voronoi diagrams have a linear complexity.

The problem is that not all bisectors are voronoi edges.

So it can become a little bit tricky in trying to think about how to

interpret these voronoi treemaps to get the hierarchical structure back out of those.

So while the voronoi diagram looks pretty,

it can be hard to interpret.

So people have also thought about circle packing.

So taking different levels, hierarchies,

and the zeroth level is our root node,

and then all the children from the zero level get packed in and so forth.

So we just, you're packing these circles into there.

This is maybe a little bit easier to interpret the hierarchical structure.

We can also extend this to a 3D view as we show here.

But it gets harder to read and interpret as this gets bigger and bigger and it takes up

more space and we wind up losing white space elements here as well.

So again, another option instead of doing node link or space dealing with treemap,

we can try a circle packing algorithm to fill in these treemap elements.

So I don't want people to think that they're just constrained

to node link diagrams or treemaps.

There's lots of different ways we can think about

what visual metaphors might enable us to

represent a hierarchical structure being inspired by things in nature,

thinking about taking advantage of different geometric concepts,

whether its circle packing or voronoi diagrams,

the goal of all of these things is to try to help

us visualize as much of the data as possible.

Remember with a node link diagram,

we already have sort of shape constrained by the shape of the nodes,

we're going to use circles, we can add color,

we can add size.

But again, this can cause weird elements to occur.

Imagine in our node link diagram,

it's size corresponds to the size of the file.

So is the root node supposed to be giant,

and then they get smaller as they go down.

Should we do a different method where they get bigger as they go up?

How do we use size to help add another dimension?

Should we just add color and ignore size?

How can we augment this and use

multiple visual variables to show multivariate aspects of the data?

These are the challenges we want to face and think about how we can use

these different data visualization tools in different ways to

help us explore and understand our data. Thank you.