JavaData & JavaData Visualization in Java for Technical Computing

Data Visualization in Java for Technical Computing content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.


The primary goal of visual analysis for Technical Computing is to enable the engineer, scientist, economist, and all related professionals to better understand his/her data through the use of visual methods. Scientific or business data can be massive, and when one tries to sift through to find correlations among numerous variables, it is time consuming and often leads to a limited understanding of parameters of interest to a professional.

Visual display of quantitative information can be a useful tool in learning experiences and of understanding physical phenomena, have created a new demand for interpretation, analysis, and display of massive quantities of data. With well-designed visual tools, the investigator can analyse these data sets more efficiently. In some cases visual analysis can lead to new discoveries.

With the availability of Java2D, Java3D, and J.A.I. (Java Advanced Imaging) in Java2 and later versions have encouraged different vendors, industrial and academic researchers, computer hobbyists, and the like to develop Java tools (libraries and stand-alone programs) for numerical data visual analysis. Some of these tools are commercial, GPL, or copyrighted, but source code is still available for interested Java developers.

Advantage of Numerical Data Visualization

There are a lot of physical parameters or variables that are the subject of certain data investigations that are not easy to observe. For physical (tangible) phenomena, the difficulties relates to:

  • The human eye’s inability to see objects that are smaller than our visual resolution. For example, you cannot see atoms or molecules, but electronic sensors can capture important physical measurable quantities from experimenting with or manipulating them.
  • The inability of human temporal perception to resolve time-interval lapses of very fast events such as a flying bullet. The moment you think you heard a gun fire, the bullet is already embedded in its target.

Engineers use other technologies, such as fast digital photography, to capture the bullet’s path frame by frame; air turbulence sensors map out the path the bullet follows. All this data is then fed into a computer software visualization package for analysis. Without visual analysis, it would take longer for engineers to fully understand the path of the bullet, because numerical data captured from measuring devices are just too much to thoroughly analyse by hand or with non-visual software.

Visualization will give you a much wider view of the problem set that is to be investigated; in other words, you can see the problem entirely from a different analysis point of view. Non-visual software will still give you what your search algorithm finds, but you would not know whether that solution is global (entire) or local (restricted to the domains you specified). It also it does not indicate whether a small deviation from the solution is still approximate enough or completely inapplicable. The following plots, Figure 1, illustrate this point.

All the plots from Figure 1 are peaks plots; plot-A has three peaks (D, E, and F) and two troughs (unlabelled); plot-B and plot-C are both single peaks with different sharpness and height. If an initial area (x and y) is specified for the algorithm (optimisations) to search for the peaks and this specified area domain does not contain the tallest peak (peak-D from plot-A in Figure 1), the search will come up with the smaller peak as a solution (either peak-E or peak-F, depending on the area boundary of search). But, looking at plot-A definitely tells you that peak-E or peak-F is a local maxima, not a global one, which is peak-D (the highest in plot-A). The global maxima (peak-D) was outside the initial guess domain of search. Because you cannot exhaust your efforts by keeping guessing that the entire x-y plane that is infinite, for an area (domain) that contains the global maxima, it is much faster to visualize the data, then make a few adjustments, and you will arrive at the optimum solution. Such an optimum search algorithm (steepest-descend-algorithm) is the foundation of a neural network, where the searches start from an initial guess point, and then descend in the direction that minimizes the penalty of its movement, until it finds the solution (converge).

The other point that I want to make is, that even though the search algorithm finds the global maxima (or minima), it does not tell you its sensitivity to small movement (delta change) in any direction from that specific maxima. The sharper the peak is, the more sensitive it is to small change, regardless of its height. You can visually see from Figure 1 which is the sensitive peak (sharp) and which is less sensitive (flat-top) to small change; therefore, plot-C is more sensitive than plot-B. Why is sensitivity important? There are a lot of physical designs that state sensitivity is very important for robustness of performance. An example is a designing of a “Micro-circuit digital filter,” for integrated circuitry. Certain parameters need to be estimated and find the tolerance to variables such as electrical current or voltage frequency. Visualization software assists the Electrical Engineer to pinpoint the window (range of frequencies or bandwidth) that the filter would perform to a tolerable level, without noticeable degradation of operation. Thus, plot-B is typical of a high-bandwidth low-pass (the filter blocks all high frequencies above a cut-off level and allow only low frequencies to pass) while plot-C is a low-bandwidth low-pass (or narrow bandwidth) filter. Figure 1 is a common type of visualization that is widely used in engineering, science, finance, economics, business, and so on.

