private void adjustDateLineCrossingPoints() {
ArrayList<LatLon> corners = new ArrayList<LatLon>(Arrays.asList(sw, se, nw, ne));
if (!LatLon.locationsCrossDateLine(corners)) return;
double lonSign = 0;
for (LatLon corner : corners) {
if (Math.abs(corner.getLongitude().degrees) != 180)
lonSign = Math.signum(corner.getLongitude().degrees);
}
if (lonSign == 0) return;
if (Math.abs(sw.getLongitude().degrees) == 180
&& Math.signum(sw.getLongitude().degrees) != lonSign)
sw = new Position(sw.getLatitude(), sw.getLongitude().multiply(-1), sw.getElevation());
if (Math.abs(se.getLongitude().degrees) == 180
&& Math.signum(se.getLongitude().degrees) != lonSign)
se = new Position(se.getLatitude(), se.getLongitude().multiply(-1), se.getElevation());
if (Math.abs(nw.getLongitude().degrees) == 180
&& Math.signum(nw.getLongitude().degrees) != lonSign)
nw = new Position(nw.getLatitude(), nw.getLongitude().multiply(-1), nw.getElevation());
if (Math.abs(ne.getLongitude().degrees) == 180
&& Math.signum(ne.getLongitude().degrees) != lonSign)
ne = new Position(ne.getLatitude(), ne.getLongitude().multiply(-1), ne.getElevation());
}
/**
* 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);
}
/**
* Select the visible grid elements
*
* @param dc the current <code>DrawContext</code>.
*/
protected void selectRenderables(DrawContext dc) {
if (dc == null) {
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new IllegalArgumentException(message);
}
Sector vs = dc.getVisibleSector();
OrbitView view = (OrbitView) dc.getView();
// Compute labels offset from view center
Position centerPos = view.getCenterPosition();
Double pixelSizeDegrees =
Angle.fromRadians(
view.computePixelSizeAtDistance(view.getZoom())
/ dc.getGlobe().getEquatorialRadius())
.degrees;
Double labelOffsetDegrees = pixelSizeDegrees * view.getViewport().getWidth() / 4;
Position labelPos =
Position.fromDegrees(
centerPos.getLatitude().degrees - labelOffsetDegrees,
centerPos.getLongitude().degrees - labelOffsetDegrees,
0);
Double labelLatDegrees = labelPos.getLatitude().normalizedLatitude().degrees;
labelLatDegrees = Math.min(Math.max(labelLatDegrees, -76), 78);
labelPos =
new Position(
Angle.fromDegrees(labelLatDegrees), labelPos.getLongitude().normalizedLongitude(), 0);
if (vs != null) {
for (GridElement ge : this.gridElements) {
if (ge.isInView(dc)) {
if (ge.renderable instanceof GeographicText) {
GeographicText gt = (GeographicText) ge.renderable;
if (labelPos.getLatitude().degrees < 72
|| "*32*34*36*".indexOf("*" + gt.getText() + "*") == -1) {
// Adjust label position according to eye position
Position pos = gt.getPosition();
if (ge.type.equals(GridElement.TYPE_LATITUDE_LABEL))
pos =
Position.fromDegrees(
pos.getLatitude().degrees,
labelPos.getLongitude().degrees,
pos.getElevation());
else if (ge.type.equals(GridElement.TYPE_LONGITUDE_LABEL))
pos =
Position.fromDegrees(
labelPos.getLatitude().degrees,
pos.getLongitude().degrees,
pos.getElevation());
gt.setPosition(pos);
}
}
this.graticuleSupport.addRenderable(ge.renderable, GRATICULE_UTM);
}
}
// System.out.println("Total elements: " + count + " visible sector: " + vs);
}
}
public java.awt.Dimension getPreferredSize(DrawContext dc) {
java.awt.Dimension imageSize = this.getImageSize(dc);
java.awt.Dimension insetSize = null;
// Optionally set the annotation's inset size to the image size.
if (this.isFitSizeToImage()) {
insetSize = imageSize;
}
// Fallback to the superclass preferred size.
if (insetSize == null) {
insetSize = super.getPreferredSize(dc);
// Optionally set the annotation's aspect ratio to that of the image. We'll use the superclass
// width, and
// override it's height to match the image's aspect ration.
if (this.isUseImageAspectRatio() && imageSize != null) {
double aspect = imageSize.getHeight() / imageSize.getWidth();
insetSize =
new java.awt.Dimension(insetSize.width, (int) Math.round(aspect * insetSize.width));
}
}
java.awt.Insets insets = this.getAttributes().getInsets();
return new java.awt.Dimension(
insetSize.width + (insets.left + insets.right),
insetSize.height + (insets.top + insets.bottom));
}
public void computeMetricScaleExtremes(
int UTMZone, String hemisphere, GridElement ge, double size) {
if (UTMZone != this.zone) return;
if (size < 1 || size > this.maxResolution) return;
UTMExtremes levelExtremes = this.extremes[(int) Math.log10(size) - 1];
if (ge.type.equals(GridElement.TYPE_LINE_EASTING)
|| ge.type.equals(GridElement.TYPE_LINE_EAST)
|| ge.type.equals(GridElement.TYPE_LINE_WEST)) {
levelExtremes.minX = ge.value < levelExtremes.minX ? ge.value : levelExtremes.minX;
levelExtremes.maxX = ge.value > levelExtremes.maxX ? ge.value : levelExtremes.maxX;
} else if (ge.type.equals(GridElement.TYPE_LINE_NORTHING)
|| ge.type.equals(GridElement.TYPE_LINE_SOUTH)
|| ge.type.equals(GridElement.TYPE_LINE_NORTH)) {
if (hemisphere.equals(levelExtremes.minYHemisphere))
levelExtremes.minY = ge.value < levelExtremes.minY ? ge.value : levelExtremes.minY;
else if (hemisphere.equals(AVKey.SOUTH)) {
levelExtremes.minY = ge.value;
levelExtremes.minYHemisphere = hemisphere;
}
if (hemisphere.equals(levelExtremes.maxYHemisphere))
levelExtremes.maxY = ge.value > levelExtremes.maxY ? ge.value : levelExtremes.maxY;
else if (hemisphere.equals(AVKey.NORTH)) {
levelExtremes.maxY = ge.value;
levelExtremes.maxYHemisphere = hemisphere;
}
}
}
protected void showAnnotationPanel(String annoText) {
String text = this.splitLines(annoText);
AnnotationAttributes attrs = this.getAnnotationPanelAttributes(text);
int yOffset =
Math.min(this.controller.getWWPanel().getSize().height - attrs.getSize().height, 250);
Point location = new Point(10 + attrs.getSize().width / 2, yOffset);
if (this.annotationPanel != null)
this.annotationPanel.setAttributes(this.getAnnotationPanelAttributes(text));
else
this.annotationPanel =
new ScreenAnnotation(annoText, location, getAnnotationPanelAttributes(text));
this.annotationPanel.setScreenPoint(location);
this.annotationPanel.setText(text);
if (this.annotationLayer == null) {
this.annotationLayer = new AnnotationLayer();
this.annotationLayer.setPickEnabled(false);
}
this.annotationLayer.removeAllAnnotations();
this.annotationLayer.addAnnotation(this.annotationPanel);
if (!this.controller.getActiveLayers().contains(this.annotationLayer))
this.controller.addInternalLayer(this.annotationLayer);
}
/**
* @param placeNameServiceSet the set of PlaceNameService objects that PlaceNameLayer will render.
* @throws IllegalArgumentException if {@link
* gov.nasa.worldwind.layers.placename.PlaceNameServiceSet} is null
*/
public PlaceNameLayer(PlaceNameServiceSet placeNameServiceSet) {
if (placeNameServiceSet == null) {
String message = Logging.getMessage("nullValue.PlaceNameServiceSetIsNull");
Logging.logger().fine(message);
throw new IllegalArgumentException(message);
}
//
this.placeNameServiceSet = placeNameServiceSet.deepCopy();
for (int i = 0; i < this.placeNameServiceSet.getServiceCount(); i++) {
// todo do this for long as well and pick min
int calc1 =
(int)
(PlaceNameService.TILING_SECTOR.getDeltaLatDegrees()
/ this.placeNameServiceSet
.getService(i)
.getTileDelta()
.getLatitude()
.getDegrees());
int numLevels = (int) Math.log(calc1);
navTiles.add(
new NavigationTile(
this.placeNameServiceSet.getService(i),
PlaceNameService.TILING_SECTOR,
numLevels,
"top"));
}
if (!WorldWind.getMemoryCacheSet().containsCache(Tile.class.getName())) {
long size = Configuration.getLongValue(AVKey.PLACENAME_LAYER_CACHE_SIZE, 2000000L);
MemoryCache cache = new BasicMemoryCache((long) (0.85 * size), size);
cache.setName("Placename Tiles");
WorldWind.getMemoryCacheSet().addCache(Tile.class.getName(), cache);
}
}
public void clear() {
int numLevels = (int) Math.log10(this.maxResolution);
this.extremes = new UTMExtremes[numLevels];
for (int i = 0; i < numLevels; i++) {
this.extremes[i] = new UTMExtremes();
this.extremes[i].clear();
}
}
/**
* Determine the panel size needed to display the full annotation.
*
* @param annoText the annotation text.
* @return the required panel size.
*/
protected Dimension computePanelSize(String annoText) {
Dimension lengths = this.computeLengths(annoText);
// The numbers used below are the average width of a character and average height of a line in
// Arial-Plain-12.
int width = 7 * Math.min(lengths.width, this.maxLineLength);
int height = lengths.height * 17;
return new Dimension(width, height);
}
protected ArrayList<SquareZone> createSquaresGrid(
int UTMZone,
String hemisphere,
Sector UTMZoneSector,
double minEasting,
double maxEasting,
double minNorthing,
double maxNorthing) {
ArrayList<SquareZone> squares = new ArrayList<SquareZone>();
double startEasting = Math.floor(minEasting / ONEHT) * ONEHT;
double startNorthing = Math.floor(minNorthing / ONEHT) * ONEHT;
int cols = (int) Math.ceil((maxEasting - startEasting) / ONEHT);
int rows = (int) Math.ceil((maxNorthing - startNorthing) / ONEHT);
SquareZone[][] squaresArray = new SquareZone[rows][cols];
int col = 0;
for (double easting = startEasting; easting < maxEasting; easting += ONEHT) {
int row = 0;
for (double northing = startNorthing; northing < maxNorthing; northing += ONEHT) {
SquareZone sz =
new SquareZone(UTMZone, hemisphere, UTMZoneSector, easting, northing, ONEHT);
if (sz.boundingSector != null && !sz.isOutsideGridZone()) {
squares.add(sz);
squaresArray[row][col] = sz;
}
row++;
}
col++;
}
// Keep track of neighbors
for (col = 0; col < cols; col++) {
for (int row = 0; row < rows; row++) {
SquareZone sz = squaresArray[row][col];
if (sz != null) {
sz.setNorthNeighbor(row + 1 < rows ? squaresArray[row + 1][col] : null);
sz.setEastNeighbor(col + 1 < cols ? squaresArray[row][col + 1] : null);
}
}
}
return squares;
}
protected double computeScale(java.awt.Rectangle viewport) {
if (this.resizeBehavior.equals(AVKey.RESIZE_SHRINK_ONLY)) {
return Math.min(1d, (this.toViewportScale) * viewport.width / this.getScaledIconWidth());
} else if (this.resizeBehavior.equals(AVKey.RESIZE_STRETCH)) {
return (this.toViewportScale) * viewport.width / this.getScaledIconWidth();
} else if (this.resizeBehavior.equals(AVKey.RESIZE_KEEP_FIXED_SIZE)) {
return 1d;
} else {
return 1d;
}
}
/**
* 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
}
}
/**
* Compute the view range footprint on the globe.
*
* @param dc the current <code>DrawContext</code>
* @param steps the number of steps.
* @return an array list of <code>LatLon</code> forming a closed shape.
*/
protected ArrayList<LatLon> computeViewFootPrint(DrawContext dc, int steps) {
ArrayList<LatLon> positions = new ArrayList<LatLon>();
Position eyePos = dc.getView().getEyePosition();
Angle distance =
Angle.fromRadians(
Math.asin(
dc.getView().getFarClipDistance()
/ (dc.getGlobe().getRadius() + eyePos.getElevation())));
if (distance.degrees > 10) {
double headStep = 360d / steps;
Angle heading = Angle.ZERO;
for (int i = 0; i <= steps; i++) {
LatLon p = LatLon.greatCircleEndPosition(eyePos, heading, distance);
positions.add(p);
heading = heading.addDegrees(headStep);
}
return positions;
} else return null;
}
public void createRenderables() {
this.gridElements = new ArrayList<GridElement>();
ArrayList<Position> positions = new ArrayList<Position>();
Position p1, p2;
Object polyline;
Sector lineSector;
// left segment
positions.clear();
if (this.isTruncated) {
computeTruncatedSegment(sw, nw, this.UTMZoneSector, positions);
} else {
positions.add(sw);
positions.add(nw);
}
if (positions.size() > 0) {
p1 = positions.get(0);
p2 = positions.get(1);
polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE);
lineSector = Sector.boundingSector(p1, p2);
GridElement ge = new GridElement(lineSector, polyline, GridElement.TYPE_LINE_WEST);
ge.setValue(this.SWEasting);
this.gridElements.add(ge);
}
// right segment
positions.clear();
if (this.isTruncated) {
computeTruncatedSegment(se, ne, this.UTMZoneSector, positions);
} else {
positions.add(se);
positions.add(ne);
}
if (positions.size() > 0) {
p1 = positions.get(0);
p2 = positions.get(1);
polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE);
lineSector = Sector.boundingSector(p1, p2);
GridElement ge = new GridElement(lineSector, polyline, GridElement.TYPE_LINE_EAST);
ge.setValue(this.SWEasting + this.size);
this.gridElements.add(ge);
}
// bottom segment
positions.clear();
if (this.isTruncated) {
computeTruncatedSegment(sw, se, this.UTMZoneSector, positions);
} else {
positions.add(sw);
positions.add(se);
}
if (positions.size() > 0) {
p1 = positions.get(0);
p2 = positions.get(1);
polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE);
lineSector = Sector.boundingSector(p1, p2);
GridElement ge = new GridElement(lineSector, polyline, GridElement.TYPE_LINE_SOUTH);
ge.setValue(this.SWNorthing);
this.gridElements.add(ge);
}
// top segment
positions.clear();
if (this.isTruncated) {
computeTruncatedSegment(nw, ne, this.UTMZoneSector, positions);
} else {
positions.add(nw);
positions.add(ne);
}
if (positions.size() > 0) {
p1 = positions.get(0);
p2 = positions.get(1);
polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE);
lineSector = Sector.boundingSector(p1, p2);
GridElement ge = new GridElement(lineSector, polyline, GridElement.TYPE_LINE_NORTH);
ge.setValue(this.SWNorthing + this.size);
this.gridElements.add(ge);
}
// Label
if (this.name != null) {
// Only add a label to squares above some dimension
if (this.boundingSector.getDeltaLon().degrees
* Math.cos(this.centroid.getLatitude().radians)
> .2
&& this.boundingSector.getDeltaLat().degrees > .2) {
LatLon labelPos = null;
if (this.UTMZone != 0) // Not at poles
{
labelPos = this.centroid;
} else if (this.isPositionInside(new Position(this.squareCenter, 0))) {
labelPos = this.squareCenter;
} else if (this.squareCenter.getLatitude().degrees
<= this.UTMZoneSector.getMaxLatitude().degrees
&& this.squareCenter.getLatitude().degrees
>= this.UTMZoneSector.getMinLatitude().degrees) {
labelPos = this.centroid;
}
if (labelPos != null) {
GeographicText text = new UserFacingText(this.name, new Position(labelPos, 0));
text.setPriority(this.size * 10);
this.gridElements.add(
new GridElement(this.boundingSector, text, GridElement.TYPE_GRIDZONE_LABEL));
}
}
}
}
public void selectRenderables(DrawContext dc) {
try {
OrbitView view = (OrbitView) dc.getView();
// Compute easting and northing label offsets
Double pixelSize = view.computePixelSizeAtDistance(view.getZoom());
Double eastingOffset = view.getViewport().width * pixelSize * offsetFactorX / 2;
Double northingOffset = view.getViewport().height * pixelSize * offsetFactorY / 2;
// Derive labels center pos from the view center
Position centerPos = view.getCenterPosition();
double labelEasting;
double labelNorthing;
String labelHemisphere;
if (this.zone > 0) {
UTMCoord UTM =
UTMCoord.fromLatLon(centerPos.getLatitude(), centerPos.getLongitude(), dc.getGlobe());
labelEasting = UTM.getEasting() + eastingOffset;
labelNorthing = UTM.getNorthing() + northingOffset;
labelHemisphere = UTM.getHemisphere();
if (labelNorthing < 0) {
labelNorthing = 10e6 + labelNorthing;
labelHemisphere = AVKey.SOUTH;
}
} else {
UPSCoord UPS =
UPSCoord.fromLatLon(centerPos.getLatitude(), centerPos.getLongitude(), dc.getGlobe());
labelEasting = UPS.getEasting() + eastingOffset;
labelNorthing = UPS.getNorthing() + northingOffset;
labelHemisphere = UPS.getHemisphere();
}
Position labelPos;
for (int i = 0; i < this.extremes.length; i++) {
UTMExtremes levelExtremes = this.extremes[i];
double gridStep = Math.pow(10, i);
double gridStepTimesTen = gridStep * 10;
String graticuleType = getTypeFor((int) gridStep);
if (levelExtremes.minX <= levelExtremes.maxX) {
// Process easting scale labels for this level
for (double easting = levelExtremes.minX;
easting <= levelExtremes.maxX;
easting += gridStep) {
// Skip multiples of ten grid steps except for last (higher) level
if (i == this.extremes.length - 1 || easting % gridStepTimesTen != 0) {
try {
labelPos = computePosition(this.zone, labelHemisphere, easting, labelNorthing);
if (labelPos == null) continue;
Angle lat = labelPos.getLatitude();
Angle lon = labelPos.getLongitude();
Vec4 surfacePoint = getSurfacePoint(dc, lat, lon);
if (viewFrustum.contains(surfacePoint) && isPointInRange(dc, surfacePoint)) {
String text = String.valueOf((int) (easting % this.scaleModulo));
GeographicText gt = new UserFacingText(text, new Position(lat, lon, 0));
gt.setPriority(gridStepTimesTen);
addRenderable(gt, graticuleType);
}
} catch (IllegalArgumentException ignore) {
}
}
}
}
if (!(levelExtremes.maxYHemisphere.equals(AVKey.SOUTH) && levelExtremes.maxY == 0)) {
// Process northing scale labels for this level
String currentHemisphere = levelExtremes.minYHemisphere;
for (double northing = levelExtremes.minY;
(northing <= levelExtremes.maxY)
|| !currentHemisphere.equals(levelExtremes.maxYHemisphere);
northing += gridStep) {
// Skip multiples of ten grid steps except for last (higher) level
if (i == this.extremes.length - 1 || northing % gridStepTimesTen != 0) {
try {
labelPos = computePosition(this.zone, currentHemisphere, labelEasting, northing);
if (labelPos == null) continue;
Angle lat = labelPos.getLatitude();
Angle lon = labelPos.getLongitude();
Vec4 surfacePoint = getSurfacePoint(dc, lat, lon);
if (viewFrustum.contains(surfacePoint) && isPointInRange(dc, surfacePoint)) {
String text = String.valueOf((int) (northing % this.scaleModulo));
GeographicText gt = new UserFacingText(text, new Position(lat, lon, 0));
gt.setPriority(gridStepTimesTen);
addRenderable(gt, graticuleType);
}
} catch (IllegalArgumentException ignore) {
}
if (!currentHemisphere.equals(levelExtremes.maxYHemisphere)
&& northing >= 10e6 - gridStep) {
// Switch hemisphere
currentHemisphere = levelExtremes.maxYHemisphere;
northing = -gridStep;
}
}
}
} // end northing
} // for levels
} catch (IllegalArgumentException ignore) {
}
}
// 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();
}
}