// type 'java Parallel' to run this application
public static void main(String args[]) throws VisADException, RemoteException, IOException {
RealType index = RealType.getRealType("index");
RealType[] coords = new RealType[NCOORDS];
for (int i = 0; i < NCOORDS; i++) {
coords[i] = RealType.getRealType("coord" + i);
}
RealTupleType range = new RealTupleType(coords);
FunctionType ftype = new FunctionType(index, range);
Integer1DSet index_set = new Integer1DSet(NROWS);
float[][] samples = new float[NCOORDS][NROWS];
for (int i = 0; i < NCOORDS; i++) {
for (int j = 0; j < NROWS; j++) {
samples[i][j] = (float) Math.random();
}
}
FlatField data = new FlatField(ftype, index_set);
data.setSamples(samples, false);
// create a 2-D Display using Java3D
DisplayImpl display = new DisplayImplJ3D("display", new TwoDDisplayRendererJ3D());
parallel(display, data);
// create JFrame (i.e., a window) for display and slider
JFrame frame = new JFrame("Parallel Coordinates VisAD Application");
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// create JPanel in JFrame
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setAlignmentY(JPanel.TOP_ALIGNMENT);
panel.setAlignmentX(JPanel.LEFT_ALIGNMENT);
frame.getContentPane().add(panel);
// add display to JPanel
panel.add(display.getComponent());
// set size of JFrame and make it visible
frame.setSize(500, 500);
frame.setVisible(true);
}
/**
* set up the types
*
* @throws VisADException On badness
*/
private void setupTypes() throws VisADException {
if (curve_type == null) {
RealTupleType latlon = RealTupleType.LatitudeLongitudeTuple;
curve_type = new SetType(latlon);
// (front_index ->
// ((Latitude, Longitude) -> (front_red, front_green, front_blue)))
count++;
front_index = RealType.getRealType("front_index" + count);
front_red = RealType.getRealType("front_red" + count);
front_green = RealType.getRealType("front_green" + count);
front_blue = RealType.getRealType("front_blue" + count);
RealTupleType rgb = new RealTupleType(front_red, front_green, front_blue);
front_inner = new FunctionType(latlon, rgb);
front_type = new FunctionType(front_index, front_inner);
fronts_type = new FunctionType(RealType.Time, front_type);
}
}
/** create parallel coordinates display for data */
public static void parallel(DisplayImpl display, FlatField data)
throws VisADException, RemoteException {
FunctionType ftype = (FunctionType) data.getType();
RealType index = (RealType) ftype.getDomain().getComponent(0);
RealTupleType range = (RealTupleType) ftype.getRange();
int ncoords = range.getDimension();
int nrows = data.getLength();
Set index_set = data.getDomainSet();
float[][] samples = data.getFloats(false);
RealType x = RealType.getRealType("coordinate");
RealType y = RealType.getRealType("value");
SetType xy = new SetType(new RealTupleType(x, y));
FunctionType ptype = new FunctionType(index, xy);
FieldImpl pfield = new FieldImpl(ptype, index_set);
for (int j = 0; j < nrows; j++) {
float[][] locs = new float[2][ncoords];
for (int i = 0; i < ncoords; i++) {
locs[0][i] = i;
locs[1][i] = samples[i][j];
}
Gridded2DSet set = new Gridded2DSet(xy, locs, ncoords);
pfield.setSample(j, set, false);
}
// create a DataReference for river system
DataReference parallel_ref = new DataReferenceImpl("parallel");
parallel_ref.setData(pfield);
display.addMap(new ScalarMap(x, Display.XAxis));
display.addMap(new ScalarMap(y, Display.YAxis));
// enable axis scales
display.getGraphicsModeControl().setScaleEnable(true);
// link display to parallel display
display.addReference(parallel_ref);
}
public synchronized void drag_direct(VisADRay ray, boolean first, int mouseModifiers) {
if (barbValues == null || ref == null || shadow == null) return;
if (first) {
stop = false;
} else {
if (stop) return;
}
// modify direction if mshift != 0
// modify speed if mctrl != 0
// modify speed and direction if neither
int mshift = mouseModifiers & InputEvent.SHIFT_MASK;
int mctrl = mouseModifiers & InputEvent.CTRL_MASK;
float o_x = (float) ray.position[0];
float o_y = (float) ray.position[1];
float o_z = (float) ray.position[2];
float d_x = (float) ray.vector[0];
float d_y = (float) ray.vector[1];
float d_z = (float) ray.vector[2];
if (pickCrawlToCursor) {
if (first) {
offset_count = OFFSET_COUNT_INIT;
} else {
if (offset_count > 0) offset_count--;
}
if (offset_count > 0) {
float mult = ((float) offset_count) / ((float) OFFSET_COUNT_INIT);
o_x += mult * offsetx;
o_y += mult * offsety;
o_z += mult * offsetz;
}
}
if (first || refirst) {
point_x = barbValues[2];
point_y = barbValues[3];
point_z = 0.0f;
line_x = 0.0f;
line_y = 0.0f;
line_z = 1.0f; // lineAxis == 2 in DataRenderer.drag_direct
} // end if (first || refirst)
float[] x = new float[3]; // x marks the spot
// DirectManifoldDimension = 2
// intersect ray with plane
float dot = (point_x - o_x) * line_x + (point_y - o_y) * line_y + (point_z - o_z) * line_z;
float dot2 = d_x * line_x + d_y * line_y + d_z * line_z;
if (dot2 == 0.0) return;
dot = dot / dot2;
// x is intersection
x[0] = o_x + dot * d_x;
x[1] = o_y + dot * d_y;
x[2] = o_z + dot * d_z;
/*
System.out.println("x = " + x[0] + " " + x[1] + " " + x[2]);
*/
try {
Tuple data = (Tuple) link.getData();
int n = ((TupleType) data.getType()).getNumberOfRealComponents();
Real[] reals = new Real[n];
int k = 0;
int m = data.getDimension();
for (int i = 0; i < m; i++) {
Data component = data.getComponent(i);
if (component instanceof Real) {
reals[k++] = (Real) component;
} else if (component instanceof RealTuple) {
for (int j = 0; j < ((RealTuple) component).getDimension(); j++) {
reals[k++] = (Real) ((RealTuple) component).getComponent(j);
}
}
}
if (first || refirst) {
// get first Data flow vector
for (int i = 0; i < 3; i++) {
int j = flowToComponent[i];
data_flow[i] = (j >= 0) ? (float) reals[j].getValue() : 0.0f;
}
if (coord != null) {
float[][] ds = {{data_flow[0]}, {data_flow[1]}, {data_flow[2]}};
ds = coord.toReference(ds);
data_flow[0] = ds[0][0];
data_flow[1] = ds[1][0];
data_flow[2] = ds[2][0];
}
data_speed =
(float)
Math.sqrt(
data_flow[0] * data_flow[0]
+ data_flow[1] * data_flow[1]
+ data_flow[2] * data_flow[2]);
float barb0 = barbValues[2] - barbValues[0];
float barb1 = barbValues[3] - barbValues[1];
/*
System.out.println("data_flow = " + data_flow[0] + " " + data_flow[1] +
" " + data_flow[2]);
System.out.println("barbValues = " + barbValues[0] + " " + barbValues[1] +
" " + barbValues[2] + " " + barbValues[3]);
System.out.println("data_speed = " + data_speed);
*/
} // end if (first || refirst)
// convert x to a flow vector, and from spatial to earth
if (getRealVectorTypes(which_barb) instanceof EarthVectorType) {
// don't worry about vector magnitude -
// data_speed & display_speed take care of that
float eps = 0.0001f; // estimate derivative with a little vector
float[][] spatial_locs = {
{barbValues[0], barbValues[0] + eps * (x[0] - barbValues[0])},
{barbValues[1], barbValues[1] + eps * (x[1] - barbValues[1])},
{0.0f, 0.0f}
};
/*
System.out.println("spatial_locs = " + spatial_locs[0][0] + " " +
spatial_locs[0][1] + " " + spatial_locs[1][0] + " " +
spatial_locs[1][1]);
*/
float[][] earth_locs = spatialToEarth(spatial_locs);
// WLH - 18 Aug 99
if (earth_locs == null) return;
/*
System.out.println("earth_locs = " + earth_locs[0][0] + " " +
earth_locs[0][1] + " " + earth_locs[1][0] + " " +
earth_locs[1][1]);
*/
x[2] = 0.0f;
x[0] =
(earth_locs[1][1] - earth_locs[1][0])
* ((float) Math.cos(Data.DEGREES_TO_RADIANS * earth_locs[0][0]));
x[1] = earth_locs[0][1] - earth_locs[0][0];
/*
System.out.println("x = " + x[0] + " " + x[1] + " " + x[2]);
*/
} else { // if (!(getRealVectorTypes(which_barb) instanceof EarthVectorType))
// convert x to vector
x[0] -= barbValues[0];
x[1] -= barbValues[1];
// adjust for spatial map scalings but don't worry about vector
// magnitude - data_speed & display_speed take care of that
// also, spatial is Cartesian
double[] ranges = getRanges();
for (int i = 0; i < 3; i++) {
x[i] /= ranges[i];
}
/*
System.out.println("ranges = " + ranges[0] + " " + ranges[1] +
" " + ranges[2]);
System.out.println("x = " + x[0] + " " + x[1] + " " + x[2]);
*/
}
// WLH 6 August 99
x[0] = -x[0];
x[1] = -x[1];
x[2] = -x[2];
/* may need to do this for performance
float[] xx = {x[0], x[1], x[2]};
addPoint(xx);
*/
float x_speed = (float) Math.sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
/* WLH 16 April 2002 - from Ken
if (x_speed < 0.000001f) x_speed = 0.000001f;
*/
if (x_speed < 0.01f) x_speed = 0.01f;
if (first || refirst) {
display_speed = x_speed;
}
refirst = false;
if (mshift != 0) {
// only modify data_flow direction
float ratio = data_speed / x_speed;
x[0] *= ratio;
x[1] *= ratio;
x[2] *= ratio;
/*
System.out.println("direction, ratio = " + ratio + " " +
data_speed + " " + x_speed);
System.out.println("x = " + x[0] + " " + x[1] + " " + x[2]);
*/
} else if (mctrl != 0) {
// only modify data_flow speed
float ratio = x_speed / display_speed;
if (data_speed < EPS) {
data_flow[0] = 2.0f * EPS;
refirst = true;
}
x[0] = ratio * data_flow[0];
x[1] = ratio * data_flow[1];
x[2] = ratio * data_flow[2];
/*
System.out.println("speed, ratio = " + ratio + " " +
x_speed + " " + display_speed);
System.out.println("x = " + x[0] + " " + x[1] + " " + x[2]);
*/
} else {
// modify data_flow speed and direction
float ratio = data_speed / display_speed;
/*
System.out.println("data_speed = " + data_speed +
" display_speed = " + display_speed +
" ratio = " + ratio + " EPS = " + EPS);
System.out.println("x = " + x[0] + " " + x[1] +" " + x[2] +
" x_speed = " + x_speed);
data_speed = 21.213203 display_speed = 0.01 ratio = 2121.3203 EPS = 0.2
x = 1.6170928E-4 1.6021729E-4 -0.0 x_speed = 0.01
wind = (0.3430372, 0.33987218) at (-35.0, 5.0)
*/
if (data_speed < EPS) {
data_flow[0] = 2.0f * EPS;
x[0] = data_flow[0];
x[1] = data_flow[1];
x[2] = data_flow[2];
refirst = true;
} else {
x[0] *= ratio;
x[1] *= ratio;
x[2] *= ratio;
}
}
if (coord != null) {
float[][] xs = {{x[0]}, {x[1]}, {x[2]}};
xs = coord.fromReference(xs);
x[0] = xs[0][0];
x[1] = xs[1][0];
x[2] = xs[2][0];
}
// now replace flow values
Vector vect = new Vector();
for (int i = 0; i < 3; i++) {
int j = flowToComponent[i];
if (j >= 0) {
RealType rtype = (RealType) reals[j].getType();
reals[j] = new Real(rtype, (double) x[i], rtype.getDefaultUnit(), null);
// WLH 31 Aug 2000
Real r = reals[j];
Unit overrideUnit = null;
if (directMap[i] != null) {
overrideUnit = directMap[i].getOverrideUnit();
}
Unit rtunit = rtype.getDefaultUnit();
// units not part of Time string
if (overrideUnit != null
&& !overrideUnit.equals(rtunit)
&& !RealType.Time.equals(rtype)) {
double d = (float) overrideUnit.toThis((double) x[0], rtunit);
r = new Real(rtype, d, overrideUnit);
String valueString = r.toValueString();
vect.addElement(rtype.getName() + " = " + valueString);
} else {
// create location string
vect.addElement(rtype.getName() + " = " + x[i]);
}
}
}
getDisplayRenderer().setCursorStringVector(vect);
Data newData = null;
// now build new RealTuple or Flat Tuple
if (data instanceof RealTuple) {
newData =
new RealTuple(
((RealTupleType) data.getType()), reals, ((RealTuple) data).getCoordinateSystem());
} else {
Data[] new_components = new Data[m];
k = 0;
for (int i = 0; i < m; i++) {
Data component = data.getComponent(i);
if (component instanceof Real) {
new_components[i] = reals[k++];
} else if (component instanceof RealTuple) {
Real[] sub_reals = new Real[((RealTuple) component).getDimension()];
for (int j = 0; j < ((RealTuple) component).getDimension(); j++) {
sub_reals[j] = reals[k++];
}
new_components[i] =
new RealTuple(
((RealTupleType) component.getType()),
sub_reals,
((RealTuple) component).getCoordinateSystem());
}
}
newData = new Tuple(new_components, false);
}
ref.setData(newData);
} catch (VisADException e) {
// do nothing
System.out.println("drag_direct " + e);
e.printStackTrace();
} catch (RemoteException e) {
// do nothing
System.out.println("drag_direct " + e);
e.printStackTrace();
}
}
/** test BarbManipulationRendererJ3D */
public static void main(String args[]) throws VisADException, RemoteException {
System.out.println("BMR.main()");
// construct RealTypes for wind record components
RealType lat = RealType.Latitude;
RealType lon = RealType.Longitude;
RealType windx = RealType.getRealType("windx", CommonUnit.meterPerSecond);
RealType windy = RealType.getRealType("windy", CommonUnit.meterPerSecond);
RealType red = RealType.getRealType("red");
RealType green = RealType.getRealType("green");
// EarthVectorType extends RealTupleType and says that its
// components are vectors in m/s with components parallel
// to Longitude (positive east) and Latitude (positive north)
EarthVectorType windxy = new EarthVectorType(windx, windy);
RealType wind_dir = RealType.getRealType("wind_dir", CommonUnit.degree);
RealType wind_speed = RealType.getRealType("wind_speed", CommonUnit.meterPerSecond);
RealTupleType windds = null;
if (args.length > 0) {
System.out.println("polar winds");
windds =
new RealTupleType(
new RealType[] {wind_dir, wind_speed}, new WindPolarCoordinateSystem(windxy), null);
}
// construct Java3D display and mappings that govern
// how wind records are displayed
DisplayImpl display = new DisplayImplJ3D("display1", new TwoDDisplayRendererJ3D());
ScalarMap lonmap = new ScalarMap(lon, Display.XAxis);
display.addMap(lonmap);
ScalarMap latmap = new ScalarMap(lat, Display.YAxis);
display.addMap(latmap);
FlowControl flow_control;
if (args.length > 0) {
ScalarMap winds_map = new ScalarMap(wind_speed, Display.Flow1Radial);
display.addMap(winds_map);
winds_map.setRange(0.0, 1.0); // do this for barb rendering
ScalarMap windd_map = new ScalarMap(wind_dir, Display.Flow1Azimuth);
display.addMap(windd_map);
windd_map.setRange(0.0, 360.0); // do this for barb rendering
flow_control = (FlowControl) windd_map.getControl();
flow_control.setFlowScale(0.15f); // this controls size of barbs
} else {
ScalarMap windx_map = new ScalarMap(windx, Display.Flow1X);
display.addMap(windx_map);
windx_map.setRange(-1.0, 1.0); // do this for barb rendering
ScalarMap windy_map = new ScalarMap(windy, Display.Flow1Y);
display.addMap(windy_map);
windy_map.setRange(-1.0, 1.0); // do this for barb rendering
flow_control = (FlowControl) windy_map.getControl();
flow_control.setFlowScale(0.15f); // this controls size of barbs
}
display.addMap(new ScalarMap(red, Display.Red));
display.addMap(new ScalarMap(green, Display.Green));
display.addMap(new ConstantMap(1.0, Display.Blue));
DataReferenceImpl[] refs = new DataReferenceImpl[N * N];
int k = 0;
// create an array of N by N winds
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
double u = 2.0 * i / (N - 1.0) - 1.0;
double v = 2.0 * j / (N - 1.0) - 1.0;
// each wind record is a Tuple (lon, lat, (windx, windy), red, green)
// set colors by wind components, just for grins
Tuple tuple;
double fx = 30.0 * u;
double fy = 30.0 * v;
if (args.length > 0) {
double fd = Data.RADIANS_TO_DEGREES * Math.atan2(-fx, -fy);
double fs = Math.sqrt(fx * fx + fy * fy);
tuple =
new Tuple(
new Data[] {
new Real(lon, 10.0 * u),
new Real(lat, 10.0 * v - 40.0),
new RealTuple(windds, new double[] {fd, fs}),
new Real(red, u),
new Real(green, v)
});
} else {
tuple =
new Tuple(
new Data[] {
new Real(lon, 10.0 * u),
new Real(lat, 10.0 * v - 40.0),
new RealTuple(windxy, new double[] {fx, fy}),
new Real(red, u),
new Real(green, v)
});
}
// construct reference for wind record
refs[k] = new DataReferenceImpl("ref_" + k);
refs[k].setData(tuple);
// link wind record to display via BarbManipulationRendererJ3D
// so user can change barb by dragging it
// drag with right mouse button and shift to change direction
// drag with right mouse button and no shift to change speed
BarbManipulationRendererJ3D renderer = new BarbManipulationRendererJ3D();
renderer.setKnotsConvert(true);
display.addReferences(renderer, refs[k]);
// link wind record to a CellImpl that will listen for changes
// and print them
WindGetterJ3D cell = new WindGetterJ3D(flow_control, refs[k]);
cell.addReference(refs[k]);
k++;
}
}
// instead of linking the wind record "DataReferenceImpl refs" to
// the WindGetterJ3Ds, you can have some user interface event (e.g.,
// the user clicks on "DONE") trigger code that does a getData() on
// all the refs and stores the records in a file.
// create JFrame (i.e., a window) for display and slider
JFrame frame = new JFrame("test BarbManipulationRendererJ3D");
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// create JPanel in JFrame
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setAlignmentY(JPanel.TOP_ALIGNMENT);
panel.setAlignmentX(JPanel.LEFT_ALIGNMENT);
frame.getContentPane().add(panel);
// add display to JPanel
panel.add(display.getComponent());
// set size of JFrame and make it visible
frame.setSize(500, 500);
frame.setVisible(true);
}
/**
* run 'java FlowTest middle_latitude' to test with (lat, lon) run 'java FlowTest middle_latitude
* x' to test with (lon, lat) adjust middle_latitude for south or north
*/
public static void main(String args[]) throws VisADException, RemoteException {
double mid_lat = -10.0;
if (args.length > 0) {
try {
mid_lat = Double.valueOf(args[0]).doubleValue();
} catch (NumberFormatException e) {
}
}
boolean swap = (args.length > 1);
RealType lat = RealType.Latitude;
RealType lon = RealType.Longitude;
RealType[] types;
if (swap) {
types = new RealType[] {lon, lat};
} else {
types = new RealType[] {lat, lon};
}
RealTupleType earth_location = new RealTupleType(types);
System.out.println("earth_location = " + earth_location + " mid_lat = " + mid_lat);
RealType flowx = RealType.getRealType("flowx", CommonUnit.meterPerSecond);
RealType flowy = RealType.getRealType("flowy", CommonUnit.meterPerSecond);
RealType red = RealType.getRealType("red");
RealType green = RealType.getRealType("green");
EarthVectorType flowxy = new EarthVectorType(flowx, flowy);
TupleType range = null;
range = new TupleType(new MathType[] {flowxy, red, green});
FunctionType flow_field = new FunctionType(earth_location, range);
DisplayImpl display = new DisplayImplJ3D("display1", new TwoDDisplayRendererJ3D());
ScalarMap xmap = new ScalarMap(lon, Display.XAxis);
display.addMap(xmap);
ScalarMap ymap = new ScalarMap(lat, Display.YAxis);
display.addMap(ymap);
ScalarMap flowx_map = new ScalarMap(flowx, Display.Flow1X);
display.addMap(flowx_map);
flowx_map.setRange(-10.0, 10.0);
ScalarMap flowy_map = new ScalarMap(flowy, Display.Flow1Y);
display.addMap(flowy_map);
flowy_map.setRange(-10.0, 10.0);
FlowControl flow_control = (FlowControl) flowy_map.getControl();
flow_control.setFlowScale(0.05f);
display.addMap(new ScalarMap(red, Display.Red));
display.addMap(new ScalarMap(green, Display.Green));
display.addMap(new ConstantMap(1.0, Display.Blue));
double lonlow = -10.0;
double lonhi = 10.0;
double latlow = mid_lat - 10.0;
double lathi = mid_lat + 10.0;
Linear2DSet set;
if (swap) {
set = new Linear2DSet(earth_location, lonlow, lonhi, N, latlow, lathi, N);
} else {
set = new Linear2DSet(earth_location, latlow, lathi, N, lonlow, lonhi, N);
}
double[][] values = new double[4][N * N];
int m = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
int k = i;
int l = j;
if (swap) {
k = j;
l = i;
}
double u = (N - 1.0) / 2.0 - l;
double v = k - (N - 1.0) / 2.0;
// double u = 2.0 * k / (N - 1.0) - 1.0;
// double v = 2.0 * l / (N - 1.0);
double fx = 6.0 * u;
double fy = 6.0 * v;
values[0][m] = fx;
values[1][m] = fy;
values[2][m] = u;
values[3][m] = v;
m++;
}
}
FlatField field = new FlatField(flow_field, set);
field.setSamples(values);
DataReferenceImpl ref = new DataReferenceImpl("ref");
ref.setData(field);
display.addReference(ref);
// create JFrame (i.e., a window) for display and slider
JFrame frame = new JFrame("test FlowTest");
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// create JPanel in JFrame
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setAlignmentY(JPanel.TOP_ALIGNMENT);
panel.setAlignmentX(JPanel.LEFT_ALIGNMENT);
frame.getContentPane().add(panel);
// add display to JPanel
panel.add(display.getComponent());
// set size of JFrame and make it visible
frame.setSize(500, 500);
frame.setVisible(true);
}