A fast approch to OpenDX
OpenDX is a powerfull (very powerfull) program to visualize 2-3D data.
In the opensource community, it is the equivalent of "grace" (or xmgrace) for 1D data.
I was extremely frustrated the first time I tried to use it because of the way the
documentation was written (no offense intended : I am gratefull !). As it is the custom
in the open source, if you're not happy with what you get, instead of complaining to people who owe
you nothing, do it yourself. And so, this is why you're reading these lines.
If you use grace for 1D data (i.e. y=f(x) ), you know how easy it is to get started. Just put some two
columns formated data in a text file, say "test.dat", and then at the prompt,
$ xmgrace test.dat
and you have a mgnificent graph in a nice window before your eyes ! You can do much
better later by playing around menus and reading the manual, but hey, at least
you have something.
Well, OpenDX does not seem so simple : you have the visual editor, the data model,
the transformators and animators and renderers and executions, ... where to start ?
The point of what I am writing is to show you that in fact, OpenDX is as simple
as grace, and you can get your data displayed in seconds. Once you get the basics,
you can spend hours learning all the power of dx.
Let's generate some data.
dx knows about a lot of sophisticated data format like HDF and CDF. I don't know about you,
but I don't use these formats. I have rather arrays of data (in ascii or binary) like
2 4 6
3.1 3 5.5
1 4.4 2
let's generate some bigger array. The C program enclosed here generates the function
z=sin(6*Pi*(x^2+y^2)) for x and y between -0.5 and 0.5 on a 100x100 grid. Compile the program
$ gcc -o generate generate1.c -lm (Comment/Explanation)
$ generate > test1.data (Comment/Explanation)
Now you have in the ascii file "test1.dat" your 100x100 z data. If you don't like C, generate the
file with whatever you have at hand : scilab, text editor(tedious!), mathlab,pascal ...
Getting the picture
dx can read your data in (nearly) all formats. Just describe your data to it by
You get the following window:
Put the name of your file ("test1.dat") in the "data file name" box and check the "Grid or Scattered file" box
(your data is an evenly spaced grid). Your window enlarges to:
You get to describe your data by pushing the "describe data" button. A new and bigger window appears where you
can put all the details about the way your data is organized :
Your data here is simple enough and you don't have to give much details. The file name box is automatically
filled ; The ascii menu is already chosen for "data format" ; the order doesn't really matter here. Just fill the
Grid size boxes by putting 100 and 100 in it. Save the file as "test1.general" under the file menu. We'll get
to this "test1.general" in a moment, but let's mention that it is a plain ascii file describing your data. Dx
refers to this text file to read your data.
Now, close the description window and get back to the original data prompter window.
As you can observe, the "visualize data"
button is now active, so just push it. The graph appears in a new window :
You can rotate the axes by dragging the mouse on the picture :
The Dx has chosen three diffrent kind of information to display :
z-values are shown by both height and color code ; the countour curves (iso-z) are supperposed to
the graph. You can explore the menus to zoom, navigate, rotate, change the color code,... Have fun.
A little more elaborate data
2 or 3D data are voluminous and seldom put in ascii files. Very often, they are in a binary format
preceded by an N bytes header giving all kinds of useful information.
The "generate2.c" program enclosed here produce the same data as before,
but put them
in a binary format, preceded by 4100 bytes of information. By compiling and executing the program
$ gcc -o generate generate2.c -lm
you get the test2.dat binary file described above. The data are in "double" format, which on my computer
takes 8 bytes. The total file size is thus 100x100x8 + 4100 = 84100. Launching the data prompter
$ dx -prompter
filling the "file name" box and pushing the "describe data" button get you again to the description window.
This time, you have to give more informations :
Saving the file under test2.general, closing the window and pushing the now active "visualize data" button
give you the same image you had before.
- The header box has to be checked and #bytes put to 4100. That's the number of bytes dx will
skip when reading the file.
- Grid size is put as usual to 100,100
- Data format is put to Binary(IEEE) with the "Least significant bytes first" option (on my computer)
- Data order is put to Column (here the data are symetric and it does not matter,
but in general, the order is critical)
- The "type" (on the right) is put to double. Again, that's critical and dx has to know
how many bytes it has to read per item.
- you can give whatever name you want to the field (z here)
- Don't forget to push the modify button to update the type change (dx is a little awkward here).
Who needs the data prompter ?
Let's have a closer look at the "test1.general" file:
file = /home/bahram/web/OpenDX/test1.dat
grid = 100 x 100
format = ascii
interleaving = record
majority = row
field = field0
structure = scalar
type = float
dependency = positions
positions = regular, regular, 0, 1, 0, 1
That's a pretty "human" language to describe the data : the first line says where the actual data are, the second
gives the grid size and so on. This is the kind of file we can produce easily with a text editor. So,
quit all the "dx"es you have running. We'll suppose from now on that you possess a header file like the one
above which describes your data file. When you pushed on the "visualize data" button, the data prompter
in fact launched the "real" dx. Let us do it directly:
$ dx -edit
This command gives you the "visual editor" window : a blank canvas on the right side and many
(many many ...) items to choose from on the left side. Click on something on the left side,
then click somewhere on the right side and you deposit the object on the canvas. Here, we have
put three objects on the canvas :
We have connected the ouput of "import" to the input of "Autocolor", and the output of this last one to
the input of image. To connect objects, just drag the mouse from one output to an input.
- The first item is "import" from the "Import and Export" menu on the left side.
This is to open and read the data file.
- The last item is "image" from the "Rendering" menu. This is obviously to produce an image
of the data.
- The middle item here is "Autocolor" from "Transformation" menu. This is to tell the program
which kind of information we need on the image. "Autocolor" associates colors to values, from blue to
red as usual (of course, as everything in dx, this can be customized).
We have to tell "import" where to import from. Double click on it, check the "name" box, fill
the form with "test1.general" and click OK.
Now, from the menu "Execute", choose "Execute Once".
Import will first read test1.general, learn how to read the real data
in "test1.dat", read it and pass the information to "AutoColor". Autocolor
will massage the data, produce colors accordingly and pass them to "image". This
last one will display these colors on the screen :
The connected items you have on your canvas are called, in the IBM language, a "program". You can save
them with .net extensions and call them directly from the prompt
$ dx -edit simple.net
if simple.net is the name you have choosed.
Change the middle object from "AutoColor" to "Transformation->AutoGrayScale" or "Realization->Isosurface"
or "Realization->RubberSheet" to see some of the possibilities ( you have to "Execute->Ececute Once" each
time to obtain the result.
A nice enough image of our data such as this
is obtained by this program
- The data from "import" are first sent to "RubberSheet". This module converts the data you have to
- "RubberSheet" output is sent to AutoColor which as we said, associates color to values.
- A copie of the "RubberSheet" output is sent to "IsoSurface". We have done a branching here.
- The outputs of "Autocolor" and "IsoSurface" are merged together with "Collect" and
sent to "Image".
- Last thing, by modifying the options in the "Options" menu, we have turned on the axes and done
some rotation for aesthetical purposes.
What's next ?
OpenDx can do much more than visualizing scalar data defined on a regular grid. The grid can be curvilinear,
deformed or poorly defined, the data can have more than one dimension,... Think of visualising the deformation field
of an engine complex part.
To go beyond this short introduction, You're on your own. The best sources of information are the manuals (quickstart, user's guide, reference manual )
the product, or downloadable at the official web site.
As a last thought, I think we can be gratefull to IBM. Whatever the reasons behind opensourcing DX
(stabbing MS by pushing linux, too expensive to maintain,...) the product is just great. And then many
thanks to the openpeople who continue to maintain and develop the Data eXplorer.
Up : various documents, mostly my lectures.
Next : Transifinite numbers (french)