Hi Jim,
> does anyone else have the problem where their text is
> rendered in white after they use TextControl.setFont()?
>
> It's as if my constant maps are being ignored...any ideas?
I was unable to duplicate this problem by experimenting with
the maps in visad/examples/Test69.java. Specifically, I
commented out:
// dpys[0].addMap(new ScalarMap(RealType.Latitude, Display.Green));
and set various constant values in the ConstantMaps to Blue
and Red, and it always worked as expected.
However, I did find an error with ConstantMap colors for
Shape, as you reported in an email sent only to me. The fix
is in the attached visad/java3d/ShadowTypeJ3D.java.
Cheers,
Bill
----------------------------------------------------------
Bill Hibbard, SSEC, 1225 W. Dayton St., Madison, WI 53706
hibbard@xxxxxxxxxxxxxxxxx 608-263-4427 fax: 608-263-6738
http://www.ssec.wisc.edu/~billh/vis.html
//
// ShadowTypeJ3D.java
//
/*
VisAD system for interactive analysis and visualization of numerical
data. Copyright (C) 1996 - 2001 Bill Hibbard, Curtis Rueden, Tom
Rink, Dave Glowacki, Steve Emmerson, Tom Whittaker, Don Murray, and
Tommy Jasmin.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA
*/
package visad.java3d;
import visad.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.util.Vector;
import java.util.Enumeration;
import java.rmi.*;
/**
The ShadowTypeJ3D hierarchy shadows the MathType hierarchy,
within a DataDisplayLink, under Java3D.<P>
*/
public abstract class ShadowTypeJ3D extends ShadowType {
/** basic information about this ShadowTypeJ3D */
MathType Type; // MathType being shadowed
transient DataDisplayLink Link;
transient DisplayImplJ3D display;
transient private Data data; // from Link.getData()
private ShadowTypeJ3D Parent;
// String and TextControl to pass on to children
String inheritedText = null;
TextControl inheritedTextControl = null;
ShadowType adaptedShadowType;
public ShadowTypeJ3D(MathType type, DataDisplayLink link,
ShadowType parent)
throws VisADException, RemoteException {
super(type, link, getAdaptedParent(parent));
Type = type;
Link = link;
display = (DisplayImplJ3D) link.getDisplay();
Parent = (ShadowTypeJ3D) parent;
data = link.getData();
}
public static ShadowType getAdaptedParent(ShadowType parent) {
if (parent == null) return null;
else return parent.getAdaptedShadowType();
}
public ShadowType getAdaptedShadowType() {
return adaptedShadowType;
}
public ShadowRealType[] getComponents(ShadowType type, boolean doRef)
throws VisADException {
return adaptedShadowType.getComponents(type, doRef);
}
public String getParentText() {
if (Parent != null && Parent.inheritedText != null &&
Parent.inheritedTextControl != null) {
return Parent.inheritedText;
}
else {
return null;
}
}
public TextControl getParentTextControl() {
if (Parent != null && Parent.inheritedText != null &&
Parent.inheritedTextControl != null) {
return Parent.inheritedTextControl;
}
else {
return null;
}
}
public void setText(String text, TextControl control) {
inheritedText = text;
inheritedTextControl = control;
}
public Data getData() {
return data;
}
public DisplayImpl getDisplay() {
return display;
}
public MathType getType() {
return Type;
}
public int getLevelOfDifficulty() {
return adaptedShadowType.getLevelOfDifficulty();
}
public boolean getMultipleDisplayScalar() {
return adaptedShadowType.getMultipleDisplayScalar();
}
public boolean getMappedDisplayScalar() {
return adaptedShadowType.getMappedDisplayScalar();
}
public int[] getDisplayIndices() {
return adaptedShadowType.getDisplayIndices();
}
public int[] getValueIndices() {
return adaptedShadowType.getValueIndices();
}
/** checkIndices: check for rendering difficulty, etc */
public int checkIndices(int[] indices, int[] display_indices,
int[] value_indices, boolean[] isTransform, int levelOfDifficulty)
throws VisADException, RemoteException {
return adaptedShadowType.checkIndices(indices, display_indices,
value_indices,
isTransform, levelOfDifficulty);
}
/** clear AccumulationVector */
public void preProcess() throws VisADException {
}
/** transform data into a Java3D scene graph;
add generated scene graph components as children of group;
value_array are inherited valueArray values;
default_values are defaults for each display.DisplayRealTypeVector;
return true if need post-process;
this is default (for ShadowTextType) */
public boolean doTransform(Object group, Data data, float[] value_array,
float[] default_values, DataRenderer renderer)
throws VisADException, RemoteException {
return false;
}
/** render accumulated Vector of value_array-s to
and add to group; then clear AccumulationVector */
public void postProcess(Object group) throws VisADException {
}
/* helpers for doTransform */
/** map values into display_values according to ScalarMap-s in reals */
public static void mapValues(float[][] display_values, double[][] values,
ShadowRealType[] reals) throws VisADException {
ShadowType.mapValues(display_values, values, reals);
}
/** map values into display_values according to ScalarMap-s in reals */
public static void mapValues(float[][] display_values, float[][] values,
ShadowRealType[] reals) throws VisADException {
ShadowType.mapValues(display_values, values, reals);
}
public static VisADGeometryArray makePointGeometry(float[][] spatial_values,
byte[][] color_values) throws VisADException {
return ShadowType.makePointGeometry(spatial_values, color_values);
}
/**
* Construct an Appearance object from a GeometryArray
* @param mode GraphicsModeControl
* @param constant_alpha transparency attributes
* @param constant_color color to use
* @param geometry geometry to use for the appearance
* @param no_material true to not use a Material for illumination,
* false to use it for 2-D geometries
*/
public static Appearance makeAppearance(GraphicsModeControl mode,
TransparencyAttributes constant_alpha,
ColoringAttributes constant_color,
GeometryArray geometry, boolean no_material) {
Appearance appearance = new Appearance();
LineAttributes line = new LineAttributes();
line.setLineWidth(mode.getLineWidth());
appearance.setLineAttributes(line);
PointAttributes point = new PointAttributes();
point.setPointSize(mode.getPointSize());
appearance.setPointAttributes(point);
PolygonAttributes polygon = new PolygonAttributes();
polygon.setCullFace(PolygonAttributes.CULL_NONE);
polygon.setPolygonMode(mode.getPolygonMode());
appearance.setPolygonAttributes(polygon);
RenderingAttributes rendering = new RenderingAttributes();
rendering.setDepthBufferEnable(true);
appearance.setRenderingAttributes(rendering);
if (constant_color != null) {
appearance.setColoringAttributes(constant_color);
}
// only do Material if geometry is 2-D (not 0-D points or 1-D lines)
if (!(geometry instanceof LineArray ||
geometry instanceof PointArray ||
geometry instanceof IndexedLineArray ||
geometry instanceof IndexedPointArray ||
geometry instanceof IndexedLineStripArray ||
geometry instanceof LineStripArray)) {
if (!no_material) {
Material material = new Material();
material.setSpecularColor(0.0f, 0.0f, 0.0f);
// no lighting in 2-D mode
if (!mode.getMode2D()) material.setLightingEnable(true);
appearance.setMaterial(material);
/*
int format = geometry.getVertexFormat();
if (constant_color != null && (format & GeometryArray.COLOR_3 ) {
float[] fc = new float[];
Color3f c = new Color3f();
constant_color.getColor(c);
c.x;
c.y;
c.z;
geometry.setColors(0, fc);
}
*/
}
if (constant_alpha != null) {
appearance.setTransparencyAttributes(constant_alpha);
}
}
return appearance;
}
/** collect and transform Shape DisplayRealType values from display_values;
offset by spatial_values, selected by range_select */
public VisADGeometryArray[] assembleShape(float[][] display_values,
int valueArrayLength, int[] valueToMap, Vector MapVector,
int[] valueToScalar, DisplayImpl display,
float[] default_values, int[] inherited_values,
float[][] spatial_values, byte[][] color_values,
boolean[][] range_select, int index, ShadowType shadow_api)
throws VisADException, RemoteException {
return adaptedShadowType.assembleShape(display_values, valueArrayLength,
valueToMap, MapVector, valueToScalar, display, default_values,
inherited_values, spatial_values, color_values, range_select, index,
shadow_api);
}
/** collect and transform spatial DisplayRealType values from display_values;
add spatial offset DisplayRealType values;
adjust flow1_values and flow2_values for any coordinate transform;
if needed, return a spatial Set from spatial_values, with the same
topology
as domain_set (or an appropriate Irregular topology);
domain_set = null and allSpatial = false if not called from
ShadowFunctionType */
public Set assembleSpatial(float[][] spatial_values,
float[][] display_values, int valueArrayLength,
int[] valueToScalar, DisplayImpl display,
float[] default_values, int[] inherited_values,
Set domain_set, boolean allSpatial, boolean set_for_shape,
int[] spatialDimensions, boolean[][] range_select,
float[][] flow1_values, float[][] flow2_values,
float[] flowScale, boolean[] swap, DataRenderer renderer,
ShadowType shadow_api)
throws VisADException, RemoteException {
return adaptedShadowType.assembleSpatial(spatial_values, display_values,
valueArrayLength, valueToScalar, display, default_values,
inherited_values, domain_set, allSpatial, set_for_shape,
spatialDimensions, range_select, flow1_values, flow2_values,
flowScale, swap, renderer, shadow_api);
}
/** assemble Flow components;
Flow components are 'single', so no compositing is required */
public void assembleFlow(float[][] flow1_values,
float[][] flow2_values, float[] flowScale,
float[][] display_values, int valueArrayLength,
int[] valueToScalar, DisplayImpl display,
float[] default_values, boolean[][] range_select,
DataRenderer renderer, ShadowType shadow_api)
throws VisADException, RemoteException {
adaptedShadowType.assembleFlow(flow1_values, flow2_values, flowScale,
display_values, valueArrayLength, valueToScalar,
display, default_values, range_select, renderer,
shadow_api);
}
public VisADGeometryArray[] makeFlow(int which, float[][] flow_values,
float flowScale, float[][] spatial_values,
byte[][] color_values, boolean[][] range_select)
throws VisADException {
return adaptedShadowType.makeFlow(which, flow_values, flowScale,
spatial_values, color_values, range_select);
}
public boolean makeContour(int valueArrayLength, int[] valueToScalar,
float[][] display_values, int[] inherited_values,
Vector MapVector, int[] valueToMap, int domain_length,
boolean[][] range_select, int spatialManifoldDimension,
Set spatial_set, byte[][] color_values, boolean indexed,
Object group, GraphicsModeControl mode, boolean[] swap,
float constant_alpha, float[] constant_color,
ShadowType shadow_api)
throws VisADException {
return adaptedShadowType.makeContour(valueArrayLength, valueToScalar,
display_values, inherited_values, MapVector, valueToMap,
domain_length, range_select, spatialManifoldDimension,
spatial_set, color_values, indexed, group, mode,
swap, constant_alpha, constant_color, shadow_api);
}
public VisADGeometryArray makeText(String[] text_values,
TextControl text_control, float[][] spatial_values,
byte[][] color_values, boolean[][] range_select)
throws VisADException {
return adaptedShadowType.makeText(text_values, text_control, spatial_values,
color_values, range_select);
}
/** composite and transform color and Alpha DisplayRealType values
from display_values, and return as (Red, Green, Blue, Alpha) */
public byte[][] assembleColor(float[][] display_values,
int valueArrayLength, int[] valueToScalar,
DisplayImpl display, float[] default_values,
boolean[][] range_select, boolean[] single_missing,
ShadowType shadow_api)
throws VisADException, RemoteException {
return adaptedShadowType.assembleColor(display_values, valueArrayLength,
valueToScalar, display, default_values, range_select,
single_missing, shadow_api);
}
/** return a composite of SelectRange DisplayRealType values from
display_values, as 0.0 for select and Double.Nan for no select
(these values can be added to other DisplayRealType values) */
public boolean[][] assembleSelect(float[][] display_values,
int domain_length, int valueArrayLength,
int[] valueToScalar, DisplayImpl display,
ShadowType shadow_api)
throws VisADException {
return adaptedShadowType.assembleSelect(display_values, domain_length,
valueArrayLength, valueToScalar, display, shadow_api);
}
public boolean terminalTupleOrScalar(Object group, float[][] display_values,
String text_value, TextControl text_control,
int valueArrayLength, int[] valueToScalar,
float[] default_values, int[] inherited_values,
DataRenderer renderer)
throws VisADException, RemoteException {
boolean post = adaptedShadowType.terminalTupleOrScalar(group,
display_values,
text_value, text_control, valueArrayLength,
valueToScalar,
default_values, inherited_values, renderer, this);
ensureNotEmpty(group);
return post;
}
/** this is a work-around for the NullPointerException at
javax.media.j3d.Shape3DRetained.setLive(Shape3DRetained.java:448) */
public void ensureNotEmpty(Object obj) {
ensureNotEmpty(obj, display);
}
public static void ensureNotEmpty(Object obj, DisplayImpl display) {
if (!(obj instanceof Group)) return;
Group group = (Group) obj;
if (group.numChildren() > 0) return;
GeometryArray geometry
new PointArray(1, GeometryArray.COORDINATES | GeometryArray.COLOR_3);
float[] coordinates = new float[3];
coordinates[0] = 1000000.0f;
coordinates[1] = 1000000.0f;
coordinates[2] = 1000000.0f;
geometry.setCoordinates(0, coordinates);
float[] colors = new float[3];
colors[0] = 0.0f;
colors[1] = 0.0f;
colors[2] = 0.0f;
geometry.setColors(0, colors);
Appearance appearance
makeAppearance(display.getGraphicsModeControl(), null, null, geometry,
false);
Shape3D shape = new Shape3D(geometry, appearance);
group.addChild(shape);
}
public boolean addToGroup(Object group, VisADGeometryArray array,
GraphicsModeControl mode,
float constant_alpha, float[] constant_color)
throws VisADException {
if (array != null && array.vertexCount > 0) {
float af = 0.0f;
TransparencyAttributes c_alpha = null;
if (constant_alpha == 1.0f) {
// constant opaque alpha = NONE
c_alpha = new TransparencyAttributes(TransparencyAttributes.NONE, 0.0f);
}
else if (constant_alpha == constant_alpha) {
c_alpha = new TransparencyAttributes(mode.getTransparencyMode(),
constant_alpha);
af = constant_alpha;
}
else {
// WLH - 18 Aug 99 - how could this have gone undetected for so long?
// c_alpha = new TransparencyAttributes(mode.getTransparencyMode(),
1.0f);
c_alpha = new TransparencyAttributes(mode.getTransparencyMode(), 0.0f);
}
ColoringAttributes c_color = null;
if (constant_color != null && constant_color.length == 3) {
c_color = new ColoringAttributes();
c_color.setColor(constant_color[0], constant_color[1],
constant_color[2]);
// WLH 16 Oct 2001
if (!(array instanceof VisADLineArray ||
array instanceof VisADPointArray ||
array instanceof VisADLineStripArray) &&
array.colors == null) {
int color_len = 3;
if (af != 0.0f) {
color_len = 4;
}
byte r = ShadowType.floatToByte(constant_color[0]);
byte g = ShadowType.floatToByte(constant_color[1]);
byte b = ShadowType.floatToByte(constant_color[2]);
int len = array.vertexCount * color_len;
byte[] colors = new byte[len];
int k = 0;
if (color_len == 3) {
for (int i=0; i<len; i+=3) {
colors[i] = r;
colors[i+1] = g;
colors[i+2] = b;
}
}
else {
byte a = ShadowType.floatToByte(af);
for (int i=0; i<len; i+=4) {
colors[i] = r;
colors[i+1] = g;
colors[i+2] = b;
colors[i+3] = a;
}
}
array.colors = colors;
}
}
// MEM - for coordinates if mode2d
GeometryArray geometry = display.makeGeometry(array);
Appearance appearance
makeAppearance(mode, c_alpha, c_color, geometry, false);
Shape3D shape = new Shape3D(geometry, appearance);
((Group) group).addChild(shape);
return true;
}
else {
return false;
}
}
public boolean addTextToGroup(Object group, VisADGeometryArray array,
GraphicsModeControl mode,
float constant_alpha, float[] constant_color)
throws VisADException {
if (array != null && array.vertexCount > 0) {
// MEM - for coordinates if mode2d
GeometryArray geometry = display.makeGeometry(array);
TransparencyAttributes c_alpha = null;
if (constant_alpha == 1.0f) {
// constant opaque alpha = NONE
c_alpha = new TransparencyAttributes(TransparencyAttributes.NONE, 0.0f);
}
else if (constant_alpha == constant_alpha) {
c_alpha = new TransparencyAttributes(mode.getTransparencyMode(),
constant_alpha);
}
else {
// WLH - 18 Aug 99 - how could this have gone undetected for so long?
// c_alpha = new TransparencyAttributes(mode.getTransparencyMode(),
1.0f);
c_alpha = new TransparencyAttributes(mode.getTransparencyMode(), 0.0f);
}
ColoringAttributes c_color = null;
if (constant_color != null && constant_color.length == 3) {
c_color = new ColoringAttributes();
c_color.setColor(constant_color[0], constant_color[1],
constant_color[2]);
}
Appearance appearance
makeAppearance(mode, c_alpha, c_color, geometry, false);
Shape3D shape = new Shape3D(geometry, appearance);
((Group) group).addChild(shape);
if (array instanceof VisADTriangleArray) {
GeometryArray geometry2 = display.makeGeometry(array);
Appearance appearance2
makeAppearance(mode, c_alpha, c_color, geometry2, false);
// LineAttributes la = appearance2.getLineAttributes();
// better without anti-aliasing
// la.setLineAntialiasingEnable(true);
PolygonAttributes pa = appearance2.getPolygonAttributes();
pa.setPolygonMode(PolygonAttributes.POLYGON_LINE);
Shape3D shape2 = new Shape3D(geometry2, appearance2);
((Group) group).addChild(shape2);
}
return true;
}
else {
return false;
}
}
public boolean allowConstantColorSurfaces() {
return false;
}
public String toString() {
return adaptedShadowType.toString();
}
}
