protected void initRenderingParams() {
   GraticuleRenderingParams params = new GraticuleRenderingParams();
   params.setValue(GraticuleRenderingParams.KEY_LINE_COLOR, new Color(.8f, .8f, .8f, .5f));
   params.setValue(GraticuleRenderingParams.KEY_LABEL_COLOR, new Color(1f, 1f, 1f, .8f));
   params.setValue(GraticuleRenderingParams.KEY_LABEL_FONT, Font.decode("Arial-Bold-14"));
   params.setValue(GraticuleRenderingParams.KEY_DRAW_LABELS, Boolean.TRUE);
   setRenderingParams(GRATICULE_UTM, params);
 }
  protected AnnotationAttributes getAnnotationPanelAttributes(String annoText) {
    AnnotationAttributes attrs = new AnnotationAttributes();

    attrs.setAdjustWidthToText(AVKey.SIZE_FIXED);
    attrs.setSize(this.computePanelSize(annoText));
    attrs.setFrameShape(AVKey.SHAPE_RECTANGLE);
    attrs.setTextColor(Color.WHITE);
    attrs.setBackgroundColor(new Color(0f, 0f, 0f, 0.6f));
    attrs.setCornerRadius(10);
    attrs.setInsets(new Insets(10, 10, 0, 0));
    attrs.setBorderColor(new Color(0xababab));
    attrs.setFont(Font.decode("Arial-PLAIN-12"));
    attrs.setTextAlign(AVKey.LEFT);

    return attrs;
  }
예제 #3
0
/**
 * A label drawn as part of a tactical graphic. The label is drawn at constant screen size. The
 * label can include multiple lines of text, and can optionally be kept aligned with features on the
 * globe. To align a label with the globe specify an {@link
 * #setOrientationPosition(gov.nasa.worldwind.geom.Position) orientationPosition} for the label. The
 * label will be drawn along a line connecting the label's position to the orientation position.
 *
 * @author pabercrombie
 * @version $Id$
 */
public class TacticalGraphicLabel implements OrderedRenderable {
  /** Default font. */
  public static final Font DEFAULT_FONT = Font.decode("Arial-BOLD-16");
  /**
   * Default offset. The default offset aligns the label horizontal with the text alignment
   * position, and centers the label vertically. For example, if the text alignment is <code>
   * AVKey.LEFT</code>, then the left edge of the text will be aligned with the geographic position,
   * and the label will be centered vertically.
   */
  public static final Offset DEFAULT_OFFSET = new Offset(0d, -0.5d, AVKey.FRACTION, AVKey.FRACTION);
  /** Default insets around the label. */
  public static final Insets DEFAULT_INSETS = new Insets(5, 5, 5, 5);
  /** Default interior opacity. */
  public static final double DEFAULT_INTERIOR_OPACITY = 0.7;
  /** Default text effect (shadow). */
  public static final String DEFAULT_TEXT_EFFECT = AVKey.TEXT_EFFECT_SHADOW;

  /** Text split into separate lines. */
  protected String[] lines;
  /** The label's geographic position. */
  protected Position position;
  /** Offset from the geographic position at which to draw the label. */
  protected Offset offset = DEFAULT_OFFSET;
  /** Text alignment for multi-line labels. */
  protected String textAlign = AVKey.LEFT;
  /** The label is drawn along a line from the label position to the orientation position. */
  protected Position orientationPosition;

  /** Material used to draw the label. */
  protected Material material = Material.BLACK;
  /** Opacity of the text, as a value between 0 and 1. */
  protected double opacity = 1.0;

  protected double interiorOpacity = DEFAULT_INTERIOR_OPACITY;
  /** Font used to draw the label. */
  protected Font font = DEFAULT_FONT;
  /** Space (in pixels) between lines in a multi-line label. */
  protected int lineSpacing = 5; // TODO compute default based on font size

  /**
   * Effect applied to the text. May be {@link AVKey#TEXT_EFFECT_SHADOW} or {@link
   * AVKey#TEXT_EFFECT_NONE}.
   */
  protected String effect = DEFAULT_TEXT_EFFECT;
  /**
   * Insets that separate the text from its frame. Only applies when the text interior is rendered.
   */
  protected Insets insets = DEFAULT_INSETS;
  /** Indicates whether or not to draw the label interior. */
  protected boolean drawInterior;

  /** Indicates whether or not batch rendering is enabled. */
  protected boolean enableBatchRendering = false;
  /** Indicates whether or not batch picking is enabled. */
  protected boolean enableBatchPicking = true;

  /** Indicates an object that represents the label during picking. */
  protected Object delegateOwner;

  // Computed each frame
  protected long frameTimeStamp = -1L;
  /** Geographic position in cartesian coordinates. */
  protected Vec4 placePoint;
  /** Location of the place point projected onto the screen. */
  protected Vec4 screenPlacePoint;
  /**
   * Location of the upper left corner of the text measured from the lower left corner of the
   * viewport. This point in OGL coordinates.
   */
  protected Point screenPoint;
  /**
   * Rotation applied to the label. This is computed each frame based on the orientation position.
   */
  protected Angle rotation;
  /**
   * Height of a line of text, computed in {@link
   * #computeBoundsIfNeeded(gov.nasa.worldwind.render.DrawContext)}.
   */
  protected int lineHeight;
  /** Size of the label. */
  protected Rectangle2D bounds;
  /** Cached bounds for each line of text. */
  protected Rectangle2D[] lineBounds;
  /** Extent of the label on the screen. */
  protected Rectangle screenExtent;
  /** Distance from the eye point to the label's geographic location. */
  protected double eyeDistance;

  /** Stack handler used for beginDrawing/endDrawing state. */
  protected OGLStackHandler BEogsh = new OGLStackHandler();
  /** Support object used during picking. */
  protected PickSupport pickSupport = new PickSupport();
  /** Active layer. */
  protected Layer pickLayer;

  /** Create a new empty label. */
  public TacticalGraphicLabel() {}

  /**
   * Create a new label.
   *
   * @param text Label text.
   */
  public TacticalGraphicLabel(String text) {
    this.setText(text);
  }

  /**
   * Indicates the text of this label.
   *
   * @return The label's text.
   */
  public String getText() {
    if (this.lines != null) {
      StringBuilder sb = new StringBuilder();

      for (int i = 0; i < this.lines.length - 1; i++) {
        sb.append(this.lines[i]).append("\n");
      }
      sb.append(this.lines[this.lines.length - 1]);

      return sb.toString();
    }

    return null;
  }

  /**
   * Specifies the text of this label. The text may include multiple lines, separated by newline
   * characters.
   *
   * @param text New text.
   */
  public void setText(String text) {
    if (text != null) this.lines = text.split("\n");
    else this.lines = null;

    this.bounds = null; // Need to recompute
  }

  /**
   * Indicates the label's position. The label is drawn at an offset from this position.
   *
   * @return The label's geographic position.
   * @see #getOffset()
   */
  public Position getPosition() {
    return this.position;
  }

  /**
   * Indicates the label's geographic position. The label is drawn at an offset from this position.
   *
   * @param position New position.
   * @see #getOffset()
   */
  public void setPosition(Position position) {
    this.position = position;

    // Label has moved, need to recompute screen extent. Explicitly set the extent to null so that
    // it will be
    // recomputed even if the application calls setPosition multiple times per frame.
    this.screenExtent = null;
  }

  /**
   * Indicates the current text alignment. Can be one of {@link AVKey#LEFT} (default), {@link
   * AVKey#CENTER} or {@link AVKey#RIGHT}.
   *
   * @return the current text alignment.
   */
  public String getTextAlign() {
    return this.textAlign;
  }

