Example #1
0
        public static void ZoomToBookmark(IGlobeDisplay globeDisplay, IBookmark3D pBookmark3D, double doubleDuration)
        {
            try
            {
                //创建动画轨迹并添加
                IAnimationTrack pAnimationTrack = CreateZoomOverLocationAnimation(globeDisplay, pBookmark3D);

                //播放轨迹
                IGlobe           globe           = globeDisplay.Globe;
                IAnimationTracks animationTracks = (IAnimationTracks)globe;
                //// Add Track
                //animationTracks.AddTrack(pAnimationTrack);
                // Only enable the track with the parsed name
                for (int i = 0; i <= animationTracks.TrackCount - 1; i++)
                {
                    IAnimationTrack animationTrackTest = (IAnimationTrack)animationTracks.Tracks.get_Element(i);
                    if (animationTrackTest.Name == pAnimationTrack.Name)
                    {
                        animationTrackTest.IsEnabled = true;
                    }
                    else
                    {
                        animationTrackTest.IsEnabled = false;
                    }
                }

                // Play Track
                System.DateTime dateTimeStart = DateTime.Now;
                double          doubleElapsed = 0;
                while (doubleElapsed <= doubleDuration)
                {
                    // Animation Viewer
                    animationTracks.ApplyTracks(globe.GlobeDisplay.ActiveViewer, doubleElapsed, doubleDuration);
                    globe.GlobeDisplay.ActiveViewer.Redraw(true);

                    // Get Elapsed Time
                    System.TimeSpan timeSpanElapsed = DateTime.Now.Subtract(dateTimeStart);
                    doubleElapsed = timeSpanElapsed.TotalSeconds;
                }

                // Display Last Frame (if slow viewer)
                animationTracks.ApplyTracks(globe.GlobeDisplay.ActiveViewer, 1d, 1d);

                #region 根据当前摄像机姿态决定应该为Global模式还是Local模式
                AutoSwitchGlobeCameraOrientationMode(globe);
                #endregion

                globe.GlobeDisplay.ActiveViewer.Redraw(true);

                // Remove Track
                animationTracks.RemoveTrack(pAnimationTrack);
            }
            catch { }
        }
        private void WrapFrame_(
            IAnimationTrack track,
            int frame,
            out int trackFrame)
        {
            var frameCount = track.Frames.Count;

            if (track.Type == 1)
            {
                trackFrame = frame % frameCount;
            }
            else
            {
                trackFrame = 0;
            }
        }
Example #3
0
        private void PlayAnimationFast(int cycles, int iteration)
        {
            IGlobe           globe        = axGlobeControl1.Globe;
            IGlobeDisplay    globeDisplay = globe.GlobeDisplay;
            Scene            scene        = (Scene)globeDisplay.Scene;
            IAnimationTracks sceneTracks  = (IAnimationTracks)scene;

            IArray trackCamArray = new ArrayClass();
            IArray trackGlbArray = new ArrayClass();
            IArray trackLyrArray = new ArrayClass();

            string sError;

            if (sceneTracks.TrackCount == 0)
            {
                sError = m_AnimFilePath;
                if (sError == "")
                {
                    sError = "To get a Sample animation file, Developer Kit Samples need to be installed!";
                    System.Windows.Forms.MessageBox.Show("The current document doesn't contain animation file." + 0x000A + sError);
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show("The current document doesn't contain animation file." + 0x000A + "Load " + m_AnimFilePath + @"\AnimationSample.aga for sample.");
                }
                return;
            }

            IAnimationTrack track;
            IAnimationTrack trackLayer;
            IAnimationTrack trackGlobe = null;
            IAnimationType  animType;
            IAnimationType  animLayer;
            IAnimationType  animGlobeCam = null;
            IKeyframe       kFGlbCam;
            IKeyframe       kFGlbLayer;
            int             k;

            int[] count = new int[1000];

            //get each track from the scene and store tracks of the same kind in an Array
            for (int i = 0; i <= sceneTracks.TrackCount - 1; i++)
            {
                track    = (IAnimationTrack)sceneTracks.Tracks.get_Element(i);
                k        = i;
                animType = track.AnimationType;

                if (animType.CLSID.Value.ToString() == "{7CCBA704-3933-4D7A-8E89-4DFEE88AA937}")
                {
                    //GlobeLayer
                    trackLayer = new AnimationTrackClass();
                    trackLayer = track;
                    trackLayer.AnimationType = animType;
                    kFGlbLayer = new GlobeLayerKeyframeClass();
                    animLayer  = animType;
                    //Store the keyframe count of each track in an array
                    count[i] = trackLayer.KeyframeCount;
                    trackLyrArray.Add(trackLayer);
                }
                else if (animType.CLSID.Value.ToString() == "{D4565495-E2F9-4D89-A8A7-D0B69FD7A424}")
                {
                    //Globe Camera type
                    trackGlobe = new AnimationTrackClass();
                    trackGlobe = track;
                    trackGlobe.AnimationType = animType;
                    kFGlbCam     = new GlobeCameraKeyframeClass();
                    animGlobeCam = animType;
                    //Store the keyframe count of each track in an array
                    count[i] = trackGlobe.KeyframeCount;
                    trackGlbArray.Add(trackGlobe);
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show("Animation Type " + animType.Name + " Not Supported. Check if the animation File is Valid!");
                    return;
                }
            }

            int larger = Greatest(ref count);

            //if nothing gets passed by the argument it takes the max no of keyframes
            if (iteration == 0)
            {
                iteration = larger;
            }

            IAnimationTrack trackCamera;
            IAnimationType  animCam = null;
            IKeyframe       kFBkmark;
            double          time = 0;
            int             keyFrameLayerCount; int keyFrameCameraCount; int keyFrameCount;

            for (int i = 1; i <= cycles; i++)                    //no of cycles...
            {
                for (int start = 0; start <= iteration; start++) //no of iterations...
                {
                    for (int j = 0; j <= trackCamArray.Count - 1; j++)
                    {
                        trackCamera = (IAnimationTrack)trackCamArray.get_Element(j);
                        if (trackCamera != null)
                        {
                            if (time >= trackCamera.BeginTime)
                            {
                                keyFrameCameraCount = trackGlobe.KeyframeCount;
                                kFBkmark            = trackCamera.get_Keyframe(keyFrameCameraCount - keyFrameCameraCount);
                                //reset object
                                animCam.ResetObject(scene, kFBkmark);
                                //interpolate by using track
                                trackCamera.InterpolateObjectProperties(scene, time);
                                keyFrameCameraCount = keyFrameCameraCount - 1;
                            }
                        }
                    }

                    for (k = 0; k <= trackGlbArray.Count - 1; k++)
                    {
                        trackGlobe = (IAnimationTrack)trackGlbArray.get_Element(k);
                        if (trackGlobe != null)
                        {
                            if (time >= trackGlobe.BeginTime)
                            {
                                keyFrameCount = trackGlobe.KeyframeCount;
                                kFGlbCam      = trackGlobe.get_Keyframe(trackGlobe.KeyframeCount - keyFrameCount);
                                //reset object
                                animGlobeCam.ResetObject(scene, kFGlbCam);
                                //interpolate by using track
                                trackGlobe.InterpolateObjectProperties(scene, time);
                                keyFrameCount = keyFrameCount - 1;
                            }
                        }
                    }

                    for (int t = 0; t <= trackLyrArray.Count - 1; t++)
                    {
                        trackLayer = (IAnimationTrack)trackLyrArray.get_Element(t);
                        if (trackLayer != null)
                        {
                            if (time >= trackLayer.BeginTime)
                            {
                                keyFrameLayerCount = trackLayer.KeyframeCount;
                                kFGlbLayer         = trackLayer.get_Keyframe(trackLayer.KeyframeCount - keyFrameLayerCount);
                                //interpolate by using track
                                trackLayer.InterpolateObjectProperties(scene, time);
                                keyFrameLayerCount = keyFrameLayerCount - 1;
                            }
                        }
                    }

                    //reset interpolation Point
                    time = start / iteration;
                    //refresh the globeviewer(s)
                    globeDisplay.RefreshViewers();
                }
            }
        }
