graph
sys
tool
lib
analyze
format
|
|
These packages are integrated graphics and visualization
systems. They are distinguished from the separately listed
graphics
toolkits
and libraries
in that all have some sort
of user interface (usually graphical) that allow them to
be used interactively. They are usually built on top of
toolkits and/or libraries and most likely started out as
one or the other.
Last updated and checked on Mar. 23, 2004, only seven years
after the previous update on Aug. 17, 1997.
Note: This, although still available, has been succeeded by
Grace.
A general 2-D plotting package for UNIX workstations
with a Motif GUI interface.
This package, also known as xmgr and xvgr, was created and
is maintained by Paul Turner. There is a mailing list to which
users can submit questions or suggestions.
The features include a point and click Motif interface, the
capability of plotting up to 10 graphics with 30 data sets
per graph, data reading from files or pipes, support for
reading 1-D variables from
NetCDF files,
several axis combinations (e.g. XY, log-linear, log-log, linear-log,
bar, and stacked bar charts), error bars, a block data feature,
continuous display of the location of the pointer, user-defined
scaling, tick marks, labels, symbols, colors, etc., graph legends,
annotative text, operations on data sets, region operations,
mouse-powered
point editing, a batch mode, several math operations, pan, zoom, shrink,
expand, a command line interpreter, output suport for PostScript, HPGL,
and Framemaker, and more.
The source code is available as well as binaries for Linux and Sun
platforms. There is no user's manual although it's fairly easy to
learn how to use this package.
[
http://plasma-gate.weizmann.ac.il/Xmgr/]
Blender is the first and only fully integrated 3D graphics creation suite
allowing modeling, animation, rendering, post-production, realtime interactive
3D and game creation and playback with cross-platform compatibility.
[
http://www.blender3d.org/]
Climate Data Analysis Tools (CDAT) is a software infrastructure that uses an object-oriented scripting language to link together separate software subsystems and packages thus forming an integrated environment for solving model diagnosis problems. The power of the system comes from Python and its ability to seamlessly interconnect software. Python provides a general purpose and full-featured scripting language with a variety of user interfaces including command-line interaction, stand-alone scripts (applications) and graphical user interfaces (GUI). The CDAT subsystems, implemented as modules, provide access to and management of gridded data (Climate Data Management System or CDMS); large-array numerical operations (Numerical Python); and visualization (Visualization and Control System or VCS).
One of the most difficult challenges facing climate researchers today is the cataloging and analysis of massive amounts of multi-dimensional global atmospheric and oceanic model data. To reduce the labor intensive and time-consuming process of data management, retrieval, and analysis, PCMDI and other DOE sites have come together to develop intelligent filing system and data management software for the linking of storage devices located throughout the United States and the international climate research community. This effort, headed by PCMDI, NCAR, and ANL will allow users anywhere to remotely access this distributed multi-petabyte archive and perform analysis. PCMDI's CDAT is an innovative system that supports exploration and visualization of climate scientific datasets. As an "open system", the software sub-systems (i.e., modules) are independent and freely available to the global climate community. CDAT is easily extended to include new modules and as a result of its flexibility, PCMDI has integrated other popular software components, such as: the popular Live Access Server (LAS) and the Distributed Oceanographic Data System (DODS). Together with ANL's Globus middleware software, CDAT's focus is to allow climate researchers the ability to access and analyze multi-dimensional distributed climate datasets.
[
http://esg.llnl.gov/cdat/]
ChomboVis is a program for visualization of 2D and 3D AMR data sets. It is layered on top of the Visualization Toolkit (VTK) and provides a graphical and programmable user interface for interacting with the data set.
[
http://seesar.lbl.gov/anag/chombo/chombovis.html]
CViz is a visualization tool designed for analyzing high-dimensional data (data with many elements) in large, complex data sets. CViz easily loads the data sets, displays the most important factors relating clusters of records, and provides full-motion visualization of the inherent data clusters.
[
http://www.alphaworks.ibm.com/formula/CViz]
This is a powerful, flexible
scientific, engineering, statistics, mathematics and graphics system.
It is an interactive, command-driven language/system with
English-like syntax developed at the National Institute of
Standards and Technology in response to data analysis problems.
An early version of a graphical user interface is available as
of July 1995 that requires both the
Tcl/Tk and
Expect packages.
The capabilities include raw graphics (e.g. 2-D, 3-D, contour and color
plots), analysis graphics (e.g. plotting data and functions, mixing
data and functions, etc.), presentation graphics (e.g. Hershey fonts,
Greek symbols, PostScript output, etc.), summary graphics (e.g. pie
charts, histograms, error bar plots, X-Y plots, etc.), diagrammatic
graphics, graphical data analysis (e.g. scatter plots, probability
plots, etc.), exploratory data analysis (e.g. box plots, robust
smoothing, linear/polynomial/nonlinear fitting, general
transformations, bootstrap plots, etc.), time series analysis (e.g.
lag plots, autocorrelation plots, spectral plots, Fourier plots,
etc.), smoothing, fitting, statistics and probability calculations,
multivariate analysis, experiment design, a large number of
math functions, and much more.
Further details about the
DATAPLOT specific capabilities are available.
The source code is available as well as binaries for Convex, Dec Alpha,
HP-9000, IBM RS6000, SGI and Sun platforms. It should install on
other UNIX platforms with a Fortran compiler and a C compiler, the
latter being necessary for X11 support. There is also a source
code only C version of the program created by running the Fortran
source code through the f2c program.
The documentation is
contained in several TeX files, including files describing
new features, the command set, and several help files.
This package is a whopping load of Fortran code,
which compiled on the first attempt on an Ultrix box but died
during the linking stage for reason(s) I've yet to ascertain, although
I suspect the large size might play some role.
[http://www.itl.nist.gov/div898/software/dataplot.html/]
An interactive visualization environment that allows the user
to interact with numerical or simulation data.
In this environment the user can interactively allocate memory
for the data, manipulate and display it. These tasks can also
be specified in an executable command file. The results can
be displayed in an X Windows screen or used to create a
PostScript file.
Features include support of multiple windows and displays, black and
white and color screen support, a C language-like programming
syntax, support for multi-dimensional variables in memory and disk
in multiple formats and of different types, automatic conversion from
one variable type to another, a large set of built-in mathematical
functions, a large library of display routines (e.g. X-Y plots,
2-D contour plots and images, 3-D display of 2-D data rrays with
hidden line removal, etc.), interactive graphics animations with
movie-like capabilities, an interactive graphics editor, an
interactive diagnostics system, interactive feature tracking,
and interactive color map editor, and an interactive threshold
changer.
It is written in C to run on UNIX systems under X Windows using
the Athena widget set and other standard X11 libraries.
There are binaries for SGI, SUN, DEC Alpha, IBM and HP platforms,
and the source code is also available. The package is documented
in a 113-page PostScript user's manual.
[
http://www.caip.rutgers.edu/vizlab_group_files/RESEARCH/VISIOMETRICS/DAVID/]
DEVise (Data Exploration and Visualization) is a data exploration system that allows users to easily develop, browse, and share visual presentations of large tabular datasets (possibly containing or referencing multimedia objects) from several sources.
Our emphasis is on developing an intuitive yet powerful set of querying and visualization primitives that can be easily combined to develop a rich set of visual presentations that integrate data from a wide range of application domains.
[
http://www.cs.wisc.edu/~devise/devise.html]
A computational environment the provides a tool for exploring
dynamical systems. It integrates a GUI, data management,
a set of numerical algorithms with a capability of adding
more, and the capability of communicating with other
programs. It was developed for the X Window system and
the original port was to Sun platforms, although it supposedly
can be ported to any platform for which a port of the
XView library
has been made, a list of which is available in the
indicated directory.
[
http://www.lorentz.leidenuniv.nl/~patra/dstool/]
A workstation-based visualization and analysis environment
designed to meet the needs of physical scientists studying global
ocean-climate interactions. It provides a high-automated,
flexible, end-to-end environment in which large and complex
gridded data sets can be easily probed. Ferret provides the
user with a choice of three interfaces: a command-line interface
with an extensive command language, a point-and-click X Windows
interface, and a Web interface that allows remote users to
access data over an Internet connection. An interactive
demonstration of the
Ferret Web interface is available.
Ferret graphics capabilities include a range of 1-D and 2-D
plot types, e.g. contour plots (outline and color filled), rasters
(images), line plots, scatter plots, mesh diagrams
for limited 3-D visualization. It can also create animations,
although other packages are needed to view them.
All graphics are automatically
labeled using information from the self-describing data sets
it uses. Most graph attributes (layout, labels, color palettes, etc.)
can be modified. The self-describing data format used by Ferret
is NetCDF, and it can
also ingest ASCII and binary floating point files (as well as
output in all three formats and therefore function as a
translator).
Many powerful analysis features are available in Ferret.
A collection of basic transformations (i.e. filters) including
derivatives integrals, statistics, smoothers, etc. is
available and all can be applied symetrically along any axis
of a variable. Variables can be combined in mathematical
expressions using built-in operators and functions.
A very nice feature is the ability to unify data sets defined
on different grids, thus allowing data from a variety of sources
to be merged for analysis and visualization.
Ferret is available only in binary form for DEC Alpha and MIPS,
Sun SunOS and Solaris, IBM RS6000, SGI IRIX, and HP-UX platforms.
The source code of the Web interface is available separately
and as of 3/96 the X Windows interface was still in the
prototype stage. A user's guide is available in either
PostScript or plain text form as well as release notes for
various versions.
[http://www.ferret.noaa.gov/Ferret/]
Fityk is a general-purpose nonlinear curve fitting and data analysis software.
Although it is being developed to analyze powder diffraction patterns, it can be used to fit analytical functions to any kind of data: crystallographic module is an independent part of the program.
At present fityk knows only about common peak-shaped functions (Gaussian, Lorentzian, Voigt, Pearson VII etc.) but more sophisticated formulae can be easily added if necessary.
In terms of powder diffraction fityk will fit the data with a set of position-correlated peaks to give the refined lattice parameters, zero-shift, sample displacement and wavelength.
Fityk offers everything a decent refinement program should offer but first of all intuitive graphical interface. Apart from the standard Marquardt least-square algorithm one may choose a genetic algorithm or Nelder-Mead simplex method for complex or unstable cases.
Fityk already works under Linux, Windows and MacOS X and can in principle be ported to other systems because it's GUI is written with a portable wxWindows library.
[
http://www.unipress.waw.pl/~wojdyr/fityk/]
Flounder is a quick way to visualize regularly spaced 4D data, i.e., a data set that is a function of x, y, z, and time.
The features include:
- animation;
- 4-D display;
- display of multiple files linked by time;
- 2-D slices along principal axes;
- adjustable color scales and quantization levels;
- contour plots;
- isosurfaces;
- 3-D surface rendering and solid rendering;
- saving images as GIF, PNG or EPS;
- saving movies as animated GIF or AVI;
- displaying time series at spatial locations with zoom;
- vertical and horizontal profiles; and
- tableau plots.
[
http://www.enel.ucalgary.ca/~vigmond/flounder/index.html]
A mathematical visualization system that provides a
purely functional, collection-oriented language with
symbolic differentiation and optimization. You can type
in a parametric equation and see the resulting curve or
surface. The source code is available as is a manual
in PostScript format.
[
http://draves.org/fnord/fnord.html]
FreeWRL is an open-source(R) VRML and X3D browser written by a merry band of developers, who wish to produce a high quality, up to date, browser that is in the public domain.
It is written for Unix/Linux and Mac OS/X workstations and while the primary goal of some of the developers is to enable Shared Virtual Worlds, other developers want it to look good, too. So, while the rendering is great, the control of FreeWRL is fantastic. FreeWRL supports Javascript, Java Class invocation, and the EAI version 1 spec. You can control the scene by the mouse, keyboard, joystick, motion sensors, or just about anything you care to patch in.
[
http://freewrl.sourceforge.net/]
An interactive program for viewing and manipulating geometric
objects. It can be used as a standalone viewer for static objects or
as a display engine for other programs which produce dynamically
changing geometry.
As a standalone viewer it can be used to see and manipulate
objects described in a wide variety of file formats.
As a display engine is can handle data coming from another program
that is running simultaneously; as the other program changes the
data the Geomview image dynamically reflects the changes.
Such external programs are called external modules.
Geomview allows multiple independently controllable objects and
cameras. It provides interactive control for motion, appearances
(including lighting, shading, and materials), picking on an
object, edge or vertex level, snapshots in SGI image file or
Renderman RIB format, and adding or deleting objects is provided
via direct mouse manipulation, control panels, and keyboard shortcuts.
It supports several simple data types including polyhedra with shared
vertices, quadrilaterals, rectangular meshes, vectors, and Bezier
surface patches of arbitrary degree including rational patches.
Object hierarchies can be constructed with lists of objects and
instances of objects transformed by one or many 4x4 matrices, and
arbitrary portions of changing hierarchies can be transmitted
by creating named references. Geomview can also display 3-D
graphics output from Mathematica and Maple.
Geomview is available as source code or in binary format for
SGI IRIX, Sun Solaris and SunOS, Linux ELF (Intel),
HP, IBM RS/6000, DEC Alpha, and NeXT platforms.
The source code can be compiled on generic UNIX platforms
with the X Window System,
Motif, and an ANSI C compiler.
The 140+ page manual is available in either HTML or
PostScript format.
[http://www.geomview.org/]
A 3-D GIS for geology and geophysics.
Geotouch is a program for exploratory data analysis in 3-- and 4--D, whose
most significant features is interactive communication between diverse
datasets.
The primary kinds of data handles include point, vector, raster
and wireframe datasets, in addition to specialized forms such as focal
mechanisms and ellipsoidal information.
Geotouch is designed to be fast, so that it can be run with the minimum number of input parameters. There are no memory limitations, other than the limitations imposed by the local operating system. The program accepts, either on the command line or via menu driven dialogue boxes, names of files containing geographic objects and other parameters, which describe the database. The main window is a map view showing objects projected on the horizontal surface (Figure 1). Subsidiary windows include cross sections and spin windows. The investigator can access attributes of the databases by selecting the objects and requesting information.
This used to be called Xmap8.
http://www.unc.edu/~leesj/Geotouch/
GeoVISTA Studio is an open software development environment designed for geospatial data. Studio is a programming-free environment that allows users to quickly build applications for geocomputation and geographic visualization.
Studio Includes Interactive Query Devices for Exploratory GeoVisualization, 3D Render for complex and sophisticated 3D graphics, 2D mapping and statistical tools.
Studio provides a:
- Visual Programming-Free Environment for rapid development.
- Component-Oriented Programming: uses JavaBeans as programming components. Any JavaBeans (developed by 3rd parties) can be plugged in!
- Recursive Development turns a developed application into a JavaBean component. Developed components (applications) are reusable (scalable), and developed components can be shared by other Studio users and/or java programmers.
[
http://www.geovistastudio.psu.edu/jsp/index.jsp]
A high quality graphics package for scientists. It combines
a user friendly interface with a full range of facilities for
producing publication quality graphs, diagrams, posters and
slides, and allows the user to modify every feature down to
the smallest details using a large set of graphics primitives.
The graphics primitives are combined into graph modules, i.e.
collections of commands that specify various features of the
graph, e.g. annotations, tic marks, legends, line widths,
axis labels, as well as what kind of graph to draw and how
and where to read the data. The graphs can be created in
black and white and in color. There are also utilities for
fitting equations to experimental data and general data
manipulation. Quasi 3-D surface plots can be made using
a wire frame with hidden line removal. Output
devices supported include VT100, 125 and 250, TEK4010,
X Windows, PostScript, HPGL, EPSON, and HP Deskjet.
Several examples are included with the package that can
be used as templates.
The source code for GLE is available as well as binaries for
DECstation, SUN, VMS, PC, OS2, and Linux platforms.
Documentation is supplied in a 150+ page combination tutorial
and user's manual in PostScript format which includes many
examples. This package was last updated in 1995.
[http://sunsite.unc.edu/pub/Linux/science/visualization/]
The Graphics Language
Interpreter is a complete
graphics system offering an environment for plotting complex
data sets and displaying images. It combines powerful interfaces,
flexible graphics utilities, and an extensive set of programming
tools to provide a complete solution for data analysis and
scientific visualization.
The components of the GLI system are:
- GLI, a command line interpreter that accepts simple
statements from the GLI, GUS and GKS command languages which allow
data to be read, manipulated and plotted by sophisticated 2-- and
3--D plotting utilities;
- GLI/TCL, which provides full support for all
Tcl/Tk comands and widgets;
- GLI/SIMPLEPLOT, which provides a command--driven environment
for signal processing;
- GLI/SIGHT, the Simple Interactive Graphics Handling Tool is
a high--level graphics editor with a point--and--click interface for
the creation, editing and publishing of 2--D graphs and freehand drawings;
- GLI/IMAGE, a complete system for processing and displaying
color and grayscale images based on the PBM format provided as a GUI
point--and--click interface;
- GLI/GUS, the Graphics Utility System offers many high--level
graphics utilities and data handling commands, e.g. 2-- and 3--D line
graphs, scatter diagrams, bar and pie charts, contours, histograms,
3--D surfaces, data filters, linear and logarithmic transformations, and
automatic text generation;
- GLI/GKS, an implementation of GKS level 0a
with minimal segment functionality which supports most popular graphics
devices including X displays and PostScript; and
- GLI/CGMVIEW, which displays CGM files generated on any
computer system and can also print CGM files to any device supported
by GLI/GKS.
A source code distribution of GLI is available which is said to
work on several platforms including Linux Intel.
A manual is available in PostScript format, although I think it
is written in German. More later as I attempt to compile and
use the thing (12/98).
[
http://iffwww.iff.kfa-juelich.de/gli/]
The General Mesh
Viewer is a 3-D scientific visualization
tool designed to view simulation data from any type of structured
or unstructured mesh. The features include reading and displaying
any cell geometry, displaying nodes, cells, surfaces and
particle tracers, interpolation of grid data, isolating a cell
or groups of cells for closer analysis, a wide variety of
animation options, a flight mode for interactive fly-throughs
of the simulation, an intuitive and well-behaved interface, and
more. It is currently available (5/96) in beta test versions
in binary form for SGI, Sun, IBM and HP platforms. Documentation
is available in HTML and PostScript formats.
[http://www-xdiv.lanl.gov/XCM/gmv/GMVHome.html]
A command-line driven interactive function plotting utility for
UNIX, DOS and VMS platforms. It handles both curves (2-D) and
surfaces (3-D), with surfaces plotted as a mesh fitting the
specified function, floating in the 3-D coordinate space, or
as a contour plot on the x-y plane. There are many plot styles
for 2-D plots. Gnuplot supports many different types of terminals
and printers, and is most likely easier to install than anything
here, even from source code.
[http://www.gnuplot.info/]
Grace is a WYSIWYG 2D plotting tool for the X Window System and M*tif.
Grace runs on practically any version of Unix-like OS.
Its capabilities are roughly similar to GUI-based programs like Sigmaplot
or Microcal Origin plus script-based tools like Gnuplot or Genplot. Its
strength lies in the fact that it combines the convenience of a graphical
user interface with the power of a scripting language which enables it
to do sophisticated calculations or perform automated tasks.
[
http://plasma-gate.weizmann.ac.il/Grace/]
An interactive tool
for the analysis and display of Earth science data. It provides
an integrated environment for access, manipulation, and display
of gridded data.
GrADS implements a 4-D data model, where the dimensions
are usually latitude, longitude, level and time, and each data set
is located within this 4-D space using a separate data description file.
Both gridded and station data may be described, and the gridded
data may be unevenly spaced. Intercomparison of separate data sets
is greatly facilitated by the 4-D data space model, which allows
disparate data to be graphically overlaid with correct spatial
and temporal matching.
Features of GrADS include direct support for both Gaussian and variable
resolution of ocean model grids, a command language with Fortran-like
expressions that can be run interactively or in batch mode,
a rich set of built-in functions and the capability of
adding new functions as external routines written in any programming
language, and a large variety of graphical output techniques.
Graphical output forms include line, bar, and scatter plots as well
as contour, shaded contour, streamline, wind vector, grid box, shaded
grid box, and station model plots. These plots can be viewed
interactively or output to either monochrome or color PostScript
files for printing. Almost all graph attributes can be modified
by the user or the reasonable and intuitive default values may
be used.
The scripting or command language can be used to develop user
interfaces where widgets are displayed and actions are performed
based on pointing and clicking.
It is available in binary form for all commonly available
UNIX workstations (including Linux) and for DOS platforms.
The documentation is available as either a 148-page
PostScript file or online as a hypertext document.
Reference cards for both GrADS commands and the scripting
language are also available as is a mailing list for
GrADS users.
[http://grads.iges.org/grads/head.html]
The Geographic Resources
Analysis Support
System is a raster- and vector-based
Geographic Information System (GIS), an image processing
sytem, and a graphics production system. It can serve
as an educational tool due to its ease of use via a simple
graphical user interface, and it can also be use as a research
tool due to the capability of extending and customizing it
via programs written in the native GRASS language
that call the available libraries. GRASS allows the quick
and easy analysis, storage, updating, modeling, and displaying
of landscape data.
GRASS contains over 40 programs to render images on both
interactive and hardcopy devices, over 60 raster manipulation
programs, over 30 vector manipulation programs, around
30 multi-spectral image processing and manipulation
programs, 16 data management programs, and more. There is
also an extensive library of user contributed programs.
The source code, written in ANSI C, is available as are
binaries for CDC, InterGraph, Linux, PC, SGI, and SUN4
platforms at the home site. Ports to other machines are also available at
scattered locations. Minimum requirements for this large package
are 8 Mb of RAM and 100+ Mb of free disk space. Documentation
is extensive and includes several user's and reference manuals
in both hypertext and PostScript format as well as several
tutorials scattered about on the Web.
[http://hgeo02.geog.uni-hannover.de/grass/]
Guppi is a GNOME-based framework for graphing and interactive data analysis.
[
http://www.gnome.org/projects/guppi/]
The Integrated Data Viewer (IDV) from Unidata is a Java(TM)-based software framework for analyzing and visualizing geoscience data. This IDV release includes a software library and a reference application made from that software. It uses the VisAD library for data models and for creating visualizations, and other Java-based utility packages.
The IDV "reference application" is a display and analysis software package with many of the standard 2-D data displays that other Unidata packages (e.g. GEMPAK and McIDAS) provide. It also provides 3-D views of the atmosphere and allows users to interactively slice, dice, and probe the data, creating cross-sections, profiles, animations and value read-outs of multi-dimensional data sets.
Computations using any data from IDV data sources are supported through built-in and user-supplied formulas and Jython language methods.
A feature unique to the IDV is an integrated HTML display that can be used to create HTML-based users' interfaces to control the IDV. You can also embed fully-interactive 2D and 3D IDV displays in HTML pages, when viewed with the IDV.
[
http://my.unidata.ucar.edu/content/software/IDV/index.html]
A drawing editor for creating figures for inclusion into
LaTeX documents which can also be used to prepare transparencies
or slides. Ipe drawings combine PostScript data with LaTeX
source code, both stored in the same file. It is also extensible,
allowing editing functions or geometric objects to be added by
the user. It is written in C++, runs under the X Window
system, and requires the Motif library. The source code is
available as well as binaries for SGI and Linux platforms.
A 50-page manual comes with the distribution, and an
online hypertext version is available.
[http://www.ibiblio.org/pub/Linux/apps/graphics/draw/]
A stand-alone 3D graphics tool driven by the command language
Tcl. It is an interactive version of a 3D graphics library called
ZICLIB, the capabilities of which include management of true or
pseudo colors, illumination modeling, shading, transparency, etc.
This can be used as a stand-alone package or can be driven from
Maple, Mathematica or Reduce. The source code is available as
well as a binary for Sun platforms. Compilation requires the
Tcl/Tk package. It can be found at the
Izic FTP site.
[http://www.inria.fr/safir/SAM/Izic/]
LCA Vision is free scientific visualization tool that started in 1998 as a remake of an older LCA program you may or may not know called 4D2. A complete remake of that program from scratch implemented with the open code/ open source C++ libraries, the visualization toolkit library(vtk, at http://www.kitware.com) and fast light (user interface) toolkit(fltk, at http://www.fltk.org), we have grown considerably in the time since.
The features of LCAVision include:
- simple and parallel isosurfacing
- fast and simple slicing
- contour line slicing
- carpet plotting, or elevation-mapped slicing
- threshold, or eroded "cutaway" slicing
- volumetric rendering with a configurable transparency map
- hedgehog vector visualization
- streamline vector visualization
- particle visualization
- adaptive mesh refinment (AMR) bounding box and basic
isosurfacing visualization
- coloring by colormamps, colors and datasets
- easy render window interaction, camera options, and a 3-D cursor
complete with coordinate and scalar values output at any picked position
- a WYSIWYG render window write to TIFF
- configurable coordinate axes
- remote visualization capabilities
[
http://zeus.ncsa.uiuc.edu/~miksa/LCAVision.html]
The Linked Windows Interactive Data System is a visual
data exploration system which has served as a testbed and
prototyping environment for a NASA/JPL program of research
into graphical methods for rapidly and interactively accessing,
displaying, and analyzing large multivariate multidisciplinary
datasets. It provides interactive 2-D and 3-D graphical data
displays, hardcopy output, interactive color manipulation,
animation creation and display, manipulation of data subsets,
journaling and macro capability, and network support for
collaborative research. At present it only runs on SGI
and Sun platforms.
[http://www.openchannelfoundation.org/projects/LinkWinds/]
A typesetting system that produces PostScript output.
This is sort of like but not equivalent to the TeX package
and its ancillaries. The reason it's listed here is that you
can fairly easily create simple graphics using the Lout package
and output these in PostScript form. You also might want to
check out its typesetting capabilities, which are just different
enough from those of TeX to make Lout interesting in its own
right.
[http://snark.ptc.spbu.ru/~uwe/lout/lout.html]
Alt: [USA]
MayaVi is a free, easy to use scientific data visualizer. It is written in Python and uses the amazing Visualization Toolkit (VTK) for the graphics. It provides a GUI written using Tkinter. MayaVi is free and distributed under the conditions of the BSD license. It is also cross platform and should run on any platform where both Python and VTK are available (which is almost any *nix, Mac OSX or Windows).
The features include:
- modules for visualizing computational grids and scalar, vector and tensor data;
- several data filters;
- volume visualization of data via texture and ray cast mappers;
- support for any VTK dataset;
- support for PLOT3D data;
- simultaneous use of multiple datasets;
- a pipeline browser;
- modular design;
- a lookup table editor; and
- a light manipulation kit.
[
http://mayavi.sourceforge.net/]
An interactive graphical analysis tool for visualizing and
analyzing data on 2D and 3D meshes. It is general purpose in
that it handles many different mesh types, provides many different
ways of viewing the data, and is virtually hardware/vendor
independent while still providing graphics at the speed of
the native graphics hardware. Plot types implemented include
material boundary plots, iso-contours, mesh plots, velocity
contour plots, 3D surface plots of 2D mesh data, and stereoscopic
viewing of any 3D image. Data operations supported include
reflection about any axis, orthogonal and arbitrary slicing of
3D data, material selection, index selection, and algebraic
and mathematical function manipulation of data. Mesh-TV uses
the SILO data storage
and retrieval library, which can be obtained separately.
At present (1/31/96) there is a
Mesh-TV Linux port
as well as
Mesh-TV binaries for IBM, HP and Sun workstations. A PostScript
manual is also available in the latter location.
[http://www.llnl.gov/bdiv/meshtv/]
A system that implements a picture-drawing language similar to
Metafont except that it outpus PostScript commands instead of
run-length-encoded bitmaps. It is a powerful language for producing
figures for documents to be printed on PostScript printers. It
provides easy access to all the features of PostScript and includes
facilities for integrating text and graphics.
TeX needs to be installed in order that this can be installed. The
MetaPost manual can be separately obtained as report #162
in the indicated directory although it is also contained within
the distribution package.
[http://cm.bell-labs.com/who/hobby/MetaPost.html]
Simulating, analyzing and understanding complex interactions of molecular systems requires computational methods that come from areas as diverse as computational Chemistry, Biology, Physics, Mathematics and Engeneering. One of the challenges in our daily work is the efficient use of this wide variety of, often rapidly evolving, computational methods used by our simulations.
Over the last few years we have investigated a new strategy for developing our simulation and analysis software. This new approach is based on the idea of using the interpreted language Python as the environment in which we develop independent and re-usable components to deal with different aspects of structural bioinformatics.
The MGLTools suite consists of:
- PMV, the Python Molecule Viewer;
- ADT, the AutoDock Toolkit; and
- ViPEr, the Visual Programming Environment.
ViPEr is a visual-programming environment in which a user can interactively build networks describing novel combinations of computational methods, and yielding new visualizations of their data without actually writing code. Nodes encapsulating specific computational methods are organized in libraries and displayed in ViPEr. The user can drag-and-drop them onto a canvas and connect their input and output ports to define an execution flow. Subnetworks can be encapsulated into macro nodes, allowing nesting of networks. Tooltips and balloon help provide runtime information about a node's function, inputs and outputs. Data flowing through nodes can be interactively monitored and introspected.
ViPEr comprises a set of standard nodes including an OpenGL 3D-visualization library. The SymServ library implements a set of nodes defining geometric transformations such as point symmetries, translation, rotation, helical arrangements etc. These nodes allow describing complex hierarchical symmetries such as icosahedral symmetry as tree-like structures. The MolKit library, which is based on our Python MolKit library, allows reading, writing, representing and querying molecular data structures. The Imaging library exposes the Python Image Library thus enabling image processing in ViPEr. Many more custom nodes have been written to date, including nodes to read electron density maps, to compute isocontour surfaces, to mapping textures onto geometry, to convert a 2-D image to 3-D heightfield, and node to converter molecular data into various 3-D file formats (VRML, STL). ViPEr has been successfully used to combine in 3-D electron microscopy and atomic fore microscopy data to build and refine models of supramolecular assemblies.
[
http://www.scripps.edu/~sanner/python/index.html]
A graphics package developed at the National Center for
Atmospheric Research. This package isn't free, but it's not terribly
expensive, either. Versions before 4.0 were libraries with some
applications, while 4.0+ versions have an interactive GUI.
It will install fairly easily on most UNIX
platforms.
[http://ngwww.ucar.edu/]
ncBrowse is a Java application that provides flexible, interactive graphical displays of data and attributes from a wide range of netCDF data file conventions.
The features include:
- 3D visualizations and
LAS data access;
- OPeNDAP support;
- variable mapping and animation;
- direct access of remote NetCDF files using the
HTTPClient library;
- works with arbitrary NetCDF files;
- browses files using the
EPIC and
COARDS conventions;
- provides a tree view of NetCDF files;
- handles dimensions without an associated variable;
- uses the SGT library
to perform 1- and 2-D cuts through data.
[
http://www.epic.noaa.gov/java/ncBrowse/]
This is an extended collaboration with the goal of creating a standard framework
that allows running, anaylsis and visualization of numerical simulations within a
common parallel environment: from N-body to the whole N-chilada!.
[
http://hpcc.astro.washington.edu/nchilada/bin/view/Nchilada/WebHome]
NDimViewer is a web-based visualization system for numerical approximation of dynamical systems and representation of the calculated data using the techniques mentioned above. It is specialized for high dimensional dynamical systems with a dimension count up to 25, depending on the chosen technique. The implementation itself is separated into a calculation and a visualization part, which are treated independently.
[
http://www.cg.tuwien.ac.at/research/vis/dynsys/NDimViewer/]
penDX is a uniquely powerful, full-featured software package for the
visualization of scientific, engineering and analytical data: Its open
system design is built on a standard interface environments. And its
sophisticated data model provides users with great flexibility in creating visualizations.
The GUI is built on the standard interface environment: OSF/Motif(tm) and X Window System(tm). The current version supports software-rendered images on 8-, 12-, 16-, 24-, and 32-bit windows.
The GUI has a wide variety of interactors, both direct and indirect. Direct interactors allow you to directly manipulate images (e.g. rotate or zoom). Indirect interactors (dials, switches, buttons, sliders) enable you to control various aspects of your visualization. Interactors are "smarter" because they're data-driven. Interactors are auto-ranging and self-limiting. They examine your data and, depending on its type, will determine the minimum and maximum of the data, or create a list for an option menu based on your data. You can even set the label of the interactor based on some aspect of your data (e.g., metadata).
The data-driven concept is not simply for sliders, dials and option menus. It also applies to vector interactors. These will reconfigure themselves based on the dimensionality of the data. They will also auto-range themselves based on the maximum and minimum of each vector component. Both the ColorMap Editor and the Sequencer are also data-driven.
OpenDX provides hundreds of functions. To make the system easier for you to use, these functions have been grouped into powerful, polymorphic modules. For example, "Compute" does the work of dozens of individual functions. It directly solves arbitrary algebraic and trigonometric equations, as well as recasts your data.
One of the most distinctive characteristics of OpenDX is its object-oriented, self-describing Data Model. Because it handles all your data input, regardless of source, in a uniform way, it allows individual modules to act appropriately. Moreover, OpenDX maintains the coordinate system throughout the realization and visualization steps. These are the reasons why correlating data from many sources is such a snap with OpenDX.
[
http://www.opendx.org/]
-
Data Explorer Tutorials
Although Data Explorer is an easy package to learn to use, tutorials have been created that let you quickly learn some of the basics. Although this tutorial was designed for users at Dalhousie Physical Oceanography, it was be useful to other DX users as well.
Panoply is a cross-platform Java application which interactively creates plots of globally gridded data contained within netCDF datasets. Features include:
- Plot global maps or zonal averages.
- Slice specific latitude-longitude arrays from multidimensional arrays which also have dimensions in altitude, time, etc.
- Select from more than 30 global map projections.
- Combine two arrays in one plot by differencing, summing or averaging.
- Draw continent outlines or masks on the plot.
- Open any PAL, ACT or CWC color table.
- Save plots to disk as PNG or GIF images.
[http://www.giss.nasa.gov/tools/panoply/]
An application designed with the need to visualize large data sets in mind.
ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++.
The features of ParaView include:
- Handles structured (uniform, non-uniform rectilinear grids as well as curvilinear grids), unstructured, polygonal and image data
- All processing operations (filters) produce datasets. This allows the user to either process further or to save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking and apply glyphs (for example, vector arrows) to the result.
- Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
- Vectors fields can be inspected by applying glyphs (currently arrows -vector arrows-, cones and spheres) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
- A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
- Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons etc. and can be processed by a multitude of filters.
- The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for rectilinear grids).
- With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
- Data can be probed on a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
- ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description
- Runs parallel on distributed and shared memory systems using MPI. These include workstation clusters, visualization systems, large servers, supercomputers etc.
- ParaView is fully scriptable using the simple but powerful Tcl language. Every operation has a corresponding script command. Every command executed during a session can be saved in a trace file which can be re-loaded to reproduce the session. Furthermore, since the session file is simply a Tcl script, it can be edited/modified and loaded to obtain different results.
- ParaView uses the data parallel model in which the data is broken into pieces to be processed by different processes. Most of the visualization algorithms function without any change when running in parallel. ParaView also supports ghost levels used to produce piece invariant results. Ghost levels are points/cells shared between processes and are used by algorithms which require neighborhood information.
[
http://www.paraview.org/HTML/Index.html]
PHYSICA is a high level, interactive programming environment with user friendly graphics and sophisticated mathematical analysis capabilities. Over 200 numeric and character functions are provided, as well as over 30 operators, providing all of the operations of simple calculus, along with powerful curve fitting, filtering and smoothing techniques, and employing a dynamic array management scheme allowing arrays limited in size only by system resources. Algebraic expressions of arbitrary complexity are evaluated using a lexical scanner approach. Line graphs, histograms and pie charts, as well as contour, density and surface plots are available. The user interface is a command language with a simple to use and easy to learn syntax, incorporating basic elements of a structured programming language including conditional branching, looping and subroutine calling constructs.
[
http://www.triumf.ca/people/chuma/physica/homepage.html]
PLOTMTV's capabilities include 2D line and scatter plots (x-vs-y), contour plots, 3D surface, line and scatter plots as well as vector plots. The program has an rough but functional Graphical User Interface, through which it is possible to zoom in, zoom out, pan, toggle between 2D and 3D plots, and rotate 3D plots. Both color and grayscale postscript output are supported.
[http://packages.debian.org/stable/math/plotmtv]
Plot Plus is a general purpose scientific graphics package. Plot Plus will read most standard ASCII or binary files and the netCDF file format. Plot Plus is an interactive, command driven, scientific graphics package.
[
http://dwd6.home.mindspring.com/]
[
http://www.pmel.noaa.gov/epic/software/pplus.htm]
PLplot is a library of functions that are useful for making scientific plots.
PLplot can be used from within compiled languages such as C, C++, FORTRAN and Java, and interactively from interpreted languages such as Octave, Python, Perl and Tcl.
The PLplot library can be used to create standard x-y plots, semilog plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page with multiple lines in each graph.
A variety of output file devices such as Postscript, png, jpeg, LaTeX and others, as well as interactive devices such as xwin, tk, xterm and Tektronics devices are supported. New devices can be easily added by writing a small number of device dependent routines.
There are almost 2000 characters in the extended character set. This includes four different fonts, the Greek alphabet and a host of mathematical, musical, and other symbols. Some devices supports its own way of dealing with text, such as the Postscript and LaTeX drivers, or the png and jpeg drivers that uses the Freetype library.
[http://plplot.sourceforge.net/]
POLKA is a general purpose animation system that is particularly well-suited
to building algorithm and program animations. One of the first foci for the
system was to build animations of parallel programs and computations, but
POLKA is ideal for animating good old serial programs too. POLKA is
descended from the XTango system, but it is far more powerful and flexible.
All of our most recent development was with POLKA, not XTango. POLKA supports
color, real-time, 2 & 1/2 dimensional, smooth animations. To see examples
(still frames) from Polka animations, see the
visualization gallery. The focus of the system is on a balance of power
and ease-of-use. POLKA provides its own high-level abstractions to make the creation
of animations easier and faster than with many other systems. Programmers need not
be graphics experts to develop their own animations.
Polka also includes an interactive, front-end called
Samba.
Samba is an animation
interpreter that reads one ascii command per line,
then performs that animation directive.
[http://www.cc.gatech.edu/gvu/softviz/parviz/polka.html]
A set of applications for interactively plotting data written
to behave similarly to MONGO but using
PGPLOT as the basic
plotting package. This is one of the many
astronomy-related packages
available from the
Starlink Software Store.
PONGO features include interactively reading data from a text
file, performing complicated mathematical manipulations of the
data using Fortran-like statements that define the required
transformation, the availability of specialized extra data columns,
many interactive cursor functions, the drawing of error ellipses
and vector plots, simple statistical analysis of the data,
data resampling, the definition of user-specified functions,
the plotting of astronomical position data in any of several
available geometries, and much more.
A binary distribution of the PONGO package (along with binary
distributions of the needed ancillary packages) is available for
several platforms, including Linux. The documentation is
contained within the distribution in LaTeX format.
[http://star-www.rl.ac.uk/store/storeapps.html]
pV3 (which stands for parallel Visual3), is a distributed system
that builds heavily on the technology developed for Visual3. It has
been designed specifically for co-processing visualization of data
generated in a distributed and parallel compute arenas.
It is the latest in a series of programs designed for the real time
visualization of 3-D large scale solutions of transient (unsteady)
problems.
[http://raphael.mit.edu/pv3/pv3.html]
An interactive tool for displaying satellite images and weather
data. It plots color satellite image data as well as contour and
vector fields and continental outlines. A wide variety of parameters
can be interactively changed to modify the form of the graphs and
images. SatView runs under X Windows and requires both the
XView library
and the NCAR graphics package to run.
The last release of this was in 1995.
[http://www.atmos.washington.edu/gcg/SV.man/index.html]
[
ftp://eos.atmos.washington.edu/pub]
SciGraphica is a scientific application for data analysis and technical graphics. It pretends to be a clone of the popular commercial (and expensive) application "Microcal Origin". It fully supplies plotting features for 2D, 3D and polar charts. The aim is to obtain a fully-featured, cross-plattform, user-friendly, self-growing scientific application. It is free and open-source, released under the GPL license.
[
http://scigraphica.sourceforge.net/]
TerraVisionTM is an Open Source distributed, interactive terrain visualization system developed by SRI International. It allows users to navigate, in real time, through a 3-D graphical representation of a real landscape created from elevation data and aerial images of that landscape. There are many terrain visualization tools on the market, but here are some of the features that make TerraVisionTM unique:
- TerraVisionTM can browse huge datasets, in the order of terabytes.
- All data can be distributed over multiple servers across the Web.
- 3-D VRML and GeoVRML models can be overlaid, e.g. buildings, wind vectors, etc.
- TerraVision can access OGC Web Map Servers (WMS)
- Datasets of different size, resolution, source, and coordinate system are supported.
To interact in real-time with massive, remotely located repositories, TerraVision employs a tiled, multi-resolution data representation. This involves segmenting the original data into rectangular tiles over a range of resolutions, where each tile contains the same number of pixels or elevation data. By employing customized caching, culling, and data fetching optimizations, the number of polygons and texture maps required for rendering remains approximately constant, independent of dataset size and the viewpoint. Tiles are requested for an area using a coarse-to-fine progression so that TerraVision always has low-resolution data for the area of interest.
[
http://www.ai.sri.com/TerraVision/]
Tgif (pronounced t-g-i-f) is an Xlib based interactive 2-D drawing tool
under X11 on Linux and most UNIX platforms.
[http://bourbon.usc.edu:8001/tgif/]
The developement of TIPSY was motivated by the need to quickly display and analyze the results of N-body simulations. Most data visualization packages are designed for the display of gridded data, and hence are unsuitable for use with particle data. Therefore, a special package was built that could easily perform the following functions:
- Display particle positions (as points), and velocities (as line segments) from an arbitrary viewpoint.
- Zoom in to a chosen position. Due to their extremely clustered nature, structure of interest in an N-body simulation is often so small that it can not be seen when looking at the simulation as a whole.
- Color particles to display scalar fields. Examples of such fields are potential energy, or for SPH particles, density and temperature.
- Selection of a subset of the particles for display and analysis. Regions of interest are generally small subsets of the simulation.
- Following selected particles from one timestep to another.
- Finding cumulative properties of a collection of particles. This usually involves just a sum over the particles.
[
http://www-hpcc.astro.washington.edu/tools/tipsy/tipsy.html]
This has been subsumed into CDAT.
[http://www-pcmdi.llnl.gov/software/vcs/index.html]
The Visual Geophysical Exploration Environment (VGEE) combines new pedagogical models with advances in technology and the geosciences to create an inquiry-based geoscience learning environment for undergraduates using authentic scientific tools and practices. The main components of the VGEE are a set of tools specially designed to help learners visualize complex, multi-dimensional geophysical phenomena and connect those visualizations to fundamental physical principles.
The VGEE tools include:
- A 5D visualization environment that enables learners to construct realistic 3D graphics and animations of what is occurring within a dataset. (Note that 5D refers to the three spatial dimensions plus time and multiple variables)
- Geophysical datasets of observed and modeled data used within the visualization environment; the initial dataset is related to the El Niño Southern Oscillation (ENSO)
- A set of concept models to illustrate fundamental geophysical principles in idealized contexts
- A set of probes used to investigate the role of fundamental principles within learner-created visualizations
[
http://www.dpc.ucar.edu/vgee/index.htm]
Interactive visualization software for discrete data in 1-, 2- and 3-D.
[
http://www-sop.inria.fr/sinus/Softs/vigie.html]
Vis5D is a software system that can be used to visualize both gridded data and irregularly located data. Sources for this data can come from numerical weather models, surface observations and other similar sources. Vis5D can work on data in the form of a five-dimensional rectangle. That is, the data are real numbers at each point of a "grid" which spans three space dimensions, one time dimension and a dimension for enumerating multiple physical variables. Of course, Vis5D works perfectly well on data sets with only one variable, one time step (i.e. no time dynamics) or one vertical level. However, your data grids should have at least two rows and columns. Vis5D can also work with irregularly spaced data which are stored as "records". Each record contains a geographic location, a time, and a set of variables which can contain either character or numerical data.
A major feature of Vis5D is support for comparing multiple data sets. This extra data can be incorporated at run-time as a list of *.v5d files or imported at anytime after Vis5D is running. Data can be overlaid in the same 3-D display and/or viewed side-by-side spread sheet style. Data sets that are overlaid are aligned in space and time. In the spread sheet style, multiple displays can be linked. Once linked, the time steps from all data sets are merged and the controls of the linked displays are synchronized.
The Vis5D system includes the vis5d visualization program, several programs for managing and analyzing five-dimensional data grids, and instructions and sample source code for converting your data into its file format. We have included the Vis5D source code so you can modify it or write new programs. You can download the sample data sets from the LAMPS model and from Bob Schlesinger's thunderstorm model, so you can work through our examples. (We have also included a small dataset, hole.v5d, so you can verify that Vis5D works and try a couple of simple plots.)
Over time, various enhanced versions of Vis5d have accumulated, which for one reason or another weren't folded into the main Vis5d tree. These forks unfortunately did not remain in sync with the main tree, nor were they coordinated with one another. Vis5d+ is a project that, with the original Vis5d authors' blessing, intends to be a central repository for third-party Vis5d enhancements in the future. We continue to communicate closely with the Vis5d authors, track changes in the main tree, and share bugfixes where possible.
[
http://vis5d.sourceforge.net/]
Visapult is an application and framework used for remote and distributed, high performance direct volume rendering. The Visapult application consists of two software components that work together in a pipelined fashion in order to perform volume rendering. The two software components consist of a viewer, which runs on your desktop machine, and which presents a GUI along with support for interactive transformations of the volume rendering. The other component, called the backEnd, runs on some other machine, and performs that tasks of data loading and partial rendering. The viewer, running on the desktop, is able to achieve interactive frame rates even with extremely large datasets due to its use of Image Based Rendering Accelerated Volume Rendering. The viewer requires OpenGL support on the display workstation, along with OpenRM Scene Graph, an Open Source scene graph distribution.
Each of the backEnd and viewer are parallel programs. The backEnd is a distributed memory application that uses MPI as the parallel programming and execution framework. As such, the backEnd will run on any platform that supports MPI programs. The backEnd will read the raw scientific data using domain decomposition strategy that seeks to equally balance the amount of data to be read and processed by each PE. Each backEnd PE reads data and renders, using a software compositing algorithm, in parallel. The results of this activity are then sent to the viewer. For each backEnd PE, there exists a separate TCP communication channel to a corresponding execution thread within the viewer. Unlike the backEnd, the viewer is parallelized using pthreads, and is intended to be run on a single workstation. The viewer can benefit from multiple CPUs on any SMP platform, so best performance will occur when the viewer is run on an SMP platform, such as a multi-processor SGI, Sun or x86.
[
http://www-vis.lbl.gov/Research/visapult2/index.html]
isIt is a free interactive parallel visualization and graphical analysis tool for viewing scientific data on Unix and PC platforms. Users can quickly generate visualizations from their data, animate them through time, manipulate them, and save the resulting images for presentations. VisIt contains a rich set of visualization features so that you can view your data in a variety of ways. It can be used to visualize scalar and vector fields defined on two- and three-dimensional (2D and 3D) structured and unstructured meshes. VisIt was designed to handle very large data set sizes in the terascale range and yet can also handle small data sets in the kilobyte range.
[
http://www.llnl.gov/VisIt/home.html]
ViSta, the Visual Statistics System,
features statistical visualizations that are
highly dynamic and very interactive.
ViSta constructs very-high-interaction, dynamic graphics that show you multiple views of your data simultaneously. The graphics are designed to augment your visual intuition so that you can better understand your data.
[
http://forrest.psych.unc.edu/research/]
A volume visualization system that unites numerous visualization
methods within a comprehensive visualization system, providing
a flexible tool for the scientist and engineer as well as the
visualization developer and researcher. It has been designed
to supply a wide range of functionality with numerous methods
provided within each functional component, to offer a user interface organized
into functional components for ease of use, to allow new representations
or algorithms to be easily added, to be portable, and to be freely
available.
The components of VolVis include a file I/O component which can
handle various file types including slice, image, function, and
environment files. The object control component allows the user
to control most object properties for system objects, e.g. position,
orientation, color, texture, etc. The rendering component offers
a variety of techniques ranging from a rough approximation of the
final image to accurate rendering within a global illumination
model, with each available rendering algorithm offering several
levels of accuracy. The image control component facilitates the
manipulation of images generated by VolVis. A navigation component
allows the interactive control of object position and orientation.
an animation component the creation of image sequences.
A measurement component can be used to obtain quantitative
information from the data models, e.g. surface and volume area.
A filter component can be used to enhance features, smooth data,
or reduce noise.
VolVis is written in C and highly portable. It will run on most UNIX
workstations support X/Motif, although some components require
special hardware capabilities.
[http://www.cs.sunysb.edu/~vislab/volvis_home.html]
The VPython package includes the Python language with the
IDLE interative development environment, a Python module
called Visual that creates real-time 3-D output, and
the Numeric module for fast array processing.
The Visual module can create 3D objects (such as spheres, curves, etc.) and position them in 3D space. Visual, running in a separate thread, automatically updates a 3D scene many times per second, to reflect the current positions of the objects. The programmer does not need to deal with display management, but can focus on the computational aspects of the program. The user can navigate in the 3D scene by using the mouse to zoom and rotate while the program is running. Visual supports full vector algebra.
[
http://vpython.org/]
The Visualization Toolkit is a software system for 3-D graphics
and visualization. It includes and C++ class library and a Tcl
implementation based on the class library, and is designed on
object-oriented principles. The graphics model used is at a higher
level of abstraction than rendering libraries like openGL or pEX,
which means it is easier to create useful graphics and visualization
applications. In vtk applications can be written directly in C++
or in Tcl/Tk. It is a true visualization system that supports a
wide variety of visualization algorithms including scalar, vector
and tensor visualization and advanced modeling techniques like
implicit modeling and polygon reduction. The rendering libraries
supported are Sun's XGL, SGI's GL and OpenGL, HP's starbase and
the freely available Mesa OpenGL renderer.
The only pricey bit about
this package is that the documentation is in a book that must
be purchased from Prentice-Hall. Vtk should compile and run on
most UNIX platforms, including Linux.
[http://public.kitware.com/VTK/]
An interactive package that can be used to produce high
quality scientific graphical output. WIP is basically a
command line user interface built on top of the
PGPLOT graphics
library package. It was developed by an astronomer for
use by astronomers but it has much wider application
possibilities.
Salient features of WIP include the capability of reading
two-dimensional images and automatically sense the image
type (and thus simplifying the overlaying of images with different
resolutions and spatial extents), an interpreted language
with variables that allow arbitrarily difficult expressions
to be evaluated internally, support for user defineable
macros which can be defined and edited at run time or
read from external files, and conditional commands and
loop constructs that allow greater flexibility in the
creation of complex plotting instructions.
The source code for WIP is available and will requires an
ANSI-C compiler for installation. It has been successfully
installed on Sun, VAX/VMS, Linux, Cray and CONVEX systems.
It requires the prior installation of the PGPLOT package
to function. A 150 page user's manual for WIP is available
in Postscript format.
[http://bima.astro.umd.edu/wip]
A color imaging and data analysis tool based on the
X Window system. It was developed for the analysis of 3-D 32-bit
floating point scientific data stored in NCSA
HDF
format. Features include color raster
display of 2D slices from 3D datasets, display of actual data
values in spreadsheet form, continuous and single-step animation
of color raster images, tiling of multiple images in a single
window, arbitrary slicing and dicing, 3-D visible volume
rendering, and many more. The source code is available as well
as binaries for Cray, Dec (3100 and Alpha), IBM, SGI, and
Sun platforms.
This was last updated in 1994.
[ftp://ftp.ncsa.uiuc.edu/Unix/XDataSlice/]
A contouring program for iso-lines. It features high-quality
nonlinear interpolation with bicubics on a rectangular grid,
area filling, X Window and PostScript output, customization
with a resource file, interative labeling of contour lines,
interactive data probing for value and derivatives, placing
of symbols according to information read from a file, exact
location of extrema and saddle points, and computation of profiles.
XFarbe reads an ASCII data file with a 2-D array, interpolates a
bicubic representation of the data, computes isolines in vector
form, and optionally fills the areas between the isolines with
colors. Output can be to either an X display or a PostScript
output file. Various attributes of the graph can be modified,
e.g. contour levels, annotation strings, coordinates, colors,
etc. Several additional options are also available.
[http://www.fhi-berlin.mpg.de/grz/pub/xfarbe.html]
Xfig is an interactive drawing tool which runs under X Window System Version 11 Release 4 (X11R4) or later, on most UNIX-compatible platforms. It is freeware.
In xfig, figures may be drawn using objects such as circles, boxes, lines, spline curves, text, etc. It is also possible to import images in formats such as GIF, JPEG, EPSF (PostScript), etc. Those objects can be created, deleted, moved or modified. Attributes such as colors or line styles can be selected in various ways. For text, 35 fonts are available. Text can also include Latin-1 characters.
Xfig saves figures in its native Fig format, but they may be converted into various formats such as PostScript, GIF, JPEG, HP-GL, etc. xfig has facility to print figures to a PostScript printer, too.
There are some applications which can produce output in the Fig format. For example, xfig doesn't have a facility to create graphs, but tools such as gnuplot or xgraph can create graphs and export them in Fig format. Even if your favorite application can't generate output for xfig, tools such as pstoedit or hp2xx may allow you to read and edit those figures with xfig. If you want to import images into the figure but you don't need to edit the image itself (like this example), it is also possible to import images in formats such as GIF, JPEG, EPSF (PostScript), etc.
Most operation are performed using the mouse, but some operations may also be performed using keyboard accelerators (shortcuts). Use of a three-button mouse is recommended, but it is also possible to use a two-button mouse (if you have a two-button mouse and your X server doesn't emulate a three-button mouse, press the Meta (or Alt) key and right mouse button together to simulate mouse button 2). Normally, mouse buttons 1 to 3 are assigned to the left, middle, and right buttons respectively.
[http://www.xfig.org/]
XGobi is a data visualization system with state-of-the-art interactive
and dynamic methods for the manipulation of views of data.
It implements 2-D displays of projections of points and lines
in high-dimensional spaces, as well as parallel coordinate
displays and textual views thereof. Project tools include dotplots
of single variables, plots of pairs of variables, 3-D data
rotations, various grand tours, and interactive projection pursuit.
Views of the data can be reshaped. Points can be labeled and
brushed with glyphs and colons. Lines can be edited and
colored. Several XGobi processes can be run simultaneously and
linked for lableing, brushing and sharing of projections. Missing
data are accomodated and their patterns can be examined; multiple
imputations can be given to XGobi for rapid visual diagnostics.
XGobi includes an extensive on-line help facility.
XGobi can be integrated in other software systems, as has been
done for the data analysis language S and the interactive
multidimensional scaling program XGvis.
[http://lib.stat.cmu.edu/general/XGobi/]
-
GGobi is a data visualization system for viewing high-dimensional data and is the next edition of xgobi. It provides a new interface to many of the features of xgobi, built using Gtk, the GIMP toolkit and provides several new features.
[
http://www.ggobi.org/]
This software allows users to visually explore multivariate
data using a variety of methods. This is accomplished via several
data projection techniques as well as by the use of a concept
called an N-dimensional brush.
The data projection techniques include the scatterplot, the
glyph, parallel coordinates, and dimensional stacking.
Scatterplots are an old and commonly used data projection
technique wherein n-dimensional clouds of points are graphed
and viewed from various perspectives. A glyph is any of a
large number of techniques which map data values to various
geometric and color attributes of graphical primitives or
symbols, with the histogram being the most widely recognized
form. In the parallel coordinates technique each dimension
corresponds to an axis with the n axes organized as uniformly
spaced vertical lines, with data elements manifesting themselves
as a connected set of points. Dimensional stacking involves
projecting high dimensional data by embedding dimensions within
other dimensions. Brushing is a method for recovering the
spatial relationships of data when a given number of dimensions
is project into a smaller number by highlighting data points
that fall into a user-defined subspace.
The source code of this package
is available and it appears to be installable on generic UNIX
boxes running X-Windows. It requires that both the Athena Widgets
and the WCL be first
installed. Documentation is available in the form of
a user's manual in PostScript format.
[
http://davis.wpi.edu/~xmdv/]
An X Windows paint program that offers such painting operations
as brushing, spraying, lines, arcs, pattern fill, text, boxes,
circles and polygons. It also supports multiple images with cut
and paste between them, and zooming. Several file formats are
supported. There is no manual but the online help is more than
adequate. It's not McPaint or anything but it's free and
eminently useful.
[
https://sourceforge.net/projects/sf-xpaint/]
A plotting program written in C using Xlib to run in UNIX
and X-Windows. It reads the data from an ACII file and plots
them in an X-Window where you can zoom, read coordinates
interactively, save to a PostScript file, change the way points
are plotted and connected, and more.
[
http://www.vscht.cz/mat/Pavel.Pokorny/xpplot/]
A general purpose algorithm animation system that supports
programmers developing color, real-time, 2 and 2 1/2 dimensional
smooth animations of their own algorithms and programs. The
focus is on ease-of-use. It is implemented on top of UNIX and
the X11 Window system and can be used on either color or B&W
monitors. It is known to install on Sun, IBM, SGI, DEC and
HP workstations. This is the predecessor to
POLKA, which is recommended by the
developer as a better and more flexible package.
[http://www.cc.gatech.edu/gvu/softviz/algoanim/xtango.html]
This is a really nifty interactive image display for the
X Window system. You can display images from a large number
of formats, transform them from one format to another, perform
screen grabs, cut and paste portions of images to create other
images, process images in various ways (e.g. magnify, stretch,
compress, rotate, flip, smooth, dither, emboss, etc.), and
adjust and change colors and other image attributes such as
brightness. The only thing you can't do with this package is
create an image from scratch. This is shareware and more than
worth the $25 that John Bradley, the author, is asking, especially
since he also produced an exemplary 120 page manual for it. An
online hypertext xv manual is available for your perusal.
[
http://www.trilon.com/xv/xv.html]
A tool for creating scientific plots of both draft and
publication quality quickly and efficiently. This is built
on top of both
Yorick and
PLplot and as such
features the capabilities of both.
The capabilities include accessing all of Yorick's features
including data generation and interpretation; creating all
variations of linear and log plots; creating 3D surface (i.e.
mesh) and 3D line and scatter plots; grid line generation;
the use of many fonts and symbols; several output devices
including X11, PostScript and Laserjet; and more. See the
descriptions of Yorick and PLplot for further details.
The present version (6/96) is available only as a binary
for Linux platforms and requires that both the PLplot library
and the Yorick executable already be installed on your machine.
The documentation consists of a tutorial and reference manual
that demonstrates most of the capabilities of YPLOT.
[
http://yplot.sourceforge.net/]
|
|
|