Fixed SurfaceText rotation.

- Modified the SurfaceText class by first, removing the offset
  calculation in the drawText() method. We want the text to be drawn
  normally without any offsets added at this point. Then, we modified
  the applyDrawTransform() method by moving the text to the center,
  applying the rotation, moving the text back to the offset position.
  A new private method called getRotatedTextDimensions() was added. This
  method calculates the pixel-dimensions of the rotated text. Changed
  the cumputeSector() method to take the rotated-text dimensions into
  account when calculating the bounding-sector.
- Changed the SurfaceTextUsage class by changing the code to add a lot
  of SurfaceText objects. We iterate over all of the different
  position-offsets as well as incrementing the angle by 30-degrees so
  that we can see the text rotation together with the bounding-box. The
  position of the surface-text is drawn with a red-dot for debugging
  purposes (we use a placemark for this).

Author: wcmatthysen

src/gov/nasa/worldwind/render/SurfaceText.java

@@ -420,13 +420,6 @@ protected void drawGeographic(DrawContext dc, SurfaceTileDrawContext sdc)
     protected void drawText(DrawContext dc)
     {
         TextRenderer tr = this.getTextRenderer(dc);
-
-        Point2D point = this.getOffset().computeOffset(this.textBounds.getWidth(), this.textBounds.getHeight(), null,
-            null);
-
-        int x = (int) point.getX();
-        int y = (int) point.getY();
-
         try
         {
             tr.begin3DRendering();
@@ -435,9 +428,9 @@ protected void drawText(DrawContext dc)
             CharSequence text = this.getText();
 
             tr.setColor(bgColor);
-            tr.draw(text, x + 1, y - 1);
+            tr.draw(text, 1, -1);
             tr.setColor(this.getColor());
-            tr.draw(text, x, y);
+            tr.draw(text, 0, 0);
         }
         finally
         {
@@ -487,9 +480,24 @@ protected void applyDrawTransform(DrawContext dc, SurfaceTileDrawContext sdc)
 
         // Apply the scaling factor to draw the text at the correct geographic size
         gl.glScaled(this.scale, this.scale, 1d);
-
-        // Apply rotation angle
+        
+        double widthInPixels = this.textBounds.getWidth();
+        double heightInPixels = this.textBounds.getHeight();
+        
+        Point2D textDimensions = getRotatedTextDimensions();
+        double rotatedPixelHeight = textDimensions.getY();
+        double rotatedPixelWidth = textDimensions.getX();
+        
+        Point2D textOffset = getOffset().computeOffset(rotatedPixelWidth, rotatedPixelHeight, null, null);
+        
+        // Move to offset position.
+        gl.glTranslated(rotatedPixelWidth / 2.0 + textOffset.getX(), rotatedPixelHeight / 2.0 + textOffset.getY(), 0);
+
+        // Apply rotation angle on from center.
         gl.glRotated(-this.heading.degrees, 0, 0, 1);
+
+        // Move to center.
+        gl.glTranslated(-widthInPixels / 2.0, -heightInPixels / 2.0, 0);
     }
 
     /**
@@ -552,6 +560,54 @@ protected Color computeBackgroundColor(Color color)
         else
             return new Color(1, 1, 1, 0.7f);
     }
+    
+    private Point2D getRotatedTextDimensions()
+    {
+        double widthInPixels = this.textBounds.getWidth();
+        double heightInPixels = this.textBounds.getHeight();
+        
+        Angle rotation = Angle.normalizedLongitude(this.heading);
+        double ct = Math.cos(rotation.radians);
+        double st = Math.sin(rotation.radians);
+
+        double hct = heightInPixels * ct;
+        double wct = widthInPixels * ct;
+        double hst = heightInPixels * st;
+        double wst = widthInPixels * st;
+        
+        if (rotation.degrees > 0)
+        {
+            if (rotation.degrees < 90)
+            {
+                // 0 < theta < 90
+                heightInPixels = hct + wst;
+                widthInPixels = wct + hst;
+            }
+            else
+            {
+                // 90 <= theta <= 180
+                heightInPixels = wst - hct;
+                widthInPixels = hst - wct;
+            }
+        }
+        else
+        {
+            if (rotation.degrees > -90 )
+            {
+                // -90 < theta <= 0
+                heightInPixels = hct - wst;
+                widthInPixels = wct - hst;
+            }
+            else
+            {
+                // -180 <= theta <= -90
+                heightInPixels = -(hct + wst);
+                widthInPixels = -(wct + hst);
+            }
+        }
+        
+        return new Point2D.Double(widthInPixels, heightInPixels);
+    }
 
     /**
      * Compute the sector covered by this surface text.
@@ -565,30 +621,32 @@ protected Sector[] computeSector(DrawContext dc)
         // Compute text extent depending on distance from eye
         Globe globe = dc.getGlobe();
 
-        double widthInPixels = this.textBounds.getWidth();
-        double heightInPixels = this.textBounds.getHeight();
-
-        double heightInMeters = this.textSizeInMeters;
+        Point2D textDimensions = getRotatedTextDimensions();
+        double heightInPixels = textDimensions.getY();
+        double widthInPixels = textDimensions.getX();
+        
+        double heightFactor = heightInPixels / this.textBounds.getHeight();
+        double heightInMeters = heightFactor * this.textSizeInMeters;
         double widthInMeters = heightInMeters * (widthInPixels / heightInPixels);
-
+        
         double radius = globe.getRadius();
         double heightInRadians = heightInMeters / radius;
         double widthInRadians = widthInMeters / radius;
 
-        // Compute the offset from the reference position. Convert pixels to meters based on the geographic size
-        // of the text.
-        Point2D point = this.getOffset().computeOffset(widthInPixels, heightInPixels, null, null);
+        // Compute the offset from the reference position.
+        // Convert pixels to meters based on the geographic size of the text.
+        Point2D textOffset = getOffset().computeOffset(widthInPixels, heightInPixels, null, null);
 
         double metersPerPixel = heightInMeters / heightInPixels;
 
-        double dxRadians = (point.getX() * metersPerPixel) / radius;
-        double dyRadians = (point.getY() * metersPerPixel) / radius;
-
+        double dxRadians = (textOffset.getX() * metersPerPixel) / radius;
+        double dyRadians = (textOffset.getY() * metersPerPixel) / radius;
+        
         double minLat = this.location.latitude.addRadians(dyRadians).degrees;
         double maxLat = this.location.latitude.addRadians(dyRadians + heightInRadians).degrees;
         double minLon = this.location.longitude.addRadians(dxRadians).degrees;
         double maxLon = this.location.longitude.addRadians(dxRadians + widthInRadians).degrees;
-
+        
         this.drawLocation = LatLon.fromDegrees(minLat, minLon);
 
         if (maxLon > 180) {

src/gov/nasa/worldwindx/examples/SurfaceTextUsage.java

@@ -7,10 +7,14 @@
 package gov.nasa.worldwindx.examples;
 
 import gov.nasa.worldwind.Configuration;
+import gov.nasa.worldwind.WorldWind;
 import gov.nasa.worldwind.avlist.AVKey;
 import gov.nasa.worldwind.geom.Angle;
 import gov.nasa.worldwind.geom.Position;
 import gov.nasa.worldwind.layers.RenderableLayer;
+import gov.nasa.worldwind.render.Offset;
+import gov.nasa.worldwind.render.PointPlacemark;
+import gov.nasa.worldwind.render.PointPlacemarkAttributes;
 import gov.nasa.worldwind.render.SurfaceText;
 
 /**
@@ -21,27 +25,55 @@
  */
 public class SurfaceTextUsage extends ApplicationTemplate
 {
+    private static Position center = Position.fromDegrees(38.9345, -120.1670, 50000);
+    
     public static class AppFrame extends ApplicationTemplate.AppFrame
     {
         public AppFrame()
         {
             super(true, true, false);
 
             RenderableLayer layer = new RenderableLayer();
+            
+            int j = 0;
+            for (double x = -1.0; x <= 0.0; x += 0.5, j++)
+            {
+                for (double y = -1.0; y <= 0.0; y += 0.5, j++)
+                {
+                    for (int i = 0; i <= 12; i++)
+                    {
+                        double latitude = center.latitude.degrees + ((j - 4) / 5.0);
+                        double longitude = center.longitude.degrees + ((i - 6) / 5.0);
+                        Position position = Position.fromDegrees(latitude, longitude, 0);
+                        
+                        SurfaceText surfaceText = new SurfaceText("Test Label Description", position);
+                        surfaceText.setDrawBoundingSectors(true);
+                        surfaceText.setHeading(Angle.fromDegrees(i * 30));
+                        surfaceText.setOffset(Offset.fromFraction(x, y));
+                        layer.addRenderable(surfaceText);
 
-            SurfaceText surfaceText = new SurfaceText("Desolation Wilderness", Position.fromDegrees(38.9345, -120.1670, 0));
-            surfaceText.setHeading(Angle.fromDegrees(30));
-            layer.addRenderable(surfaceText);
+                        PointPlacemark placemark = new PointPlacemark(position);
+                        placemark.setAltitudeMode(WorldWind.CLAMP_TO_GROUND);
+                        PointPlacemarkAttributes attrs = new PointPlacemarkAttributes();
+                        attrs.setLabelColor("ffffffff");
+                        attrs.setLineColor("ff0000ff");
+                        attrs.setUsePointAsDefaultImage(true);
+                        attrs.setScale(5d);
+                        placemark.setAttributes(attrs);
+                        layer.addRenderable(placemark);
+                    }
+                }
+            }
 
             this.getWwd().getModel().getLayers().add(layer);
         }
     }
 
     public static void main(String[] args)
     {
-        Configuration.setValue(AVKey.INITIAL_LATITUDE, 38.9345);
-        Configuration.setValue(AVKey.INITIAL_LONGITUDE, -120.1670);
-        Configuration.setValue(AVKey.INITIAL_ALTITUDE, 50000);
+        Configuration.setValue(AVKey.INITIAL_LATITUDE, center.latitude.degrees);
+        Configuration.setValue(AVKey.INITIAL_LONGITUDE, center.longitude.degrees);
+        Configuration.setValue(AVKey.INITIAL_ALTITUDE, center.elevation);
 
         ApplicationTemplate.start("WorldWind Surface Text", AppFrame.class);
     }