In this essay, i give a list of requirements that i think is necessary for a software system for creating scientific visualization for the next decade.

For the past 10 years, i have been strongly interested in mathematical visualization. I'm not a professor, and am not doing it for the educational purposes per se. Geometry has just been beautiful for me, and i'm also a professional programer. Programing computers to visualize geometric theorems or geometric objects, has been a immense personal pleasure. A particular aspect of visualization, is to design it so that when viewed, it forces a immediate and crystal clear understanding of the object or theorem.

I have for the past couple years sought for a software platform/system where i can build 3D objects, with abilities to do interactive manipulation (such as moving a slider to change a parametric surface's parameter), dynamic rotation (viewing from different angles instantaneously), animations (such as morphing that shows geometric processes), and most of all, walk-thru in it as if it is a building (⁖ the perception of actually walking on a moebius strip or Klein bottle is vastly different than just viewing it from a distance.).

In the following, i give itemized descriptions on features necessary in a visualization system, based on my experiences.

For math visualization, it is absolutely necessary to be able to rotate the object in real-time. For example, when viewing a complex surface, a molecule structure, or the design of a mechanical device. This requirement is so basic it warrants no further explanation.

The programer should be able to build buttons and sliders that change parameters and have the object reflect these changes visually in real time.

This real-time interactivity is frequently needed. For example, most math visualizations involve a function, a process, or a geometric object, that varies by parameters, and the key to the visualization is showing how the parameter changes the object or its graph. Some Examples follows.

Computing power today are some 50 times faster than a
decade ago. However, math visualizations, have not advanced in any qualitative way.
For example, let's consider the simple task of plotting of polynomial equations.
As we know, 2nd degree polynomials of 2 variables are
conic sections.
It would nice, that the program can show the general form
`A x^2 + B x y + C y^2 + D x + E y + F == 0`

and let users change the constants by sliders, and have the graph
change on the fly. Ideally, the application would show 2 images side
by side. One image shows the planar curve, while another images shows
a 3D object of a cut cone. The user should be able to rotate the 3D cone
in real time. Moreover, there can be sliders to allow users to
change the angle of the cutting plane, or the angle of the cone, and
have the plane curve in the other window change in real time, as well
as the corresponding equation.

Such a application would give immense feedback that reinforces learning, which is what visualization is about. Similiarly, this can be done for 3rd degree polynomials (i.e. “Cubic curves”), and the visualization of polynomials of 3 variables. (i.e. “implicit surface”)

There are tens, if not hundreds, elementary equation and function graphing software. However, it is almost impossible to find one that shows the power of interactivity described above. Apple Computer Inc, bundled with OS X as current as of March 2007, a plotting software (called Grapher) that has no interactivity features (except dynamic rotation). And Mathematica's abilities for plotting polynomial equations in as late as 2005, is basically the same as in 1995. Its ability for visual experiment and study of polynomials of 3 variables is practically zero. (postscript: Mathematica version 6, released in 2007 after this essay, has interactive graphics features.)

I have personally played with perhaps over 20 major plotting software over the past 15 years, and i only know one that has interactive graphing feature. (See: Nucalc)

The software system must have the capabilities for programers to build animation, and view the animation interactively in real-time (as opposed to generating the animation once and save it as a movie file).

For example, once a programer has coded the animation, she should easily play it forward and backward in the program, as well as changing parameters and re-run the new animation without going thru some compilation or export process. For example, if the animation involves a morphing 3D object, the system should also allow the user to rotate it while the morphing is on-going, all in real-time.

For example, this system should allow programer to easily create a animation that morphs a sphere into a cube, or a bunch of spheres flying in space as a swarm of flies or in some controlled artificial formation like airplanes air show.

In this example, you can see the trace by a point on the boundary of the circle. What happens if the tracing point is nearer to the center of the circle? This is a example where a interactive slider will help. As a user adjust the slider, the animation should show its effects in real-time.

This is a example where it shows the importance of being able to rotate the object in real-time in a on-going morph.

To create a visualization for the stereographic projection, ideally, the user should be able to drag and rotate or move the whole plane with respect to the sphere, as to see the effect on the mapping. Also, the user should be able to rotate the sphere and see the mapping change on the plane. The user should also be able to drag a point constrained on the sphere's surface or on the plane's surface, to see its corresponding point. Lastly, it is ideal in this visualization to let users change the pattern on plane or on the sphere to arbitrary images. For example, the plane should have a default set of images, one of a rectangular grid, and also a polar grid. (These grids would visually demonstrate the important property of circles mapping to circles) The sphere should have a set of images of projected platonic solids. (These would demonstrate the important concept of platonic solids as nets) And, the user should be able to plot the graph of arbitrary complex function on the plane to see its projected image on the sphere. (i.e. The Riemann sphere)

Today, it is non-trivial to create a visualization such as this. For example, the above image is created in Mathematica. (then the graphical data is exported into JavaView for viewing real-time rotation) To generate this static image in Mathematica, the programer needs to write a projection function that maps graphics primitives on a plane onto the sphere. Even though Mathematica is a powerful system with literally hundreds of advanced math functions and high-level graphics system, to simply create this static image, in general requires a scientist to have a couple years of Mathematica programing experience. Further, as of early 2007, Mathematica (version 5) does not support sliders or any graphical interactivity. (Note: Mathematica version 6 provides interactive features but was published after this essay was written.)

(For a Java Applet that does a small part of visualization discussed above, see stereop by John M Sullivan.)

Examples of system that do NOT satisfy the real-time animation requirement discussed in this section includes: Mathematica (up to version 5), 3D-XplorMath, most CAD systems. Most of these systems allow animations, but usually for a generate-once and save-as-static-movie-file, not designed for interactive view.

Examples of visualization systems that do satisfy the animation requirement to some degree includes: Interactive plane geometry software (2D only), Macromedia Flash (2D only), 3D Game Engines.

The software system should have the capability of walk-thru or fly-thru. That is, effectively letting user to fly a camera in real-time, and view things from this camera's position and orientation.

The most obvious application of this requirement is in CAD systems that are specialized for architecture. This feature is built-in in today's 3D games, where the player can walk inside structures and look about, viewing the environment either from a so-called first-person view or 3rd-person view.

For example, if i build a fancy 3D-maze or elaborate cathedral, i should be able to say, walk inside it, so as to view the object from inside and as well as getting the experience of perceiving such a structure.

The ability to do walk-thru has significant applications in math visualization too, however, it is seldom realized. Here are some examples of its application.

Compare the above image with the following abstract rendering that is commonly found in math visualization software.

Perhaps due to the evolution of our perception system, the experience of actually walking on or inside a math object, is vastly different than just seeing it as zero-thickness abstract lines and sheets rotating around its center.

Although, the virtual world created by computer graphics only fake the experience of actually being there, still, such a virtual world experience throws a impact on understanding. Imagine, demonstrating the one-sidedness property of surfaces such as the Moebius strip or Klein bottle thru a live rotation and explanation, compared to having the student taking a walk INSIDE such a house, and suddenly felt the single-sided oddity. A person experiencing such a situation will probably remember it for life.

The ability to do walk-thrus also fits well in visualizations involving 3-dimensional lattices, such as Crystallographic group, 3D-tilings (sphere packing), or visualizing periodic minimal surfaces.

For example, the following images of periodic minimal surfaces are shown in the way they are traditionally presented, as a few representative patchs of the periodic surface, and users can rotate them in real-time.

As the way they are shown, their periodic structure is not visually clear, especially those non-rectangular ones. (⁖ the last 3) It takes some effort to imagine how space is partitioned by them.

Now, imagine these shown in a walk-thru system, where the space is filled with its repetitions, and the user effectively becomes a bee, flying or walking about in it, able to observe details in a close-up on any point of the surface from any angle, or getting a bird's eye's overview of the surface's lattice symmetry from a distance. More importantly, as a walk-thru model, the structure essentially becomes systematic tunnels and walls. Going thru these tunnels gives the user a maze-exploration experience, on how the space is partitioned. Our brain's construction and understanding of spacial structures by walking around it, is built into our genes (See: Path integration aka Dead reckoning.). Only with walk-thru models can we exploit this important sensory ability.

There is effectively no visualization system that lets programers easily code interactive walk-thrus. The possible exception is 3D Game Engines, however, it requires a advanced game programer with years of dedicated experience to create any thing in it, and the work is rather tedious. (typically with C++, with huge amount of understanding of operating systems, graphics hardware, lots of specialized libraries.)

(Some game engines have higher level (scripting) languages that let users (players) create objects or scenes in-world. We will discuss this in the later section of this article)

The system must be easy to use for average programers or scientists. For example, a person who had just a year of programing experience, should be able to code a variety of visualization projects with the system.

Often, these high-level languages are called scripting languages. Mathematica, Python, Processing Macromedia Flash, Unity (game engine), CAD systems (AutoLISP), are examples of high-level systems.

In contrast, low-level language such as Java, C, C++, C# , or, systems such as OpenGL and Game Engines, or application programing systems such as Cocoa (API) and X Window System, all require professional programers with years of experience to create even the most simple visualization. These are not useful to most scientists or engineers.

The system must have a set of basic primitives or shapes that serve as building blocks. For example, spheres, torus, cubes, as well as meshes of triangles. Also, more complicated surface such as parametric surfaces and algebraic surfaces. (⁖ all these primitives are supported by the 3D-modeler and rendering engine POV-Ray.)

The system should support various standard coordinates systems (cartesian, polar, spherical, cylindrical), projection systems (central, parallel, panaramic for global, and stereographic, cylindrical, etc for local or per object dimensional change), lighting system (multiple light sources, full color control, shadowing) and camera control system. (Most items here are supported by POV-Ray.)

The system should have built-in support for dimensions higher than 3. It should have buildin facilities to easily project or slice a higher-dimensional object into 3D object. (⁖ as demonstrated by Mark Newbold's Hyperstar Java Applet for visualizing higher dimensional Regular polytope.)

The system should also support non-euclidean models. (⁖ Supported by the visualization system JReality, and demonstrated by Jeff Week's 3-manifold fly-thru software CurvedSpaces)

A whole set of buildin 2D, 3D geometric transformation functions. (these should be general to work on n-dimensional coordinates)

For a system aimed for math visualization, it would also be necessary to have access to a full range of math functions, such as integration, derivative, so called elliptic functions and other special functions. (⁖ Mathematica)

[Continues on page 2]