覆盖层和MapKit似乎存在“问题”。与注释不同，叠加层不会被重用，因此在添加多个叠加层时会导致真实设备出现内存问题。我多次遇到过这个问题。所以我的问题是，如何重用MKOverlay，从而提高MapKit叠加的性能？
对此的回答不是“重复使用”，而是将它们全部绘制到一个MKOverlayView然后在地图上绘制。
在地图上绘图时，多个MKPolygons，MKOverlays等会导致大量内存使用。这是由于MapKit没有重复使用叠加层。由于注释有reuseWithIdentifier，但覆盖层却没有。每个叠加层在地图上创建一个新图层作为MKOverlayView，其中包含叠加层。通过这种方式，内存使用量将会快速增长，并且地图使用会变得......让我们说这种情况几乎不可能。
因此有一个解决方法：您可以将所有MKOverlays添加到一个MKOverlayView，而不是单独绘制每个叠加层。这样你实际上只创建了一个MKOverlayView，因此不需要重复使用。
这是解决问题的方法，在这种情况下对于MKPolygons，但对于像MKCircles等其他人来说应该没有什么不同。
创建一个类：MultiPolygon（NSObject的子类）
在MultiPolygon.h：
#import <MapKit/MapKit.h> //Add import MapKit
@interface MultiPolygon : NSObject <MKOverlay> {
NSArray *_polygons;
MKMapRect _boundingMapRect;
}
- (id)initWithPolygons:(NSArray *)polygons;
@property (nonatomic, readonly) NSArray *polygons;
@end
在MultiPolygon.m：
@implementation MultiPolygon
@synthesize polygons = _polygons;
- (id)initWithPolygons:(NSArray *)polygons
{
if (self = [super init]) {
_polygons = [polygons copy];
NSUInteger polyCount = [_polygons count];
if (polyCount) {
_boundingMapRect = [[_polygons objectAtIndex:0] boundingMapRect];
NSUInteger i;
for (i = 1; i < polyCount; i++) {
_boundingMapRect = MKMapRectUnion(_boundingMapRect, [[_polygons objectAtIndex:i] boundingMapRect]);
}
}
}
return self;
}
- (MKMapRect)boundingMapRect
{
return _boundingMapRect;
}
- (CLLocationCoordinate2D)coordinate
{
return MKCoordinateForMapPoint(MKMapPointMake(MKMapRectGetMidX(_boundingMapRect), MKMapRectGetMidY(_boundingMapRect)));
}
@end
现在创建一个类：MultiPolygonView（MKOverlayPathView的子类）
在MultiPolygonView.h：
#import <MapKit/MapKit.h>
@interface MultiPolygonView : MKOverlayPathView
@end
在MultiPolygonView.m：
#import "MultiPolygon.h" //Add import "MultiPolygon.h"
@implementation MultiPolygonView
- (CGPathRef)polyPath:(MKPolygon *)polygon
{
MKMapPoint *points = [polygon points];
NSUInteger pointCount = [polygon pointCount];
NSUInteger i;
if (pointCount < 3)
return NULL;
CGMutablePathRef path = CGPathCreateMutable();
for (MKPolygon *interiorPolygon in polygon.interiorPolygons) {
CGPathRef interiorPath = [self polyPath:interiorPolygon];
CGPathAddPath(path, NULL, interiorPath);
CGPathRelease(interiorPath);
}
CGPoint relativePoint = [self pointForMapPoint:points[0]];
CGPathMoveToPoint(path, NULL, relativePoint.x, relativePoint.y);
for (i = 1; i < pointCount; i++) {
relativePoint = [self pointForMapPoint:points[i]];
CGPathAddLineToPoint(path, NULL, relativePoint.x, relativePoint.y);
}
return path;
}
- (void)drawMapRect:(MKMapRect)mapRect
zoomScale:(MKZoomScale)zoomScale
inContext:(CGContextRef)context
{
MultiPolygon *multiPolygon = (MultiPolygon *)self.overlay;
for (MKPolygon *polygon in multiPolygon.polygons) {
CGPathRef path = [self polyPath:polygon];
if (path) {
[self applyFillPropertiesToContext:context atZoomScale:zoomScale];
CGContextBeginPath(context);
CGContextAddPath(context, path);
CGContextDrawPath(context, kCGPathEOFill);
[self applyStrokePropertiesToContext:context atZoomScale:zoomScale];
CGContextBeginPath(context);
CGContextAddPath(context, path);
CGContextStrokePath(context);
CGPathRelease(path);
}
}
}
@end
对我们来说，它会在你的ViewController中导入MultiPolygon.h和MultiPolygonView.h
从所有人创建一个多边形：作为一个例子，我有一个多边形数组：polygonsInArray。
MultiPolygon *allPolygonsInOne = [[MultiPolygon alloc] initWithPolygons:polygonsInArray];
将allPolygonsInOne添加到mapView：
[mapView addOverlay:allPolygonsInOne];
还要更改你的viewForOverlay方法：
-(MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay
{
if ([overlay isKindOfClass:[MultiPolygon class]]) {
MultiPolygonView *polygonsView = [[MultiPolygonView alloc] initWithOverlay:(MultiPolygon*)overlay];
polygonsView.fillColor = [[UIColor magentaColor] colorWithAlphaComponent:0.8];
polygonsView.strokeColor = [[UIColor blueColor] colorWithAlphaComponent:0.8];
polygonsView.lineWidth = 1;
return polygonsView;
}
else {
return nil;
}
}
这大大减少了mapView上多个叠加层的内存使用量。你现在没有重复使用，因为只绘制了一个OverlayView。所以不需要重复使用。
@wkberg发布的Swift 4版本的Objective-C代码：
MultiPolygon.swift：
import MapKit
/// A concatenation of multiple polygons to allow a single overlay to be drawn in the map,
/// which will consume less resources
class MultiPolygon: NSObject, MKOverlay {
var polygons: [MKPolygon]?
var boundingMapRect: MKMapRect
init(polygons: [MKPolygon]?) {
self.polygons = polygons
self.boundingMapRect = MKMapRect.null
super.init()
guard let pols = polygons else { return }
for (index, polygon) in pols.enumerated() {
if index == 0 { self.boundingMapRect = polygon.boundingMapRect; continue }
boundingMapRect = boundingMapRect.union(polygon.boundingMapRect)
}
}
var coordinate: CLLocationCoordinate2D {
return MKMapPoint(x: boundingMapRect.midX, y: boundingMapRect.maxY).coordinate
}
}
MultiPolygonPathRenderer.swift：
import MapKit
/// A MKOverlayPathRenderer that can draw a concatenation of multiple polygons as a single polygon
/// This will consume less resources
class MultiPolygonPathRenderer: MKOverlayPathRenderer {
/**
Returns a `CGPath` equivalent to this polygon in given renderer.
- parameter polygon: MKPolygon defining coordinates that will be drawn.
- returns: Path equivalent to this polygon in given renderer.
*/
func polyPath(for polygon: MKPolygon?) -> CGPath? {
guard let polygon = polygon else { return nil }
let points = polygon.points()
if polygon.pointCount < 3 { return nil }
let pointCount = polygon.pointCount
let path = CGMutablePath()
if let interiorPolygons = polygon.interiorPolygons {
for interiorPolygon in interiorPolygons {
guard let interiorPath = polyPath(for: interiorPolygon) else { continue }
path.addPath(interiorPath, transform: .identity)
}
}
let startPoint = point(for: points[0])
path.move(to: CGPoint(x: startPoint.x, y: startPoint.y), transform: .identity)
for i in 1..<pointCount {
let nextPoint = point(for: points[i])
path.addLine(to: CGPoint(x: nextPoint.x, y: nextPoint.y), transform: .identity)
}
return path
}
/// Draws the overlay’s contents at the specified location on the map.
override func draw(_ mapRect: MKMapRect, zoomScale: MKZoomScale, in context: CGContext) {
// Taken from: http://stackoverflow.com/a/17673411
guard let multiPolygon = self.overlay as? MultiPolygon else { return }
guard let polygons = multiPolygon.polygons else { return }
for polygon in polygons {
guard let path = self.polyPath(for: polygon) else { continue }
self.applyFillProperties(to: context, atZoomScale: zoomScale)
context.beginPath()
context.addPath(path)
context.drawPath(using: CGPathDrawingMode.eoFill)
self.applyStrokeProperties(to: context, atZoomScale: zoomScale)
context.beginPath()
context.addPath(path)
context.strokePath()
}
}
}
用法 - 将叠加层添加到MKMapView：
// Add the overlay to mapView
let polygonsArray: [MKPolygon] = self.buildMKPolygons()
let multiPolygons = MultiPolygon.init(polygons: polygonsArray)
self.mapView.addOverlay(multiPolygons)
用法 - 在MKMapViewDelegate中实现viewForOverlay：
// Method viewForOverlay:
func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
if overlay is MultiPolygon {
let polygonRenderer = MultiPolygonPathRenderer(overlay: overlay)
polygonRenderer.lineWidth = 0.5
polygonRenderer.strokeColor = .mainGreen
polygonRenderer.miterLimit = 2.0
polygonRenderer.fillColor = UIColor.mainGreen.withAlphaComponent(0.2)
return polygonRenderer
}
return MKOverlayRenderer()
}