Coreplot Animation of a sequence of plots

Question

I have a number of plots, which depict (x,y) data at different time intervals, and wish to plot them in a sequence one after the other(like a gif file). My approach was generate all the plots, use a Timer.scheduledTimer and initially hide all plots, unhiding current plot and hiding previous plot at each fired schedule. The time between each plot hiding/unhiding shows a blank graph for more time than the plots are shown. Each plot has 32x32 data points. How can I speed this up, so I never see a blank graph? Another approach was to fade out one plot, whilst introducing the next, but I see the same effect.

   @objc func tapAnimationButton(_ sender: Any) {
        isAnimating = !isAnimating
        plotSpacesUserInteraction = !plotSpacesUserInteraction
        if let _animationButton = animationButton {
            _animationButton.isSelected = isAnimating
            previousAnimatedPlot = nil
            if isAnimating {
                animationCounter = 0
                for i in 0..<plotDetails.count {
//                    fieldsplots[i].isHidden = true
                   fieldsplots[i].opacity = 0.0
                }
                animationTimer = Timer.scheduledTimer(timeInterval: 0.5, target: self, selector: #selector(animateGraph(_:)), userInfo: nil, repeats: true)
                if let _animationTimer = animationTimer {
                    animateGraph(_animationTimer)
                }
            }
            else {
                animationTimer?.invalidate()
                animationTimer = nil
            }
        }
    }
    
    @objc func animateGraph(_ timer: Timer) {
        if animationSeconds > 120.0  {
            timer.invalidate()
            self.animationTimer = nil
            animationSeconds = 0.0
            animationCounter = 0
            previousAnimatedPlot = nil
        }
        else {
            if let currentAnimatedPlot = self.graph.plot(at: animationCounter) {
//                previousAnimatedPlot?.isHidden = true
//                currentAnimatedPlot.isHidden = false

                previousAnimatedPlot?.opacity = 1.0
                let fadeOutAnimation = CABasicAnimation(keyPath: "opacity")
                fadeOutAnimation.duration = 0.1
                fadeOutAnimation.isRemovedOnCompletion = false
                fadeOutAnimation.fillMode = CAMediaTimingFillMode.forwards
                fadeOutAnimation.toValue = Float(0.0)
                previousAnimatedPlot?.add(fadeOutAnimation, forKey: "animateOpacity")
                
                currentAnimatedPlot.opacity = 0.0
                let fadeInAnimation = CABasicAnimation(keyPath: "opacity")
                fadeInAnimation.duration = 0.1
                fadeInAnimation.isRemovedOnCompletion = false
                fadeInAnimation.fillMode = CAMediaTimingFillMode.forwards
                fadeInAnimation.toValue = Float(1.0)
                currentAnimatedPlot.add(fadeInAnimation, forKey: "animateOpacity")

                previousAnimatedPlot = currentAnimatedPlot
            }
            animationSeconds += 0.5
            animationCounter += 1;
            if animationCounter >= plotDetails.count {
                animationCounter = 0
            }
        }
    }

Answer 1

The fade in/out method actually works...not sure how I missed that.

Answer 2

As an add-on to answer, in order to produce a gif image one needs to hide/unhide the plots in sequence

      for currentPlot in self.graph.allPlots() {
            currentPlot.isHidden = true
        }
        var images: [UIImage] = []
        var previousPlot: CPTPlot?
        
        for currentPlot in self.graph.allPlots() {
            if let _previousPlot = previousPlot {
                _previousPlot.isHidden = true
            }
            currentPlot.isHidden = false
        
            if let image = graph.imageOfLayer() {
                images.append(image)
            }
            previousPlot = currentPlot
        }
        for currentPlot in self.graph.allPlots() {
            currentPlot.isHidden = false
        }
        
        if images.count > 2 {
            TwoDPlot_Utilities.GIFExport(with: images, plot: thisplot, plotIndex: plotIndex, frameDelay: 0.5)
        }