Slashdot Mirror

No, you don't, although usually you're not worth suing unless you do make money. People who file patent infringement lawsuits care very, very much about how much money you make. Lawyers can calculate all the damages they want, and courts can award them, but somebody still has to collect, and if you don't have any money there's nothing to collect.

You can do things like distribute an implementation of a patented algorithm with the warning that it's patented and should be used in an infringing manner (you said this yourself!). VTK for example, has some patented components that you're free to use, with the warning that they are patented. You can download them, play with them, use them for research, do all kinds of things with them. You couldn't do that under your supposedly not-strange software writer gets sued system.

Gnuplot can do quite a lot too.

Now, Matplotlib, in Python, was designed to clone the MatLab plotting facilities. Then someone tied it into vtk..

Kitware was the company founded to support the Visualization Toolkit (VTK), an open source software system for data visualization. VTK has a huge C++ library as well as hooks for scripting for very rapid development. Who wouldn't want to build custom 3D views of their data?

I don't do 3D CAD, but being a biochemist type, I actually hang out with lots of folks that do work with all kinds of 3D data such as molecular models and volumetric MRI datasets. Workstation cards are especially useful for their stereo support, which many bio-folks find helpful when modelling. Most of the development is done on linux using stuff like VTK or VMD - its not just the engineering guys doing CAD in windows that want workstation cards.

As a scientist that uses linux daily for 3D applications, I would like to see an open source workstation card for 3D graphics, dangit.

Yet good stuff is emerging - see for example VTK for visualization or the OpenCascade library.

A few years back 3D visualization of math and physics was a pain in the neck, but these days you've got a change to poke at fairly simple APIs of free libraries that do an amazing job.

I agree CAD is tricky, but these examples tell me that we'll get there at some point.

I'm a plasma physicist and I work in the domain of radiofrequency waves propagation and absorption in fusion plasmas. I've been busy developping a code that solves the Maxwell's equations, which are equivalent to the wave equation (3-D full-wave calculation). The case of a plasma is tricky because it both time *and* space dispersive.
I won't be able to even start explaining this stuff in this post, but my code uses finite elements for the radial direction and Fourier decompositions for the two periodic directions of a fusion device. These numerical methods work well. I also know finite difference codes which work well. So, I think you should look a bit harder, because FE or FD methods usually do the trick, even for "variable wave speed at different points in the domain"... Regarding the boundary conditions, well, you'd better be very careful, because they will usually completely determine the solution. Again, it is my experience that Finite elements are well adapted to this task but you'll have to do some research.
Finally, for the vizualisation, matplotlib and vtk work for me.
First, try to determine and explain more precisely what it is you want to do: "to obtain good numerical approximations to the classic second-order wave equation, preferably in three space dimensions" sounds a but vague. Pick up the right textbooks, scientific journals, learn, exchange with the community. I know my post sounds a bit patronizing but this is science, and this kind of effort takes dedication, time and patience. I think Slashdot and Google are hardly the right places to start...

In what ways can you code plots of surface charts using a z(x,y) function or a cloud of points?

These are really two separate questions. Plotting a surface for z=f(x,y) requires evaluating the function over the domain and constructing a tesselated mesh with vertices at each point. Once you have the mesh, you need to render it, which involves issues like hidden surface removal, shading, perspective and so on. Not a small undertaking to write all that from scratch.

There are several algorithms for rendering clouds of points, depending on the nature of the data. First you have to cluster the points, then you have to mesh them, then render. It's not trivial by any stretch. Have a search through ACM SIGGRAPH for a few of the top algorithms.

I'm looking for a tutorial that explains this that doesn't use DirectX or OpenGL libraries (the language I'm using cannot use either framework anyway).

The vast majority of books that would cover this kind of thing will be either be: a) practically oriented and use OpenGL (or equivalent) for the rendering, or b) be highly theoretical and written in dense mathematics. It is unlikely that you will find a book that fits your description. The best you can probably hope for is to find an OpenGL book and abstract away the algorithms you need (after all, OpenGL is really just the lowest rendering stage).

(Now of course, one must ask the question: why are you restricting yourself to using a language or environment that is clearly not appropriate to solving the problem at hand?)

