[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Distributed visualization anyone?


I think most of us do distributed computation, but what about
distributed visualization?

In particular, here's what I have in mind.  I'm running some PETSc
timestepping simulations on a small beowulf, which will soon move to a
large beowulf.  I'd like to be able to do real-time timestep viewing of
a distributed 3-D dataset.

So I coded up a link between PETSc and geomview, in which each processor
generates the triangulation of an isoquant contour in its local dataset
of a PETSc distributed array object (DA), plus one shadow node in each
direction so there are no gaps.  (This next part is unimplemented, but)
it then sends that triangulation to node 0.  (This part is implemented)
node 0 then sends the triangle data to geomview in a separate process
which was forked from the PETSc program earlier (only on node 0).

Output at http://lyre.mit.edu/~powell/petscgeom.html is real pretty, but
hardly new, lots of people do contour surfaces.  As you can see, it
exposes a bug in geomview's transparency rendering, geomview needs a
depth sorter to do that right, but it looks beautiful as long as you
look in the right direction- or turn off transparency. :-)

What I think _is_ new is the ability to generate these triangulations in
real time in a distributed fashion, after every timestep or Newton
iteration, in the same app that's generating the data.  Does anyone know
of other packages which do this, free or non-?

I'm going to package the petscgeom library that does this real soon,
just looking for ideas for now.  In the meantime, I'm attaching the
library's TODO list, as food for thought.

Moving beyond this: my current library only does triangulated contour
surfaces, there are also luminance/opacity-based visualization concepts,
and all kinds of flow visualization schemes, all of which would be fun
to do in parallel.  Also, the PETSc DA is a structured grid, my library
currently further requires a cartesian grid with uniform spacing (though
x, y and z spacings can be different).  Unstructured grids would require
a new PETSc distributed object which doesn't yet exist...


-Adam P.

GPG fingerprint: D54D 1AEE B11C CE9B A02B  C5DD 526F 01E8 564E E4B6

          Welcome to the best software in the world today cafe!

Stuff to do for PETSc-Geomview:

- Get the triangles into some kind of distributed object, like a vector, but of
  flexible size.  Then provide a mechanism for gathering them all to node zero
  for display in Geomview.

- Use Geomview's binary format to significantly compress the data stream in the
  pipe and improve resolution over the ASCII transfer.

- Merge the corner points so instead of three unique points for each triangle,
  we share corner points with adjacent triangles, cutting back enormously on
  the internal storage/communication requirements as well as the amount of data
  which must be piped to Geomview.  Hopefully do this as-we-go to avoid
  multiple passes through the data -- want to do everything in cache if

- Manipulate triangles to reduce the number of triangles being sent to Geomview
  (and accelerate rotation there too!).  Maybe do this with Evolver-style
  routines e.g. equiangulate, eliminate small edges, eliminate edges with low
  curvature at both endpoints, though we don't want to alter the triangulation
  too much.

- Provide for animation by repeated generation and display of triangulations at
  various stored timesteps with a controlled framerate.  Automate the
  production of mpeg movies of such animations.

- Implement local disc storage of vectors, in order to store timesteps locally
  at each node for rapid production of such movies from a data set too large to
  fit into (distributed) memory.

Yeah, baby!

Reply to: