MKMapKit(十)：动态轨迹DynamicPathOverlay

2017-03-12

动态轨迹Overlay

根据网上一些代码整理和修改，得出以下的动态轨迹Overlay，其中结构体的Scale代表了颜色的百分比，1为最大值，0为最小值

CrumbPathOverlay.h


#import <UIKit/UIKit.h>
#import <MapKit/MapKit.h>

typedef struct {
    CLLocationCoordinate2D coordinate;
    CGFloat scale;
}CrumbPoint;


CG_INLINE CrumbPoint CrumbPointMake(CLLocationCoordinate2D coordinate, CGFloat scale) {
    CrumbPoint point;
    point.coordinate = coordinate;
    point.scale = scale;
    return point;
}

@interface CrumbPathOverlay : NSObject <MKOverlay>

@property (nonatomic, weak) MKOverlayRenderer *render;
@property (nonatomic, readonly) CrumbPoint *points;
@property (nonatomic, readonly) NSUInteger pointsCount;

- (instancetype)initWithOrigin:(CrumbPoint)point;

- (void)addCoordinate:(CrumbPoint)point;
- (void)lockPointArray;
- (void)unlockPointArray;

@end

CrumbPathOverlay.m


#import <pthread.h>
#import "CrumbPathOverlay.h"

#define INITIAL_POINT_SPACE 1000
#define MINIMUM_DELTA_METERS 10.0

@interface CrumbPathOverlay()

@property (nonatomic, assign) MKMapRect boundingRect;
@property (nonatomic, assign) pthread_rwlock_t rwLock;
@property (nonatomic, assign) NSUInteger pointSpace;

@end

@implementation CrumbPathOverlay




- (instancetype)initWithOrigin:(CrumbPoint)point {
    self = [super init];
    if (self) {
        _pointSpace = INITIAL_POINT_SPACE;
        _pointsCount = 1;
        _points = malloc(sizeof(CrumbPoint)*_pointSpace);
        _points[0] = point;
        _boundingRect = [self worldRectWithCenter:_points[0].coordinate];
        pthread_rwlock_init(&_rwLock,NULL);

    }
    return self;}


- (CLLocationCoordinate2D)coordinate {
    return _points[0].coordinate;
}

- (MKMapRect)boundingMapRect {
    return _boundingRect;
}


- (MKMapRect)worldRectWithCenter:(CLLocationCoordinate2D)coordinate {
    MKMapPoint center = MKMapPointForCoordinate(coordinate);
    double width = MKMapSizeWorld.width/4;
    double height = MKMapSizeWorld.height/4;
    MKMapPoint origin = MKMapPointMake(center.x - width/2, center.y - height/2);

    return MKMapRectMake(origin.x, origin.y, width , height);

}


-(void)dealloc{
    free(_points);
    pthread_rwlock_destroy(&_rwLock);
}



#pragma mark - Point add

- (void)addCoordinate:(CrumbPoint)point {
    //LOCK Thread because we are going to changing the list of points
    pthread_rwlock_wrlock(&_rwLock);

    //receive new point and previous point
    MKMapPoint newPoint = MKMapPointForCoordinate(point.coordinate);
    MKMapPoint prevPoint = MKMapPointForCoordinate(_points[_pointsCount-1].coordinate);


    //Get the distance between this new point and previous point
    CLLocationDistance metersApart = MKMetersBetweenMapPoints(newPoint, prevPoint);
    MKMapRect updateRect = MKMapRectNull;

    if (metersApart > MINIMUM_DELTA_METERS){
        //Grow (multiply 2) the points array if full
        if (_pointSpace == _pointsCount){
            _pointSpace *= 2;
            _points = realloc(_points, sizeof(CrumbPoint) * _pointSpace);
        }

        //Add the new point to points array
        _points[_pointsCount] = point;
        _pointsCount++;

        //Compute MKMapRect bounding prevPoint and newPoint
        double minX = MIN(newPoint.x,prevPoint.x);
        double minY = MIN(newPoint.y,prevPoint.y);
        double maxX = MAX(newPoint.x, prevPoint.x);
        double maxY = MAX(newPoint.y, prevPoint.y);

        updateRect = MKMapRectMake(minX, minY, maxX - minX, maxY - minY);
    }
    //UNLOCK Thread
    pthread_rwlock_unlock(&_rwLock);

    //Make Update Display
    if (_render) {
        [_render setNeedsDisplayInMapRect:updateRect];
    }
}




#pragma mark - Thread Lock

- (void)lockPointArray {
    pthread_rwlock_rdlock(&_rwLock);
}

- (void)unlockPointArray {
    pthread_rwlock_unlock(&_rwLock);
}

@end

动态轨迹Render

CrumbPathRender.h


#import <UIKit/UIKit.h>
#import <MapKit/MapKit.h>
#import "CrumbPathOverlay.h"


@interface CrumbPathRender : MKOverlayPathRenderer

- (instancetype)initWithOverlay:(CrumbPathOverlay *)overlay;

@property (nonatomic, assign) CGFloat beginHue;
@property (nonatomic, assign) CGFloat endHue;
@property (nonatomic, assign) CGFloat minScreenPointDelta;

@end

CrumbPathRender.m

#import "CrumbPathRender.h"


@interface CrumbPathRender ()

@property (nonatomic, weak) CrumbPathOverlay *crumb;
@property (nonatomic, assign) CGFloat hueRange;

@end


@implementation CrumbPathRender