Others have suggested the classic Foley & Van Dam book, which is excellent and provides much useful material. But the one you really want is the Visualisation Toolkit book. It describes the algorithms and implementation behind VTK, and covers precisely the algorithms that your are asking about (clouds, surfaces, etc etc). VTK is implemented using OpenGL, but the book focuses on the algorithms, and includes comprehensive citations to the original papers where these algorithms are published. It is one of the best books available on Viz and 3D.

• The Visualization Toolkit: An Object-Oriented Approach To 3D Graphics, 3rd Edition - Softcover textbook, 520 pages, printed in full color, and comes with the VTK 4.4 CD (ISBN 1-930934-12-2)

(It can also be ordered from Amazon, but they're on backorder.)

Now go read it, and tell me you still want to re-implement all that yourself from scratch.

How is the 3D mess generated and how can the 2D contour plots be generated as well?

Contour plots involve yet another class of algorithm, producing isocurve from data cells. Others have mentioned marching cubes, there's also marching squares and a few others that are used. Note that marching cubes is patented, so you need a license for commercial use! (Others who blindly suggested this might also want to take note.)

I'm assuming once I know that I can also use it to make torus plots as well.

I wouldn't. What the hell is a torus plot?

Remember, I'm asking for the explanation of the underlying math and an example code that does that. The GNUPlot gallery has some examples that I find helpful, but are there similar examples out there? (Remember, I am writing the plotting code as well)? Can anyone help or point me in the right direction?"

The VTK book will provide all the maths and algorithms you require, if you insist on going forward and reimplimenting all this yourself. But why? Methinks you are drastically underestimating the complexity of the task you are asking. Especially if you aren't already experienced in the areas of 3D rendering, vectors, linear algebra, (and it appears you are not) you are going to be climbing a massive

VTK has also spawned off two other opensource projects, DART and Cmake.

OpenDX ( http://www.opendx.org/ ) is very powerful, and unlike VTK, it has free documentation.

VTK simply encourages you to buy their books - the books are in no way necessary to use VTK. They have quite comprehensive documentation which can be found online, downloaded as a tarball, or as compressed html, or if you like, generated from the source download via Doxygen.

If you want a less technical introduction, or a lon detailed explanation of how the 3D moelling technology works then the User's Guide or VTK Textbook may come in handy, but to claim they are charging to documentation is to say that Perl charges for documentation via the O'Reilly books. It is entirely optional, and a wealth of detailed tecnical documentation is already available for free.

I have used both OpenDX and VTK. It didn't take me long to see the clear benefits of VTK. Knowledge of any of C++, Java, Python, or Tcl will see you producing stuff in VTK very quickly and the variety and power of the libraries are far in advance of what OpenDX offers.

Jedidiah.

If you take a look at ParaView, a project built on top of VTK by Kitware, you might notice that Kitware is funded by ASCI. And what is ASCI? It is a cooperative program spread across Sandia, Lawrence Livermore, and Los Alamos National Labs. The labs do indeed fund a good bit of open-source software.

Hell, why stop there? VTK and MayaVi are also pretty amazing visualization kits, both of which are either written in or provide python bindings. (MayaVi is built on VTK, but it provides a nice wrapper.) VTK has great isosurface locaters and some pretty awesome vector algorithms for looking at 2d and 3d data. We use it for physical applications at my work...

Where are the new 'Pro' features.

I know that programmable pixel shaders etc. are useful, but why does OpenGL not specify things like raytraced and radiosity lighting models, along with voxel primitives, and features for window and page oriented output of arbitary geometry (including support for true curves/surfaces etc.) ala Postscript.

Voxel primitives are there: 3D textures.

Radiosity and raytracing are difficult to put in hardware because they would require you to have a full description of the scene in memory. This flies agains a fundamental assumption of OpenGL that geometry may be streamed to the video card -- keep the state small. A scene description language that performs radiosity calculations should be a layer on top of OpenGL, not subsumed into it. OpenGL's design intent has always been "Provide a wafer-thin layer of sanity over the graphics hardware so that people can make things go really fast." It has never been "Make programming graphics easy." Making graphics programming easy is the job of other layers such as Crystal Space (games) or VTK (visualization).