Java Tool—VisAD (Visualization for Algorithm Development)

VisAD is a Java component library API for interactive and collaborative visualization and analysis of numerical data. The advantage of this library is that you do not need prior knowledge of Java3D; it is built on top of Java3D. This takes away the need to deal with its low-level functionality. The Space Science and Engineering Center (SSEC) at the University of Wisconsin-Madison, the University Corporation for Atmospheric Research (UCAR), and the National Center for Supercomputing Applications (NCSA) at the University of Illinois at Urbana-Champaign worked together to develop collaborative scientific and engineering programs using the Java 3D API.

SSEC develops satellite instruments and data systems that support earth and space science projects. The SSEC Visualization project focuses on making advanced visualization techniques useful to scientists in their daily work, primarily through VisAD.

The VisAD system combines:

  • Support data sharing and real-time collaboration among geographically distributed users. Distributed computing is integrated at the lowest levels of the system using Java RMI(Remote Method Invocation) distributed objects.
  • A general mathematical data model that can be adapted to virtually any numerical data, that supports data sharing among different users and different data sources.
  • A general display model that supports interactive 3D, data fusion, multiple data views, direct manipulation, collaboration, and virtual reality. The display model has been adapted to Java3D and Java2D.
  • Data analysis and computation integrated with visualization to support computational steering and other complex interaction modes.
  • Developer extensibility in as many ways as possible.

VisAD Design

  • MathType:
    The MathType class defines the type of data; it also does not contain the actual data. This class is extended to handle specific types of data.
    • RealType: The most fundamental data types are declared as RealType. An example is Longitude, Time, and Temperature. Usually in mathematical functions, it is called independent variables, provided one variable does not depend on one other.
    • RealTupleType: Multiple RealTypes can be grouped together as a RealTupleType; for example, (Longitude, Latitude, Altitude) or (x,y,z,v).
    • FunctionType: This is a mapping of one MathType to another. Example, (Time) -> (Temperature) or (Longitude, Latitude, Altitude) -> (x,y,z,v). Because FunctionType is itself a MathType, you can map more complex data type transformation: (Time) -> ((Longitude, Latitude, Altitude) -> (x,y,z,v))

  • Data Implementations:
    To represent some actual data in VisAD, you need to create a data implementation (DataImpl class, or one of its subclasses) based upon a MathType. If you have a FuntionType that conceptually maps (Time) -> (Temperature), you need to define a finite domain set of times that increases monotonically and assigns the corresponding temperature values to complete a data implementation. Because the MathType class contain no data, it can be used by multiple data implementations. This means that you could have another temperature-time series by creating a new FieldImpl with the same FuntionType but defining a different domain set and assigning new temperature values. You could even create a time series just by defining a new domain set and re-sampling an existing data implementation.
  • VisAD also understands the concept of units (SI—Systems International) and coordinate systems so data with different units and on different coordinate systems that can be used together transparently. Each data implementation has a DataReference. This is the only object you need to pass data around. Everything you need to know about the data can be obtained via the DataReference methods.

  • Data Display:
    VisAD allows you to easily create 2D and 3D displays after the data implementations are set up. Display mappings (ScalarMaps) are based on MathTypes, not data implementations. If you map Time to the X-Axis, any data with Time as part of its MathType will be appropriately displayed along the X-Axis. To display the temperature time series mentioned above, you need to create a new display object, add two ScalarMaps to the display (Time to XAxis and Temperature to YAxis), and then add the DataReference to the display. VisAD does the rest. VisAD also automaticallys update the display when the data changes; this is an advantage feature for real-time display.

    Suppose you have RealTypes Longitude, Latitude, and Altitude mapped to the display’s XAxis, YAxis, and ZAxis respectively. If we have some terrain data with the MathType (Longitude, Latitude) -> (Altitude) and add its DataReference to the display, we will get a 3D surface that looks something like the real thing. You can add color by simply mapping a RealType to a color (for example, map Altitude to Red).

    You can add additional data to the display simply by adding the DataReference. Let’s imagine we have some model data with the MathType (Longitude, Latitude, Altitude) -> (U, V, T, RH) and all are already been mapped. Even though the model data may be sampled on a different grid than the terrain data, because they share some of the same MathTypes they will be displayed together appropriately. Simply adding to the display a mapping of RH to RGBA will give us a colorful, semi-transparent representation of RH that may look something like clouds. Existing data at a given altitude and assign to a new data implementation with a MathType (Longitude, Latitude) -> (RH, Altitude). In addition to color, RH can be mapped to IsoContour to get contour lines instead of a raster image.

    If we have Time as part of the MathType, we can get an animation simply by adding a map of Time to Animation. A Display’s ScalarMaps can be controlled (often graphically) using Controls. This allows for user configurability of the display.

  • RMI:
    VisAD uses Java’s Remote Method Invocation to allow for distributed computing; for example, data objects and display objects can reside on different machines yet still work with each other.

  • Cell:
    Just as a Display automatically updates when the data changes, a Cell will perform its action whenever the data associated with its data reference changes. This can be used to cause other things to happen (such as redraw a Shape object) when data changes.

  • Interaction with Data:
    VisAD provides a number of special User Interface (UI) components. Interaction in VisAD generally occurs with the assistance of a Control. Control is a class that is implemented by GraphicsModeControl, ColorControl, AnimationControl, and others. The choice of UIs depends not only on the data, but also on how interactive the application can be. One thing to notice, though, is that in VisAD the display is the main user interface. Not only does it provide the user with information about the data, but it supports interactive rotation, pan, and zoom.

