Better performance of UIBezierPath drawing iOS Swift ?

Question

In my app I'm doing some drawing, but the way I'm doing it is very inefficient and updating the view takes long time. I'm just curious of there is a better way to achieve this. The image and the code are below.

Any kind of help is highly appreciated.

func drawDialWithCurrentValue(  currentValue:CGFloat, andNewValue newValue:CGFloat)
{
    let radius = 500.0

    let circlePath = UIBezierPath(arcCenter: CGPoint(x: 0,y: radius),
                                  radius: CGFloat(radius),
                                  startAngle: CGFloat(0),
                                  endAngle:CGFloat(M_PI * 2),
                                  clockwise: true)


    let shapeLayer = CAShapeLayer()
    shapeLayer.path = circlePath.CGPath

    shapeLayer.fillColor = UIColor.blueColor().CGColor

    shapeLayer.strokeColor = UIColor.blueColor().CGColor

    shapeLayer.lineWidth = 3.0

    drawView.layer.addSublayer(shapeLayer)

    let x0 = 0.0
    let y0 = radius

    var x1 = x0
    var y1 = y0

    var degsInRadians = 0.0

    for var index = 0; index < 360; index++
    {
        if index%2 == 0
        {
            degsInRadians = Double(index) * (M_PI/180)

            x1 = x0 + radius * cos(degsInRadians)
            y1 = y0 + radius * sin(degsInRadians)


            let linePath = UIBezierPath()

            linePath.moveToPoint(CGPoint( x: x1, y: y1))

            linePath.addLineToPoint(CGPoint( x:0, y:radius))

            let shapeLayerLine = CAShapeLayer()
            shapeLayerLine.path = linePath.CGPath

            shapeLayerLine.fillColor = UIColor.clearColor().CGColor

            shapeLayerLine.strokeColor = UIColor.greenColor().CGColor

            shapeLayerLine.lineWidth = 3.0

            drawView.layer.addSublayer(shapeLayerLine)
        }
    }

    let innerCirc = UIBezierPath(arcCenter: CGPoint(x: 0,y: radius),
        radius: CGFloat(radius - 100),
        startAngle: CGFloat(0),
        endAngle:CGFloat(M_PI * 2),
        clockwise: true)


    let shapeLayer2 = CAShapeLayer()
    shapeLayer2.path = innerCirc.CGPath

    shapeLayer2.fillColor = UIColor.blueColor().CGColor

    shapeLayer2.strokeColor = UIColor.blueColor().CGColor

    shapeLayer2.lineWidth = 3.0

    drawView.layer.addSublayer(shapeLayer2)
}

Answer 1

You can do this with only two layers. One for the line segments and one for the background circle (which has a different stroke color).

This function will make a single BezierPath for all the line segments (for your top layer). If you are not going to be scaling at every draw, you should set keep a single copy of the path in a static (or instance) variable and reuse it. Even if you do resize the shape, you should only recalculate the path when the radius actually changes.

func clockSegments(count:Int, radius:CGFloat, length:CGFloat)->UIBezierPath
{
  let allSegments = UIBezierPath()
  let baseSegment = UIBezierPath()

  // baseSegment is horizontal movement from origin, followed by line up to radius
  // (0,0).....................---------
  baseSegment.moveToPoint(    CGPointMake(radius-length, 0.0) )
  baseSegment.addLineToPoint( CGPointMake(radius,        0.0) )
  baseSegment.lineWidth = 3

  // rotate and add segments 
  let segmentAngle = 2 * CGFloat(M_PI) / CGFloat(count)
  let rotate       = CGAffineTransformMakeRotation(segmentAngle)   
  for _ in 1...count
  {
     allSegments.appendPath(baseSegment)
     baseSegment.applyTransform(rotate)
  }

  return allSegments
}

to get the segment path for the parameters you used in your example you can call the function like this:

layer.path = clockSegments(360, radius:500, length:100)

On an iPad3, using SpriteKit, rendering choked at 200 segments but if I used two shape nodes with 180 each, it had no problem. This may hint at a practical limit to the number of elements in the BezierPath. If you encounter this issue, you could add a parameter to offset the starting segment and use two 180 segment layers (one being rotated by 1 degree).