gov/nasa/worldwind/geom/SurfaceShape.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.geom;
   8
   9 import gov.nasa.worldwind.*;
  10 import gov.nasa.worldwind.layers.*;
  11
  12 import javax.media.opengl.*;
  13 import java.awt.*;
  14 import java.awt.image.*;
  15 import java.util.*;
  16 import java.util.List;
  17
  18 import com.sun.opengl.util.texture.*;
  19
  20 /**
  21  * @author tag
  22  * @version $Id: SurfaceShape.java 2234 2007-07-07 00:10:08Z tgaskins $
  23  */
  24 public abstract class SurfaceShape implements Renderable, Disposable, Movable
  25 {
  26     private static final Color DEFAULT_COLOR = new Color(1f, 1f, 0f, 0.4f);
  27     private static final Color DEFAULT_BORDER_COLOR = new Color(1f, 1f, 0f, 0.7f);
  28     private static final Dimension DEFAULT_TEXTURE_SIZE = new Dimension(512, 512);
  29     private static final double DEFAULT_NUM_EDGE_INTERVALS_PER_DEGREE = 1;
  30
  31     private ArrayList<TextureTile> tiles = new ArrayList<TextureTile>();
  32     private Dimension textureSize = DEFAULT_TEXTURE_SIZE;
  33     private Paint paint;
  34     private Color borderColor;
  35     private Stroke stroke = new BasicStroke();
  36     private boolean drawBorder = true;
  37     private boolean drawInterior = true;
  38     private boolean antiAlias = true;
  39     private double numEdgeIntervalsPerDegree = DEFAULT_NUM_EDGE_INTERVALS_PER_DEGREE;
  40     private ArrayList<LatLon> positions = new ArrayList<LatLon>();
  41
  42     protected abstract BufferedImage drawShape(BufferedImage image, Sector sector);
  43
  44     public SurfaceShape(Iterable<LatLon> positions, Color color, Color borderColor)
  45     {
  46         if (positions == null)
  47         {
  48             String message = WorldWind.retrieveErrMsg("nullValue.PositionsListIsNull");
  49             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  50             throw new IllegalArgumentException(message);
  51         }
  52
  53         // Copy positions list.
  54         for (LatLon posNext : positions)
  55         {
  56             this.positions.add(posNext);
  57         }
  58
  59         // Make tile(s)
  60         createTextureTiles();
  61         // Set draw attributes
  62         this.paint = color != null ? color : DEFAULT_COLOR;
  63         this.borderColor = borderColor != null ? borderColor : DEFAULT_BORDER_COLOR;
  64     }
  65
  66     private void createTextureTiles()
  67     {
  68         if (!LatLon.positionsCrossLongitudeBoundary(this.positions))
  69         {
  70             this.tiles.add(new TextureTile(Sector.boundingSector(this.positions)));
  71         }
  72         else
  73         {
  74             Sector[] sectors = this.computeSplitSectors(this.positions);
  75             this.tiles.add(new TextureTile(sectors[0]));
  76             this.tiles.add(new TextureTile(sectors[1]));
  77         }
  78     }
  79
  80     /**
  81      * Returns two 'mirror' sectors each on one side of the longitude boundary - for boundary crossing shapes
  82      *
  83      * @param positions the shape positions
  84      * @return an array of two sectors representing the shape
  85      */
  86     private Sector[] computeSplitSectors(ArrayList<LatLon> positions)
  87     {
  88         Sector[] sectors = new Sector[2];
  89         // Find out longitude extremes for each sides
  90         double maxWest = Angle.NEG180.getDegrees();
  91         double minEast = Angle.POS180.getDegrees();
  92         // Find out absolute latitude extremes
  93         double minSouth = Angle.POS90.getDegrees();
  94         double maxNorth = Angle.NEG90.getDegrees();
  95
  96         LatLon lastPos = null;
  97         for (LatLon pos : positions)
  98         {
  99             double lat = pos.getLatitude().getDegrees();
 100             if (lat > maxNorth)
 101                 maxNorth = lat;
 102             if (lat < minSouth)
 103                 minSouth = lat;
 104
 105             double lon = pos.getLongitude().getDegrees();
 106             if (lon <= 0 && lon > maxWest)
 107                 maxWest = lon;
 108             if (lon >= 0 && lon < minEast)
 109                 minEast = lon;
 110
 111             if (lastPos != null)
 112             {
 113                 double lastLon = lastPos.getLongitude().getDegrees();
 114                 if (Math.signum(lon) != Math.signum(lastLon))
 115                     if (Math.abs(lon - lastLon) < 180)
 116                     {
 117                         // Crossing the zero longitude line too
 118                         maxWest = 0;
 119                         minEast = 0;
 120                     }
 121             }
 122             lastPos = pos;
 123         }
 124         // Mirror the two sectors - same longitude span
 125         maxWest = minEast < -maxWest ? -minEast : maxWest;
 126         minEast = minEast > -maxWest ? -maxWest : minEast;
 127
 128         sectors[0] = Sector.fromDegrees(minSouth, maxNorth, minEast, 180d); // East side
 129         sectors[1] = Sector.fromDegrees(minSouth, maxNorth, -180d, maxWest); // West side
 130
 131         return sectors;
 132     }
 133
 134     public void dispose()
 135     {
 136         if (this.tiles.size() > 0)
 137             for (TextureTile tile : this.tiles)
 138             {
 139                 tile.dispose();
 140             }
 141         tiles.clear();
 142     }
 143
 144     public ArrayList<Sector> getSectors()
 145     {
 146         ArrayList<Sector> sectors = new ArrayList<Sector>();
 147         for (TextureTile tile : this.tiles)
 148         {
 149             sectors.add(tile.getSector());
 150         }
 151         return sectors;
 152     }
 153
 154     public List<LatLon> getPositions()
 155     {
 156         return positions;
 157     }
 158
 159     public Paint getPaint()
 160     {
 161         return paint;
 162     }
 163
 164     public void setPaint(Paint paint)
 165     {
 166         this.paint = paint;
 167         this.clearTextureData();
 168     }
 169
 170     public Color getBorderColor()
 171     {
 172         return borderColor;
 173     }
 174
 175     public void setBorderColor(Color borderColor)
 176     {
 177         this.borderColor = borderColor;
 178         this.clearTextureData();
 179     }
 180
 181     public Dimension getTextureSize()
 182     {
 183         return textureSize;
 184     }
 185
 186     public void setTextureSize(Dimension textureSize)
 187     {
 188         this.textureSize = textureSize;
 189         this.clearTextureData();
 190     }
 191
 192     public Stroke getStroke()
 193     {
 194         return stroke;
 195     }
 196
 197     public void setStroke(Stroke stroke)
 198     {
 199         this.stroke = stroke;
 200         this.clearTextureData();
 201     }
 202
 203     public boolean isDrawBorder()
 204     {
 205         return drawBorder;
 206     }
 207
 208     public void setDrawBorder(boolean drawBorder)
 209     {
 210         this.drawBorder = drawBorder;
 211         this.clearTextureData();
 212     }
 213
 214     public boolean isDrawInterior()
 215     {
 216         return drawInterior;
 217     }
 218
 219     public void setDrawInterior(boolean drawInterior)
 220     {
 221         this.drawInterior = drawInterior;
 222         this.clearTextureData();
 223     }
 224
 225     public boolean isAntiAlias()
 226     {
 227         return antiAlias;
 228     }
 229
 230     public void setAntiAlias(boolean antiAlias)
 231     {
 232         this.antiAlias = antiAlias;
 233         this.clearTextureData();
 234     }
 235
 236     public double getNumEdgeIntervalsPerDegree()
 237     {
 238         return numEdgeIntervalsPerDegree;
 239     }
 240
 241     public void setNumEdgeIntervalsPerDegree(double numEdgeIntervals)
 242     {
 243         this.numEdgeIntervalsPerDegree = numEdgeIntervals;
 244         this.clearTextureData();
 245     }
 246
 247     private boolean intersects(Sector sector)
 248     {
 249         for (TextureTile tile : this.tiles)
 250         {
 251             if (tile.getSector().intersects(sector))
 252                 return true;
 253         }
 254         return false;
 255     }
 256
 257     public void render(DrawContext dc)
 258     {
 259         if (!this.intersects(dc.getVisibleSector()))
 260             return;
 261
 262         if (!this.tiles.get(0).holdsTexture())
 263             makeTextureData(this.textureSize);
 264
 265         GL gl = dc.getGL();
 266
 267         gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT);
 268
 269         try
 270         {
 271             if (!dc.isPickingMode())
 272             {
 273                 gl.glEnable(GL.GL_BLEND);
 274                 gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
 275             }
 276
 277             gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
 278             gl.glEnable(GL.GL_CULL_FACE);
 279             gl.glCullFace(GL.GL_BACK);
 280
 281             dc.getSurfaceTileRenderer().renderTiles(dc, this.tiles);
 282         }
 283         finally
 284         {
 285             gl.glPopAttrib();
 286         }
 287     }
 288
 289     private void makeTextureData(Dimension size)
 290     {
 291         for (TextureTile tile : this.tiles)
 292         {
 293             BufferedImage image = new BufferedImage((int) size.getWidth(), (int) size.getHeight(),
 294                 BufferedImage.TYPE_4BYTE_ABGR);
 295
 296             TextureData td = new TextureData(GL.GL_RGBA, GL.GL_RGBA, false,
 297                 this.drawShape(image, tile.getSector()));
 298             td.setMustFlipVertically(false);
 299             tile.setTextureData(td);
 300         }
 301     }
 302
 303     private void clearTextureData()
 304     {
 305         for (TextureTile tile : this.tiles)
 306         {
 307             if (tile.getTextureData() != null)
 308                 tile.setTextureData(null);
 309
 310             if (tile.holdsTexture())
 311                 tile.setTexture(null);
 312         }
 313     }
 314
 315     public Position getReferencePosition()
 316     {
 317         LatLon centroid = this.tiles.get(0).getSector().getCentroid();
 318         return new Position(centroid, 0);
 319     }
 320
 321     public void move(Position position)
 322     {
 323         if (position == null)
 324         {
 325             String msg = WorldWind.retrieveErrMsg("nullValue.PositionIsNull");
 326             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 327             throw new IllegalArgumentException(msg);
 328         }
 329
 330         for (int i = 0; i < this.positions.size(); i++)
 331         {
 332             this.positions.set(i, this.positions.get(i).add(position));
 333         }
 334
 335         ArrayList<TextureTile> oldTiles = this.tiles;
 336         this.tiles = new ArrayList<TextureTile>(oldTiles.size());
 337         this.createTextureTiles();
 338
 339         // Re-use the existing texture if possible.
 340         if (oldTiles.size() == 1 && this.tiles.size() == 1)
 341         {
 342             TextureTile oldTile = oldTiles.get(0);
 343             TextureTile newTile = this.tiles.get(0);
 344             if (oldTile.getTextureData() != null)
 345                 newTile.setTextureData(oldTile.getTextureData());
 346             if (oldTile.holdsTexture())
 347                 newTile.setTexture(oldTile.getTexture());
 348         }
 349         else
 350         {
 351             // Dispose of any current textures
 352             for (TextureTile tile : oldTiles)
 353             {
 354                 tile.dispose();
 355             }
 356         }
 357     }
 358
 359     public void moveTo(Position position)
 360     {
 361         if (position == null)
 362         {
 363             String msg = WorldWind.retrieveErrMsg("nullValue.PositionIsNull");
 364             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 365             throw new IllegalArgumentException(msg);
 366         }
 367
 368         Position delta = position.subtract(this.getReferencePosition());
 369         this.move(delta);
 370     }
 371 }