How to Get every CGPoint on UIBezierPath in Swift

Question

I want to find out all the cgpoints which comes under the path of UIBezierPath for this i have 3 points by which I am creating the UIBezier path. I have tried below code but it is not providing the accurate results. Please check the attached image Could any body help me out on this.

Thanks in advance:)

  func getPathElementsPointsAndTypes() -> ([CGPoint],[CGPathElementType]) {
    var arrayPoints : [CGPoint]! = [CGPoint]()
    var arrayTypes : [CGPathElementType]! = [CGPathElementType]()
    self.forEach { element in
        switch (element.type) {
        case CGPathElementType.moveToPoint:
            arrayPoints.append(element.points[0])
            arrayTypes.append(element.type)
        case .addLineToPoint:
            arrayPoints.append(element.points[0])
            arrayTypes.append(element.type)
        case .addQuadCurveToPoint:
            arrayPoints.append(element.points[0])
            arrayPoints.append(element.points[1])
            arrayTypes.append(element.type)
            arrayTypes.append(element.type)
        case .addCurveToPoint:
            arrayPoints.append(element.points[0])
            arrayPoints.append(element.points[1])
            arrayPoints.append(element.points[2])
            arrayTypes.append(element.type)
            arrayTypes.append(element.type)
            arrayTypes.append(element.type)
        default: break
        }
    }
    return (arrayPoints,arrayTypes)
}

Answer 1

Let's take a step back for a moment. Why do you want all these points? Is it to see if someone is touching the outline of the path? If so use CGPathCreateCopyByStrokingPath to create a new path that is filled where the original was stroked, and then use the new path's containsPoint method. Easy.

If you really want "all" the points you have to accept that mathematically there are an infinite number of points on lines and curves so you can't get them all. In iOS where points are CGFloat pairs there are still too many to practically have "all" the points. You can however get pretty much as many points as you like across any part of the curve, so if say "100 points on the path" or "1000 points on the path" (or pretty much any integer you like) will solve your problem then this is still a solvable problem.

Iterating through each path element is a good start.

For each line you need to generate "all" the points on the line, that is pretty simple geometry: compute a vector from the start point to the end. Iterate from 0.0 to 1.0 in steps as small as you like. Multiply the vector by that fraction, add it to the start point and that is your point.

For each curve you need a more complex equation here is some pseudo code:

function computeCurve(points[], t):
  if(points.length==1):
    recordPoint(points[0])
  else:
    newpoints=array(points.size-1)
    for(i=0; i<newpoints.length; i++):
      newpoints[i] = (1-t) * points[i] + t * points[i+1]
    computeCurve(newpoints, t)

For a seriously good overview of how bezier curves "really work" look at https://pomax.github.io/bezierinfo/ (it has pseudo code - including basically that part I cribbed above, but nothing you can directly execute in Swift).

For code that already does this on iOS look at:

https://github.com/CodingMeSwiftly/UIBezierPath-Superpowers

For macOS I made a fairly minor fork to support the slightly different set of primitives on macOS:

https://github.com/stripes/UIBezierPath-Superpowers

They will give you a new method for UIBezierPath (or NSBezierPath) mx_point(at fraction: CGFloat) that lets you give it a value 0 to 1 and get the point you are interest in. It also has a method to give you the total length of the path so if you don't need "100 points on the path" but "points on the path no more then 3 pixels apart" you can kind-of use that to get some estimates of how fast to step that fraction. It is only a guess because some parts of an arc will "move" faster than others. So you will need to generate each point and if they are too far apart for your usage step back a little.

Good luck!