iOS-raywenderlich翻译-使用MapKit叠加图层

#import <MapKit/MapKit.h>

@interface PVParkMapViewController : UIViewController <MKMapViewDelegate>

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

@interface PVPark : NSObject

@property (nonatomic, readonly) CLLocationCoordinate2D *boundary;
@property (nonatomic, readonly) NSInteger boundaryPointsCount;

@property (nonatomic, readonly) CLLocationCoordinate2D midCoordinate;
@property (nonatomic, readonly) CLLocationCoordinate2D overlayTopLeftCoordinate;
@property (nonatomic, readonly) CLLocationCoordinate2D overlayTopRightCoordinate;
@property (nonatomic, readonly) CLLocationCoordinate2D overlayBottomLeftCoordinate;
@property (nonatomic, readonly) CLLocationCoordinate2D overlayBottomRightCoordinate;

@property (nonatomic, readonly) MKMapRect overlayBoundingMapRect;

@property (nonatomic, strong) NSString *name;

- (instancetype)initWithFilename:(NSString *)filename;

@end

- (instancetype)initWithFilename:(NSString *)filename {
self = [super init];
if (self) {
NSString *filePath = [[NSBundle mainBundle] pathForResource:filename ofType:@"plist"];
NSDictionary *properties = [NSDictionary dictionaryWithContentsOfFile:filePath];

CGPoint midPoint = CGPointFromString(properties[@"midCoord"]);
_midCoordinate = CLLocationCoordinate2DMake(midPoint.x, midPoint.y);

CGPoint overlayTopLeftPoint = CGPointFromString(properties[@"overlayTopLeftCoord"]);
_overlayTopLeftCoordinate = CLLocationCoordinate2DMake(overlayTopLeftPoint.x, overlayTopLeftPoint.y);

CGPoint overlayTopRightPoint = CGPointFromString(properties[@"overlayTopRightCoord"]);
_overlayTopRightCoordinate = CLLocationCoordinate2DMake(overlayTopRightPoint.x, overlayTopRightPoint.y);

CGPoint overlayBottomLeftPoint = CGPointFromString(properties[@"overlayBottomLeftCoord"]);
_overlayBottomLeftCoordinate = CLLocationCoordinate2DMake(overlayBottomLeftPoint.x, overlayBottomLeftPoint.y);

NSArray *boundaryPoints = properties[@"boundary"];

_boundaryPointsCount = boundaryPoints.count;

_boundary = malloc(sizeof(CLLocationCoordinate2D)*_boundaryPointsCount);

for(int i = 0; i < _boundaryPointsCount; i++) {
CGPoint p = CGPointFromString(boundaryPoints[i]);
_boundary[i] = CLLocationCoordinate2DMake(p.x,p.y);
}
}

return self;
}

- (CLLocationCoordinate2D)overlayBottomRightCoordinate {
return CLLocationCoordinate2DMake(self.overlayBottomLeftCoordinate.latitude, self.overlayTopRightCoordinate.longitude);
}

- (MKMapRect)overlayBoundingMapRect {

MKMapPoint topLeft = MKMapPointForCoordinate(self.overlayTopLeftCoordinate);
MKMapPoint topRight = MKMapPointForCoordinate(self.overlayTopRightCoordinate);
MKMapPoint bottomLeft = MKMapPointForCoordinate(self.overlayBottomLeftCoordinate);

return MKMapRectMake(topLeft.x,
topLeft.y,
fabs(topLeft.x - topRight.x),
fabs(topLeft.y - bottomLeft.y));
}

#import "PVPark.h"

@interface PVParkMapViewController ()

@property (nonatomic, strong) PVPark *park;
@property (nonatomic, strong) NSMutableArray *selectedOptions;

@end

- (void)viewDidLoad
{
[super viewDidLoad];

self.selectedOptions = [NSMutableArray array];
self.park = [[PVPark alloc] initWithFilename:@"MagicMountain"];

CLLocationDegrees latDelta = self.park.overlayTopLeftCoordinate.latitude - self.park.overlayBottomRightCoordinate.latitude;

// think of a span as a tv size, measure from one corner to another
MKCoordinateSpan span = MKCoordinateSpanMake(fabsf(latDelta), 0.0);

MKCoordinateRegion region = MKCoordinateRegionMake(self.park.midCoordinate, span);

self.mapView.region = region;
}

- (IBAction)mapTypeChanged:(id)sender {
// TODO: Implement
}