  /**
   * Specifies the text alignment. Can be one of {@link AVKey#LEFT} (default), {@link AVKey#CENTER},
   * or {@link AVKey#RIGHT}.
   *
   * @param textAlign New text alignment.
   */
  public void setTextAlign(String textAlign) {
    if (textAlign == null) {
      String message = Logging.getMessage("nullValue.StringIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.textAlign = textAlign;
  }

  /**
   * Indicates the offset from the geographic position at which to draw the label. See {@link
   * #setOffset(gov.nasa.worldwind.render.Offset) setOffset} for more information on how the offset
   * is interpreted.
   *
   * @return The offset at which to draw the label.
   */
  public Offset getOffset() {
    return this.offset;
  }

  /**
   * Specifies the offset from the geographic position at which to draw the label. The default
   * offset aligns the label horizontal with the text alignment position, and centers the label
   * vertically. For example, if the text alignment is <code>AVKey.LEFT</code>., then the left edge
   * of the text will be aligned with the geographic position, and the label will be centered
   * vertically.
   *
   * <p>When the text is rotated a horizontal offset moves the text along the orientation line, and
   * a vertical offset moves the text perpendicular to the orientation line.
   *
   * @param offset The offset at which to draw the label.
   */
  public void setOffset(Offset offset) {
    if (offset == null) {
      String message = Logging.getMessage("nullValue.OffsetIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.offset = offset;
  }

  /**
   * Indicates the font used to draw the label.
   *
   * @return The label's font.
   */
  public Font getFont() {
    return this.font;
  }

  /**
   * Specifies the font used to draw the label.
   *
   * @param font New font.
   */
  public void setFont(Font font) {
    if (font == null) {
      String message = Logging.getMessage("nullValue.FontIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    if (font != this.font) {
      this.font = font;
      this.bounds = null; // Need to recompute
    }
  }

  /**
   * Indicates the line spacing applied to multi-line labels.
   *
   * @return The space (in pixels) between lines of a multi-line label.
   */
  public int getLineSpacing() {
    return lineSpacing;
  }

  /**
   * Specifies the line spacing applied to multi-line labels.
   *
   * @param lineSpacing New line spacing.
   */
  public void setLineSpacing(int lineSpacing) {
    if (lineSpacing < 0) {
      String message = Logging.getMessage("generic.ArgumentOutOfRange");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.lineSpacing = lineSpacing;
  }

  /**
   * Indicates the material used to draw the label.
   *
   * @return The label's material.
   */
  public Material getMaterial() {
    return this.material;
  }

  /**
   * Specifies the material used to draw the label.
   *
   * @param material New material.
   */
  public void setMaterial(Material material) {
    if (material == null) {
      String message = Logging.getMessage("nullValue.MaterialIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.material = material;
  }

  /**
   * Indicates whether or not to draw a colored frame behind the label.
   *
   * @return <code>true</code> if the label's interior is drawn, otherwise <code>false</code>.
   * @see #setDrawInterior(boolean)
   */
  public boolean isDrawInterior() {
    return this.drawInterior;
  }

  /**
   * Specifies whether or not to draw a colored frame behind the label.
   *
   * @param drawInterior <code>true</code> if the label's interior is drawn, otherwise <code>false
   *     </code>.
   * @see #isDrawInterior()
   */
  public void setDrawInterior(boolean drawInterior) {
    this.drawInterior = drawInterior;
  }

  /**
   * Indicates the opacity of the text as a floating-point value in the range 0.0 to 1.0. A value of
   * 1.0 specifies a completely opaque text, and 0.0 specifies a completely transparent text. Values
   * in between specify a partially transparent text.
   *
   * @return the opacity of the text as a floating-point value from 0.0 to 1.0.
   */
  public double getOpacity() {
    return this.opacity;
  }

  /**
   * Specifies the opacity of the text as a floating-point value in the range 0.0 to 1.0. A value of
   * 1.0 specifies a completely opaque text, and 0.0 specifies a completely transparent text. Values
   * in between specify a partially transparent text.
   *
   * @param opacity the opacity of text as a floating-point value from 0.0 to 1.0.
   * @throws IllegalArgumentException if <code>opacity</code> is less than 0.0 or greater than 1.0.
   */
  public void setOpacity(double opacity) {
    if (opacity < 0 || opacity > 1) {
      String message = Logging.getMessage("generic.OpacityOutOfRange", opacity);
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.opacity = opacity;
  }

  /**
   * Indicates the opacity of label's interior as a floating-point value in the range 0.0 to 1.0. A
   * value of 1.0 specifies a completely opaque interior, and 0.0 specifies a completely transparent
   * interior. Values in between specify a partially transparent interior.
   *
   * @return the opacity of the interior as a floating-point value from 0.0 to 1.0.
   */
  public double getInteriorOpacity() {
    return this.interiorOpacity;
  }

  /**
   * Specifies the opacity of the label's interior as a floating-point value in the range 0.0 to
   * 1.0. A value of 1.0 specifies a completely opaque interior, and 0.0 specifies a completely
   * transparent interior. Values in between specify a partially transparent interior.
   *
   * @param interiorOpacity the opacity of label's interior as a floating-point value from 0.0 to
   *     1.0.
   * @throws IllegalArgumentException if <code>opacity</code> is less than 0.0 or greater than 1.0.
   */
  public void setInteriorOpacity(double interiorOpacity) {
    if (opacity < 0 || opacity > 1) {
      String message = Logging.getMessage("generic.OpacityOutOfRange", opacity);
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.interiorOpacity = interiorOpacity;
  }

  /**
   * Indicates the orientation position. The label oriented on a line drawn from the label's
   * position to the orientation position.
   *
   * @return Position used to orient the label. May be null.
   */
  public Position getOrientationPosition() {
    return this.orientationPosition;
  }

  /**
   * Specifies the orientation position. The label is oriented on a line drawn from the label's
   * position to the orientation position. If the orientation position is null then the label is
   * drawn with no rotation.
   *
   * @param orientationPosition Draw label oriented toward this position.
   */
  public void setOrientationPosition(Position orientationPosition) {
    this.orientationPosition = orientationPosition;
  }

  /**
   * Indicates the amount of space between the label's content and its frame, in pixels.
   *
   * @return the padding between the label's content and its frame, in pixels.
   * @see #setInsets(java.awt.Insets)
   */
  public Insets getInsets() {
    return this.insets;
  }

  /**
   * Specifies the amount of space (in pixels) between the label's content and the edges of the
   * label's frame.
   *
   * @param insets the desired padding between the label's content and its frame, in pixels.
   * @throws IllegalArgumentException if <code>insets</code> is <code>null</code>.
   * @see #getInsets()
   */
  public void setInsets(Insets insets) {
    if (insets == null) {
      String message = Logging.getMessage("nullValue.InsetsIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.insets = insets;
  }

  /**
   * Indicates an effect used to decorate the text. Can be one of {@link AVKey#TEXT_EFFECT_SHADOW}
   * (default), or {@link AVKey#TEXT_EFFECT_NONE}.
   *
   * @return the effect used for text rendering
   */
  public String getEffect() {
    return this.effect;
  }

  /**
   * Specifies an effect used to decorate the text. Can be one of {@link AVKey#TEXT_EFFECT_SHADOW}
   * (default), or {@link AVKey#TEXT_EFFECT_NONE}.
   *
   * @param effect the effect to use for text rendering
   */
  public void setEffect(String effect) {
    if (effect == null) {
      String message = Logging.getMessage("nullValue.StringIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.effect = effect;
  }

  /**
   * Returns the delegate owner of this label. If non-null, the returned object replaces the label
   * as the pickable object returned during picking. If null, the label itself is the pickable
   * object returned during picking.
   *
   * @return the object used as the pickable object returned during picking, or null to indicate the
   *     the label is returned during picking.
   */
  public Object getDelegateOwner() {
    return this.delegateOwner;
  }

  /**
   * Specifies the delegate owner of this label. If non-null, the delegate owner replaces the label
   * as the pickable object returned during picking. If null, the label itself is the pickable
   * object returned during picking.
   *
   * @param owner the object to use as the pickable object returned during picking, or null to
   *     return the label.
   */
  public void setDelegateOwner(Object owner) {
    this.delegateOwner = owner;
  }

  /**
   * Indicates whether batch picking is enabled.
   *
   * @return true if batch rendering is enabled, otherwise false.
   * @see #setEnableBatchPicking(boolean).
   */
  public boolean isEnableBatchPicking() {
    return this.enableBatchPicking;
  }

  /**
   * Specifies whether adjacent Labels in the ordered renderable list may be pick-tested together if
   * they are contained in the same layer. This increases performance but allows only the top-most
   * of the label to be reported in a {@link gov.nasa.worldwind.event.SelectEvent} even if several
   * of the labels are at the pick position.
   *
   * <p>Batch rendering ({@link #setEnableBatchRendering(boolean)}) must be enabled in order for
   * batch picking to occur.
   *
   * @param enableBatchPicking true to enable batch rendering, otherwise false.
   */
  public void setEnableBatchPicking(boolean enableBatchPicking) {
    this.enableBatchPicking = enableBatchPicking;
  }

  /**
   * Indicates whether batch rendering is enabled.
   *
   * @return true if batch rendering is enabled, otherwise false.
   * @see #setEnableBatchRendering(boolean).
   */
  public boolean isEnableBatchRendering() {
    return this.enableBatchRendering;
  }

  /**
   * Specifies whether adjacent Labels in the ordered renderable list may be rendered together if
   * they are contained in the same layer. This increases performance and there is seldom a reason
   * to disable it.
   *
   * @param enableBatchRendering true to enable batch rendering, otherwise false.
   */
  public void setEnableBatchRendering(boolean enableBatchRendering) {
    this.enableBatchRendering = enableBatchRendering;
  }

  /**
   * Get the label bounding {@link java.awt.Rectangle} using OGL coordinates - bottom-left corner x
   * and y relative to the {@link gov.nasa.worldwind.WorldWindow} bottom-left corner. If the label
   * is rotated then the returned rectangle is the bounding rectangle of the rotated label.
   *
   * @param dc the current DrawContext.
   * @return the label bounding {@link java.awt.Rectangle} using OGL viewport coordinates.
   * @throws IllegalArgumentException if <code>dc</code> is null.
   */
  public Rectangle getBounds(DrawContext dc) {
    if (dc == null) {
      String message = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.computeGeometryIfNeeded(dc);
    return this.screenExtent;
  }

  /**
   * Compute label geometry, if it has not already been computed this frame, or if the label
   * position has changed since the extent was last computed.
   *
   * @param dc Current geometry.
   */
  protected void computeGeometryIfNeeded(DrawContext dc) {
    // Re-use rendering state values already calculated this frame. If the screenExtent is null,
    // recompute even if
    // the timestamp is the same. This prevents using a stale position if the application calls
    // setPosition and
    // getBounds multiple times before the label is rendered.
    long timeStamp = dc.getFrameTimeStamp();
    if (timeStamp != this.frameTimeStamp || this.screenExtent == null) {
      this.computeGeometry(dc);
      this.frameTimeStamp = timeStamp;
    }
  }

  /**
   * Compute the bounds of the text, if necessary.
   *
   * @param dc the current DrawContext.
   */
  protected void computeBoundsIfNeeded(DrawContext dc) {
    // Do not compute bounds if they are available. Computing text bounds is expensive, so only do
    // this
    // calculation if necessary.
    if (this.bounds != null) return;

    TextRenderer textRenderer =
        OGLTextRenderer.getOrCreateTextRenderer(dc.getTextRendererCache(), this.getFont());

    int width = 0;
    int maxLineHeight = 0;
    this.lineBounds = new Rectangle2D[this.lines.length];

    for (int i = 0; i < this.lines.length; i++) {
      Rectangle2D lineBounds = textRenderer.getBounds(lines[i]);
      width = (int) Math.max(lineBounds.getWidth(), width);

      double thisLineHeight = Math.abs(lineBounds.getY());
      maxLineHeight = (int) Math.max(thisLineHeight, maxLineHeight);

      this.lineBounds[i] = lineBounds;
    }
    this.lineHeight = maxLineHeight;

    // Compute final height using maxLineHeight and number of lines
    this.bounds =
        new Rectangle(
            this.lines.length,
            maxLineHeight,
            width,
            this.lines.length * maxLineHeight + this.lines.length * this.lineSpacing);
  }

  /**
   * Compute the label's screen position from its geographic position.
   *
   * @param dc Current draw context.
   */
  protected void computeGeometry(DrawContext dc) {
    // Project the label position onto the viewport
    Position pos = this.getPosition();
    if (pos == null) return;

    this.placePoint = dc.computeTerrainPoint(pos.getLatitude(), pos.getLongitude(), 0);
    this.screenPlacePoint = dc.getView().project(this.placePoint);

    this.eyeDistance = this.placePoint.distanceTo3(dc.getView().getEyePoint());

    boolean orientationReversed = false;
    if (this.orientationPosition != null) {
      // Project the orientation point onto the screen
      Vec4 orientationPlacePoint =
          dc.computeTerrainPoint(
              this.orientationPosition.getLatitude(), this.orientationPosition.getLongitude(), 0);
      Vec4 orientationScreenPoint = dc.getView().project(orientationPlacePoint);

      this.rotation = this.computeRotation(this.screenPlacePoint, orientationScreenPoint);

      // The orientation is reversed if the orientation point falls to the right of the screen
      // point. Text is
      // never drawn upside down, so when the orientation is reversed the text flips vertically to
      // keep the text
      // right side up.
      orientationReversed = (orientationScreenPoint.x <= this.screenPlacePoint.x);
    }

    this.computeBoundsIfNeeded(dc);

    Offset offset = this.getOffset();
    Point2D offsetPoint =
        offset.computeOffset(this.bounds.getWidth(), this.bounds.getHeight(), null, null);

    // If a rotation is applied to the text, then rotate the offset as well. An offset in the x
    // direction
    // will move the text along the orientation line, and a offset in the y direction will move the
    // text
    // perpendicular to the orientation line.
    if (this.rotation != null) {
      double dy = offsetPoint.getY();

      // If the orientation is reversed we need to adjust the vertical offset to compensate for the
      // flipped
      // text. For example, if the offset normally aligns the top of the text with the place point
      // then without
      // this adjustment the bottom of the text would align with the place point when the
      // orientation is
      // reversed.
      if (orientationReversed) {
        dy = -(dy + this.bounds.getHeight());
      }

      Vec4 pOffset = new Vec4(offsetPoint.getX(), dy);
      Matrix rot = Matrix.fromRotationZ(this.rotation.multiply(-1));

      pOffset = pOffset.transformBy3(rot);

      offsetPoint = new Point((int) pOffset.getX(), (int) pOffset.getY());
    }

    int x = (int) (this.screenPlacePoint.x + offsetPoint.getX());
    int y = (int) (this.screenPlacePoint.y - offsetPoint.getY());

    this.screenPoint = new Point(x, y);
    this.screenExtent = this.computeTextExtent(x, y, this.rotation);
  }

  /**
   * Determine if this label intersects the view or pick frustum.
   *
   * @param dc Current draw context.
   * @return True if this label intersects the active frustum (view or pick). Otherwise false.
   */
  protected boolean intersectsFrustum(DrawContext dc) {
    View view = dc.getView();
    Frustum frustum = view.getFrustumInModelCoordinates();

    // Test the label's model coordinate point against the near and far clipping planes.
    if (this.placePoint != null
        && (frustum.getNear().distanceTo(this.placePoint) < 0
            || frustum.getFar().distanceTo(this.placePoint) < 0)) {
      return false;
    }

    if (dc.isPickingMode()) return dc.getPickFrustums().intersectsAny(this.screenExtent);
    else return view.getViewport().intersects(this.screenExtent);
  }

  /**
   * Compute the amount of rotation to apply to a label in order to keep it oriented toward its
   * orientation position.
   *
   * @param screenPoint Geographic position of the text, projected onto the screen.
   * @param orientationScreenPoint Orientation position, projected onto the screen.
   * @return The rotation angle to apply when drawing the label.
   */
  protected Angle computeRotation(Vec4 screenPoint, Vec4 orientationScreenPoint) {
    // Determine delta between the orientation position and the label position
    double deltaX = screenPoint.x - orientationScreenPoint.x;
    double deltaY = screenPoint.y - orientationScreenPoint.y;

    if (deltaX != 0) {
      double angle = Math.atan(deltaY / deltaX);
      return Angle.fromRadians(angle);
    } else {
      return Angle.POS90; // Vertical label
    }
  }

  /** {@inheritDoc} */
  public double getDistanceFromEye() {
    return this.eyeDistance;
  }

  /** {@inheritDoc} */
  public void render(DrawContext dc) {
    // This render method is called three times during frame generation. It's first called as a
    // Renderable
    // during Renderable picking. It's called again during normal rendering. And it's called a third
    // time as an OrderedRenderable. The first two calls determine whether to add the label the
    // ordered renderable
    // list during pick and render. The third call just draws the ordered renderable.

    if (dc == null) {
      String msg = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }

    if (dc.isOrderedRenderingMode()) this.drawOrderedRenderable(dc);
    else this.makeOrderedRenderable(dc);
  }

  /** {@inheritDoc} */
  public void pick(DrawContext dc, Point pickPoint) {
    // This method is called only when ordered renderables are being drawn.
    // Arg checked within call to render.

    if (dc == null) {
      String msg = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }

    this.pickSupport.clearPickList();
    try {
      this.pickSupport.beginPicking(dc);
      this.render(dc);
    } finally {
      this.pickSupport.endPicking(dc);
      this.pickSupport.resolvePick(dc, pickPoint, this.pickLayer);
    }
  }

  /**
   * Draws the graphic as an ordered renderable.
   *
   * @param dc the current draw context.
   */
  protected void makeOrderedRenderable(DrawContext dc) {
    if (this.lines == null || this.position == null) return;

    this.computeGeometryIfNeeded(dc);

    // Don't draw if beyond the horizon.
    double horizon = dc.getView().getHorizonDistance();
    if (this.eyeDistance > horizon) return;

    if (this.intersectsFrustum(dc)) dc.addOrderedRenderable(this);

    if (dc.isPickingMode()) this.pickLayer = dc.getCurrentLayer();
  }

  /**
   * Draws the graphic as an ordered renderable.
   *
   * @param dc the current draw context.
   */
  protected void drawOrderedRenderable(DrawContext dc) {
    this.beginDrawing(dc);
    try {
      this.doDrawOrderedRenderable(dc, this.pickSupport);

      if (this.isEnableBatchRendering()) this.drawBatched(dc);
    } finally {
      this.endDrawing(dc);
    }
  }

  /**
   * Draw this label during ordered rendering.
   *
   * @param dc Current draw context.
   * @param pickSupport Support object used during picking.
   */
  protected void doDrawOrderedRenderable(DrawContext dc, PickSupport pickSupport) {
    TextRenderer textRenderer =
        OGLTextRenderer.getOrCreateTextRenderer(dc.getTextRendererCache(), font);
    if (dc.isPickingMode()) {
      this.doPick(dc, pickSupport);
    } else {
      this.drawText(dc, textRenderer);
    }
  }

  /**
   * Establish the OpenGL state needed to draw text.
   *
   * @param dc the current draw context.
   */
  protected void beginDrawing(DrawContext dc) {
    GL gl = dc.getGL();

    int attrMask =
        GL.GL_DEPTH_BUFFER_BIT // for depth test, depth mask and depth func
            | GL.GL_TRANSFORM_BIT // for modelview and perspective
            | GL.GL_VIEWPORT_BIT // for depth range
            | GL.GL_CURRENT_BIT // for current color
            | GL.GL_COLOR_BUFFER_BIT // for alpha test func and ref, and blend
            | GL.GL_DEPTH_BUFFER_BIT // for depth func
            | GL.GL_ENABLE_BIT; // for enable/disable changes

    this.BEogsh.pushAttrib(gl, attrMask);

    if (!dc.isPickingMode()) {
      gl.glEnable(GL.GL_BLEND);
      OGLUtil.applyBlending(gl, false);
    }

    // Do not depth buffer the label. (Labels beyond the horizon are culled above.)
    gl.glDisable(GL.GL_DEPTH_TEST);
    gl.glDepthMask(false);

    // The image is drawn using a parallel projection.
    this.BEogsh.pushProjectionIdentity(gl);
    gl.glOrtho(
        0d, dc.getView().getViewport().width, 0d, dc.getView().getViewport().height, -1d, 1d);

    this.BEogsh.pushModelviewIdentity(gl);
  }

  /**
   * Pop the state set in beginDrawing.
   *
   * @param dc the current draw context.
   */
  protected void endDrawing(DrawContext dc) {
    this.BEogsh.pop(dc.getGL());
  }

  /**
   * Draw labels for picking.
   *
   * @param dc Current draw context.
   * @param pickSupport the PickSupport instance to be used.
   */
  protected void doPick(DrawContext dc, PickSupport pickSupport) {
    GL gl = dc.getGL();

    Angle heading = this.rotation;

    double headingDegrees;
    if (heading != null) headingDegrees = heading.degrees;
    else headingDegrees = 0;

    int x = this.screenPoint.x;
    int y = this.screenPoint.y;

    boolean matrixPushed = false;
    try {
      if (headingDegrees != 0) {
        gl.glPushMatrix();
        matrixPushed = true;

        gl.glTranslated(x, y, 0);
        gl.glRotated(headingDegrees, 0, 0, 1);
        gl.glTranslated(-x, -y, 0);
      }

      for (int i = 0; i < this.lines.length; i++) {
        Rectangle2D bounds = this.lineBounds[i];
        double width = bounds.getWidth();
        double height = bounds.getHeight();

        x = this.screenPoint.x;
        if (this.textAlign.equals(AVKey.CENTER)) x = x - (int) (width / 2.0);
        else if (this.textAlign.equals(AVKey.RIGHT)) x = x - (int) width;
        y -= this.lineHeight;

        Color color = dc.getUniquePickColor();
        int colorCode = color.getRGB();
        PickedObject po = new PickedObject(colorCode, this.getPickedObject(), this.position, false);
        pickSupport.addPickableObject(po);

        // Draw line rectangle
        gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());

        try {
          gl.glBegin(GL.GL_POLYGON);
          gl.glVertex3d(x, y, 0);
          gl.glVertex3d(x + width - 1, y, 0);
          gl.glVertex3d(x + width - 1, y + height - 1, 0);
          gl.glVertex3d(x, y + height - 1, 0);
          gl.glVertex3d(x, y, 0);
        } finally {
          gl.glEnd();
        }

        y -= this.lineSpacing;
      }
    } finally {
      if (matrixPushed) {
        gl.glPopMatrix();
      }
    }
  }

  /**
   * Draw the label's text. This method sets up the text renderer, and then calls {@link
   * #doDrawText(TextRenderer) doDrawText} to actually draw the text.
   *
   * @param dc Current draw context.
   * @param textRenderer Text renderer.
   */
  protected void drawText(DrawContext dc, TextRenderer textRenderer) {
    GL gl = dc.getGL();

    Angle heading = this.rotation;

    double headingDegrees;
    if (heading != null) headingDegrees = heading.degrees;
    else headingDegrees = 0;

    boolean matrixPushed = false;
    try {
      int x = this.screenPoint.x;
      int y = this.screenPoint.y;

      if (headingDegrees != 0) {
        gl.glPushMatrix();
        matrixPushed = true;

        gl.glTranslated(x, y, 0);
        gl.glRotated(headingDegrees, 0, 0, 1);
        gl.glTranslated(-x, -y, 0);
      }

      if (this.isDrawInterior()) this.drawInterior(dc);

      textRenderer.begin3DRendering();
      try {
        this.doDrawText(textRenderer);

        // Draw other labels that share the same text renderer configuration, if possible.
        if (this.isEnableBatchRendering()) this.drawBatchedText(dc, textRenderer);
      } finally {
        textRenderer.end3DRendering();
      }
    } finally {
      if (matrixPushed) {
        gl.glPopMatrix();
      }
    }
  }

  /**
   * Render the label interior as a filled rectangle.
   *
   * @param dc Current draw context.
   */
  protected void drawInterior(DrawContext dc) {
    GL gl = dc.getGL();

    double width = this.bounds.getWidth();
    double height = this.bounds.getHeight();

    int x = this.screenPoint.x;
    int y = this.screenPoint.y;

    // Adjust x to account for text alignment
    int xAligned = x;
    if (AVKey.CENTER.equals(textAlign)) xAligned = x - (int) (width / 2);
    else if (AVKey.RIGHT.equals(textAlign)) xAligned = x - (int) width;

    // We draw text top-down, so adjust y to compensate.
    int yAligned = (int) (y - height);

    // Apply insets
    Insets insets = this.getInsets();
    xAligned -= insets.left;
    width = width + insets.left + insets.right;
    yAligned -= insets.bottom;
    height = height + insets.bottom + insets.top;

    if (!dc.isPickingMode()) {
      // Apply the frame background color and opacity if we're in normal rendering mode.
      Color color = this.computeBackgroundColor(this.getMaterial().getDiffuse());
      gl.glColor4ub(
          (byte) color.getRed(),
          (byte) color.getGreen(),
          (byte) color.getBlue(),
          (byte) (this.interiorOpacity < 1 ? (int) (this.interiorOpacity * 255 + 0.5) : 255));
    }

    try {
      // Draw a quad
      gl.glPushMatrix();
      gl.glTranslated(xAligned, yAligned, 0);
      gl.glScaled(width, height, 1.0);
      dc.drawUnitQuad();
    } finally {
      gl.glPopMatrix();
    }
  }

  /**
   * Draw the label's text. This method assumes that the text renderer context has already been set
   * up.
   *
   * @param textRenderer renderer to use.
   */
  protected void doDrawText(TextRenderer textRenderer) {
    Color color = this.material.getDiffuse();
    Color backgroundColor = this.computeBackgroundColor(color);
    float opacity = (float) this.getOpacity();

    int x = this.screenPoint.x;
    int y = this.screenPoint.y;

    float[] compArray = new float[3];
    if (AVKey.TEXT_EFFECT_SHADOW.equals(this.effect) && backgroundColor != null) {
      backgroundColor.getRGBColorComponents(compArray);

      textRenderer.setColor(compArray[0], compArray[1], compArray[2], opacity);
      this.drawMultiLineText(textRenderer, x + 1, y - 1);
    }

    color.getRGBColorComponents(compArray);
    textRenderer.setColor(compArray[0], compArray[1], compArray[2], opacity);
    this.drawMultiLineText(textRenderer, x, y);
  }

  protected void drawMultiLineText(TextRenderer textRenderer, int x, int y) {
    if (this.lines == null) {
      String msg = Logging.getMessage("nullValue.StringIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }

    for (int i = 0; i < this.lines.length; i++) {
      String line = this.lines[i];
      Rectangle2D bounds = this.lineBounds[i];

      int xAligned = x;
      if (this.textAlign.equals(AVKey.CENTER)) xAligned = x - (int) (bounds.getWidth() / 2);
      else if (this.textAlign.equals(AVKey.RIGHT)) xAligned = x - (int) (bounds.getWidth());

      y -= this.lineHeight;
      textRenderer.draw3D(line, xAligned, y, 0, 1);
      y -= this.lineSpacing;
    }
  }

  /**
   * Draws this ordered renderable and all subsequent Label ordered renderables in the ordered
   * renderable list. This method differs from {@link
   * #drawBatchedText(gov.nasa.worldwind.render.DrawContext, TextRenderer) drawBatchedText} in that
   * this method re-initializes the text renderer to draw the next label, while {@code
   * drawBatchedText} re-uses the active text renderer context. That is, {@code drawBatchedText}
   * attempts to draw as many labels as possible that share same text renderer configuration as this
   * label, and this method attempts to draw as many labels as possible regardless of the text
   * renderer configuration of the subsequent labels.
   *
   * @param dc the current draw context.
   */
  protected void drawBatched(DrawContext dc) {
    // Draw as many as we can in a batch to save ogl state switching.
    Object nextItem = dc.peekOrderedRenderables();

    if (!dc.isPickingMode()) {
      while (nextItem != null && nextItem instanceof TacticalGraphicLabel) {
        TacticalGraphicLabel nextLabel = (TacticalGraphicLabel) nextItem;
        if (!nextLabel.isEnableBatchRendering()) break;

        dc.pollOrderedRenderables(); // take it off the queue
        nextLabel.doDrawOrderedRenderable(dc, this.pickSupport);

        nextItem = dc.peekOrderedRenderables();
      }
    } else if (this.isEnableBatchPicking()) {
      while (nextItem != null && nextItem instanceof TacticalGraphicLabel) {
        TacticalGraphicLabel nextLabel = (TacticalGraphicLabel) nextItem;
        if (!nextLabel.isEnableBatchRendering() || !nextLabel.isEnableBatchPicking()) break;

        if (nextLabel.pickLayer != this.pickLayer) // batch pick only within a single layer
        break;

        dc.pollOrderedRenderables(); // take it off the queue
        nextLabel.doDrawOrderedRenderable(dc, this.pickSupport);

        nextItem = dc.peekOrderedRenderables();
      }
    }
  }

  /**
   * Draws text for subsequent Label ordered renderables in the ordered renderable list. This method
   * is called after the text renderer has been set up (after beginRendering has been called), so
   * this method can only draw text for subsequent labels that use the same font and rotation as
   * this label. This method differs from {@link #drawBatched(gov.nasa.worldwind.render.DrawContext)
   * drawBatched} in that this method reuses the active text renderer context to draw as many labels
   * as possible without switching text renderer state.
   *
   * @param dc the current draw context.
   * @param textRenderer Text renderer used to draw the label.
   */
  protected void drawBatchedText(DrawContext dc, TextRenderer textRenderer) {
    // Draw as many as we can in a batch to save ogl state switching.
    Object nextItem = dc.peekOrderedRenderables();

    if (!dc.isPickingMode()) {
      while (nextItem != null && nextItem instanceof TacticalGraphicLabel) {
        TacticalGraphicLabel nextLabel = (TacticalGraphicLabel) nextItem;
        if (!nextLabel.isEnableBatchRendering()) break;

        boolean sameFont = this.font.equals(nextLabel.getFont());
        boolean sameRotation =
            (this.rotation == null && nextLabel.rotation == null)
                || (this.rotation != null && this.rotation.equals(nextLabel.rotation));
        boolean drawInterior = nextLabel.isDrawInterior();

        // We've already set up the text renderer state, so we can can't change the font or text
        // rotation.
        // Also can't batch render if the next label needs an interior since that will require
        // tearing down the
        // text renderer context.
        if (!sameFont || !sameRotation || drawInterior) break;

        dc.pollOrderedRenderables(); // take it off the queue
        nextLabel.doDrawText(textRenderer);

        nextItem = dc.peekOrderedRenderables();
      }
    }
  }

  /**
   * Indicates the object that represents this label during picking.
   *
   * @return If a delegate owner is set, returns the delegate owner. Otherwise returns this label.
   */
  protected Object getPickedObject() {
    Object owner = this.getDelegateOwner();
    return (owner != null) ? owner : this;
  }

  /**
   * Determine the screen rectangle covered by a label. The input coordinate identifies either the
   * top left, top center, or top right corner of the label, depending on the text alignment. If the
   * label is rotated to align with features on the surface then the extent will be the smallest
   * screen rectangle that completely encloses the rotated label.
   *
   * @param x X coordinate at which to draw the label.
   * @param y Y coordinate at which to draw the label.
   * @param rotation Label rotation.
   * @return The rectangle, in OGL screen coordinates (origin at bottom left corner), that is
   *     covered by the label.
   */
  protected Rectangle computeTextExtent(int x, int y, Angle rotation) {
    double width = this.bounds.getWidth();
    double height = this.bounds.getHeight();

    String textAlign = this.getTextAlign();

    int xAligned = x;
    if (AVKey.CENTER.equals(textAlign)) xAligned = x - (int) (width / 2);
    else if (AVKey.RIGHT.equals(textAlign)) xAligned = x - (int) width;

    int yAligned = (int) (y - height);

    Rectangle screenRect = new Rectangle(xAligned, yAligned, (int) width, (int) height);

    // Compute bounds of the rotated rectangle, if there is a rotation angle.
    if (rotation != null && rotation.degrees != 0) {
      screenRect = this.computeRotatedScreenExtent(screenRect, x, y, rotation);
    }

    return screenRect;
  }

  /**
   * Compute the bounding screen extent of a rotated rectangle.
   *
   * @param rect Rectangle to rotate.
   * @param x X coordinate of the rotation point.
   * @param y Y coordinate of the rotation point.
   * @param rotation Rotation angle.
   * @return The smallest rectangle that completely contains {@code rect} when rotated by the
   *     specified angle.
   */
  protected Rectangle computeRotatedScreenExtent(Rectangle rect, int x, int y, Angle rotation) {
    Rectangle r = new Rectangle(rect);

    // Translate the rectangle to the rotation point.
    r.translate(-x, -y);

    // Compute corner points
    Vec4[] corners = {
      new Vec4(r.getMaxX(), r.getMaxY()),
      new Vec4(r.getMaxX(), r.getMinY()),
      new Vec4(r.getMinX(), r.getMaxY()),
      new Vec4(r.getMinX(), r.getMinY())
    };

    // Rotate the rectangle
    Matrix rotationMatrix = Matrix.fromRotationZ(rotation);
    for (int i = 0; i < corners.length; i++) {
      corners[i] = corners[i].transformBy3(rotationMatrix);
    }

    // Find the bounding rectangle of rotated points.
    int minX = Integer.MAX_VALUE;
    int minY = Integer.MAX_VALUE;
    int maxX = -Integer.MAX_VALUE;
    int maxY = -Integer.MAX_VALUE;

    for (Vec4 v : corners) {
      if (v.x > maxX) maxX = (int) v.x;

      if (v.x < minX) minX = (int) v.x;

      if (v.y > maxY) maxY = (int) v.y;

      if (v.y < minY) minY = (int) v.y;
    }

    // Set bounds and translate the rectangle back to where it started.
    r.setBounds(minX, minY, maxX - minX, maxY - minY);
    r.translate(x, y);

    return r;
  }

  /**
   * Compute a contrasting background color to draw the label's outline.
   *
   * @param color Label color.
   * @return A color that contrasts with {@code color}.
   */
  protected Color computeBackgroundColor(Color color) {
    float[] colorArray = new float[4];
    Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), colorArray);

    if (colorArray[2] > 0.5) return new Color(0, 0, 0, 0.7f);
    else return new Color(1, 1, 1, 0.7f);
  }
}
예제 #4
0
/**
 * Renders a scalebar graphic in a screen corner.
 *
 * @author Patrick Murris
 * @version $Id: ScalebarLayer.java 12872 2009-12-09 15:26:15Z patrickmurris $
 */
public class ScalebarLayer extends AbstractLayer {
  // Units constants
  public static final String UNIT_METRIC = "gov.nasa.worldwind.ScalebarLayer.Metric";
  public static final String UNIT_IMPERIAL = "gov.nasa.worldwind.ScalebarLayer.Imperial";

  // Display parameters - TODO: make configurable
  private Dimension size = new Dimension(150, 10);
  private Color color = Color.white;
  private int borderWidth = 20;
  private String position = AVKey.SOUTHEAST;
  private String resizeBehavior = AVKey.RESIZE_SHRINK_ONLY;
  private String unit = UNIT_METRIC;
  private Font defaultFont = Font.decode("Arial-PLAIN-12");
  private double toViewportScale = 0.2;

  private PickSupport pickSupport = new PickSupport();
  private Vec4 locationCenter = null;
  private Vec4 locationOffset = null;
  private double pixelSize;

  // Draw it as ordered with an eye distance of 0 so that it shows up in front of most other things.
  // TODO: Add general support for this common pattern.
  private OrderedIcon orderedImage = new OrderedIcon();

  private class OrderedIcon implements OrderedRenderable {
    public double getDistanceFromEye() {
      return 0;
    }

    public void pick(DrawContext dc, Point pickPoint) {
      ScalebarLayer.this.draw(dc);
    }

    public void render(DrawContext dc) {
      ScalebarLayer.this.draw(dc);
    }
  }

  /** Renders a scalebar graphic in a screen corner */
  public ScalebarLayer() {
    setPickEnabled(false);
  }

  // Public properties

  /**
   * Get the apparent pixel size in meter at the reference position.
   *
   * @return the apparent pixel size in meter at the reference position.
   */
  public double getPixelSize() {
    return this.pixelSize;
  }

  /**
   * Get the scalebar graphic Dimension (in pixels)
   *
   * @return the scalebar graphic Dimension
   */
  public Dimension getSize() {
    return this.size;
  }

  /**
   * Set the scalebar graphic Dimenion (in pixels)
   *
   * @param size the scalebar graphic Dimension
   */
  public void setSize(Dimension size) {
    if (size == null) {
      String message = Logging.getMessage("nullValue.DimensionIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }
    this.size = size;
  }

  /**
   * Get the scalebar color
   *
   * @return the scalebar Color
   */
  public Color getColor() {
    return this.color;
  }

  /**
   * Set the scalbar Color
   *
   * @param color the scalebar Color
   */
  public void setColor(Color color) {
    if (color == null) {
      String msg = Logging.getMessage("nullValue.ColorIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }
    this.color = color;
  }

  /**
   * Returns the scalebar-to-viewport scale factor.
   *
   * @return the scalebar-to-viewport scale factor
   */
  public double getToViewportScale() {
    return toViewportScale;
  }

  /**
   * Sets the scale factor applied to the viewport size to determine the displayed size of the
   * scalebar. This scale factor is used only when the layer's resize behavior is
   * AVKey.RESIZE_STRETCH or AVKey.RESIZE_SHRINK_ONLY. The scalebar's width is adjusted to occupy
   * the proportion of the viewport's width indicated by this factor. The scalebar's height is
   * adjusted to maintain the scalebar's Dimension aspect ratio.
   *
   * @param toViewportScale the scalebar to viewport scale factor
   */
  public void setToViewportScale(double toViewportScale) {
    this.toViewportScale = toViewportScale;
  }

  public String getPosition() {
    return this.position;
  }

  /**
   * Sets the relative viewport location to display the scalebar. Can be one of AVKey.NORTHEAST,
   * AVKey.NORTHWEST, AVKey.SOUTHEAST (the default), or AVKey.SOUTHWEST. These indicate the corner
   * of the viewport.
   *
   * @param position the desired scalebar position
   */
  public void setPosition(String position) {
    if (position == null) {
      String msg = Logging.getMessage("nullValue.PositionIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }
    this.position = position;
  }

  /**
   * Returns the current scalebar center location.
   *
   * @return the current location center. May be null.
   */
  public Vec4 getLocationCenter() {
    return locationCenter;
  }

  /**
   * Specifies the screen location of the scalebar center. May be null. If this value is non-null,
   * it overrides the position specified by #setPosition. The location is specified in pixels. The
   * origin is the window's lower left corner. Positive X values are to the right of the origin,
   * positive Y values are upwards from the origin. The final scalebar location will be affected by
   * the currently specified location offset if a non-null location offset has been specified (see
   * #setLocationOffset).
   *
   * @param locationCenter the scalebar center. May be null.
   * @see #setPosition, #setLocationOffset
   */
  public void setLocationCenter(Vec4 locationCenter) {
    this.locationCenter = locationCenter;
  }

  /**
   * Returns the current location offset. See #setLocationOffset for a description of the offset and
   * its values.
   *
   * @return the location offset. Will be null if no offset has been specified.
   */
  public Vec4 getLocationOffset() {
    return locationOffset;
  }

  /**
   * Specifies a placement offset from the scalebar's position on the screen.
   *
   * @param locationOffset the number of pixels to shift the scalebar from its specified screen
   *     position. A positive X value shifts the image to the right. A positive Y value shifts the
   *     image up. If null, no offset is applied. The default offset is null.
   * @see #setLocationCenter, #setPosition
   */
  public void setLocationOffset(Vec4 locationOffset) {
    this.locationOffset = locationOffset;
  }

  /**
   * Returns the layer's resize behavior.
   *
   * @return the layer's resize behavior
   */
  public String getResizeBehavior() {
    return resizeBehavior;
  }

  /**
   * Sets the behavior the layer uses to size the scalebar when the viewport size changes, typically
   * when the World Wind window is resized. If the value is AVKey.RESIZE_KEEP_FIXED_SIZE, the
   * scalebar size is kept to the size specified in its Dimension scaled by the layer's current icon
   * scale. If the value is AVKey.RESIZE_STRETCH, the scalebar is resized to have a constant size
   * relative to the current viewport size. If the viewport shrinks the scalebar size decreases; if
   * it expands then the scalebar enlarges. If the value is AVKey.RESIZE_SHRINK_ONLY (the default),
   * scalebar sizing behaves as for AVKey.RESIZE_STRETCH but it will not grow larger than the size
   * specified in its Dimension.
   *
   * @param resizeBehavior the desired resize behavior
   */
  public void setResizeBehavior(String resizeBehavior) {
    this.resizeBehavior = resizeBehavior;
  }

  public int getBorderWidth() {
    return borderWidth;
  }

  /**
   * Sets the scalebar offset from the viewport border.
   *
   * @param borderWidth the number of pixels to offset the scalebar from the borders indicated by
   *     {@link #setPosition(String)}.
   */
  public void setBorderWidth(int borderWidth) {
    this.borderWidth = borderWidth;
  }

  public String getUnit() {
    return this.unit;
  }

  /**
   * Sets the unit the scalebar uses to display distances. Can be one of {@link #UNIT_METRIC} (the
   * default), or {@link #UNIT_IMPERIAL}.
   *
   * @param unit the desired unit
   */
  public void setUnit(String unit) {
    this.unit = unit;
  }

  /**
   * Get the scalebar legend Fon
   *
   * @return the scalebar legend Font
   */
  public Font getFont() {
    return this.defaultFont;
  }

  /**
   * Set the scalebar legend Fon
   *
   * @param font the scalebar legend Font
   */
  public void setFont(Font font) {
    if (font == null) {
      String msg = Logging.getMessage("nullValue.FontIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }
    this.defaultFont = font;
  }

  // Rendering
  @Override
  public void doRender(DrawContext dc) {
    dc.addOrderedRenderable(this.orderedImage);
  }

  @Override
  public void doPick(DrawContext dc, Point pickPoint) {
    // Delegate drawing to the ordered renderable list
    dc.addOrderedRenderable(this.orderedImage);
  }

  // Rendering
  public void draw(DrawContext dc) {
    GL gl = dc.getGL();

    boolean attribsPushed = false;
    boolean modelviewPushed = false;
    boolean projectionPushed = false;

    try {
      gl.glPushAttrib(
          GL.GL_DEPTH_BUFFER_BIT
              | GL.GL_COLOR_BUFFER_BIT
              | GL.GL_ENABLE_BIT
              | GL.GL_TEXTURE_BIT
              | GL.GL_TRANSFORM_BIT
              | GL.GL_VIEWPORT_BIT
              | GL.GL_CURRENT_BIT);
      attribsPushed = true;

      gl.glDisable(GL.GL_TEXTURE_2D); // no textures

      gl.glEnable(GL.GL_BLEND);
      gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
      gl.glDisable(GL.GL_DEPTH_TEST);

      double width = this.size.width;
      double height = this.size.height;

      // Load a parallel projection with xy dimensions (viewportWidth, viewportHeight)
      // into the GL projection matrix.
      java.awt.Rectangle viewport = dc.getView().getViewport();
      gl.glMatrixMode(javax.media.opengl.GL.GL_PROJECTION);
      gl.glPushMatrix();
      projectionPushed = true;
      gl.glLoadIdentity();
      double maxwh = width > height ? width : height;
      gl.glOrtho(0d, viewport.width, 0d, viewport.height, -0.6 * maxwh, 0.6 * maxwh);

      gl.glMatrixMode(GL.GL_MODELVIEW);
      gl.glPushMatrix();
      modelviewPushed = true;
      gl.glLoadIdentity();

      // Scale to a width x height space
      // located at the proper position on screen
      double scale = this.computeScale(viewport);
      Vec4 locationSW = this.computeLocation(viewport, scale);
      gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z());
      gl.glScaled(scale, scale, 1);

      // Compute scale size in real world
      Position referencePosition = dc.getViewportCenterPosition();
      if (referencePosition != null) {
        Vec4 groundTarget = dc.getGlobe().computePointFromPosition(referencePosition);
        Double distance = dc.getView().getEyePoint().distanceTo3(groundTarget);
        this.pixelSize = dc.getView().computePixelSizeAtDistance(distance);
        Double scaleSize = this.pixelSize * width * scale; // meter
        String unitLabel = "m";
        if (this.unit.equals(UNIT_METRIC)) {
          if (scaleSize > 10000) {
            scaleSize /= 1000;
            unitLabel = "Km";
          }
        } else if (this.unit.equals(UNIT_IMPERIAL)) {
          scaleSize *= 3.280839895; // feet
          unitLabel = "ft";
          if (scaleSize > 5280) {
            scaleSize /= 5280;
            unitLabel = "mile(s)";
          }
        }

        // Rounded division size
        int pot = (int) Math.floor(Math.log10(scaleSize));
        if (!Double.isNaN(pot)) {
          int digit = Integer.parseInt(String.format("%.0f", scaleSize).substring(0, 1));
          double divSize = digit * Math.pow(10, pot);
          if (digit >= 5) divSize = 5 * Math.pow(10, pot);
          else if (digit >= 2) divSize = 2 * Math.pow(10, pot);
          double divWidth = width * divSize / scaleSize;

          // Draw scale
          if (!dc.isPickingMode()) {
            // Set color using current layer opacity
            Color backColor = this.getBackgroundColor(this.color);
            float[] colorRGB = backColor.getRGBColorComponents(null);
            gl.glColor4d(
                colorRGB[0],
                colorRGB[1],
                colorRGB[2],
                (double) backColor.getAlpha() / 255d * this.getOpacity());
            gl.glTranslated((width - divWidth) / 2, 0d, 0d);
            this.drawScale(dc, divWidth, height);

            colorRGB = this.color.getRGBColorComponents(null);
            gl.glColor4d(colorRGB[0], colorRGB[1], colorRGB[2], this.getOpacity());
            gl.glTranslated(-1d / scale, 1d / scale, 0d);
            this.drawScale(dc, divWidth, height);

            // Draw label
            String label = String.format("%.0f ", divSize) + unitLabel;
            gl.glLoadIdentity();
            gl.glDisable(GL.GL_CULL_FACE);
            drawLabel(
                dc,
                label,
                locationSW.add3(
                    new Vec4(divWidth * scale / 2 + (width - divWidth) / 2, height * scale, 0)));
          } else {
            // Picking
            this.pickSupport.clearPickList();
            this.pickSupport.beginPicking(dc);
            // Draw unique color across the map
            Color color = dc.getUniquePickColor();
            int colorCode = color.getRGB();
            // Add our object(s) to the pickable list
            this.pickSupport.addPickableObject(colorCode, this, referencePosition, false);
            gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());
            gl.glTranslated((width - divWidth) / 2, 0d, 0d);
            this.drawRectangle(dc, divWidth, height);
            // Done picking
            this.pickSupport.endPicking(dc);
            this.pickSupport.resolvePick(dc, dc.getPickPoint(), this);
          }
        }
      }
    } finally {
      if (projectionPushed) {
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glPopMatrix();
      }
      if (modelviewPushed) {
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glPopMatrix();
      }
      if (attribsPushed) gl.glPopAttrib();
    }
  }

  // Draw scale rectangle
  private void drawRectangle(DrawContext dc, double width, double height) {
    GL gl = dc.getGL();
    gl.glBegin(GL.GL_POLYGON);
    gl.glVertex3d(0, height, 0);
    gl.glVertex3d(0, 0, 0);
    gl.glVertex3d(width, 0, 0);
    gl.glVertex3d(width, height, 0);
    gl.glVertex3d(0, height, 0);
    gl.glEnd();
  }

  // Draw scale graphic
  private void drawScale(DrawContext dc, double width, double height) {
    GL gl = dc.getGL();
    gl.glBegin(GL.GL_LINE_STRIP);
    gl.glVertex3d(0, height, 0);
    gl.glVertex3d(0, 0, 0);
    gl.glVertex3d(width, 0, 0);
    gl.glVertex3d(width, height, 0);
    gl.glEnd();
    gl.glBegin(GL.GL_LINE_STRIP);
    gl.glVertex3d(width / 2, 0, 0);
    gl.glVertex3d(width / 2, height / 2, 0);
    gl.glEnd();
  }

  // Draw the scale label
  private void drawLabel(DrawContext dc, String text, Vec4 screenPoint) {
    TextRenderer textRenderer =
        OGLTextRenderer.getOrCreateTextRenderer(dc.getTextRendererCache(), this.defaultFont);

    Rectangle2D nameBound = textRenderer.getBounds(text);
    int x = (int) (screenPoint.x() - nameBound.getWidth() / 2d);
    int y = (int) screenPoint.y();

    textRenderer.begin3DRendering();

    textRenderer.setColor(this.getBackgroundColor(this.color));
    textRenderer.draw(text, x + 1, y - 1);
    textRenderer.setColor(this.color);
    textRenderer.draw(text, x, y);

    textRenderer.end3DRendering();
  }

  private final float[] compArray = new float[4];
  // Compute background color for best contrast
  private Color getBackgroundColor(Color color) {
    Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), compArray);
    if (compArray[2] > 0.5) return new Color(0, 0, 0, 0.7f);
    else return new Color(1, 1, 1, 0.7f);
  }

  private double computeScale(java.awt.Rectangle viewport) {
    if (this.resizeBehavior.equals(AVKey.RESIZE_SHRINK_ONLY)) {
      return Math.min(1d, (this.toViewportScale) * viewport.width / this.size.width);
    } else if (this.resizeBehavior.equals(AVKey.RESIZE_STRETCH)) {
      return (this.toViewportScale) * viewport.width / this.size.width;
    } else if (this.resizeBehavior.equals(AVKey.RESIZE_KEEP_FIXED_SIZE)) {
      return 1d;
    } else {
      return 1d;
    }
  }

  private Vec4 computeLocation(java.awt.Rectangle viewport, double scale) {
    double scaledWidth = scale * this.size.width;
    double scaledHeight = scale * this.size.height;

    double x;
    double y;

    if (this.locationCenter != null) {
      x = this.locationCenter.x - scaledWidth / 2;
      y = this.locationCenter.y - scaledHeight / 2;
    } else if (this.position.equals(AVKey.NORTHEAST)) {
      x = viewport.getWidth() - scaledWidth - this.borderWidth;
      y = viewport.getHeight() - scaledHeight - this.borderWidth;
    } else if (this.position.equals(AVKey.SOUTHEAST)) {
      x = viewport.getWidth() - scaledWidth - this.borderWidth;
      y = 0d + this.borderWidth;
    } else if (this.position.equals(AVKey.NORTHWEST)) {
      x = 0d + this.borderWidth;
      y = viewport.getHeight() - scaledHeight - this.borderWidth;
    } else if (this.position.equals(AVKey.SOUTHWEST)) {
      x = 0d + this.borderWidth;
      y = 0d + this.borderWidth;
    } else // use North East
    {
      x = viewport.getWidth() - scaledWidth / 2 - this.borderWidth;
      y = viewport.getHeight() - scaledHeight / 2 - this.borderWidth;
    }

    if (this.locationOffset != null) {
      x += this.locationOffset.x;
      y += this.locationOffset.y;
    }

    return new Vec4(x, y, 0);
  }

  @Override
  public String toString() {
    return Logging.getMessage("layers.Earth.ScalebarLayer.Name");
  }
}