/**
* Converts grid-relative winds to true (or absolute) winds. The U and V components of true wind
* are {@link WesterlyWind} and {@link SoutherlyWind}, respectively. If the input {@link
* visad.Field} is not a time-series, then it must be a {@link visad.FlatField} and it must be
* compatible with the argument of {@link #cartesianHorizontalWind(FlatField)}. If, however, the
* the input {@link visad.Field} is a time-series, then its domain must be a temporal {@link
* visad.Gridded1DSet} or a {@link visad.SingletonSet} and its range values must be compatible
* with the argument of {@link #cartesianHorizontalWind(FlatField)}.
*
* @param rel The grid-relative winds.
* @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 is not a time-series and is incompatible
* with {@link #cartesianHorizontalWind(FlatField)}, or if the input field is a time-series
* but its range values are incompatible with {@link #cartesianHorizontalWind(FlatField)}.
* @throws VisADException if a VisAD failure occurs.
* @throws RemoteException if a Java RMI failure occurs.
*/
public static Field cartesianHorizontalWind(Field rel) throws VisADException, RemoteException {
RealTupleType domType = ((FunctionType) rel.getType()).getDomain();
Field result = null;
if (RealType.Time.equalsExceptNameButUnits(domType)
|| RealType.TimeInterval.equalsExceptNameButUnits(domType)) {
result = timeSeriesCartesianHorizontalWind(rel);
} else {
result = cartesianHorizontalWind((FlatField) rel);
}
return result;
}
/**
* 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;
}
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();
}
}