- (IBAction)mapTypeChanged:(id)sender {
switch (self.mapTypeSegmentedControl.selectedSegmentIndex) {
case 0:
self.mapView.mapType = MKMapTypeStandard;
break;
case 1:
self.mapView.mapType = MKMapTypeHybrid;
break;
case 2:
self.mapView.mapType = MKMapTypeSatellite;
break;
default:
break;
}
}

[self.mapView addOverlay:overlay];

- (MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay

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

@class PVPark;

@interface PVParkMapOverlay : NSObject <MKOverlay>

- (instancetype)initWithPark:(PVPark *)park;

@end

#import "PVParkMapOverlay.h"
#import "PVPark.h"

@implementation PVParkMapOverlay

@synthesize coordinate;
@synthesize boundingMapRect;

- (instancetype)initWithPark:(PVPark *)park {
self = [super init];
if (self) {
boundingMapRect = park.overlayBoundingMapRect;
coordinate = park.midCoordinate;
}

return self;
}

@end

#import <MapKit/MapKit.h>

@interface PVParkMapOverlayView : MKOverlayView

- (instancetype)initWithOverlay:(id<MKOverlay>)overlay overlayImage:(UIImage *)overlayImage;

@end

#import "PVParkMapOverlayView.h"

@interface PVParkMapOverlayView ()

@property (nonatomic, strong) UIImage *overlayImage;

@end

@implementation PVParkMapOverlayView

- (instancetype)initWithOverlay:(id<MKOverlay>)overlay overlayImage:(UIImage *)overlayImage {
self = [super initWithOverlay:overlay];
if (self) {
_overlayImage = overlayImage;
}

return self;
}

- (void)drawMapRect:(MKMapRect)mapRect zoomScale:(MKZoomScale)zoomScale inContext:(CGContextRef)context {
CGImageRef imageReference = self.overlayImage.CGImage;

MKMapRect theMapRect = self.overlay.boundingMapRect;
CGRect theRect = [self rectForMapRect:theMapRect];

CGContextScaleCTM(context, 1.0, -1.0);
CGContextTranslateCTM(context, 0.0, -theRect.size.height);
CGContextDrawImage(context, theRect, imageReference);
}

@end

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

#import "PVParkMapOverlayView.h"
#import "PVParkMapOverlay.h"

- (void)addOverlay {
PVParkMapOverlay *overlay = [[PVParkMapOverlay alloc] initWithPark:self.park];
[self.mapView addOverlay:overlay];
}

- (void)loadSelectedOptions {
[self.mapView removeAnnotations:self.mapView.annotations];
[self.mapView removeOverlays:self.mapView.overlays];
for (NSNumber *option in self.selectedOptions) {
switch ([option integerValue]) {
case PVMapOverlay:
[self addOverlay];
break;
default:
break;
}
}
}

- (MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay {
if ([overlay isKindOfClass:PVParkMapOverlay.class]) {
UIImage *magicMountainImage = [UIImage imageNamed:@"overlay_park"];
PVParkMapOverlayView *overlayView = [[PVParkMapOverlayView alloc] initWithOverlay:overlay overlayImage:magicMountainImage];

return overlayView;
}

return nil;
}

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

typedef NS_ENUM(NSInteger, PVAttractionType) {
PVAttractionDefault = 0,
PVAttractionRide,
PVAttractionFood,
PVAttractionFirstAid
};

@interface PVAttractionAnnotation : NSObject <MKAnnotation>

@property (nonatomic) CLLocationCoordinate2D coordinate;
@property (nonatomic, strong) NSString *title;
@property (nonatomic, strong) NSString *subtitle;
@property (nonatomic) PVAttractionType type;

@end

#import "PVAttractionAnnotation.h"

@implementation PVAttractionAnnotation

@end

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

@interface PVAttractionAnnotationView : MKAnnotationView

@end

#import "PVAttractionAnnotationView.h"
#import "PVAttractionAnnotation.h"

@implementation PVAttractionAnnotationView

- (id)initWithAnnotation:(id<MKAnnotation>)annotation reuseIdentifier:(NSString *)reuseIdentifier {
self = [super initWithAnnotation:annotation reuseIdentifier:reuseIdentifier];
if (self) {
PVAttractionAnnotation *attractionAnnotation = self.annotation;
switch (attractionAnnotation.type) {
case PVAttractionFirstAid:
self.image = [UIImage imageNamed:@"firstaid"];
break;
case PVAttractionFood:
self.image = [UIImage imageNamed:@"food"];
break;
case PVAttractionRide:
self.image = [UIImage imageNamed:@"ride"];
break;
default:
self.image = [UIImage imageNamed:@"star"];
break;
}
}

return self;
}

@end

#import "PVAttractionAnnotation.h"
#import "PVAttractionAnnotationView.h"

- (void)addAttractionPins {
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"MagicMountainAttractions" ofType:@"plist"];
NSArray *attractions = [NSArray arrayWithContentsOfFile:filePath];
for (NSDictionary *attraction in attractions) {
PVAttractionAnnotation *annotation = [[PVAttractionAnnotation alloc] init];
CGPoint point = CGPointFromString(attraction[@"location"]);
annotation.coordinate = CLLocationCoordinate2DMake(point.x, point.y);
annotation.title = attraction[@"name"];
annotation.type = [attraction[@"type"] integerValue];
annotation.subtitle = attraction[@"subtitle"];
[self.mapView addAnnotation:annotation];
}
}

- (void)loadSelectedOptions {
[self.mapView removeAnnotations:self.mapView.annotations];
[self.mapView removeOverlays:self.mapView.overlays];
for (NSNumber *option in self.selectedOptions) {
switch ([option integerValue]) {
case PVMapOverlay:
[self addOverlay];
break;
case PVMapPins:
[self addAttractionPins];
break;
default:
break;
}
}
}

- (MKAnnotationView *)mapView:(MKMapView *)mapView viewForAnnotation:(id<MKAnnotation>)annotation {
PVAttractionAnnotationView *annotationView = [[PVAttractionAnnotationView alloc] initWithAnnotation:annotation reuseIdentifier:@"Attraction"];
annotationView.canShowCallout = YES;
return annotationView;
}

- (void)addRoute {
NSString *thePath = [[NSBundle mainBundle] pathForResource:@"EntranceToGoliathRoute" ofType:@"plist"];
NSArray *pointsArray = [NSArray arrayWithContentsOfFile:thePath];

NSInteger pointsCount = pointsArray.count;

CLLocationCoordinate2D pointsToUse[pointsCount];

for(int i = 0; i < pointsCount; i++) {
CGPoint p = CGPointFromString(pointsArray[i]);
pointsToUse[i] = CLLocationCoordinate2DMake(p.x,p.y);
}

MKPolyline *myPolyline = [MKPolyline polylineWithCoordinates:pointsToUse count:pointsCount];

[self.mapView addOverlay:myPolyline];
}

- (void)loadSelectedOptions {
[self.mapView removeAnnotations:self.mapView.annotations];
[self.mapView removeOverlays:self.mapView.overlays];
for (NSNumber *option in self.selectedOptions) {
switch ([option integerValue]) {
case PVMapOverlay:
[self addOverlay];
break;
case PVMapPins:
[self addAttractionPins];
break;
case PVMapRoute:
[self addRoute];
break;
default:
break;
}
}
}

- (MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay {
if ([overlay isKindOfClass:PVParkMapOverlay.class]) {
UIImage *magicMountainImage = [UIImage imageNamed:@"overlay_park"];
PVParkMapOverlayView *overlayView = [[PVParkMapOverlayView alloc] initWithOverlay:overlay overlayImage:magicMountainImage];

return overlayView;
} else if ([overlay isKindOfClass:MKPolyline.class]) {
MKPolylineView *lineView = [[MKPolylineView alloc] initWithOverlay:overlay];
lineView.strokeColor = [UIColor greenColor];

return lineView;
}

return nil;
}

- (void)addBoundary {
MKPolygon *polygon = [MKPolygon polygonWithCoordinates:self.park.boundary
count:self.park.boundaryPointsCount];
[self.mapView addOverlay:polygon];
}

- (void)loadSelectedOptions {
[self.mapView removeAnnotations:self.mapView.annotations];
[self.mapView removeOverlays:self.mapView.overlays];
for (NSNumber *option in self.selectedOptions) {
switch ([option integerValue]) {
case PVMapOverlay:
[self addOverlay];
break;
case PVMapPins:
[self addAttractionPins];
break;
case PVMapRoute:
[self addRoute];
break;
case PVMapBoundary:
[self addBoundary];
break;
default:
break;
}
}
}

- (MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay {
if ([overlay isKindOfClass:PVParkMapOverlay.class]) {
UIImage *magicMountainImage = [UIImage imageNamed:@"overlay_park"];
PVParkMapOverlayView *overlayView = [[PVParkMapOverlayView alloc] initWithOverlay:overlay overlayImage:magicMountainImage];

return overlayView;
} else if ([overlay isKindOfClass:MKPolyline.class]) {
MKPolylineView *lineView = [[MKPolylineView alloc] initWithOverlay:overlay];
lineView.strokeColor = [UIColor greenColor];

return lineView;
} else if ([overlay isKindOfClass:MKPolygon.class]) {
MKPolygonView *polygonView = [[MKPolygonView alloc] initWithOverlay:overlay];
polygonView.strokeColor = [UIColor magentaColor];

return polygonView;
}

return nil;
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array>
<string>{34.42481,-118.596914}</string>
<string>{34.423383,-118.596101}</string>
<string>{34.423628,-118.595197}</string>
<string>{34.421832,-118.595404}</string>
</array>
</plist>

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

@interface PVCharacter : MKCircle <MKOverlay>

@property (nonatomic, strong) NSString *name;
@property (nonatomic, strong) UIColor *color;

@end

#import "PVCharacter.h"

@implementation PVCharacter

@end

#import "PVCharacter.h"

- (void)addCharacterLocation {
NSString *batmanFilePath = [[NSBundle mainBundle] pathForResource:@"BatmanLocations" ofType:@"plist"];
NSArray *batmanLocations = [NSArray arrayWithContentsOfFile:batmanFilePath];
CGPoint batmanPoint = CGPointFromString(batmanLocations[rand()%4]);
PVCharacter *batman = (PVCharacter *)[PVCharacter circleWithCenterCoordinate:CLLocationCoordinate2DMake(batmanPoint.x, batmanPoint.y)
radius:MAX(5, rand()%40)];
batman.color = [UIColor blueColor];

NSString *tazFilePath = [[NSBundle mainBundle] pathForResource:@"TazLocations" ofType:@"plist"];
NSArray *tazLocations = [NSArray arrayWithContentsOfFile:tazFilePath];
CGPoint tazPoint = CGPointFromString(tazLocations[rand()%4]);
PVCharacter *taz = (PVCharacter *)[PVCharacter circleWithCenterCoordinate:CLLocationCoordinate2DMake(tazPoint.x, tazPoint.y)
radius:MAX(5, rand()%40)];
taz.color = [UIColor orangeColor];

NSString *tweetyFilePath = [[NSBundle mainBundle] pathForResource:@"TweetyBirdLocations" ofType:@"plist"];
NSArray *tweetyLocations = [NSArray arrayWithContentsOfFile:tweetyFilePath];
CGPoint tweetyPoint = CGPointFromString(tweetyLocations[rand()%4]);
PVCharacter *tweety = (PVCharacter *)[PVCharacter circleWithCenterCoordinate:CLLocationCoordinate2DMake(tweetyPoint.x, tweetyPoint.y)
radius:MAX(5, rand()%40)];
tweety.color = [UIColor yellowColor];

[self.mapView addOverlay:batman];
[self.mapView addOverlay:taz];
[self.mapView addOverlay:tweety];
}

- (MKOverlayView *)mapView:(MKMapView *)mapView viewForOverlay:(id<MKOverlay>)overlay {
if ([overlay isKindOfClass:PVParkMapOverlay.class]) {
UIImage *magicMountainImage = [UIImage imageNamed:@"overlay_park"];
PVParkMapOverlayView *overlayView = [[PVParkMapOverlayView alloc] initWithOverlay:overlay overlayImage:magicMountainImage];

return overlayView;
} else if ([overlay isKindOfClass:MKPolyline.class]) {
MKPolylineView *lineView = [[MKPolylineView alloc] initWithOverlay:overlay];
lineView.strokeColor = [UIColor greenColor];

return lineView;
} else if ([overlay isKindOfClass:MKPolygon.class]) {
MKPolygonView *polygonView = [[MKPolygonView alloc] initWithOverlay:overlay];
polygonView.strokeColor = [UIColor magentaColor];

return polygonView;
} else if ([overlay isKindOfClass:PVCharacter.class]) {
MKCircleView *circleView = [[MKCircleView alloc] initWithOverlay:overlay];
circleView.strokeColor = [(PVCharacter *)overlay color]];

return circleView;
}

return nil;
}

- (void)loadSelectedOptions {
[self.mapView removeAnnotations:self.mapView.annotations];
[self.mapView removeOverlays:self.mapView.overlays];
for (NSNumber *option in self.selectedOptions) {
switch ([option integerValue]) {
case PVMapOverlay:
[self addOverlay];
break;
case PVMapPins:
[self addAttractionPins];
break;
case PVMapRoute:
[self addRoute];
break;
case PVMapBoundary:
[self addBoundary];
break;
case PVMapCharacterLocation:
[self addCharacterLocation];
break;
default:
break;
}
}
}