Efficiently finding NSManagedObject (Polygon) that a given point is within - ios

Question

I'm trying to find if a given point (CLLocationCoordinate2D) is within a Polygon NSManagedObject.
My Polygon object is defined as:
public class Polygon: NSManagedObject {
#NSManaged var points: NSOrderedSet?
#NSManaged var centroid: Point?
#NSManaged var computed : NSNumber!
}
And the Point object:
public class Point: NSManagedObject {
#NSManaged var longitude: NSNumber!
#NSManaged var latitude: NSNumber!
}
My current method uses this for creating the predicate for Polygon objects:
public static func nearbyPredicate(offset offset: Double, nearLocation location: CLLocationCoordinate2D) -> NSPredicate {
let maxLat = location.latitude + offset
let minLat = location.latitude - offset
let maxLong = location.longitude - offset
let minLong = location.longitude + offset
return NSPredicate(format: "(centroid.latitude <= %#) && (centroid.latitude >= %#) && (centroid.longitude >= %#) && (centroid.longitude <= %#) && (computed == false)", argumentArray: [maxLat, minLat, maxLong, minLong])
}
Where offset is an arbitrary search 'radius'. The computed property is a boolean that I set to true once I have tried to detect if the Polygon contains the given point so that subsequent fetch calls exclude the object (as seen in the predicate). For detection, I first fetch Polygons with that predicate above, then use this:
let location : CLLocationCoordinate2D // ... point to test
for poly in polysFetched {
poly.computed = NSNumber(bool: true)
let path = UIBezierPath()
path.moveToPoint(CGPoint(x: (poly.points!.array as! [Point]).first!.longitude.doubleValue, y: (poly.points!.array as! [Point]).first!.latitude.doubleValue)) //set initial point
for pt in poly.points!.array as! [Point] {
path.addLineToPoint(CGPoint(x: pt.longitude.doubleValue, y: pt.latitude.doubleValue))
}
if (CGPathContainsPoint(path.CGPath, nil, CGPoint(x: location.longitude, y: location.latitude), false)) {
print("Poly \(poly) matches location \(location)")
return
}
}
This can be computationally heavy. The polygons I'm testing against can be quite large and oddly shaped.
Is there anyway to make this process more efficient using Core Data? Is there a way to offset the computation of calculating the containment of a point in an NSFetchRequest or in other ways?

Answer 1

I ended up resolving this in a few ways and sped up the process significantly. Since the Point NSManagedObject only existed for the purpose of fetching them via the Polygon relationships and computing the path (UIBezierPath) for the Polygon, I just computed the path during the creation of the Polygon object and stored it as a property. I also changed the Centriod relationship into the two properties c_lat, c_long and removed the Point class altogether! Indexing the c_lat and c_long properties sped up fetch requests too.
The new Polygon class is:
public class Polygon: NSManagedObject {
#NSManaged internal var pathData : NSData!
#NSManaged internal var c_lat : NSNumber!
#NSManaged internal var c_long : NSNumber!
#NSManaged var computed : NSNumber!
var path : UIBezierPath {
get {
return NSKeyedUnarchiver.unarchiveObjectWithData(pathData) as! UIBezierPath
}
set {
pathData = NSKeyedArchiver.archivedDataWithRootObject(newValue)
}
}
var centroid : CLLocationCoordinate2D {
get {
return CLLocationCoordinate2D(latitude: c_lat.doubleValue, longitude: c_long.doubleValue)
}
set {
c_lat = newValue.latitude
c_long = newValue.longitude
}
}
func containsLocation(location : CLLocationCoordinate2D) -> Bool {
return self.path.containsPoint(CGPoint(x: location.latitude, y: location.longitude))
}
}
Code Different's comment on my original post suggested the Wikipedia page for detecting points in polygons, but conveniently that is abstracted away from me with UIBezierPath and there exists a function CGPathContainsPoint that takes a boolean as its last argument to choose between the two algorithms for detecting points in polygons mentioned in the Wikipedia article.
For those encountering the same or similar issues that I did, I recommend inlining relationships and using computed properties to access non-primitive types of data you'd like to store in Core Data.