Geometry: Requirements for a Visualization System for 2020

, ,

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.

Requirement: Real-Time 3D Rotation

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.

Chen Gackstatter minimal surface
The Chen Gackstatter minimal surface as shown by the software 3D-XplorMath. This surface has several axes 3-fold symmetries, but a static image does not show this. (interactive rotation with Java Applet)

Requirement: Real-time Interactivity

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.

Example: Moebius Transformation

moebApplet
A software that plots a complex valued function (the Moebius transformation ), by showing the pre-image and post-image of the function. The function is keyed by various parameters that can be represented as points in the plane. Dragging these points will change the image interactively. (Source: MoeApplet by Paul Murray.)

Example: Regular Polytopes

hyperspace star
A Java applet showing a slice of 4-dimensional symmetric polytope , with sliders that change the polytope's parameters in real-time. Dragging the polytope will rotate it in real-time. (Source: Hyperstar Java Applet by Mark Newbold)

Example: Plane Geometry

geometer's sketch pad
A interactive plane geometry software showing a Equiangular Spiral, and its inverse curve with respect to a point O. Equiangular spiral is a family of curves varying by a parameter θ, from 0 to π/2. This parameter can be changed by dragging the point E of the angle DAE, and the corresponding curve will be shown (blue). Its inverse curve with respect to the point O is shown in pink. Dragging the point O will change the position of O, and corresponding inverse curve will be shown. All changes happens in real-time as the user drags the control points. (See interactive GeoGebra Java Applet: equiangular spiral.)

Example: Conic Sections

ball shadow
Hyperbola and ellipse as shadows of a sphere, renderd with POV-Ray. Ideally, one would like to interactively manipulate position of the light source (the red and blue dots), or roll the ball, and see the shadow change in real-time.
conicsHypCut3D
A 3D illustration of a double cone cut to form a hyperbola. The sphere inside is called Dandelin sphere. It is the largest sphere that fits inside. It has the property that it touches the cutting plane at the focus of the curve, and the plane formed by the sphere and the cone intersects the cutting plane at the directrix of the curve.
conics
Planar view of the conics section family of curves.

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)

Requirement: Easy-to-create, Real-Time Animation

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 jet airplane air show.

Example: Cycloidal Curves

cycloidGen
A movie generated by Mathematica, showing how the cycloid curve is generated by rolling a circle. cycloidGen.mov

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.

Example: Cellular Automaton

lifelab
A software that computes the cellular automaton known as Game Of Life, showing it as a animation as it evolves. At any point in time, a user can add more cells to it by clicking in the window, and continue the animation to see its effects. For video, see Conway's Game of Life Recursively Defined.

Example: Helicoid-catenoid Surface Family

helicoid-catenoid twist4
A frame of a software generated animation, showing the isometry property of the surface family helicoid-catenoid.

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

Example: Sphere-eversion

sphere eversion
The classic Sphere-eversion visualization problem, visually demonstrating how a sphere can be turned inside-out without creating any crease. (Source: John M Sullivan img src) (For detail about this problem, see: Smale's paradox)

Example: Stereographic Projection

sphere proj illus
A illustration showing Stereographic Projection.

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.

Requirement: 3D Walk-thru

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.

Example: Walking on Surfaces

hyperbolic paraboloid
A hyperbolic-paraboloid, with a human character standing on top of it. (A hyperbolic-poraboloid demonstrates a ruled surface. Namely, the surface is entirely made of (straight) lines.) (from the computer graphics virtual world Second Life. Credit: Henry Segerman, aka Seifert Surface.)

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

hyperbolic-paraboloid
A abstract rendering of the hyperbolic-paraboloid. Java Applet

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.

Example: 3D-Lattices

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.

karcher je st-s scherk-s scherk w handle-s schwarz h family-s lidinoid-s gyroid-s
Periodic minimal surfaces. Source: Richard Palais, Karcher Hermann.

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.

Example: 3-Manifolds

curved space mac
Screenshot of Jeff Week's Curved Space software. This program lets users fly-thru various 3-manifolds. There is basically no other way of visualizing 3-manifolds other than the techniques of walk-thru.

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)

Requirement: Easy to Use for Average Programers

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.

Requirement: Rich Buildin Set of Primitives

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]

blog comments powered by Disqus