Sample Code

Let’s create plot-A from Figure 1. The mathematical function for plot-A in Figure 1 is a popular test function for algorithm design in the area of Artificial Neural Network, Linear and Non-linear Optimization, and Genetic Algorithm. The mathematical function is just called “peaks” because it has three peaks and two troughs. In Neural Network, given a starting random point (arbitrary) on the peak surface of plot-A, the Network is trained and analyses how well it self-adapts to finding the maxima (or minima) of the peaks. The results is used to determine the design parameters such as number of input-output neurons, hidden neuron layers, network learning rate, network momentum, and so on. The mathematical representation of the peaks is shown in Equation 1:

Equation 1

The independent variables x and y in Equation 1 are mapped to RealType objects latitude and longitude, as shown in Listing 1. Dependent variable z [where z = f(x,y)] is mapped to RealType object altitude. To run the sample code shown in Listing 1, you must download VisAD from SSEC(Space Science and Engineering Center) and Java3D from Sun (refer to the resources section). The VisAD distribution comes with a lot of sample code and also a number of tutorials that will get you started quickly. I recommend that you read the VisAD tutorial before running the sample app. If you scan the code in Listing 1, you notice that there is no class/classes from Java3D at all; VisAD has taken away the need to learn Java3D to write data visualization applications.

Listing 1:

