485 lines
15 KiB
C++
485 lines
15 KiB
C++
//
|
|
// Generated by the J2ObjC translator. DO NOT EDIT!
|
|
// source: MapUtils.java
|
|
//
|
|
// Created by Remarket on 18.10.12.
|
|
//
|
|
|
|
#include <Entity.h>
|
|
#include <IOSCharArray.h>
|
|
#include <IOSClass.h>
|
|
#include <LatLon.h>
|
|
#include <MapUtils.h>
|
|
#include <Node.h>
|
|
#include <Relation.h>
|
|
#include <Way.h>
|
|
#include <java/lang/Double.h>
|
|
#include <java/lang/Long.h>
|
|
#include <java/lang/Math.h>
|
|
#include <java/lang/NullPointerException.h>
|
|
#include <java/lang/StringBuilder.h>
|
|
#include <java/util/ArrayList.h>
|
|
#include <java/util/Collection.h>
|
|
#include <java/util/Collections.h>
|
|
#include <java/util/Iterator.h>
|
|
#include <java/util/List.h>
|
|
|
|
class MapUtils {
|
|
|
|
static NSString * MapUtils_BASE_SHORT_OSM_URL_ = @"http://osm.org/go/";
|
|
static IOSCharArray * MapUtils_intToBase64_;
|
|
|
|
static NSString * BASE_SHORT_OSM_URL {
|
|
return MapUtils_BASE_SHORT_OSM_URL_;
|
|
}
|
|
|
|
static IOSCharArray * intToBase64 {
|
|
return MapUtils_intToBase64_;
|
|
}
|
|
|
|
static double getDistance ( Node* e1, Node* e2 ) {
|
|
return getDistance( e1.getLatitude(), e1.getLongitude(), e2.getLatitude(), e2.getLongitude());
|
|
}
|
|
|
|
static double getDistance ( LatLon* l, double latitude, double longitude ) {
|
|
return getDistance( l.getLatitude(), l.getLongitude(), latitude, longitude);
|
|
}
|
|
|
|
static double getDistance ( Node* e1, double latitude, double longitude ) {
|
|
return getDistance( e1.getLatitude(), e1.getLongitude(), latitude, longitude);
|
|
}
|
|
|
|
static double getDistance ( Node* e1, LatLon* point ) {
|
|
return getDistance( e1.getLatitude(), e1.getLongitude(), point.getLatitude(), point.getLongitude());
|
|
}
|
|
|
|
static double scalarMultiplication ( double xA, double yA, double xB, double yB, double xC, double yC ) {
|
|
double multiple = (xB - xA) * (xC - xA) + (yB - yA) * (yC - yA);
|
|
return multiple;
|
|
}
|
|
|
|
static double getOrthogonalDistance ( double lat, double lon, double fromLat, double fromLon, double toLat, double toLon ) {
|
|
return getDistance( getProjection(lat, lon, fromLat, fromLon, toLat, toLon), lat, lon);
|
|
}
|
|
|
|
static LatLon * getProjection ( double lat, double lon, double fromLat, double fromLon, double toLat, double toLon ) {
|
|
double mDist = (fromLat - toLat) * (fromLat - toLat) + (fromLon - toLon) * (fromLon - toLon);
|
|
double projection = scalarMultiplication(fromLat, fromLon, toLat, toLon, lat, lon);
|
|
double prlat;
|
|
double prlon;
|
|
if (projection < 0) {
|
|
prlat = fromLat;
|
|
prlon = fromLon;
|
|
}
|
|
else if (projection >= mDist) {
|
|
prlat = toLat;
|
|
prlon = toLon;
|
|
}
|
|
else {
|
|
prlat = fromLat + (toLat - fromLat) * (projection / mDist);
|
|
prlon = fromLon + (toLon - fromLon) * (projection / mDist);
|
|
}
|
|
return [[[LatLon alloc] initprlat, prlon] autorelease];
|
|
}
|
|
|
|
static double getDistance ( double lat1, double lon1, double lat2, double lon2 ) {
|
|
double R = 6371;
|
|
double dLat = Math.toRadians(lat2 - lat1);
|
|
double dLon = Math.toRadians(lon2 - lon1);
|
|
double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos( Math.toRadians(lat1)) * Math.cos( Math.toRadians(lat2)) * Math.sin(dLon / 2)* Math.sin(dLon / 2);
|
|
double c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1 - a));
|
|
return R * c * 1000;
|
|
}
|
|
|
|
static double getDistance ( LatLon* l1, LatLon* l2 ) {
|
|
return getDistance( l1.getLatitude(), l1.getLongitude(), l2.getLatitude(), l2.getLongitude());
|
|
}
|
|
|
|
static LatLon * getCenter ( Entity* e ) {
|
|
if ([e isKindOfClass:[Node class]]) {
|
|
return getLatLon();
|
|
}
|
|
else if ([e isKindOfClass:[Way class]]) {
|
|
return getWeightCenterForNodes( getNodes());
|
|
}
|
|
else if ([e isKindOfClass:[Relation class]]) {
|
|
id<JavaUtilList> list = [[[JavaUtilArrayList alloc] init] autorelease];
|
|
{
|
|
id<JavaLangIterable> array__ = (id<JavaLangIterable>) getMembers(nil);
|
|
if (!array__) {
|
|
@throw [[[JavaLangNullPointerException alloc] init] autorelease];
|
|
}
|
|
id<JavaUtilIterator> iter__ = [array__ iterator];
|
|
while ([iter__ hasNext]) {
|
|
Entity * fe = (Entity *) [iter__ next];
|
|
LatLon *c = nil;
|
|
if (!([fe isKindOfClass:[Relation class]])) {
|
|
c = getCenter(fe);
|
|
}
|
|
if (c != nil) {
|
|
list.add(c);
|
|
}
|
|
}
|
|
}
|
|
return getWeightCenter(list);
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
static LatLon * getWeightCenter ( JavaUtilCollection* nodes ) {
|
|
if ( nodes.isEmpty()) {
|
|
return nil;
|
|
}
|
|
double longitude = 0;
|
|
double latitude = 0;
|
|
{
|
|
id<JavaLangIterable> array__ = (id<JavaLangIterable>) nodes;
|
|
if (!array__) {
|
|
@throw [[[JavaLangNullPointerException alloc] init] autorelease];
|
|
}
|
|
id<JavaUtilIterator> iter__ = [array__ iterator];
|
|
while ([iter__ hasNext]) {
|
|
LatLon * n = (LatLon *) [iter__ next];
|
|
longitude += n.getLongitude();
|
|
latitude += n.getLatitude();
|
|
}
|
|
}
|
|
return [[[LatLon alloc] initlatitude / nodes.size(), longitude / nodes.size()] autorelease];
|
|
}
|
|
|
|
static LatLon * getWeightCenterForNodes ( JavaUtilCollection* nodes ) {
|
|
if ( nodes.isEmpty()) {
|
|
return nil;
|
|
}
|
|
double longitude = 0;
|
|
double latitude = 0;
|
|
int count = 0;
|
|
{
|
|
id<JavaLangIterable> array__ = (id<JavaLangIterable>) nodes;
|
|
if (!array__) {
|
|
@throw [[[JavaLangNullPointerException alloc] init] autorelease];
|
|
}
|
|
id<JavaUtilIterator> iter__ = [array__ iterator];
|
|
while ([iter__ hasNext]) {
|
|
Node * n = (Node *) [iter__ next];
|
|
if (n != nil) {
|
|
count++;
|
|
longitude += n.getLongitude();
|
|
latitude += n.getLatitude();
|
|
}
|
|
}
|
|
}
|
|
if (count == 0) {
|
|
return nil;
|
|
}
|
|
return [[[LatLon alloc] initlatitude / count, longitude / count] autorelease];
|
|
}
|
|
|
|
static LatLon * getMathWeightCenterForNodes ( JavaUtilCollection* nodes ) {
|
|
if ( nodes.isEmpty()) {
|
|
return nil;
|
|
}
|
|
double longitude = 0;
|
|
double latitude = 0;
|
|
double sumDist = 0;
|
|
Node *prev = nil;
|
|
{
|
|
id<JavaLangIterable> array__ = (id<JavaLangIterable>) nodes;
|
|
if (!array__) {
|
|
@throw [[[JavaLangNullPointerException alloc] init] autorelease];
|
|
}
|
|
id<JavaUtilIterator> iter__ = [array__ iterator];
|
|
while ([iter__ hasNext]) {
|
|
Node * n = (Node *) [iter__ next];
|
|
if (n != nil) {
|
|
if (prev == nil) {
|
|
prev = n;
|
|
}
|
|
else {
|
|
double dist = MapUtils.getDistance(prev, n);
|
|
sumDist += dist;
|
|
longitude += ( prev.getLongitude() + n.getLongitude()) * dist / 2;
|
|
latitude += ( n.getLatitude() + n.getLatitude()) * dist / 2;
|
|
prev = n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sumDist == 0) {
|
|
if (prev == nil) {
|
|
return nil;
|
|
}
|
|
return prev.getLatLon();
|
|
}
|
|
return [[[LatLon alloc] initlatitude / sumDist, longitude / sumDist] autorelease];
|
|
}
|
|
|
|
static double checkLongitude ( double longitude ) {
|
|
while (longitude < -180 || longitude > 180) {
|
|
if (longitude < 0) {
|
|
longitude += 360;
|
|
}
|
|
else {
|
|
longitude -= 360;
|
|
}
|
|
}
|
|
return longitude;
|
|
}
|
|
|
|
static double checkLatitude ( double latitude ) {
|
|
while (latitude < -90 || latitude > 90) {
|
|
if (latitude < 0) {
|
|
latitude += 180;
|
|
}
|
|
else {
|
|
latitude -= 180;
|
|
}
|
|
}
|
|
if (latitude < -85.0511) {
|
|
return -85.0511;
|
|
}
|
|
else if (latitude > 85.0511) {
|
|
return 85.0511;
|
|
}
|
|
return latitude;
|
|
}
|
|
|
|
static int get31TileNumberX ( double longitude ) {
|
|
longitude = checkLongitude(longitude);
|
|
long long l = 1l << 31;
|
|
return (int) ((longitude + 180.0) / 360.0 * l);
|
|
}
|
|
|
|
static int get31TileNumberY ( double latitude ) {
|
|
latitude = checkLatitude(latitude);
|
|
double eval = Math.log( Math.tan( Math.toRadians(latitude)) + 1 / Math.cos( Math.toRadians(latitude)));
|
|
long long l = 1l << 31;
|
|
if (eval > JavaLangMath_PI) {
|
|
eval = JavaLangMath_PI;
|
|
}
|
|
return (int) ((1 - eval / JavaLangMath_PI) / 2 * l);
|
|
}
|
|
|
|
static double get31LongitudeX ( int tileX ) {
|
|
return MapUtils.getLongitudeFromTile(21, tileX / 1024.0f);
|
|
}
|
|
|
|
static double get31LatitudeY ( int tileY ) {
|
|
return MapUtils.getLatitudeFromTile(21, tileY / 1024.0f);
|
|
}
|
|
|
|
static double getTileNumberX ( float zoom, double longitude ) {
|
|
if (longitude == 180.0) {
|
|
return getPowZoom(zoom) - 1;
|
|
}
|
|
longitude = checkLongitude(longitude);
|
|
return (longitude + 180.0) / 360.0 * getPowZoom(zoom);
|
|
}
|
|
|
|
static double getTileNumberY ( float zoom, double latitude ) {
|
|
latitude = checkLatitude(latitude);
|
|
double eval = Math.log( Math.tan( Math.toRadians(latitude)) + 1 / Math.cos( Math.toRadians(latitude)));
|
|
if ( Double.isInfinite(eval) || Double.isNaN(eval)) {
|
|
latitude = latitude < 0 ? -89.9 : 89.9;
|
|
eval = Math.log( Math.tan( Math.toRadians(latitude)) + 1 / Math.cos( Math.toRadians(latitude)));
|
|
}
|
|
double result = (1 - eval / JavaLangMath_PI) / 2 * getPowZoom(zoom);
|
|
return result;
|
|
}
|
|
|
|
static double getTileEllipsoidNumberY ( float zoom, double latitude ) {
|
|
double E2 = (double) latitude * JavaLangMath_PI / 180;
|
|
long long sradiusa = 6378137;
|
|
long long sradiusb = 6356752;
|
|
double J2 = (double) Math.sqrt(sradiusa * sradiusa - sradiusb * sradiusb) / sradiusa;
|
|
double M2 = (double) Math.log((1 + Math.sin(E2)) / (1 - Math.sin(E2))) / 2 - J2 * Math.log((1 + J2 * Math.sin(E2)) / (1 - J2 * Math.sin(E2))) / 2;
|
|
double B2 = getPowZoom(zoom);
|
|
return B2 / 2 - M2 * B2 / 2 / JavaLangMath_PI;
|
|
}
|
|
|
|
static double getLatitudeFromEllipsoidTileY ( float zoom, float tileNumberY ) {
|
|
double MerkElipsK = 0.0000001;
|
|
long long sradiusa = 6378137;
|
|
long long sradiusb = 6356752;
|
|
double FExct = (double) Math.sqrt(sradiusa * sradiusa - sradiusb * sradiusb) / sradiusa;
|
|
double TilesAtZoom = getPowZoom(zoom);
|
|
double result = (tileNumberY - TilesAtZoom / 2) / -(TilesAtZoom / (2 * JavaLangMath_PI));
|
|
result = (2 * Math.atan( Math.exp(result)) - JavaLangMath_PI / 2) * 180 / JavaLangMath_PI;
|
|
double Zu = result / (180 / JavaLangMath_PI);
|
|
double yy = (tileNumberY - TilesAtZoom / 2);
|
|
double Zum1 = Zu;
|
|
Zu = Math.asin(1 - ((1 + Math.sin(Zum1)) * Math.pow(1 - FExct * Math.sin(Zum1), FExct)) / ( Math.exp((2 * yy) / -(TilesAtZoom / (2 * JavaLangMath_PI))) * Math.pow(1 + FExct * Math.sin(Zum1), FExct)));
|
|
while ( Math.abs(Zum1 - Zu) >= MerkElipsK) {
|
|
Zum1 = Zu;
|
|
Zu = Math.asin(1 - ((1 + Math.sin(Zum1)) * Math.pow(1 - FExct * Math.sin(Zum1), FExct)) / ( Math.exp((2 * yy) / -(TilesAtZoom / (2 * JavaLangMath_PI))) * Math.pow(1 + FExct * Math.sin(Zum1), FExct)));
|
|
}
|
|
return Zu * 180 / JavaLangMath_PI;
|
|
}
|
|
|
|
static double getLongitudeFromTile ( float zoom, double x ) {
|
|
return x / getPowZoom(zoom) * 360.0 - 180.0;
|
|
}
|
|
|
|
static double getPowZoom ( float zoom ) {
|
|
if (zoom >= 0 && zoom - Math.floor(zoom) < 0.05f) {
|
|
return 1 << ((int) zoom);
|
|
}
|
|
else {
|
|
return Math.pow(2, zoom);
|
|
}
|
|
}
|
|
|
|
static float calcDiffPixelX ( float rotateSin, float rotateCos, float dTileX, float dTileY, float tileSize ) {
|
|
return (rotateCos * dTileX - rotateSin * dTileY) * tileSize;
|
|
}
|
|
|
|
static float calcDiffPixelY ( float rotateSin, float rotateCos, float dTileX, float dTileY, float tileSize ) {
|
|
return (rotateSin * dTileX + rotateCos * dTileY) * tileSize;
|
|
}
|
|
|
|
static double getLatitudeFromTile ( float zoom, double y ) {
|
|
int sign = y < 0 ? -1 : 1;
|
|
double result = Math.atan(sign * Math.sinh(JavaLangMath_PI * (1 - 2 * y / getPowZoom(zoom)))) * 180.0 / JavaLangMath_PI;
|
|
return result;
|
|
}
|
|
|
|
static int getPixelShiftX ( int zoom, double long1, double long2, int tileSize ) {
|
|
return (int) (( getTileNumberX(zoom, long1) - getTileNumberX(zoom, long2)) * tileSize);
|
|
}
|
|
|
|
static int getPixelShiftY ( int zoom, double lat1, double lat2, int tileSize ) {
|
|
return (int) (( getTileNumberY(zoom, lat1) - getTileNumberY(zoom, lat2)) * tileSize);
|
|
}
|
|
|
|
static void addIdsToList ( JavaUtilCollection* source, JavaUtilList* ids ) {
|
|
{
|
|
id<JavaLangIterable> array__ = (id<JavaLangIterable>) source;
|
|
if (!array__) {
|
|
@throw [[[JavaLangNullPointerException alloc] init] autorelease];
|
|
}
|
|
id<JavaUtilIterator> iter__ = [array__ iterator];
|
|
while ([iter__ hasNext]) {
|
|
Entity * e = (Entity *) [iter__ next];
|
|
ids.add( Long.valueOf( e.getId()));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void sortListOfEntities ( JavaUtilList* list, double lat, double lon ) {
|
|
Collections.sort(list, [[[MapUtils_$1 alloc] initlat, lon] autorelease]);
|
|
}
|
|
|
|
static NSString * buildShortOsmUrl ( double latitude, double longitude, int zoom ) {
|
|
long long lat = (long long) (((latitude + 90.0) / 180.0) * (1l << 32));
|
|
long long lon = (long long) (((longitude + 180.0) / 360.0) * (1l << 32));
|
|
long long code = interleaveBits(lon, lat);
|
|
JavaLangStringBuilder *str = [[[JavaLangStringBuilder alloc] init10] autorelease];
|
|
str.append(MapUtils_BASE_SHORT_OSM_URL_);
|
|
for (int i = 0; i < Math.ceil((zoom + 8) / 3.0); i++) {
|
|
str.append([((IOSCharArray *) NIL_CHK(MapUtils_intToBase64_)) charAtIndex:(int) ((code >> (58 - 6 * i)) & (int) 0x3f)]);
|
|
}
|
|
for (int j = 0; j < (zoom + 8) % 3; j++) {
|
|
str.append('-');
|
|
}
|
|
str.append(@"?m");
|
|
return str.description();
|
|
}
|
|
|
|
static long long interleaveBits ( long long x, long long y ) {
|
|
long long c = 0;
|
|
for (wchar_t b = 31; b >= 0; b--) {
|
|
c = (c << 1) | ((x >> b) & 1);
|
|
c = (c << 1) | ((y >> b) & 1);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static float unifyRotationDiff ( float rotate, float targetRotate ) {
|
|
float d = targetRotate - rotate;
|
|
while (d >= 180) {
|
|
d -= 360;
|
|
}
|
|
while (d < -180) {
|
|
d += 360;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
static float unifyRotationTo360 ( float rotate ) {
|
|
while (rotate < 0) {
|
|
rotate += 360;
|
|
}
|
|
while (rotate > 360) {
|
|
rotate -= 360;
|
|
}
|
|
return rotate;
|
|
}
|
|
|
|
static double alignAngleDifference ( double diff ) {
|
|
while (diff > JavaLangMath_PI) {
|
|
diff -= 2 * JavaLangMath_PI;
|
|
}
|
|
while (diff <= -JavaLangMath_PI) {
|
|
diff += 2 * JavaLangMath_PI;
|
|
}
|
|
return diff;
|
|
}
|
|
|
|
static double degreesDiff ( double a1, double a2 ) {
|
|
double diff = a1 - a2;
|
|
while (diff > 180) {
|
|
diff -= 360;
|
|
}
|
|
while (diff <= -180) {
|
|
diff += 360;
|
|
}
|
|
return diff;
|
|
}
|
|
|
|
+ (void)initialize {
|
|
if (self == [MapUtils class]) {
|
|
MapUtils_intToBase64_ = [ IOSCharArray.arrayWithCharacters((wchar_t[]){ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_', '@' }, count64) retain];
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
class MapUtils_$1 {
|
|
|
|
- (double)val$lat {
|
|
return val$lat_;
|
|
}
|
|
|
|
- (void)setVal$lat:(double)newVal$lat {
|
|
val$lat_ = newVal$lat;
|
|
}
|
|
|
|
- (double)val$lon {
|
|
return val$lon_;
|
|
}
|
|
|
|
- (void)setVal$lon:(double)newVal$lon {
|
|
val$lon_ = newVal$lon;
|
|
}
|
|
|
|
|
|
int compare ( id* o1, id* o2 ) {
|
|
return Double.compare( MapUtils.getDistance( o1.getLatLon(), val$lat_, val$lon_), MapUtils.getDistance( o2.getLatLon(), val$lat_, val$lon_));
|
|
}
|
|
|
|
(bool)isEqual:(id)param0 {
|
|
return (bool) [super isEqualparam0];
|
|
}
|
|
|
|
- (id)init ( double outer$0, double outer$1 ) {
|
|
if ((self = [super init])) {
|
|
val$lat_ = outer$0;
|
|
val$lon_ = outer$1;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
}
|
|
|
|
|