private FlatField changeRangeType(FlatField image, RealType newRangeType)
throws VisADException, RemoteException {
FunctionType ftype = (FunctionType) image.getType();
FlatField new_image =
new FlatField(new FunctionType(ftype.getDomain(), newRangeType), image.getDomainSet());
new_image.setSamples(image.getFloats(false), false);
return new_image;
}
// 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);
}
/**
* Converts grid-relative wind to true (or absolute) wind. The U and V components of true wind are
* {@link WesterlyWind} and {@link SoutherlyWind}, respectively. The domain of the input {@link
* visad.FlatField} must have a manifold dimension of two or greater and it must have a reference
* system which contains {@link visad.RealType#Latitude} and {@link visad.RealType#Longitude}. The
* number of components in the range of the input {@link visad.FlatField} must be two. Both
* components must have units convertible with {@link #DEFAULT_SPEED_UNIT}. The first and second
* components are assumed to be the wind components in the direction of increasing first and
* second manifold dimension indexes, respectively. The {@link visad.MathType} of the range of the
* returned {@link visad.FlatField} will be <code>CartesianHorizontalWind.getEarthVectorType()
* </code> and the domain will be the same as the input domain.
*
* @param rel The field of grid-relative wind.
* @return The field of true wind corresponding to the input field.
* @throws NullPointerException if <code>rel</code> is <code>null</code>.
* @throws IllegalArgumentException if the input field doesn't have two and only two components in
* its range, or if the default units of the input range aren't equal, or if the domain of the
* input field doesn't have a transformation to latitude and longitude, or the grid is
* irregular or has too few points.
* @throws VisADException if a VisAD failure occurs.
* @throws RemoteException if a Java RMI failure occurs.
* @see CartesianHorizontalWind
*/
public static FlatField cartesianHorizontalWind(FlatField rel)
throws VisADException, RemoteException {
FunctionType funcType = (FunctionType) rel.getType();
MathType rangeType = funcType.getRange();
if (rel.getRangeDimension() != 2) {
throw new IllegalArgumentException(rangeType.toString());
}
Unit[] units = rel.getDefaultRangeUnits();
if (!units[0].equals(units[1])) {
throw new IllegalArgumentException(units.toString());
}
SampledSet grid = (SampledSet) rel.getDomainSet();
// check for single point grid
if (grid instanceof SingletonSet) {
return rel;
} else if (grid instanceof GriddedSet) {
int[] lengths = ((GriddedSet) grid).getLengths();
if ((lengths[0] == 1) && (lengths[1] == 1)) {
return rel;
}
}
FlatField abs =
new FlatField(
new FunctionType(funcType.getDomain(), CartesianHorizontalWind.getEarthVectorType()),
grid,
(CoordinateSystem[]) null,
rel.getRangeSets(),
units);
abs.setSamples(trueWind(rel.getFloats(), grid), false);
return abs;
}
/**
* I have no idea what this does.
*
* @param grid sampling grid
* @param index some sort of index
* @return a new flat field with something different
* @throws RemoteException Java RMI error
* @throws VisADException VisAD error
*/
private static FlatField hatFieldOld(Set grid, int index) throws VisADException, RemoteException {
CoordinateSystem cs = grid.getCoordinateSystem();
boolean hasCS = (cs != null);
RealTupleType rtt = (hasCS) ? cs.getReference() : ((SetType) grid.getType()).getDomain();
int latI = rtt.getIndex(RealType.Latitude);
if (latI == -1) {
throw new IllegalArgumentException(grid.toString());
}
int lonI = rtt.getIndex(RealType.Longitude);
if (lonI == -1) {
throw new IllegalArgumentException(grid.toString());
}
if (grid.getManifoldDimension() < 2) {
throw new IllegalArgumentException(grid.toString());
}
int[][] neighbors = grid.getNeighbors(index);
LatLonPointImpl refPt = new LatLonPointImpl();
LatLonPointImpl neiPt = new LatLonPointImpl();
Bearing bearing = new Bearing();
float[] hat1 = new float[2];
float[] hat2 = new float[2];
float[][] hat = new float[2][grid.getLength()];
for (int i = 0; i < neighbors.length; i++) {
float[][] refCoords = grid.indexToValue(new int[] {i});
if (hasCS) {
refCoords = cs.toReference(refCoords);
}
float[][] neiCoords = grid.indexToValue(neighbors[i]);
if (hasCS) {
neiCoords = cs.toReference(neiCoords);
}
refPt.set(refCoords[latI][0], refCoords[lonI][0]);
compute(refPt, neiPt, neiCoords[latI][0], neiCoords[lonI][0], -180, bearing, hat1);
float d1 = (float) bearing.getDistance();
compute(refPt, neiPt, neiCoords[latI][1], neiCoords[lonI][1], 0, bearing, hat2);
float d2 = (float) bearing.getDistance();
boolean bad1 = Double.isNaN(d1);
boolean bad2 = Double.isNaN(d2);
if (bad1 && bad2) {
hat[0][i] = Float.NaN;
hat[1][i] = Float.NaN;
} else {
if (bad1) {
hat[0][i] = hat2[0];
hat[1][i] = hat2[1];
} else if (bad2) {
hat[0][i] = hat1[0];
hat[1][i] = hat1[1];
} else {
float tot = d1 + d2;
float c1 = d2 / tot;
float c2 = d1 / tot;
float xhat = c1 * hat1[0] + c2 * hat2[0];
float yhat = c1 * hat1[1] + c2 * hat2[1];
float mag = (float) Math.sqrt(xhat * xhat + yhat * yhat);
hat[0][i] = xhat / mag;
hat[1][i] = yhat / mag;
}
}
}
FlatField hatField =
new FlatField(
new FunctionType(
((SetType) grid.getType()).getDomain(),
new RealTupleType(
RealType.getRealType("xHat", CommonUnit.dimensionless),
RealType.getRealType("yHat", CommonUnit.dimensionless))),
grid);
hatField.setSamples(hat, false);
return hatField;
}
/**
* The returned {@link visad.FlatField} will have NaN-s for those unit vector components that
* could not be computed.
*
* @param grid The spatial grid.
* @param index The index of the manifold dimension along which to compute the unit vector.
* @return A field of components of the unit vector for the given manifold dimension.
* @throws NullPointerException if the grid is <code>null</code>.
* @throws IllegalArgumentException if the manifold dimension of the grid is less than 2 or if the
* grid doesn't contain {@link visad.RealType#Latitude} and {@link visad.RealType#Longitude}.
* @throws VisADException if a VisAD failure occurs.
* @throws RemoteException if a Java RMI failure occurs.
*/
private static FlatField hatFieldNew(Set grid, int index) throws VisADException, RemoteException {
CoordinateSystem cs = grid.getCoordinateSystem();
boolean hasCS = cs != null;
RealTupleType rtt = (hasCS) ? cs.getReference() : ((SetType) grid.getType()).getDomain();
int latI = rtt.getIndex(RealType.Latitude);
if (latI == -1) {
throw new IllegalArgumentException(rtt.toString());
}
int lonI = rtt.getIndex(RealType.Longitude);
if (lonI == -1) {
throw new IllegalArgumentException(rtt.toString());
}
if (grid.getManifoldDimension() < 2) {
throw new IllegalArgumentException(grid.toString());
}
int[][] neighbors = grid.getNeighbors(index);
LatLonPointImpl refPt = new LatLonPointImpl();
LatLonPointImpl neiPt = new LatLonPointImpl();
Bearing bearing = new Bearing();
float[] hat1 = new float[2];
float[] hat2 = new float[2];
float[][] hat = new float[2][grid.getLength()];
float[][] refCoords = null;
float[][] neiCoords = null;
float[][] domainSamples = grid.getSamples(false);
refCoords = (hasCS) ? cs.toReference(Set.copyFloats(domainSamples)) : domainSamples;
// If the grid is lat/lon or has an IdentityCoordinateSystem
// don't do the rotation
// TODO: handle rotated lat/lon grids
if (!hasCS
|| (refCoords == domainSamples)
|| (Arrays.equals(refCoords[latI], domainSamples[latI])
&& Arrays.equals(refCoords[lonI], domainSamples[lonI]))) {
if (index == 0) {
Arrays.fill(hat[0], 1);
Arrays.fill(hat[1], 0);
} else {
Arrays.fill(hat[0], 0);
Arrays.fill(hat[1], 1);
}
} else {
float latBefore, lonBefore, latAfter, lonAfter;
// int backOffset = (index==0) ? -180 : 0;
// int foreOffset = (index==0) ? 0 : -180;
int backOffset = -180;
int foreOffset = 0;
for (int i = 0; i < neighbors.length; i++) {
refPt.set(refCoords[latI][i], refCoords[lonI][i]);
if ((neighbors[i][0] < 0) || (neighbors[i][0] >= neighbors.length)) {
latBefore = Float.NaN;
lonBefore = Float.NaN;
} else {
latBefore = refCoords[latI][neighbors[i][0]];
lonBefore = refCoords[lonI][neighbors[i][0]];
}
if ((neighbors[i][1] < 0) || (neighbors[i][1] >= neighbors.length)) {
latAfter = Float.NaN;
lonAfter = Float.NaN;
} else {
latAfter = refCoords[latI][neighbors[i][1]];
lonAfter = refCoords[lonI][neighbors[i][1]];
}
compute(refPt, neiPt, latBefore, lonBefore, backOffset, bearing, hat1);
float d1 = (float) bearing.getDistance();
compute(refPt, neiPt, latAfter, lonAfter, foreOffset, bearing, hat2);
float d2 = (float) bearing.getDistance();
boolean bad1 = Double.isNaN(d1);
boolean bad2 = Double.isNaN(d2);
if (bad1 && bad2) {
hat[0][i] = Float.NaN;
hat[1][i] = Float.NaN;
} else {
if (bad1) {
hat[0][i] = hat2[0];
hat[1][i] = hat2[1];
} else if (bad2) {
hat[0][i] = hat1[0];
hat[1][i] = hat1[1];
} else {
float tot = d1 + d2;
float c1 = d2 / tot;
float c2 = d1 / tot;
float xhat = c1 * hat1[0] + c2 * hat2[0];
float yhat = c1 * hat1[1] + c2 * hat2[1];
float mag = (float) Math.sqrt(xhat * xhat + yhat * yhat);
hat[0][i] = xhat / mag;
hat[1][i] = yhat / mag;
}
}
}
}
FlatField hatField =
new FlatField(
new FunctionType(
((SetType) grid.getType()).getDomain(),
new RealTupleType(
RealType.getRealType("xHat", CommonUnit.dimensionless),
RealType.getRealType("yHat", CommonUnit.dimensionless))),
grid);
hatField.setSamples(hat, false);
return hatField;
}
/**
* Converts a time-series of grid-relative winds to a time-series of true (or absolute) winds. The
* U and V components of true wind are {@link WesterlyWind} and {@link SoutherlyWind},
* respectively. The domain of the input {@link visad.Field} must be a temporal {@link
* visad.Gridded1DSet} or a {@link visad.SingletonSet}. The range values of the input {@link
* visad.Field} must be {@link visad.FlatField}s. The domains of the range {@link
* visad.FlatField}s must have a manifold dimension of two or greater and they must have a
* reference system which contains {@link visad.RealType#Latitude} and {@link
* visad.RealType#Longitude}. The number of components in the range of the {@link
* visad.FlatField}s must be two. Both components must have units convertible with {@link
* #DEFAULT_SPEED_UNIT}. The first and second components are assumed to be the wind components in
* the direction of increasing first and second manifold dimension indexes, respectively. The
* domains of the {@link visad.FlatField}s must be equal. The {@link visad.Field} returned by this
* method has the same domain as the input {@link visad.Field}. The range values of the returned
* {@link visad.Field} are {@link visad.FlatField}s that have the same domain as the input {@link
* visad.FlatField}s. The {@link visad.MathType} of the range of the returned {@link
* visad.FlatField}s will be <code>CartesianHorizontalWind.getEarthVectorType()</code>.
*
* @param rel The time-series of grid-relative wind.
* @return The time-series of true wind corresponding to the input.
* @throws NullPointerException if <code>rel</code> is <code>null</code>.
* @throws IllegalArgumentException if the input field doesn't have a time-series domain, or if
* the range values aren't {@link visad.FlatField} with the same domain, or if the domain of
* the {@link visad.FlatField}s doesn't have a transformation to latitude and longitude, or if
* the domain is irregular or has too few points, or if the {@link visad.FlatField}s don't
* have two and only two components in their range, or if the default units of the {@link
* visad.FlatField}s range aren't equal.
* @throws VisADException if a VisAD failure occurs.
* @throws RemoteException if a Java RMI failure occurs.
* @see CartesianHorizontalWind
*/
public static Field timeSeriesCartesianHorizontalWind(Field rel)
throws VisADException, RemoteException {
FunctionType outerFuncType = (FunctionType) rel.getType();
RealTupleType outerDomType = outerFuncType.getDomain();
if (!(RealType.Time.equalsExceptNameButUnits(outerDomType)
|| !RealType.TimeInterval.equalsExceptNameButUnits(outerDomType))) {
throw new IllegalArgumentException(outerDomType.toString());
}
MathType innerFuncType = outerFuncType.getRange();
if (!(innerFuncType instanceof FunctionType)) {
throw new IllegalArgumentException(innerFuncType.toString());
}
Field innerField = (Field) rel.getSample(0);
Set innerDom = innerField.getDomainSet();
if (innerDom instanceof SingletonSet) {
return rel;
} else if (innerDom instanceof GriddedSet) {
int[] lengths = ((GriddedSet) innerDom).getLengths();
if ((lengths[0] == 1) && (lengths[1] == 1)) {
return rel;
}
}
// account for null units, assume m/sec
Unit[] rangeUnits = innerField.getDefaultRangeUnits();
if ((rangeUnits == null) || (rangeUnits[0] == null) || rangeUnits[0].isDimensionless()) {
rangeUnits = CartesianHorizontalWind.getEarthVectorType().getDefaultUnits();
}
FunctionType innerType =
new FunctionType(
((SetType) innerDom.getType()).getDomain(),
CartesianHorizontalWind.getEarthVectorType());
FlatField uvField =
new FlatField(innerType, innerDom, (CoordinateSystem) null, (Set[]) null, rangeUnits);
Field result =
new FieldImpl(new FunctionType(outerDomType, uvField.getType()), rel.getDomainSet());
// System.out.println("making rHatField");
Field rHatField = (doNewCode ? hatFieldNew(innerDom, 0) : hatFieldOld(innerDom, 0));
// System.out.println("making sHatField");
Field sHatField = (doNewCode ? hatFieldNew(innerDom, 1) : hatFieldOld(innerDom, 1));
float[][] rHats = rHatField.getFloats(false);
// ucar.unidata.util.Misc.printArray("rHats[0]", rHats[0]);
// ucar.unidata.util.Misc.printArray("rHats[1]", rHats[1]);
// System.out.println("\n");
float[][] sHats = sHatField.getFloats(false);
// ucar.unidata.util.Misc.printArray("sHats[0]", sHats[0]);
// ucar.unidata.util.Misc.printArray("sHats[1]", sHats[1]);
// System.out.println("\n");
float[] us = new float[innerDom.getLength()];
float[] vs = new float[us.length];
for (int i = 0, n = rel.getLength(); i < n; i++) {
if (i > 0) {
innerField = (Field) rel.getSample(i);
Set dom = innerField.getDomainSet();
if (!innerDom.equals(dom)) {
// System.out.println("new domain");
innerDom = dom;
rHatField = (doNewCode ? hatFieldNew(innerDom, 0) : hatFieldOld(innerDom, 0));
sHatField = (doNewCode ? hatFieldNew(innerDom, 1) : hatFieldOld(innerDom, 1));
rHats = rHatField.getFloats(false);
sHats = sHatField.getFloats(false);
/*
throw new IllegalArgumentException("template="
+ innerDom.toString() + "; domain="
+ dom.toString());
*/
}
uvField =
new FlatField(innerType, innerDom, (CoordinateSystem) null, (Set[]) null, rangeUnits);
us = new float[innerDom.getLength()];
vs = new float[us.length];
}
float[][] rsWinds = innerField.getFloats(false);
float[] rWinds = rsWinds[0];
float[] sWinds = rsWinds[1];
// ucar.unidata.util.Misc.printArray("rWinds", rWinds);
// System.out.println("\n");
// ucar.unidata.util.Misc.printArray("sWinds", sWinds);
// System.out.println("\n");
for (int j = 0; j < us.length; j++) {
us[j] = rWinds[j] * rHats[0][j] + sWinds[j] * sHats[0][j];
vs[j] = rWinds[j] * rHats[1][j] + sWinds[j] * sHats[1][j];
}
// ucar.unidata.util.Misc.printArray("us", us);
// System.out.println("\n");
// ucar.unidata.util.Misc.printArray("vs", vs);
// System.out.println("\n");
uvField.setSamples(new float[][] {us, vs}, false);
result.setSample(i, uvField, false);
}
return result;
}
/**
* Create a front from the curve
*
* @param curve the curve coordinates
* @param flip true to flip the pips
* @return The front as a FieldImpl
* @throws RemoteException On badness
* @throws VisADException On badness
*/
private FieldImpl curveToFront(float[][] curve, boolean flip)
throws VisADException, RemoteException {
if (flipTheFlip) {
flip = !flip;
}
// compute various scaling factors
int len = curve[0].length;
if (len < 2) {
return null;
}
float[] seg_length = new float[len - 1];
float curve_length = curveLength(curve, seg_length);
float delta = curve_length / (len - 1);
// curve[findex] where
// float findex = ibase + mul * repeat_shapes[shape][0][j]
float mul = rprofile_length * zoom / rsegment_length;
// curve_perp[][findex] * ratio * repeat_shapes[shape][1][j]
float ratio = delta * mul;
// compute unit perpendiculars to curve
float[][] curve_perp = new float[2][len];
for (int i = 0; i < len; i++) {
int im = i - 1;
int ip = i + 1;
if (im < 0) {
im = 0;
}
if (ip > len - 1) {
ip = len - 1;
}
float yp = curve[0][ip] - curve[0][im];
float xp = curve[1][ip] - curve[1][im];
xp = -xp;
float d = (float) Math.sqrt(xp * xp + yp * yp);
if (flip) {
d = -d;
}
xp = xp / d;
yp = yp / d;
curve_perp[0][i] = xp;
curve_perp[1][i] = yp;
}
// build Vector of FlatFields for each shape of each segment
Vector inner_field_vector = new Vector();
for (int segment = 0; true; segment++) {
// curve[findex] where
// float findex = ibase + mul * repeat_shapes[shape][0][j]
float segment_length = (segment == 0) ? fsegment_length : rsegment_length;
int profile_length = (segment == 0) ? fprofile_length : rprofile_length;
mul = profile_length * zoom / segment_length;
// curve_perp[][findex] * ratio * repeat_shapes[shape][1][j]
// float ratio = delta * mul;
// figure out if clipping is needed for this segment
// only happens for last segment
boolean clip = false;
float xclip = 0.0f;
// int ibase = segment * profile_length;
int ibase = (segment == 0) ? 0 : fprofile_length + (segment - 1) * rprofile_length;
int iend = ibase + profile_length;
if (ibase > len - 1) {
break;
}
if (iend > len - 1) {
clip = true;
iend = len - 1;
xclip = (iend - ibase) / mul;
}
// set up shapes for first or repeating segment
int nshapes = nrshapes;
float[][][] shapes = repeat_shapes;
int[][][] tris = repeat_tris;
float[] red = repeat_red;
float[] green = repeat_green;
float[] blue = repeat_blue;
if (segment == 0) {
nshapes = nfshapes;
shapes = first_shapes;
tris = first_tris;
red = first_red;
green = first_green;
blue = first_blue;
}
// iterate over shapes for segment
for (int shape = 0; shape < nshapes; shape++) {
float[][] samples = shapes[shape];
int[][] ts = tris[shape];
/*
// if needed, clip shape
if (clip) {
float[][][] outs = new float[1][][];
int[][][] outt = new int[1][][];
DelaunayCustom.clip(samples, ts, 1.0f, 0.0f, xclip, outs, outt);
samples = outs[0];
ts = outt[0];
}
*/
if ((samples == null) || (samples[0].length < 1)) {
break;
}
float[][] ss = mapShape(samples, len, ibase, mul, ratio, curve, curve_perp);
// **** get rid of previous calls to fill() ****
ts = DelaunayCustom.fill(ss);
// jeffmc: For now don't clip. This seems to fix the problem of too short a front
boolean DOCLIP = false;
if (clip && DOCLIP) {
float[][] clip_samples = {
{xclip, xclip, xclip - CLIP_DELTA},
{CLIP_DELTA, -CLIP_DELTA, 0.0f}
};
float[][] clip_ss = mapShape(clip_samples, len, ibase, mul, ratio, curve, curve_perp);
// now solve for:
// xc * clip_samples[0][0] + yc * clip_samples[1][0] = 1
// xc * clip_samples[0][1] + yc * clip_samples[1][1] = 1
// xc * clip_samples[0][2] + yc * clip_samples[1][2] < 1
float det =
(clip_samples[0][1] * clip_samples[1][0] - clip_samples[0][0] * clip_samples[1][1]);
float xc = (clip_samples[1][0] - clip_samples[1][1]) / det;
float yc = (clip_samples[0][1] - clip_samples[0][0]) / det;
float v = 1.0f;
if (xc * clip_samples[0][2] + yc * clip_samples[1][2] > v) {
xc = -xc;
yc = -yc;
v = -v;
}
float[][][] outs = new float[1][][];
int[][][] outt = new int[1][][];
DelaunayCustom.clip(ss, ts, xc, yc, v, outs, outt);
ss = outs[0];
ts = outt[0];
}
if (ss == null) {
break;
}
int n = ss[0].length;
// create color values for field
float[][] values = new float[3][n];
float r = red[shape];
float g = green[shape];
float b = blue[shape];
for (int i = 0; i < n; i++) {
values[0][i] = r;
values[1][i] = g;
values[2][i] = b;
}
// construct set and field
DelaunayCustom delaunay = new DelaunayCustom(ss, ts);
Irregular2DSet set = new Irregular2DSet(curve_type, ss, null, null, null, delaunay);
FlatField field = new FlatField(front_inner, set);
field.setSamples(values, false);
inner_field_vector.addElement(field);
// some crazy bug - see Gridded3DSet.makeNormals()
} // end for (int shape=0; shape<nshapes; shape++)
} // end for (int segment=0; true; segment++)
int nfields = inner_field_vector.size();
Integer1DSet iset = new Integer1DSet(front_index, nfields);
FieldImpl front = new FieldImpl(front_type, iset);
FlatField[] fields = new FlatField[nfields];
for (int i = 0; i < nfields; i++) {
fields[i] = (FlatField) inner_field_vector.elementAt(i);
}
front.setSamples(fields, false);
return front;
}
/**
* 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);
}
void setupServerData(LocalDisplay[] dpys) throws RemoteException, VisADException {
RealType xr = RealType.getRealType("xr");
RealType yr = RealType.getRealType("yr");
RealType zr = RealType.getRealType("zr");
RealType wr = RealType.getRealType("wr");
RealType[] types3d = {xr, yr, zr};
RealTupleType earth_location3d = new RealTupleType(types3d);
FunctionType grid_tuple = new FunctionType(earth_location3d, wr);
// int NX = 32;
// int NY = 32;
// int NZ = 32;
int NX = 35;
int NY = 35;
int NZ = 35;
Integer3DSet set = new Integer3DSet(NX, NY, NZ);
FlatField grid3d = new FlatField(grid_tuple, set);
float[][] values = new float[1][NX * NY * NZ];
int k = 0;
for (int iz = 0; iz < NZ; iz++) {
// double z = Math.PI * (-1.0 + 2.0 * iz / (NZ - 1.0));
double z = Math.PI * (-1.0 + 2.0 * iz * iz / ((NZ - 1.0) * (NZ - 1.0)));
for (int iy = 0; iy < NY; iy++) {
double y = -1.0 + 2.0 * iy / (NY - 1.0);
for (int ix = 0; ix < NX; ix++) {
double x = -1.0 + 2.0 * ix / (NX - 1.0);
double r = x - 0.5 * Math.cos(z);
double s = y - 0.5 * Math.sin(z);
double dist = Math.sqrt(r * r + s * s);
values[0][k] = (float) ((dist < 0.1) ? 10.0 : 1.0 / dist);
k++;
}
}
}
grid3d.setSamples(values);
dpys[0].addMap(new ScalarMap(xr, Display.XAxis));
dpys[0].addMap(new ScalarMap(yr, Display.YAxis));
dpys[0].addMap(new ScalarMap(zr, Display.ZAxis));
ScalarMap xrange = new ScalarMap(xr, Display.SelectRange);
ScalarMap yrange = new ScalarMap(yr, Display.SelectRange);
ScalarMap zrange = new ScalarMap(zr, Display.SelectRange);
dpys[0].addMap(xrange);
dpys[0].addMap(yrange);
dpys[0].addMap(zrange);
GraphicsModeControl mode = dpys[0].getGraphicsModeControl();
mode.setScaleEnable(true);
if (nice) mode.setTransparencyMode(DisplayImplJ3D.NICEST);
mode.setTexture3DMode(texture3DMode);
// new
RealType duh = RealType.getRealType("duh");
int NT = 32;
Linear2DSet set2 = new Linear2DSet(0.0, (double) NX, NT, 0.0, (double) NY, NT);
RealType[] types2d = {xr, yr};
RealTupleType domain2 = new RealTupleType(types2d);
FunctionType ftype2 = new FunctionType(domain2, duh);
float[][] v2 = new float[1][NT * NT];
for (int i = 0; i < NT * NT; i++) {
v2[0][i] = (i * i) % (NT / 2 + 3);
}
// float[][] v2 = {{1.0f,2.0f,3.0f,4.0f}};
FlatField field2 = new FlatField(ftype2, set2);
field2.setSamples(v2);
dpys[0].addMap(new ScalarMap(duh, Display.RGB));
ScalarMap map1color = new ScalarMap(wr, Display.RGBA);
dpys[0].addMap(map1color);
ColorAlphaControl control = (ColorAlphaControl) map1color.getControl();
control.setTable(buildTable(control.getTable()));
DataReferenceImpl ref_grid3d = new DataReferenceImpl("ref_grid3d");
ref_grid3d.setData(grid3d);
DataReferenceImpl ref2 = new DataReferenceImpl("ref2");
ref2.setData(field2);
ConstantMap[] cmaps = {new ConstantMap(0.0, Display.TextureEnable)};
dpys[0].addReference(ref2, cmaps);
dpys[0].addReference(ref_grid3d, null);
}