- (instancetype)initWithOverlay:(CrumbPathOverlay *)overlay {
    self = [super initWithOverlay:overlay];
    if (self){
        _crumb = overlay;
        _beginHue = 0.3;
        _endHue = 0.03;
        _minScreenPointDelta = 5.0;
        _hueRange = _beginHue - _endHue;
        _crumb.render = self;
        self.fillColor = [UIColor blueColor];
        self.lineWidth = 5;
    }
    return self;
}


- (id<MKOverlay>)overlay {
    return _crumb;
}

- (BOOL)canDrawMapRect:(MKMapRect)mapRect zoomScale:(MKZoomScale)zoomScale {
    return _crumb?YES:NO;
}

- (void)drawMapRect:(MKMapRect)mapRect zoomScale:(MKZoomScale)zoomScale inContext:(CGContextRef)context {

    //Lock Add
    [_crumb lockPointArray];

    //Prepare ClipRect
    CGFloat lineWidth = self.lineWidth;
    lineWidth = lineWidth / zoomScale;
    MKMapRect clipRect = MKMapRectInset(mapRect, -lineWidth, -lineWidth);


    //Make Limit Distance
    double minMapPointDelta = pow(_minScreenPointDelta / zoomScale,2);

    //For to Add
    CrumbPoint point,prevPoint = _crumb.points[0];
    for (int i = 1;i < _crumb.pointsCount;i++){
        point = _crumb.points[i];
        CGMutablePathRef path = CGPathCreateMutable();


        //Convert Map Point
        MKMapPoint mapPoint = MKMapPointForCoordinate(point.coordinate);
        MKMapPoint prevMapPoint = MKMapPointForCoordinate(prevPoint.coordinate);

        //Check Delta
        double pointDelta = pow(mapPoint.x - prevMapPoint.x,2) + pow(mapPoint.y - prevMapPoint.y,2);
        if (pointDelta < minMapPointDelta && i < _crumb.pointsCount - 1) {
            prevPoint = point;
            continue;
        }

        //Check Area
        if ([CrumbPathRender linePoint:mapPoint and:prevMapPoint intersectsRect:clipRect]) {
            //Add Line
            CGPoint startPoint = [self pointForMapPoint:mapPoint];
            CGPoint endPoint = [self pointForMapPoint:prevMapPoint];
            CGPathMoveToPoint(path, NULL, startPoint.x, startPoint.y);
            CGPathAddLineToPoint(path, NULL, endPoint.x, endPoint.y);
            //Save State
            CGContextSaveGState(context);
            //Line Prepare
            CGPathRef pathToFill = CGPathCreateCopyByStrokingPath(path, NULL, lineWidth, self.lineCap, self.lineJoin, self.miterLimit);
            CGContextAddPath(context, pathToFill);
            CGContextClip(context);
            //Color Prepare
            UIColor *startColor, *endColor;
            if(point.scale == CGFLOAT_MAX) {
                startColor = self.fillColor;
                endColor = self.fillColor;
            } else {
                CGFloat scale =  [CrumbPathRender distributeScale:prevPoint.scale];
                startColor = [CrumbPathRender hueColor:_beginHue - scale *_hueRange];
                scale =  [CrumbPathRender distributeScale:point.scale];
                endColor = [CrumbPathRender hueColor:_beginHue - scale*_hueRange];
            }

            CGGradientRef gradient = [CrumbPathRender lineColorGradient:startColor and:endColor];
            //Add Color
            CGContextDrawLinearGradient(context, gradient, startPoint, endPoint, kCGGradientDrawsAfterEndLocation);
            //Release Color
            CGGradientRelease(gradient);
            //Return State for Next
            CGContextRestoreGState(context);
        }
        prevPoint = point;
        CGPathRelease(path);
    }
    [_crumb unlockPointArray];
}


+ (CGFloat)distributeScale:(CGFloat)scale {
    CGFloat temp = scale;
    temp = temp > 1? 1: (temp < 0 ? 0 : temp);
    return temp;
}

+ (UIColor *)hueColor:(CGFloat)hue {
    return [UIColor colorWithHue:hue saturation:1.0f brightness:1.0f alpha:1.0f];
}


+ (BOOL)linePoint:(MKMapPoint)p0 and:(MKMapPoint)p1 intersectsRect:(MKMapRect) r {
    double minX = MIN(p0.x, p1.x);
    double minY = MIN(p0.y, p1.y);
    double maxX = MAX(p0.x, p1.x);
    double maxY = MAX(p0.y, p1.y);

    MKMapRect r2 = MKMapRectMake(minX, minY, maxX - minX, maxY - minY);
    return MKMapRectIntersectsRect(r, r2);
}

+ (CGGradientRef)lineColorGradient:(UIColor *)startColor and:(UIColor *)endColor {
    //Color Prepare
    CGFloat pc_r,pc_g,pc_b,pc_a, cc_r,cc_g,cc_b,cc_a;
    [startColor getRed:&pc_r green:&pc_g blue:&pc_b alpha:&pc_a];
    [endColor getRed:&cc_r green:&cc_g blue:&cc_b alpha:&cc_a];
    CGFloat gradientColors[8] = {pc_r,pc_g,pc_b,pc_a, cc_r,cc_g,cc_b,cc_a};
    CGFloat gradientLocation[2] = {0,1};
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    CGGradientRef gradient = CGGradientCreateWithColorComponents(colorSpace, gradientColors, gradientLocation, 2);
    CGColorSpaceRelease(colorSpace);
    return gradient;
}

@end