Example #4
0
        public static void ZoomToPointAnimation(AxGlobeControl axGlobeControl, double MapX, double MapY)
        {
            try
            {
                IPoint point = new PointClass();
                point.PutCoords(MapX, MapY);    //设置点击的点坐标

                //动画缩放到
                IAnimationTrack animaTrack = CreateZoomOverLocationAnimation(axGlobeControl.GlobeDisplay, MapX, MapY, 1000);
                animaTrack.IsEnabled = true;

                IAnimationTracks pTracks = axGlobeControl.Globe as IAnimationTracks;
                //for (int i = 0; i < pTracks.TrackCount; i++)
                //{
                //    IAnimationTrack pTrack = pTracks.Tracks.get_Element(i) as
                //    IAnimationTrack;
                //    pTrack.IsEnabled = true;//设置为true 才可以播放这条轨迹
                //}
                DateTime startTime = DateTime.Now;
                TimeSpan timeSpan;
                double   elapsedTime;
                double   duration = 7;
                bool     play     = true;
                do
                {
                    timeSpan    = (DateTime.Now).Subtract(startTime);
                    elapsedTime = timeSpan.TotalSeconds;
                    if (elapsedTime > duration)
                    {
                        play        = false;
                        elapsedTime = duration;
                    }
                    pTracks.ApplyTracks(axGlobeControl.Globe.GlobeDisplay.ActiveViewer, elapsedTime, duration);
                    axGlobeControl.Globe.GlobeDisplay.RefreshViewers();
                } while (play);


                #region //无动画方式
                //point = CommonBaseTool.BaseGISTools.getGeoPoint(MapX, MapY);        //转换坐标

                //IPoint ptObserver = new PointClass();
                //IPoint ptTarget = new PointClass();

                ////Observer点
                //IClone pClone1 = point as IClone;
                //ptObserver = pClone1.Clone() as IPoint;
                //ptObserver.Y = ptObserver.Y - 0.08;
                //ptObserver.Z = 15.45;
                ////Target点
                //IClone pClone2 = point as IClone;
                //ptTarget = pClone2.Clone() as IPoint;
                //ptTarget.Z = -0.01;

                //axGlobeControl.GlobeCamera.SetObserverLatLonAlt(ptObserver.Y, ptObserver.X, ptObserver.Z);
                //axGlobeControl.GlobeCamera.SetTargetLatLonAlt(ptTarget.Y, ptTarget.X, ptTarget.Z);
                #endregion

                //刷新
                axGlobeControl.GlobeDisplay.RefreshViewers();
            }
            catch { }
        }