如何在非Google地图的地图中显示某些用户位置？

Question

I'm making an app that will show the current location in a map, but this map is a image (not google maps). How can i do that? Use a map that is not google maps.

I'm wondering if is possible, somehow, to relate the google maps coordinates with this map i want to use, using core location to get these coordinates.

Any ideias?

Answer 1

1. Your image will have to be geo-referenced.

2. You will have to know the projection parameters of the map.

3. If the image is not in longitude/latitude projection you will have to project the coordinates core location provides to the same projection your map uses.

Answer 2

I'm confused by the question; latitude + longitude coordinates aren't unique to Google Maps. Will you have both a google map and your image on the same page? Or are you just wanting to display an image? Google also provide such a service using the Static Maps API

Answer 3

Here is a class I created for latitude/longitude conversions for both FAI globe and WGS-84 projections. You initialize it with a base geographic point (say: the center of your map), and it will compute distance in meters between that point and other points. If you then know the meters/pixel resolution of your map, you can easily convert it to pixel values.

The class is not very much documented, but I know you can figure it out. It uses another class of mine (Vector), but you should be able to replace that with CGPoint easily.

CAVEAT: it will not work with small scale maps. It is optimized for quick computing time assuming a large scale map (say: smaller than 100km across).

The .h file:

//
//  Earth.h
//
//  Created by René Dekker on 01/10/2011.
//  Copyright 2011. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <CoreLocation/CoreLocation.h>
#import "Vector.h"

enum EarthModel {
    EarthModelFAI = 0,
    EarthModelWGS84 = 1
};

@interface Earth : NSObject {
    enum EarthModel theModel;
    double theLongitudeScale;
    double theLatitudeScale;
    CLLocationCoordinate2D baseLocation;
}

@property CLLocationCoordinate2D baseLocation;

+ (Earth *)earthModel:(enum EarthModel)model atLatitude:(double)baseLatitude;
- (void) rebaseAtLatitude:(double)baseLatitude;

+ (Earth *)earthAtLocation:(CLLocationCoordinate2D)location model:(enum EarthModel)model;
- (void) rebaseAtLocation:(CLLocationCoordinate2D)location;

- (Vector *) differenceBetween:(CLLocationCoordinate2D)first and:(CLLocationCoordinate2D)second;
- (double) distanceBetween:(CLLocationCoordinate2D)first and:(CLLocationCoordinate2D)second;
- (CLLocationCoordinate2D) addTo:(CLLocationCoordinate2D)location vector:(Vector *)vector;
- (double) addToLongitude:(double)longitude distance:(double)distance;
- (double) addToLatitude:(double)latitude distance:(double)distance;

- (Vector *) vectorFromBase:(CLLocationCoordinate2D)location;
- (double) distanceFromBase:(CLLocationCoordinate2D)location;
- (CLLocationCoordinate2D) addToBase:(Vector *)vector;

@end

The .m file:

//
//  Earth.m
//
//  Created by René Dekker on 01/10/2011.
//  Copyright 2011. All rights reserved.
//
// The information and formulas used in the WGS84 computations come mainly from:
// http://en.wikipedia.org/wiki/World_Geodetic_System
// http://en.wikipedia.org/wiki/Meridian_arc#Meridian_distance_on_the_ellipsoid
// http://www.holoscenes.com/cgi-bin/moin.cgi/Ellipsoid
// http://www.movable-type.co.uk/scripts/gis-faq-5.1.html
// http://williams.best.vwh.net/avform.htm
// 

#import "Earth.h"

#define WGS_EQUATOR_R   6378137.0
#define WGS_POLAR_R     6356752.314245
#define F               (1/298.257223563)
#define E2              (F * (2 - F))
#define FAI_R           6371000

@implementation Earth

double modTo(double x, double lower, double upper)
{
    double range = upper - lower;
    double result = fmod(x - lower, range);
    if (result < 0) {
        result += range;
    }
    return result + lower;
}


- (void) rebaseAtLatitude:(double)baseLatitude
{
    baseLatitude *= PI_DEGREE;
    if (theModel == EarthModelWGS84) {
        double sinLat = sin(baseLatitude);
        double factor = sqrt(1 - E2*sinLat*sinLat);
        theLatitudeScale = PI_DEGREE * WGS_EQUATOR_R * (1-E2) / pow(factor, 3);
        theLongitudeScale = PI_DEGREE * WGS_EQUATOR_R * cos(baseLatitude) / factor;
    } else {
        theLatitudeScale = PI_DEGREE * FAI_R;
        theLongitudeScale = PI_DEGREE * FAI_R * cos(baseLatitude);
    }
}

- (void) rebaseAtLocation:(CLLocationCoordinate2D)location
{
    baseLocation = location;
    [self rebaseAtLatitude:location.latitude];
}

- (CLLocationCoordinate2D) baseLocation
{
    return baseLocation;
}

- (void) setBaseLocation:(CLLocationCoordinate2D)location
{
    baseLocation = location;
    [self rebaseAtLatitude:location.latitude];
}

- (Earth *) initWithModel:(enum EarthModel)model atLocation:(CLLocationCoordinate2D)location
{
    if (!(self = [super init])) {
        return nil;
    }
    theModel = model;
    [self rebaseAtLocation:location];
    return self;
}

+ (Earth *)earthModel:(enum EarthModel)model atLatitude:(double)baseLatitude
{
    CLLocationCoordinate2D location = CLLocationCoordinate2DMake(baseLatitude, 0);
    return [[[Earth alloc] initWithModel:model atLocation:location] autorelease];
}

+ (Earth *)earthAtLocation:(CLLocationCoordinate2D)location model:(enum EarthModel)model
{
    return [[[Earth alloc] initWithModel:model atLocation:location] autorelease];
}

- (Vector *) differenceBetween:(CLLocationCoordinate2D)first and:(CLLocationCoordinate2D)second
{
    double dx = modTo(first.longitude - second.longitude, -180, 180) * theLongitudeScale;
    double dy = (first.latitude - second.latitude) * theLatitudeScale;
    return [Vector withX:dx y:dy];
}

- (double) distanceBetween:(CLLocationCoordinate2D)first and:(CLLocationCoordinate2D)second
{
    double dx = modTo(first.longitude - second.longitude, -180, 180) * theLongitudeScale;
    double dy = (first.latitude - second.latitude) * theLatitudeScale;
    return hypot(dx, dy);
}

- (CLLocationCoordinate2D) addTo:(CLLocationCoordinate2D)location vector:(Vector *)vector
{
    location.latitude += vector.y / theLatitudeScale;
    location.longitude += modTo(vector.x / theLongitudeScale, -180, 180);
    return location;
}

- (Vector *) vectorFromBase:(CLLocationCoordinate2D)location
{
    return [self differenceBetween:location and:baseLocation];
}

- (double) distanceFromBase:(CLLocationCoordinate2D)location
{
    return [self distanceBetween:location and:baseLocation];
}

- (CLLocationCoordinate2D) addToBase:(Vector *)vector
{
    return [self addTo:baseLocation vector:vector];
}

- (double) addToLongitude:(double)longitude distance:(double)distance
{
    return modTo(longitude + distance / theLongitudeScale, -180, 180);
}

- (double) addToLatitude:(double)latitude distance:(double)distance
{
    return latitude + distance / theLatitudeScale;
}

- (NSString *) description
{
    return NSStringFromCLLocationCoordinate2D(baseLocation);
}

@end