gov/nasa/worldwind/view/OrbitViewModel.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government as represented by
   3 the Administrator of the National Aeronautics and Space Administration.
   4 All Rights Reserved.
   5 */
   6 package gov.nasa.worldwind.view;
   7
   8 import gov.nasa.worldwind.geom.*;
   9 import gov.nasa.worldwind.globes.Globe;
  10 import gov.nasa.worldwind.render.DrawContext;
  11 import gov.nasa.worldwind.util.Logging;
  12
  13 /**
  14  * @author dcollins
  15  * @version $Id: OrbitViewModel.java 2503 2007-08-03 23:22:10Z dcollins $
  16  */
  17 class OrbitViewModel
  18 {
  19     private Matrix transformMatrix = null;
  20
  21     public OrbitViewModel(DrawContext dc)
  22     {
  23         this(dc, Angle.ZERO, Angle.ZERO, Angle.ZERO, Angle.ZERO, 0);
  24     }
  25
  26     public OrbitViewModel(DrawContext dc,
  27                           Angle latitude, Angle longitude,
  28                           Angle heading, Angle pitch,
  29                           double altitude)
  30     {
  31         this(dc, createInitTransform(
  32             dc,
  33             latitude, longitude,
  34             heading, pitch,
  35             altitude));
  36     }
  37
  38     public OrbitViewModel(DrawContext dc, Matrix transformMatrix)
  39     {
  40         if (dc == null)
  41         {
  42             String message = Logging.getMessage("nullValue.DrawContextIsNull");
  43             Logging.logger().severe(message);
  44             throw new IllegalArgumentException(message);
  45         }
  46         if (transformMatrix == null)
  47         {
  48             String message = Logging.getMessage("nullValue.MatrixIsNull");
  49             Logging.logger().severe(message);
  50             throw new IllegalArgumentException(message);
  51         }
  52
  53         this.setTransform(dc, transformMatrix);
  54     }
  55
  56     public Matrix getTransformMatrix()
  57     {
  58         return this.transformMatrix;
  59     }
  60
  61     private void onTransformChange(DrawContext dc, Matrix newTransformMatrix)
  62     {
  63     }
  64
  65     public void setTransform(DrawContext dc, Matrix newTransformMatrix)
  66     {
  67         if (dc == null)
  68         {
  69             String message = Logging.getMessage("nullValue.DrawContextIsNull");
  70             Logging.logger().severe(message);
  71             throw new IllegalArgumentException(message);
  72         }
  73         if (newTransformMatrix == null)
  74         {
  75             String message = Logging.getMessage("nullValue.MatrixIsNull");
  76             Logging.logger().severe(message);
  77             throw new IllegalArgumentException(message);
  78         }
  79
  80         this.transformMatrix = newTransformMatrix;
  81         this.onTransformChange(dc, newTransformMatrix);
  82     }
  83
  84     public void transform(DrawContext dc, Matrix transformMatrix)
  85     {
  86         if (dc == null)
  87         {
  88             String message = Logging.getMessage("nullValue.DrawContextIsNull");
  89             Logging.logger().severe(message);
  90             throw new IllegalArgumentException(message);
  91         }
  92         if (transformMatrix == null)
  93         {
  94             String message = Logging.getMessage("nullValue.MatrixIsNull");
  95             Logging.logger().severe(message);
  96             throw new IllegalArgumentException(message);
  97         }
  98
  99         if (this.transformMatrix == null)
 100             return;
 101
 102         Matrix newTransformMatrix = this.transformMatrix.multiply(transformMatrix);
 103         this.setTransform(dc, newTransformMatrix);
 104     }
 105
 106     public void transformLatitude(DrawContext dc, Angle amount)
 107     {
 108         if (dc == null)
 109         {
 110             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 111             Logging.logger().severe(message);
 112             throw new IllegalArgumentException(message);
 113         }
 114         if (amount == null)
 115         {
 116             String message = Logging.getMessage("nullValue.AngleIsNull");
 117             Logging.logger().severe(message);
 118             throw new IllegalArgumentException(message);
 119         }
 120
 121         Matrix latTransform = this.createLatitudeTransform(dc, amount);
 122         if (latTransform == null)
 123             return;
 124
 125         if (this.transformMatrix == null)
 126             return;
 127
 128         // Test transform application.
 129         Matrix newTransformMatrix = this.transformMatrix.multiply(latTransform);
 130         Vec4 center = computeLookAtPoint(dc, this.transformMatrix);
 131         Vec4 newCenter = computeLookAtPoint(dc, newTransformMatrix);
 132         Position centerPos = dc.getGlobe().computePositionFromPoint(center);
 133         Position newCenterPos = dc.getGlobe().computePositionFromPoint(newCenter);
 134         // Abort the transform when it causes model errors.
 135         final double EPSILON = 1e-10;
 136         if (Math.abs(newCenterPos.getLongitude().subtract(centerPos.getLongitude()).degrees) > EPSILON)
 137             return;
 138
 139         this.transform(dc, latTransform);
 140     }
 141
 142     public void transformLongitude(DrawContext dc, Angle amount)
 143     {
 144         if (dc == null)
 145         {
 146             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 147             Logging.logger().severe(message);
 148             throw new IllegalArgumentException(message);
 149         }
 150         if (amount == null)
 151         {
 152             String message = Logging.getMessage("nullValue.AngleIsNull");
 153             Logging.logger().severe(message);
 154             throw new IllegalArgumentException(message);
 155         }
 156
 157         Matrix lonTransform = this.createLongitudeTransform(dc, amount);
 158         if (lonTransform == null)
 159             return;
 160
 161         this.transform(dc, lonTransform);
 162     }
 163
 164     public void transformAltitude(DrawContext dc, double amount)
 165     {
 166         if (dc == null)
 167         {
 168             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 169             Logging.logger().severe(message);
 170             throw new IllegalArgumentException(message);
 171         }
 172
 173         Matrix altTransform = this.createAltitudeTransform(dc, amount);
 174         if (altTransform == null)
 175             return;
 176
 177         this.transform(dc, altTransform);
 178     }
 179
 180     public void transformHeading(DrawContext dc, Angle amount)
 181     {
 182         if (dc == null)
 183         {
 184             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 185             Logging.logger().severe(message);
 186             throw new IllegalArgumentException(message);
 187         }
 188         if (amount == null)
 189         {
 190             String message = Logging.getMessage("nullValue.AngleIsNull");
 191             Logging.logger().severe(message);
 192             throw new IllegalArgumentException(message);
 193         }
 194
 195         Matrix headingTransform = this.createHeadingTransform(dc, amount);
 196         if (headingTransform == null)
 197             return;
 198
 199         this.transform(dc, headingTransform);
 200     }
 201
 202     public void transformPitch(DrawContext dc, Angle amount)
 203     {
 204         if (dc == null)
 205         {
 206             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 207             Logging.logger().severe(message);
 208             throw new IllegalArgumentException(message);
 209         }
 210         if (amount == null)
 211         {
 212             String message = Logging.getMessage("nullValue.AngleIsNull");
 213             Logging.logger().severe(message);
 214             throw new IllegalArgumentException(message);
 215         }
 216
 217         Matrix pitchTransform = this.createPitchTransform(dc, amount);
 218         if (pitchTransform == null)
 219             return;
 220
 221         if (this.transformMatrix == null)
 222             return;
 223
 224         // Test transform application.
 225         Matrix newTransformMatrix = this.transformMatrix.multiply(pitchTransform);
 226         Vec4 centerVec = computeLookAtPoint(dc, this.transformMatrix);
 227         Vec4 newHeading = computeHeadingVector(newTransformMatrix, centerVec);
 228         Vec4 newForward = Vec4.UNIT_NEGATIVE_Z.transformBy3(newTransformMatrix.getInverse());
 229         // Abort the transform when it causes model errors.
 230         if (newHeading.dot3(newForward) < 0)
 231             return;
 232
 233         this.transform(dc, pitchTransform);
 234     }
 235
 236     public void transformZoom(DrawContext dc, double amount)
 237     {
 238         if (dc == null)
 239         {
 240             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 241             Logging.logger().severe(message);
 242             throw new IllegalArgumentException(message);
 243         }
 244
 245         Matrix zoomTransform = this.createZoomTransform(dc, amount);
 246         if (zoomTransform == null)
 247             return;
 248
 249         this.transform(dc, zoomTransform);
 250     }
 251
 252     public Quaternion getRotation()
 253     {
 254         return Quaternion.fromMatrix(this.transformMatrix);
 255     }
 256
 257     public void setRotation(DrawContext dc, Quaternion newRotation)
 258     {
 259         if (dc == null)
 260         {
 261             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 262             Logging.logger().severe(message);
 263             throw new IllegalArgumentException(message);
 264         }
 265         if (newRotation == null)
 266         {
 267             String message = Logging.getMessage("nullValue.QuaternionIsNull");
 268             Logging.logger().severe(message);
 269             throw new IllegalArgumentException(message);
 270         }
 271
 272         if (this.transformMatrix == null)
 273             return;
 274
 275         Matrix posMatrix = Matrix.fromTranslation(
 276                 this.transformMatrix.m14,
 277                 this.transformMatrix.m24,
 278                 this.transformMatrix.m34);
 279         Matrix rotMatrix = Matrix.fromQuaternion(newRotation);
 280         Matrix newTransformMatrix = posMatrix.multiply(rotMatrix);
 281         this.setTransform(dc, newTransformMatrix);
 282     }
 283
 284     public void transformRotation(DrawContext dc, Quaternion rotation)
 285     {
 286         if (dc == null)
 287         {
 288             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 289             Logging.logger().severe(message);
 290             throw new IllegalArgumentException(message);
 291         }
 292         if (rotation == null)
 293         {
 294             String message = Logging.getMessage("nullValue.QuaternionIsNull");
 295             Logging.logger().severe(message);
 296             throw new IllegalArgumentException(message);
 297         }
 298
 299         Quaternion transformRotation = Quaternion.fromMatrix(this.transformMatrix);
 300         Quaternion newTransformRotation = transformRotation.multiply(rotation);
 301         this.setRotation(dc, newTransformRotation);
 302     }
 303
 304     // ============== Model Transforms ======================= //
 305     // ============== Model Transforms ======================= //
 306     // ============== Model Transforms ======================= //
 307
 308     private static Matrix createInitTransform(
 309         DrawContext dc,
 310         Angle latitude, Angle longitude,
 311         Angle heading, Angle pitch,
 312         double altitude)
 313     {
 314         if (dc == null
 315             || dc.getGlobe() == null
 316             || latitude == null
 317             || longitude == null
 318             || heading == null
 319             || pitch == null)
 320             return null;
 321
 322         Globe globe = dc.getGlobe();
 323 //        Vec4 globeOrigin = globe.getCenter();
 324         Matrix initTransform = Matrix.IDENTITY;
 325         // Not sure why this isn't necessary, but when globeOrigin!=0 View is still centered on the Globe,
 326         // without this code.
 327 //        initTransform = initTransform.multiply(Matrix.fromTranslation(
 328 //            globeOrigin.x,
 329 //            globeOrigin.y,
 330 //            globeOrigin.z));
 331         initTransform = initTransform.multiply(Matrix.fromTranslation(
 332             0.0,
 333             0.0,
 334             0.0 - globe.getRadiusAt(latitude, longitude)));
 335         initTransform = initTransform.multiply(Matrix.fromRotationX(heading.multiply(-1)));
 336         initTransform = initTransform.multiply(Matrix.fromRotationZ(pitch));
 337         initTransform = initTransform.multiply(Matrix.fromTranslation(
 338             0.0,
 339             0.0,
 340             0.0 - altitude));
 341         initTransform = initTransform.multiply(Matrix.fromRotationX(latitude));
 342         initTransform = initTransform.multiply(Matrix.fromRotationY(longitude.multiply(-1)));
 343
 344         return initTransform;
 345     }
 346
 347     public Matrix createLatitudeTransform(DrawContext dc, Angle amount)
 348     {
 349         if (dc == null)
 350         {
 351             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 352             Logging.logger().severe(message);
 353             throw new IllegalArgumentException(message);
 354         }
 355         if (amount == null)
 356         {
 357             String message = Logging.getMessage("nullValue.AngleIsNull");
 358             Logging.logger().severe(message);
 359             throw new IllegalArgumentException(message);
 360         }
 361
 362         Vec4 centerVec = this.getLookAtVector(dc);
 363         if (centerVec == null)
 364             return null;
 365
 366         Vec4 surfaceNormal = centerVec.normalize3();
 367         Vec4 axis = Vec4.UNIT_Y.cross3(surfaceNormal);
 368         return Matrix.fromAxisAngle(amount, axis);
 369     }
 370
 371     public Matrix createLongitudeTransform(DrawContext dc, Angle amount)
 372     {
 373         if (dc == null)
 374         {
 375             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 376             Logging.logger().severe(message);
 377             throw new IllegalArgumentException(message);
 378         }
 379         if (amount == null)
 380         {
 381             String message = Logging.getMessage("nullValue.AngleIsNull");
 382             Logging.logger().severe(message);
 383             throw new IllegalArgumentException(message);
 384         }
 385
 386         Vec4 axis = Vec4.UNIT_Y;
 387         return Matrix.fromAxisAngle(amount.multiply(-1), axis);
 388     }
 389
 390     public Matrix createAltitudeTransform(DrawContext dc, double amount)
 391     {
 392         if (dc == null)
 393         {
 394             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 395             Logging.logger().severe(message);
 396             throw new IllegalArgumentException(message);
 397         }
 398
 399         Vec4 altVec = this.getEyeVector();
 400         if (altVec == null)
 401             return null;
 402
 403         altVec = altVec.normalize3();
 404         altVec = altVec.multiply3(-amount);
 405         return Matrix.fromTranslation(altVec);
 406     }
 407
 408     public Matrix createHeadingTransform(DrawContext dc, Angle amount)
 409     {
 410         if (dc == null)
 411         {
 412             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 413             Logging.logger().severe(message);
 414             throw new IllegalArgumentException(message);
 415         }
 416         if (amount == null)
 417         {
 418             String message = Logging.getMessage("nullValue.AngleIsNull");
 419             Logging.logger().severe(message);
 420             throw new IllegalArgumentException(message);
 421         }
 422
 423         Vec4 centerVec = this.getLookAtVector(dc);
 424         if (centerVec == null)
 425             return null;
 426
 427         Vec4 axis = centerVec.normalize3();
 428         Matrix axisAngleTransform = Matrix.fromAxisAngle(amount, axis);
 429         return this.createTransformAboutPivot(axisAngleTransform, centerVec);
 430     }
 431
 432     public Matrix createPitchTransform(DrawContext dc, Angle amount)
 433     {
 434         if (dc == null)
 435         {
 436             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 437             Logging.logger().severe(message);
 438             throw new IllegalArgumentException(message);
 439         }
 440         if (amount == null)
 441         {
 442             String message = Logging.getMessage("nullValue.AngleIsNull");
 443             Logging.logger().severe(message);
 444             throw new IllegalArgumentException(message);
 445         }
 446
 447         if (this.transformMatrix == null)
 448             return null;
 449
 450         Vec4 centerVec = this.getLookAtVector(dc);
 451         if (centerVec == null)
 452             return null;
 453
 454         Vec4 axis = Vec4.UNIT_X.transformBy3(this.transformMatrix.getInverse());
 455         Matrix axisAngleTransform = Matrix.fromAxisAngle(amount.multiply(-1), axis);
 456         return this.createTransformAboutPivot(axisAngleTransform, centerVec);
 457     }
 458
 459     public Matrix createZoomTransform(DrawContext dc, double amount)
 460     {
 461         if (dc == null)
 462         {
 463             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 464             Logging.logger().severe(message);
 465             throw new IllegalArgumentException(message);
 466         }
 467
 468         if (this.transformMatrix == null)
 469             return null;
 470
 471         Vec4 zoomVec = Vec4.UNIT_NEGATIVE_Z.transformBy3(this.transformMatrix.getInverse());
 472         zoomVec = zoomVec.normalize3();
 473         zoomVec = zoomVec.multiply3(amount);
 474         return Matrix.fromTranslation(zoomVec);
 475     }
 476
 477     private Matrix createTransformAboutPivot(Matrix transform, Vec4 pivot)
 478     {
 479         if (transform == null || pivot == null)
 480             return null;
 481
 482         Matrix matrix = Matrix.IDENTITY;
 483         matrix = matrix.multiply(Matrix.fromTranslation(pivot.x, pivot.y, pivot.z));
 484         matrix = matrix.multiply(transform);
 485         matrix = matrix.multiply(Matrix.fromTranslation(-pivot.x, -pivot.y, -pivot.z));
 486         return matrix;
 487     }
 488
 489     // ============== Rotation Transforms ======================= //
 490     // ============== Rotation Transforms ======================= //
 491     // ============== Rotation Transforms ======================= //
 492
 493     public Quaternion createRotationBetweenPositions(DrawContext dc, Position beginPosition, Position endPosition)
 494     {
 495         if (dc == null)
 496         {
 497             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 498             Logging.logger().severe(message);
 499             throw new IllegalArgumentException(message);
 500         }
 501         if (beginPosition == null || endPosition == null)
 502         {
 503             String message = Logging.getMessage("nullValue.PositionIsNull");
 504             Logging.logger().severe(message);
 505             throw new IllegalArgumentException(message);
 506         }
 507
 508         Globe globe = dc.getGlobe();
 509         if (globe == null)
 510             return null;
 511
 512         Vec4 beginPoint = globe.computePointFromPosition(beginPosition);
 513         Vec4 endPoint = globe.computePointFromPosition(endPosition);
 514         if (beginPoint == null || endPoint == null)
 515             return null;
 516
 517         Angle angle = beginPoint.angleBetween3(endPoint);
 518         if (angle == null)
 519             return null;
 520
 521         Vec4 axis = beginPoint.cross3(endPoint);
 522         return Quaternion.fromAxisAngle(angle, axis);
 523     }
 524
 525     public Quaternion createRotationForward(DrawContext dc, Angle amount)
 526     {
 527         if (amount == null)
 528         {
 529             String message = Logging.getMessage("nullValue.AngleIsNull");
 530             Logging.logger().severe(message);
 531             throw new IllegalArgumentException(message);
 532         }
 533
 534         if (this.transformMatrix == null)
 535             return null;
 536
 537         Vec4 xAxis = Vec4.UNIT_X.transformBy3(this.transformMatrix.getInverse());
 538         return Quaternion.fromAxisAngle(amount, xAxis);
 539     }
 540
 541     public Quaternion createRotationRight(DrawContext dc, Angle amount)
 542     {
 543         if (amount == null)
 544         {
 545             String message = Logging.getMessage("nullValue.AngleIsNull");
 546             Logging.logger().severe(message);
 547             throw new IllegalArgumentException(message);
 548         }
 549
 550         if (this.transformMatrix == null)
 551             return null;
 552
 553         Vec4 xAxis = Vec4.UNIT_X.transformBy3(this.transformMatrix.getInverse());
 554         Vec4 centerVec = this.getLookAtVector(dc);
 555         centerVec = centerVec.normalize3();
 556         Vec4 yAxisNoTilt = centerVec.cross3(xAxis);
 557         return Quaternion.fromAxisAngle(amount.multiply(-1), yAxisNoTilt);
 558     }
 559
 560     // ============== Viewing Attributes ======================= //
 561     // ============== Viewing Attributes ======================= //
 562     // ============== Viewing Attributes ======================= //
 563
 564     public Vec4 getEyeVector()
 565     {
 566         if (this.transformMatrix == null)
 567             return null;
 568
 569         return Vec4.UNIT_W.transformBy4(this.transformMatrix.getInverse());
 570     }
 571
 572     public Position getEyePosition(DrawContext dc)
 573     {
 574         if (dc == null)
 575         {
 576             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 577             Logging.logger().severe(message);
 578             throw new IllegalArgumentException(message);
 579         }
 580
 581         Vec4 eyeVec = this.getEyeVector();
 582         if (eyeVec == null)
 583             return null;
 584
 585         if (dc.getGlobe() == null)
 586             return null;
 587
 588         return dc.getGlobe().computePositionFromPoint(eyeVec);
 589     }
 590
 591     public Vec4 getLookAtVector(DrawContext dc)
 592     {
 593         if (dc == null)
 594         {
 595             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 596             Logging.logger().severe(message);
 597             throw new IllegalArgumentException(message);
 598         }
 599
 600         if (this.transformMatrix == null)
 601             return null;
 602
 603         return computeLookAtPoint(dc, this.transformMatrix);
 604     }
 605
 606     public Position getLookAtPosition(DrawContext dc)
 607     {
 608         if (dc == null)
 609         {
 610             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 611             Logging.logger().severe(message);
 612             throw new IllegalArgumentException(message);
 613         }
 614
 615         Vec4 centerVec = this.getLookAtVector(dc);
 616         if (centerVec == null)
 617             return null;
 618
 619         if (dc.getGlobe() == null)
 620             return null;
 621
 622         return dc.getGlobe().computePositionFromPoint(centerVec);
 623     }
 624
 625     public Angle getHeading(DrawContext dc)
 626     {
 627         if (dc == null)
 628         {
 629             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 630             Logging.logger().severe(message);
 631             throw new IllegalArgumentException(message);
 632         }
 633
 634         if (this.transformMatrix == null)
 635             return null;
 636
 637         Vec4 centerVec = this.getLookAtVector(dc);
 638         if (centerVec == null)
 639             return null;
 640
 641         HeadingCoordinates headingCoordinates = computeHeadingCoordinates(centerVec);
 642         if (headingCoordinates == null)
 643             return null;
 644
 645         return computeHeading(headingCoordinates, this.transformMatrix, centerVec);
 646     }
 647
 648     public Angle getPitch(DrawContext dc)
 649     {
 650         if (dc == null)
 651         {
 652             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 653             Logging.logger().severe(message);
 654             throw new IllegalArgumentException(message);
 655         }
 656
 657         if (this.transformMatrix == null)
 658             return null;
 659
 660         Vec4 centerVec = this.getLookAtVector(dc);
 661         if (centerVec == null)
 662             return null;
 663
 664         return computePitch(this.transformMatrix, centerVec);
 665     }
 666
 667     public Double getZoom(DrawContext dc)
 668     {
 669         if (dc == null)
 670         {
 671             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 672             Logging.logger().severe(message);
 673             throw new IllegalArgumentException(message);
 674         }
 675
 676         if (this.transformMatrix == null)
 677             return null;
 678
 679         Vec4 centerVec = this.getLookAtVector(dc);
 680         if (centerVec == null)
 681             return null;
 682
 683         return computeZoom(this.transformMatrix, centerVec);
 684     }
 685
 686     // ============== Attribute Computation Support ======================= //
 687     // ============== Attribute Computation Support ======================= //
 688     // ============== Attribute Computation Support ======================= //
 689
 690     private static Vec4 computeLookAtPoint(DrawContext dc, Matrix transformMatrix)
 691     {
 692         if (dc == null
 693             || dc.getGlobe() == null
 694             || transformMatrix == null)
 695             return null;
 696
 697         Globe globe = dc.getGlobe();
 698         Vec4 eyeVec = Vec4.UNIT_W.transformBy4(transformMatrix.getInverse());
 699         Vec4 forwardVec = Vec4.UNIT_NEGATIVE_Z.transformBy3(transformMatrix.getInverse());
 700         forwardVec = forwardVec.normalize3();
 701
 702         Position centerPos = globe.getIntersectionPosition(new Line(eyeVec, forwardVec));
 703         if (centerPos == null)
 704             return computeHorizonPoint(globe, transformMatrix);
 705
 706         Angle centerLat = centerPos.getLatitude();
 707         Angle centerLon = centerPos.getLongitude();
 708         double centerElevation = dc.getVerticalExaggeration() * globe.getElevation(centerLat, centerLon);
 709         return globe.computePointFromPosition(centerLat, centerLon, centerElevation);
 710     }
 711
 712     private static Vec4 computeHorizonPoint(Globe globe, Matrix transformMatrix)
 713     {
 714         if (globe == null || transformMatrix == null)
 715             return null;
 716
 717         Vec4 globeOrigin = globe.getCenter();
 718         Vec4 eyeVec = Vec4.UNIT_W.transformBy4(transformMatrix.getInverse());
 719         Vec4 forward = Vec4.UNIT_NEGATIVE_Z.transformBy3(transformMatrix.getInverse());
 720         Vec4 origin_sub_eye = globeOrigin.subtract3(eyeVec);
 721
 722         double r = globe.getRadius();
 723         double dSquared = origin_sub_eye.getLengthSquared3() - (r * r);
 724         if (dSquared < 0)
 725             return null;
 726
 727         double d = Math.sqrt(dSquared);
 728         return forward.normalize3().multiply3(d).add3(eyeVec);
 729     }
 730
 731     private static Angle computeHeading(HeadingCoordinates headingCoords, Matrix transformMatrix, Vec4 lookAtPoint)
 732     {
 733         if (headingCoords == null
 734             || transformMatrix == null
 735             || lookAtPoint == null)
 736             return null;
 737
 738         Vec4 heading = computeHeadingVector(transformMatrix, lookAtPoint);
 739
 740         double dot = headingCoords.north.dot3(heading);
 741         // Compute the sum of magnitudes.
 742         double length = headingCoords.north.getLength3() * heading.getLength3();
 743         // Normalize the dot product, if necessary.
 744         if ((length != 0) && (length != 1.0))
 745             dot /= length;
 746
 747         if (dot < -1) // Angle is positive 180.
 748         {
 749             return Angle.POS180;
 750         }
 751         else if (dot > 1) // Angle is zero.
 752         {
 753             return Angle.ZERO;
 754         }
 755
 756         double degrees = Math.toDegrees(Math.acos(dot));
 757         if (Double.isNaN(degrees))
 758             return null;
 759
 760         if (headingCoords.east.dot3(heading) < 0)
 761             degrees = 360 - degrees;
 762
 763         // Collapses duplicate values for North heading.
 764         if (degrees == 360)
 765             degrees = 0;
 766
 767         return Angle.fromDegrees(degrees);
 768     }
 769
 770     private static class HeadingCoordinates
 771     {
 772         public final Vec4 north;
 773         public final Vec4 east;
 774
 775         public HeadingCoordinates(Vec4 north, Vec4 east)
 776         {
 777             this.north = north;
 778             this.east = east;
 779         }
 780     }
 781
 782     private static HeadingCoordinates computeHeadingCoordinates(Vec4 lookAtPoint)
 783     {
 784         if (lookAtPoint == null)
 785             return null;
 786
 787         Vec4 surfaceNormal = lookAtPoint.normalize3();
 788         Vec4 y_sub_normal = Vec4.UNIT_Y.subtract3(surfaceNormal);
 789         y_sub_normal = y_sub_normal.normalize3();
 790         Vec4 eastVec = y_sub_normal.cross3(surfaceNormal);
 791         Vec4 northVec = surfaceNormal.cross3(eastVec);
 792         eastVec = northVec.cross3(surfaceNormal);
 793
 794         return new HeadingCoordinates(northVec, eastVec);
 795     }
 796
 797     private static Vec4 computeHeadingVector(Matrix transformMatrix, Vec4 surfacePoint)
 798     {
 799         if (transformMatrix == null || surfacePoint == null)
 800             return null;
 801
 802         Vec4 surfaceNormal = surfacePoint.normalize3();
 803         Vec4 forward = Vec4.UNIT_NEGATIVE_Z.transformBy3(transformMatrix.getInverse());
 804         Vec4 up = Vec4.UNIT_Y.transformBy3(transformMatrix.getInverse());
 805
 806         final double EPSILON = 0.1;
 807         Vec4 heading = forward.cross3(surfaceNormal);
 808         if (heading.getLength3() < EPSILON)
 809             heading = up.cross3(surfaceNormal);
 810         heading = surfaceNormal.cross3(heading);
 811         heading = heading.normalize3();
 812
 813         return heading;
 814     }
 815
 816     private static Angle computePitch(Matrix transformMatrix, Vec4 lookAtPoint)
 817     {
 818         if (transformMatrix == null || lookAtPoint == null)
 819             return null;
 820
 821         Vec4 surfaceNormal = lookAtPoint.normalize3();
 822         Vec4 forward = Vec4.UNIT_Z.transformBy3(transformMatrix.getInverse());
 823         forward = forward.normalize3();
 824
 825         double dot = surfaceNormal.dot3(forward);
 826         // Compute the sum of magnitudes.
 827         double length = surfaceNormal.getLength3() * forward.getLength3();
 828         // Normalize the dot product, if necessary.
 829         if ((length != 0) && (length != 1))
 830             dot /= length;
 831
 832         if (dot <= 0) // Angle is positive 90.
 833         {
 834             return Angle.POS90;
 835         }
 836         else if (dot >= 1) // Angle is zero.
 837         {
 838             return Angle.ZERO;
 839         }
 840         else // Angle is arc-cosine of dot product.
 841         {
 842             double radians = Math.acos(dot);
 843             if (!Double.isNaN(radians))
 844                 return Angle.fromRadians(radians);
 845         }
 846
 847         return null;
 848     }
 849
 850     private static Double computeZoom(Matrix transformMatrix, Vec4 lookAtPoint)
 851     {
 852         if (transformMatrix == null || lookAtPoint == null)
 853             return null;
 854
 855         Vec4 eyeVec = Vec4.UNIT_W.transformBy4(transformMatrix.getInverse());
 856         return lookAtPoint.subtract3(eyeVec).getLength3();
 857     }
 858
 859 //    private static class SurfaceAttributes
 860 //    {
 861 //        public final Vec4 center;
 862 //        public final Position centerPos;
 863 //        public final Vec4 north;
 864 //        public final Vec4 east;
 865 //
 866 //        public SurfaceAttributes(Vec4 centerVec, Position centerPos, Vec4 headingUp, Vec4 headingRight)
 867 //        {
 868 //            this.center = centerVec;
 869 //            this.centerPos = centerPos;
 870 //            this.north = headingUp;
 871 //            this.east = headingRight;
 872 //        }
 873 //    }
 874
 875 //    private static SurfaceAttributes computeSurfaceAttributes(DrawContext dc, Matrix transformMatrix)
 876 //    {
 877 //        if (dc == null || dc.getGlobe() == null)
 878 //            return null;
 879 //
 880 //        if (transformMatrix == null)
 881 //            return null;
 882 //
 883 //        Globe globe = dc.getGlobe();
 884 //        Vec4 eyeVec = Vec4.UNIT_W.transformBy4(transformMatrix.getInverse());
 885 //        Vec4 forwardVec = Vec4.UNIT_NEGATIVE_Z.transformBy3(transformMatrix.getInverse());
 886 //        forwardVec = forwardVec.normalize3();
 887 //
 888 //        Vec4 centerVec;
 889 //        Position centerPos = globe.getIntersectionPosition(new Line(eyeVec, forwardVec));
 890 //        if (centerPos != null)
 891 //        {
 892 //            Angle centerLat = centerPos.getLatitude();
 893 //            Angle centerLon = centerPos.getLongitude();
 894 //            double centerElevation = dc.getVerticalExaggeration() * globe.getElevation(centerLat, centerLon);
 895 //            centerVec = globe.computePointFromPosition(centerLat, centerLon, centerElevation);
 896 //        }
 897 //        else
 898 //        {
 899 //            centerVec = computeHorizonPoint(globe, transformMatrix);
 900 //            centerPos = globe.computePositionFromPoint(centerVec);
 901 //        }
 902 //
 903 //        if (centerVec == null)
 904 //            return null;
 905 //
 906 //        Vec4 normalVec = centerVec.normalize3();
 907 //
 908 //        Vec4 y_sub_normal = Vec4.UNIT_Y.subtract3(normalVec);
 909 //        y_sub_normal = y_sub_normal.normalize3();
 910 //        Vec4 headingRight = y_sub_normal.cross3(normalVec);
 911 //        Vec4 headingUp = normalVec.cross3(headingRight);
 912 //        headingRight = headingUp.cross3(normalVec);
 913 //
 914 //        return new SurfaceAttributes(centerVec, centerPos, headingUp.normalize3(), headingRight.normalize3());
 915 //    }
 916 }