import visad.*;
import visad.java3d.DisplayImplJ3D;
import java.rmi.RemoteException;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class Peaks {

  //Independent variables are longitude (y) and latitude (x)
  //Dependent quantities are altitude (z) and temperature
  private RealType longitude, latitude, altitude, temperature;

  //Two Tuples: one to pack longitude and latitude together,
  //as the domain and the other for the range
  //(altitude, temperature)
  private RealTupleType domain_tuple, range_tuple;

  //The function (domain_tuple -> range_tuple )
  private FunctionType func_domain_range;

  //Data ranges for the domain are represented by the Set
  private Set domain_set;

  //Data class FlatField
  private FlatField vals_ff;

  // The DataReference from data to display
  private DataReferenceImpl data_ref;

  // The 2D display, and its the maps
  private DisplayImpl display;
  private ScalarMap latMap, lonMap, altZMap,
                    tempRGBMap , tempZMap, altRGBMap;

  public Peaks(String []args)throws RemoteException,
                                    VisADException {
    // Create the quantities, using RealType(String name);
    latitude = new RealType("latitude",SI.meter,null);
    longitude = new RealType("longitude",SI.meter,null);
    domain_tuple = new RealTupleType(latitude, longitude);
    temperature = new RealType("temperature",SI.kelvin,null);
    altitude = new RealType("altitude",SI.meter,null);

    // Create the range tuple ( altitude, temperature )
    range_tuple = new RealTupleType( altitude, temperature );

    // Create a FunctionType (domain_tuple -> range_tuple )
    func_domain_range = new FunctionType(domain_tuple, range_tuple);

    //Create the domain Set
    int NCOLS = 150,  NROWS = NCOLS;
    domain_set = new Linear2DSet(domain_tuple, -6.5, 6.5,
                                 NROWS, -6.5, 6.5, NCOLS);

    // Get the Set samples to facilitate the calculations
    float[][] set_samples = domain_set.getSamples( true );

    //Create another array, with the same number of elements of
    //altitude and temperature
    float[][] flat_samples = new float[2][NCOLS * NROWS];
  //dummy variables
    double x = 0.0, y = 0.0 , z = 0.0;

  //Fill our 'flat' array with the generated values by looping
  //over NCOLS and NROWS
    for(int c = 0; c < NCOLS; c++)
      for(int r = 0; r < NROWS; r++){
        x = (double) set_samples[0][ c * NROWS + r ];
  y = (double) set_samples[1][ c * NROWS + r ];
  z = 3*(1-x)*(1-x)*Math.exp(-(x*x) - (y+1)*(y+1)) 
                             - 10*(x/5 - Math.pow(x,3.0)
      - Math.pow(y,5.0))*Math.exp(-x*x-y*y) - 1/3*Math.exp(-
                                 (x+1)*(x+1) - (y+1)*(y+1));

  // ...altitude
  flat_samples[0][c*NROWS+r] = (float)z; 
  // ...temperature
  flat_samples[1][c*NROWS+r]  = (float)((Math.sin(0.50*(double)
                                           [1][c*NROWS+r])) ;

    // Create a FlatField using FlatField(FunctionType type,
    //                                    Set domain_set)
    vals_ff = new FlatField( func_domain_range, domain_set);

    // Note the argument is false, meaning that the array won't
    // be copied
    vals_ff.setSamples( flat_samples , false );

    // Create Display and its maps
    display = new DisplayImplJ3D("display1");

    // Get display's graphics mode control and draw scales
    GraphicsModeControl dispGMC = (GraphicsModeControl)

    //Create ScalarMaps: latitude(YAxis),longitude(XAxis),
    //altitude(ZAxis), temperature(RGB)
    latMap = new ScalarMap( latitude,    Display.YAxis );
    lonMap = new ScalarMap( longitude, Display.XAxis );

    // Add maps to display
    display.addMap( latMap );   display.addMap( lonMap );

     // altitude to z-axis and temperature to color
    altZMap = new ScalarMap( altitude,  Display.ZAxis );
    tempRGBMap = new ScalarMap( temperature,  Display.RGB );
    // Add maps to display
    display.addMap( altZMap );   display.addMap( tempRGBMap );

    // Create a data reference and set the FlatField as our data
    data_ref = new DataReferenceImpl("data_ref");
    data_ref.setData( vals_ff );

    // Add reference to display
    display.addReference( data_ref );

    // Create application window and add display to window
    JFrame jframe = new JFrame("Peaks Example");
    jframe.setSize(400, 400);

  public static void main(String[] args) throws
                RemoteException, VisADException{
    new Peaks(args);

//---------------------- End Class Definition -----------------

Area of Application

Data Visualization is used in many areas where those applications involve complex numerical data. Here are some examples of the
many uses of data visualization:

  • Computational Biology (BioInformatics):
    Computational Biology is the combination of the Life Sciences (Biology, Biochemistry, Pharmacology, and Molecular Biology), Mathematics, and Computer Science. This is one of the fastest growing area of business. According to the Bioinformatics department at UCLA, Berkeley, their PhD students are being poached by big pharmaceutical and biotechnology companies without completing their PhDs. They say that it is hard for them to attract candidates to enroll and proceed through to the PhD level or even the Master’s without the candidates leaving halfway through the course for the big money that is offered from the private sector. Computational Biology expertise is hard to find (or even teach to potential students) because a person might be doing well in the Life Sciences subjects but perform poorly in Math or Computer Science, and the top notch students in Math or Computer Science would likely perform poorly in the Life Sciences.

    There are a lot of pharmaceutical and drug companies investing a huge amount of money in visualization software. Research such as DNA mapping, protein sequencing and splicing, and protein structure prediction are the big driving factor for designing and manufacturing new drugs in the BioInformatic industries. Visualizing protein structure in 3D makes for better understanding of how to design a new drug for a target-specific treatment.

    CAVE is an advanced visualization tool that combines high-resolution, stereoscopic projection and 3D computer graphics to create the illusion of a complete sense of presence in a virtual environment. It was first developed at the University of Illinois at Chicago but the product is marketed by Fakespace Systems. The CAVE systems installed at University of Calgary (Canada) are powered by Java3D. This was a project that involved Sun Microsystems, which provides much of the hardware and software. CAVE is primarily for BioInformatics industries but it is used for visualization in other areas as well.

  • Computational Fluid Dynamics (CDF):
    CFD is the study of the mechanics of fluid flow. The fluid can be liquid or gas. Heat flow is sometimes covered in CFD, although it is a topic of Thermo-Dynamics. CFD and Thermo-Dynamics are hard-core physics topics, but they are also taught in Mechanical Engineering. One of the important analyses in CFD is to find out how the fluid flows around objects of different geometries. An aircraft design engineer would want to investigate certain shapes or geometries for an aircraft to be built. Fluid flow can exhibit non-linearity at certain physical conditions. This means that some particles of the fluid flow in a circular manner (swirling) while also moving in the direction of the flow stream. A common known non-linear flow is a hurricane; the fluid (air) flows around the eye (center) while the hurricane moves in a certain direction. Non-linear flow creates a nasty effect of slowing down solids with which they are in contact. The contact solid could be a yacht or aircraft. Non-linear flow creates a void or vortices (vortex) along its path. These vortices are the ones that designers, such as a boat designer, are trying to identify. Data visualization software is used to determine the best geometry to minimize the number and formation of vortices which have a drag-effect (friction) on the boat (or a racing yacht). Fluid drag-effect slows down yachts, aircraft, submarines, and floating solids in general.

    Figure 2: (MatLab fluid-flow model)

    The plot in Figure 2 shows a 3D fluid-flow model with an arbitrary shape object (depicted by the red color), that is in contact with the fluid (cyan cones represent fluid particles). From the plot, there is one vortex that is formed (circular or swirling green line, below left of the plot). Vortices formed and destroyed continuously, and they do not form at a particular point; some are created while others disappear or are merged to form larger ones. With the power of data visualization, engineers are able to measure the average size of vortices (diameter), density, swirling velocities, and other related physical properties, so that the design is optimal for performance, whether it is speed for a yacht or turn-rate for a F-14 Tomcat fighter aircraft. All these calculations are done even before a prototype real yacht or aircraft is built. Even so, when the real yacht is put on the water, its real performance is not that far away from the simulation result. CDF is a grande-type application, where simulations are run for even days, mostly using super-computers (yes, those scientists and engineers at Boeing (McDonald Douglas), NASA’s JPL, Northrop, Grumman, and Lockheed). The generated data from simulations is then fed to visualization software for manipulation and analysis.

    Equation 2: (Fluid-flow Continuity)

    Equation 3: (Fluid-flow Momentum in x direction)

    Equations 2 and 3 are the backbone of CFD analysis. All other equations related to CFD are derived from them. Because this article is not about physics (refer to the resources on NASA’s CFD Web site if you are interested or get a book in Differential Calculus), so I won’t describe what the equations mean. I would merely state how they will map into a VisAD data-type as shown in Listing 2. The variables are:

    • x, y and z are geometrical coordinates
    • Rho—fluid’s density (dependent on x,y,z and time—for non static flow)
    • u—fluid’s directional velocity in XAxis
    • v—fluid’s directional velocity in YAxis
    • wa—fluid’s directional velocity in ZAxis
    • t—time

    Listing 2:

      //independent variables
      RealType x = new RealType("x",SI.meter,null);
        RealType y = new RealType("y",SI.meter,null); 
        RealType z = new RealType("z",SI.meter,null);
        RealType t = RealType.Time;      //time
        //dependent variables
        RealTupleType domain_tuple = new RealTupleType
                                    (new RealType[]{x,y,z});
        RealTupleType rho_range_tuple = new RealTupleType
                                        (new RealType[]{x,y,z,t});
        RealTupleType u_range_tuple = new RealTupleType
                                     (new RealType[]{x,y,z,t});
        RealTupleType v_range_tuple = new RealTupleType
                                      (new RealType[]{x,y,z,t});
        RealTupleType w_range_tuple = new RealTupleType
                                      (new RealType[]{x,y,z,t});

    As noted from Figure 2, you can clearly see that the slicing and peeling of a surface (yellow-cyan-blue band at top of the plot) is achievable. This is important when a frame of the graph is frozen in one viewing angle, and peeled off a vortice’s outer layer to really see what its inner dynamic is; this gives an understanding of how they form, the longevity of their lifetime, and so on.

  • Computational Finance:
    Computational Finance is the application of the most appropriate features of computer science, statistics, engineering control, and mathematics to the problems of finance. Sophisticated and computationally intensive mathematical and statistical techniques for the analysis of real-time financial market data and real-time portfolio management are now available in the modern computerized world. This has opened up new opportunities as well as new challenges in computational finance for portfolio management, hedging, speculative international trading, and financial decisions. Why on earth does Finance need visualization? This question would probably have come from an accountant. Moving into Computational Finance is not accounting anymore; it is core engineering and science. Why is it regarded as engineering? Because the same mathematical techniques that are applied in science and engineering are equally applied in Computatinal Finance. Both equations, Equations 2 and 3, are the same techniques, but slightly different variant from Equation 4.

    Equation 4: (Black-Scholes Market Option Pricing Model)

    Meaning of the symbols in Equation 4 are as follows:

    • dVH—Hedge portfolio
    • QS—Number of shares of stock
    • S—Price per share
    • Qc—Number of Calls quantity
    • c—Call price
    • rho—Instantaneous standard deviation of the rate of return

    From the variable lists above, one can definitely see that stock market option pricing can be best visualized in 3D. The analysis depends on which variables are chosen for the domain and the ranges. The types of visualization for stock market analysis resemble the “peaks” of plot-A from Figure 1. Investors will look at where the troughs and peaks are. If it is a portfolio risk analysis, they will choose the coordinates of the troughs. If it is portfolio of maximum return, then they go for the highest peaks. Equation 4 is implemented in most financial software on the market. The prediction of this model is robust and approximately very close to the true values. The two physicists (Dr. Black and Dr. Scholes) who first developed the model in the 1970s won the Nobel Prize for Economics in 2000. Also, Equation 4 is a small variation of the well-known flow model in Thermo-Dynamics called heat-flow in 2-dimensions (also called Laplace 2-dimensional flow). It is quite surprising that a model that originated in Thermo-Dynamics is successfully applied in Finance.

  • Cosmology:
    Cosmology is the study of the origin of the Universe. It is close to Astronomy, but actually it is far deeper than astronomy. Cosmology is deep in Theoretical Physics and Computational Mathematics. Cosmologists made discoveries (such as discovering a new type of stars) in their study room, while Astronomers find stars from observations. A great physicist, such as Stephen Hawking, is a Cosmologist because he makes his discoveries using a pen and a paper in his study room to solve equations relating to the formation of the Universe; he never went out to an observatory to look for such strange objects in the sky or anything like that. With computer technology, he does it with high-powered computer algebra systems and some visualization software. Researchers use 3D visualization software to model their theories about the expansion of the Universe. Models can only be best understood using data visualization.
  • Atomic and Nuclear Physics:
    Visualization is a norm in Atomic and Nuclear Physics. Data visualization of atomic or nuclear reactions gives physicists a greater understanding of the properties of sub-atomic particles. When the U.S. Government agreed on the ban of nuclear testing in the early 1990s, scientists at Los Alamos Nuclear Research continued to test the nuclear bomb, not in the desert or underground but on super-computers at the Nuclear Research Lab. Data for Nuclear Research at Los Alamos had been collected since the 1950s. So this vast amount of data has been used to simulate nuclear reactions and visualize their results.

The examples for visualization applications described previously are only a small fraction of the wider applicability of data visualization and is not exhaustive.

Future Development

Java3D has a proposed draft to extend and add more functionalities in JSR-189. The following features are the proposed addition:

  • Programmable Shading
  • Extensibility
  • A Rendering Device Interface
  • Access to the native context
  • Geometry extensibility
  • Extensible geometry processing algorithms
  • Advanced Rendering Techniques
  • Stencil buffer support
  • Multipass rendering
  • Render to texture
  • Shadow map support
  • Alternate depth tests
  • Additional blending operations
  • Buffer storage hints
  • Scene antialiasing hints
  • Texture compression support

The proposed new additions would enhance the numerical data visualization in Java. The features listed above are supported by
low level 3D API’s such as OpenGL and Direct3D. They are various rendering techniques used by modern 3D applications.

There is a Mathematical API for numerical computing—JSR-83—that is still in the JCP (Java Community Process), called Multiarray. This API is designed for the compute-intensive type of simulations and analysis using visualization techniques. Numerical computation is one half of the story and the other half is Data Visualizations. Add the two together and you get Java as a true platform of choice for technical computing and data visualizations.

Downloads and Links

About the Author

Sione Palu has developed software for Publishing Systems, Imaging, Web Applications, and Symbolic and Computer Algebra Systems for secondary education. Palu graduated from the University of Auckland, New Zealand, with a science degree (B.Sc.) in mathematics and computing. His interests involve the application of Java and mathematics in the fields of mathematical modelling and simulations, symbolic AI and soft-computing, numerical analysis, image processing, wavelets, digital signal processing, control systems, and computational finance.

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories