gov/nasa/worldwind/view/BasicOrbitViewAnimator.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.util.Logging;
  10
  11 import java.lang.reflect.Constructor;
  12 import java.util.Arrays;
  13
  14 /**
  15  * @author dcollins
  16  * @version $Id: BasicOrbitViewAnimator.java 2471 2007-07-31 21:50:57Z tgaskins $
  17  */
  18 public class BasicOrbitViewAnimator implements OrbitViewAnimator
  19 {
  20     protected BasicOrbitViewAnimator()
  21     {
  22     }
  23
  24     public final void doNextState(double interpolant, OrbitView orbitView, BasicOrbitViewStateIterator stateIterator)
  25     {
  26         if (orbitView == null)
  27         {
  28             String message = Logging.getMessage("nullValue.OrbitViewIsNull");
  29             Logging.logger().severe(message);
  30             throw new IllegalArgumentException(message);
  31         }
  32         if (stateIterator == null)
  33         {
  34             String message = Logging.getMessage("nullValue.OrbitViewStateIteratorIsNull");
  35             Logging.logger().severe(message);
  36             throw new IllegalArgumentException(message);
  37         }
  38
  39         this.doNextStateImpl(interpolant, orbitView, stateIterator);
  40     }
  41
  42     protected void doNextStateImpl(double interpolant, OrbitView orbitView,
  43                                             BasicOrbitViewStateIterator stateIterator)
  44     {
  45     }
  46
  47     public final OrbitViewAnimator coalesceWith(OrbitView orbitView, OrbitViewAnimator animator)
  48     {
  49         if (orbitView == null)
  50         {
  51             String message = Logging.getMessage("nullValue.OrbitViewIsNull");
  52             Logging.logger().severe(message);
  53             throw new IllegalArgumentException(message);
  54         }
  55         if (animator == null)
  56         {
  57             String message = Logging.getMessage("nullValue.OrbitViewAnimatorIsNull");
  58             Logging.logger().severe(message);
  59             throw new IllegalArgumentException(message);
  60         }
  61
  62         return this.coalesceWithImpl(orbitView, animator);
  63     }
  64
  65     protected OrbitViewAnimator coalesceWithImpl(OrbitView orbitView, OrbitViewAnimator animator)
  66     {
  67         return this;
  68     }
  69
  70     // ============== Implementations ======================= //
  71     // ============== Implementations ======================= //
  72     // ============== Implementations ======================= //
  73
  74     public static class AngleAnimator extends BasicOrbitViewAnimator
  75     {
  76         private final Angle begin;
  77         private final Angle end;
  78         private final OrbitViewPropertyAccessor.AngleAccessor propertyAccessor;
  79
  80         public AngleAnimator(
  81             Angle begin, Angle end,
  82             OrbitViewPropertyAccessor.AngleAccessor propertyAccessor)
  83         {
  84             if (begin == null || end == null)
  85             {
  86                 String message = Logging.getMessage("nullValue.AngleIsNull");
  87                 Logging.logger().severe(message);
  88                 throw new IllegalArgumentException(message);
  89             }
  90             if (propertyAccessor == null)
  91             {
  92                 String message = Logging.getMessage("nullValue.OrbitViewPropertyAccessorIsNull");
  93                 Logging.logger().severe(message);
  94                 throw new IllegalArgumentException(message);
  95             }
  96
  97             this.begin = begin;
  98             this.end = end;
  99             this.propertyAccessor = propertyAccessor;
 100         }
 101
 102         public final Angle getBegin()
 103         {
 104             return this.begin;
 105         }
 106
 107         public final Angle getEnd()
 108         {
 109             return this.end;
 110         }
 111
 112         public final OrbitViewPropertyAccessor.AngleAccessor getPropertyAccessor()
 113         {
 114             return this.propertyAccessor;
 115         }
 116
 117         protected final void doNextStateImpl(double interpolant, OrbitView orbitView, BasicOrbitViewStateIterator stateIterator)
 118         {
 119             Angle newValue = this.nextAngle(interpolant, orbitView);
 120             if (newValue == null)
 121                 return;
 122
 123             boolean success = this.propertyAccessor.setAngle(orbitView, newValue);
 124             if (!success)
 125                 stateIterator.stop();
 126         }
 127
 128         public Angle nextAngle(double interpolant, OrbitView orbitView)
 129         {
 130             return Angle.mix(
 131                 interpolant,
 132                 this.begin,
 133                 this.end);
 134         }
 135     }
 136
 137     public static class DoubleAnimator extends BasicOrbitViewAnimator
 138     {
 139         private final double begin;
 140         private final double end;
 141         private final OrbitViewPropertyAccessor.DoubleAccessor propertyAccessor;
 142
 143         public DoubleAnimator(
 144             double begin, double end,
 145             OrbitViewPropertyAccessor.DoubleAccessor propertyAccessor)
 146         {
 147             if (propertyAccessor == null)
 148             {
 149                 String message = Logging.getMessage("nullValue.OrbitViewPropertyAccessorIsNull");
 150                 Logging.logger().severe(message);
 151                 throw new IllegalArgumentException(message);
 152             }
 153
 154             this.begin = begin;
 155             this.end = end;
 156             this.propertyAccessor = propertyAccessor;
 157         }
 158
 159         public final Double getBegin()
 160         {
 161             return this.begin;
 162         }
 163
 164         public final Double getEnd()
 165         {
 166             return this.end;
 167         }
 168
 169         public final OrbitViewPropertyAccessor.DoubleAccessor getPropertyAccessor()
 170         {
 171             return this.propertyAccessor;
 172         }
 173
 174         protected final void doNextStateImpl(double interpolant, OrbitView orbitView, BasicOrbitViewStateIterator stateIterator)
 175         {
 176             Double newValue = this.nextDouble(interpolant, orbitView);
 177             if (newValue == null)
 178                 return;
 179
 180             boolean success = this.propertyAccessor.setDouble(orbitView, newValue);
 181             if (!success)
 182                 stateIterator.stop();
 183         }
 184
 185         public Double nextDouble(double interpolant, OrbitView orbitView)
 186         {
 187             return mix(
 188                 interpolant,
 189                 this.begin,
 190                 this.end);
 191         }
 192
 193         public static double mix(double amount, double value1, double value2)
 194         {
 195             if (amount < 0)
 196                 return value1;
 197             else if (amount > 1)
 198                 return value2;
 199             return value1 * (1.0 - amount) + value2 * amount;
 200         }
 201     }
 202
 203     public static class LatLonAnimator extends BasicOrbitViewAnimator
 204     {
 205         private final LatLon begin;
 206         private final LatLon end;
 207         private final OrbitViewPropertyAccessor.LatLonAccessor propertyAccessor;
 208
 209         public LatLonAnimator(
 210             LatLon begin,
 211             LatLon end,
 212             OrbitViewPropertyAccessor.LatLonAccessor propertyAccessor)
 213         {
 214             if (begin == null || end == null)
 215             {
 216                 String message = Logging.getMessage("nullValue.LatLonIsNull");
 217                 Logging.logger().severe(message);
 218                 throw new IllegalArgumentException(message);
 219             }
 220             if (propertyAccessor == null)
 221             {
 222                 String message = Logging.getMessage("nullValue.OrbitViewPropertyAccessorIsNull");
 223                 Logging.logger().severe(message);
 224                 throw new IllegalArgumentException(message);
 225             }
 226
 227             this.begin = begin;
 228             this.end = end;
 229             this.propertyAccessor = propertyAccessor;
 230         }
 231
 232         public final LatLon getBegin()
 233         {
 234             return this.begin;
 235         }
 236
 237         public final LatLon getEnd()
 238         {
 239             return this.end;
 240         }
 241
 242         public final OrbitViewPropertyAccessor.LatLonAccessor getPropertyAccessor()
 243         {
 244             return this.propertyAccessor;
 245         }
 246
 247         protected final void doNextStateImpl(double interpolant, OrbitView orbitView, BasicOrbitViewStateIterator stateIterator)
 248         {
 249             LatLon newValue = this.nextLatLon(interpolant, orbitView);
 250             if (newValue == null)
 251                 return;
 252
 253             boolean success = this.propertyAccessor.setLatLon(orbitView, newValue);
 254             if (!success)
 255                 stateIterator.stop();
 256         }
 257
 258         public LatLon nextLatLon(double interpolant, OrbitView orbitView)
 259         {
 260             return LatLon.interpolate(
 261                 interpolant,
 262                 this.begin,
 263                 this.end);
 264         }
 265     }
 266
 267     public static class QuaternionAnimator extends BasicOrbitViewAnimator
 268     {
 269         private final Quaternion begin;
 270         private final Quaternion end;
 271         private final OrbitViewPropertyAccessor.QuaternionAccessor propertyAccessor;
 272
 273         public QuaternionAnimator(
 274             Quaternion begin, Quaternion end,
 275             OrbitViewPropertyAccessor.QuaternionAccessor propertyAccessor)
 276         {
 277             if (begin == null || end == null)
 278             {
 279                 String message = Logging.getMessage("nullValue.QuaternionIsNull");
 280                 Logging.logger().severe(message);
 281                 throw new IllegalArgumentException(message);
 282             }
 283             if (propertyAccessor == null)
 284             {
 285                 String message = Logging.getMessage("nullValue.OrbitViewPropertyAccessorIsNull");
 286                 Logging.logger().severe(message);
 287                 throw new IllegalArgumentException(message);
 288             }
 289
 290             this.begin = begin;
 291             this.end = end;
 292             this.propertyAccessor = propertyAccessor;
 293         }
 294
 295         public final Quaternion getBegin()
 296         {
 297             return this.begin;
 298         }
 299
 300         public final Quaternion getEnd()
 301         {
 302             return this.end;
 303         }
 304
 305         public final OrbitViewPropertyAccessor.QuaternionAccessor getPropertyAccessor()
 306         {
 307             return this.propertyAccessor;
 308         }
 309
 310         protected final void doNextStateImpl(double interpolant, OrbitView orbitView, BasicOrbitViewStateIterator stateIterator)
 311         {
 312             Quaternion newValue = this.nextQuaternion(interpolant, orbitView);
 313             if (newValue == null)
 314                 return;
 315
 316             boolean success = this.propertyAccessor.setQuaternion(orbitView, newValue);
 317             if (!success)
 318                 stateIterator.stop();
 319         }
 320
 321         public Quaternion nextQuaternion(double interpolant, OrbitView orbitView)
 322         {
 323             return Quaternion.mix(
 324                 interpolant,
 325                 this.begin,
 326                 this.end);
 327         }
 328     }
 329
 330     public static class CompoundAnimator extends BasicOrbitViewAnimator
 331     {
 332         private OrbitViewAnimator[] animators;
 333
 334         public CompoundAnimator(OrbitViewAnimator... animators)
 335         {
 336             if (animators == null)
 337             {
 338                 String message = Logging.getMessage("nullValue.ArrayIsNull");
 339                 Logging.logger().severe(message);
 340                 throw new IllegalArgumentException(message);
 341             }
 342
 343             int numAnimators = animators.length;
 344             this.animators = new OrbitViewAnimator[numAnimators];
 345             System.arraycopy(animators, 0, this.animators, 0, numAnimators);
 346         }
 347
 348         private CompoundAnimator newInstance(OrbitViewAnimator... animators)
 349         {
 350             if (animators == null)
 351             {
 352                 String message = Logging.getMessage("nullValue.ArrayIsNull");
 353                 Logging.logger().severe(message);
 354                 throw new IllegalArgumentException(message);
 355             }
 356
 357             CompoundAnimator newCompoundAnimator;
 358             try
 359             {
 360                 Class<? extends CompoundAnimator> cls = this.getClass();
 361                 Class<? extends OrbitViewAnimator[]> paramCls = animators.getClass();
 362                 Constructor<? extends CompoundAnimator> constructor = cls.getConstructor(paramCls);
 363                 newCompoundAnimator = constructor.newInstance((Object) animators);
 364             }
 365             catch (Exception e)
 366             {
 367                 String message = Logging.getMessage(""); // TODO
 368                 Logging.logger().severe(message);
 369                 throw new IllegalArgumentException(message);
 370             }
 371
 372             return newCompoundAnimator;
 373         }
 374
 375         public final Iterable<OrbitViewAnimator> getAnimators()
 376         {
 377             return Arrays.asList(this.animators);
 378         }
 379
 380         protected final void doNextStateImpl(double interpolant, OrbitView orbitView,
 381                                              BasicOrbitViewStateIterator stateIterator)
 382         {
 383             for (OrbitViewAnimator a : animators)
 384             {
 385                 if (a != null)
 386                 {
 387                     a.doNextState(interpolant, orbitView, stateIterator);
 388                 }
 389             }
 390         }
 391
 392         protected final OrbitViewAnimator coalesceWithImpl(OrbitView orbitView, OrbitViewAnimator animator)
 393         {
 394             if (!(animator instanceof CompoundAnimator))
 395                 return this;
 396
 397             // Cannot coalesce with different number of internal animators.
 398             CompoundAnimator that = (CompoundAnimator) animator;
 399             if (this.animators.length != that.animators.length)
 400                 return this;
 401
 402             int numAnimators = this.animators.length;
 403             OrbitViewAnimator[] newAnimators = new OrbitViewAnimator[numAnimators];
 404             for (int i = 0; i < numAnimators; i++)
 405             {
 406                 if (this.animators[i] != null && that.animators[i] != null)
 407                 {
 408                     newAnimators[i] = this.animators[i].coalesceWith(orbitView, that.animators[i]);
 409                 }
 410                 else if (this.animators[i] != null)
 411                 {
 412                     newAnimators[i] = this.animators[i];
 413                 }
 414             }
 415
 416             CompoundAnimator newCompoundAnimator = this.newInstance(newAnimators);
 417             if (newCompoundAnimator == null)
 418                 return this;
 419
 420             return newCompoundAnimator;
 421         }
 422     }
 423 }