MKMapRect und Anzeige von anzeigen-overlays, die sich über 180th meridian

Arbeite ich mit Fenstern und Grenzen kehrte aus Google Geocoding API. Wenn dabei die reverse geocoding für eine bestimmte Koordinate, der Dienst gibt mehrere Ergebnisse mit unterschiedlichen Granularität (Land -, Verwaltungs-Gebiet, Lokalität, sublocality, route, etc.). Ich möchte wählen Sie die am besten geeignete auf die Ergebnisse angesichts der aktuell sichtbare Bereich auf der Karte.

Habe ich beigelegt, Algorithmus, vergleicht die Verhältnisse der Flächen (in MKMapPoint2) von der Lage-viewport", den aktuellen Viewports und deren Kreuzung (mit MKMapRectIntersection - Funktion). Dies funktioniert sehr gut, solange sich die Lage viewport nicht erstrecken sich über die 180-meridian. In diesem Fall ist Ihre Schnittmenge ist 0.

Habe ich angefangen, zu untersuchen, die Ursache und als debugging-Hilfe-ich mache Anzeige MKPolygon overlays auf die Karte, um mir zu geben visuelle Hinweise, was Los ist. Vermeiden Sie mögliche Fehler eingeführt durch meinen code-Konvertierung zwischen geo-Koordinaten und MKMapRect habe ich konstruiert, die mit dem polygon-overlay mit original-Koordinaten aus Google-Ergebnisse wie dieses:

CLLocationCoordinate2D sw, ne, nw, se;
sw = location.viewportSouthWest.coordinate;
ne = location.viewportNorthEast.coordinate;
nw = CLLocationCoordinate2DMake(ne.latitude, sw.longitude);
se = CLLocationCoordinate2DMake(sw.latitude, ne.longitude);
CLLocationCoordinate2D coords[] = {nw, ne, se, sw};
MKPolygon *p = [MKPolygon polygonWithCoordinates:coords count:4];

Beispielsweise der problematischen Lage, hier ist der viewport zurückgegeben, für die Vereinigten Staaten, das Letzte Ergebnis vom Typ Land, wenn geocoding-Koordinaten irgendwo in Virginia:

Southwest: 18.9110643, 172.4546967  
Northeast: 71.3898880, -66.9453948

Beachten Sie, wie die Südwest-Koordinate, die sich in der unteren linken Ecke der Lage viewport liegt auf dem 180-meridian. Bei der Anzeige dieser Position überlagert, die als polygon auf der Karte zeigt es falsch an das Recht der USA Grenzen (großes braunes Rechteck, nur in der linken unteren Ecke sichtbar):

MKMapRect und Anzeige von anzeigen-overlays, die sich über 180th meridian

Ähnlich, Anzeige Lage viewport für Russland zeigt das Rechteck falsch positioniert Links von der Grenze zu Russland.

Visuell bestätigt, dass es ähnliche problem, wenn ich konvertieren Sie die Lage viewport MKMapPoints und MKMapRect und finden keine Schnittmenge zwischen den kartenviewport (weißes Rechteck im Bild oben) und die Lage viewport.

Den Weg berechne ich die map rect ist ähnlich wie Antworten in dieser Frage ALSO:

Wie passen eine bestimmte Grenzen, die aus der NE-und SW-Koordinaten in den sichtbaren Kartenausschnitt?

...das funktioniert , es sei denn die Koordinaten Spannweite der 180th meridian. Die Prüfung der MKMapRect mit MKMapRectSpans180thMeridian zurück false, so dass Bau-Methode ist falsch.

Apple-Dokumentation ist nicht hilfreich in dieser Hinsicht. Einzige Hinweis den ich gefunden habe ist in MKOverlay.h:

//boundingMapRect should be the smallest rectangle that completely contains
//the overlay.
//For overlays that span the 180th meridian, boundingMapRect should have 
//either a negative MinX or a MaxX that is greater than MKMapSizeWorld.width.
@property (nonatomic, readonly) MKMapRect boundingMapRect;

Was ist der richtige Weg, um die polygon-overlay, die sich über die 180th meridian?

Wie Sie sich richtig zu konstruieren MKMapRect über 180th meridian?

InformationsquelleAutor Palimondo | 2012-01-26

ios mapkit

Laut Kommentar in MKOverlay.h, wenn der nw-und sw-Ecken angegeben wurden als negativ MKMapPoint Werte der overlay sollte "korrekt gezeichnet".

Wenn wir versuchen, diese:

//calculation of the nw, ne, se, and sw coordinates goes here

MKMapPoint points[4];
if (nw.longitude > ne.longitude)  //does it cross 180th?
{
    //Get the mappoint for equivalent distance on
    //the "positive" side of the dateline...
    points[0] = MKMapPointForCoordinate(
                  CLLocationCoordinate2DMake(nw.latitude, -nw.longitude));

    //Reset the mappoint to the correct side of the dateline, 
    //now it will be negative (as per Apple comments)...
    points[0].x = - points[0].x;
}
else
{
    points[0] = MKMapPointForCoordinate(nw);
}
points[1] = MKMapPointForCoordinate(ne);
points[2] = MKMapPointForCoordinate(se);
points[3] = MKMapPointForCoordinate(sw);
points[3].x = points[0].x;    //set to same as NW's whether + or -

MKPolygon *p = [MKPolygon polygonWithPoints:points count:4];

[mapView addOverlay:p];

Den daraus resultierenden p.boundingMapRect zurück YES für MKMapRectSpans180thMeridian (aber der code bereits herausgefunden, dass aus den Koordinaten, da Sie nicht über die maprect, um mit zu beginnen).

Leider allerdings, die Schaffung der maprect mit den negativen Werten behebt nur die Hälfte des Problems. Die Hälfte der Fläche, die östlich der Datumsgrenze ist jetzt korrekt gezeichnet. Jedoch, die andere Hälfte westlich der Datumsgrenze nicht gezogen bei allen.

Offenbar, die gebaut-in MKPolygonView nicht nennen MKMapRectSpans180thMeridian und ziehen Sie das polygon in zwei Teile.

Können Sie erstellen ein benutzerdefiniertes overlay-Ansicht und diese zeichnen sich selbst (Sie würde erstellen Sie ein overlay, aber die Aussicht ziehen würde zwei Polygone).

Oder Sie könnte einfach erstellen Sie zwei MKPolygon overlays und lassen Sie die map anzeigen, Sie zu zeichnen, indem Sie den folgenden nach dem oben genannten code:

if (MKMapRectSpans180thMeridian(p.boundingMapRect))
{
    MKMapRect remainderRect = MKMapRectRemainder(p.boundingMapRect);

    MKMapPoint remPoints[4];
    remPoints[0] = remainderRect.origin;
    remPoints[1] = MKMapPointMake(remainderRect.origin.x + remainderRect.size.width, remainderRect.origin.y);
    remPoints[2] = MKMapPointMake(remainderRect.origin.x + remainderRect.size.width, remainderRect.origin.y + remainderRect.size.height);
    remPoints[3] = MKMapPointMake(remainderRect.origin.x, remainderRect.origin.y + remainderRect.size.height);

    MKPolygon *remPoly = [MKPolygon polygonWithPoints:remPoints count:4];

    [mapView addOverlay:remPoly];
}

Übrigens, es gibt ein ähnliches Problem mit der Zeichnung MKPolyline overlays cross +/-180 (siehe diese Frage).

InformationsquelleAutor

Da dieser Bereich ist völlig unter-dokumentiert, die Map-Kit-Funktionen-Referenz geändert werden sollte:

Warnung: Alle beschriebenen Funktionen funktionieren gut, solange Sie nicht über die 180th meridian.

Hier werden Drachen. Sie sind gewarnt worden...

Um diese Frage zu lösen, ich Griff zu den guten alten investigativen Tests. Bitte entschuldigen Sie die Kommentare um die Prosa. Sie ermöglichen copy & paste alle Quelle unten verbatim, so dass Sie spielen können, mit ihm selbst.

Zuerst eine kleine Hilfsfunktion wandelt die Eckpunkte der MKMapRect zurück in Koordinatenraum, so dass wir vergleichen unsere Ergebnisse Umbauten mit den Start-Koordinaten:

NSString* MyStringCoordsFromMapRect(MKMapRect rect) {
    MKMapPoint pNE = rect.origin, pSW = rect.origin;
    pNE.x += rect.size.width;
    pSW.y += rect.size.height;

    CLLocationCoordinate2D sw, ne;
    sw = MKCoordinateForMapPoint(pSW);
    ne = MKCoordinateForMapPoint(pNE);

    return [NSString stringWithFormat:@"{{%f, %f}, {%f, %f}}", 
            sw.latitude, sw.longitude, ne.latitude, ne.longitude];
}

/*

Und jetzt, let ' s test

Wie Erstellen MapRect Spanning 180th Meridian:

- (void)testHowToCreateMapRectSpanning180thMeridian
{

/*

Wir verwenden Lage viewport Asien, zurückgegeben durch die Google-Geocoding-API, weil es überspannt die antimeridian. Die Nordosten Ecke liegt bereits in der westlichen Hemisphäre—longitudal Bereich (-180,0):

*/

CLLocationCoordinate2D sw, ne, nw, se;
sw = CLLocationCoordinate2DMake(-12.9403000, 25.0159000);
ne = CLLocationCoordinate2DMake(81.6691780, -168.3545000);
nw = CLLocationCoordinate2DMake(ne.latitude, sw.longitude);
se = CLLocationCoordinate2DMake(sw.latitude, ne.longitude);

/*

Für die Referenz, hier sind die Grenzen auf die ganze Welt projiziert, einige 268 Millionen, nach der Umstellung auf MKMapPoints. Unsere kleine helper-Funktion zeigt uns, dass die Mercator-Projektion verwendet, ist hier nicht äußern, breiten, oben ±85 Grad. Längengrad überspannt nett von -180 bis 180 Grad.

*/

NSLog(@"\nMKMapRectWorld: %@\n => %@",
      MKStringFromMapRect(MKMapRectWorld), 
      MyStringCoordsFromMapRect(MKMapRectWorld));
//MKMapRectWorld: {{0.0, 0.0}, {268435456.0, 268435456.0}}
// => {{ -85.051129, -180.000000}, {85.051129, 180.000000}}

/*

Warum wurde die MKPolygon overlay, erstellt durch geo-Koordinaten, dargestellt an der falschen Stelle auf der Karte?

*/

//MKPolygon bounds
CLLocationCoordinate2D coords[] = {nw, ne, se, sw};
MKPolygon *p = [MKPolygon polygonWithCoordinates:coords count:4];
MKMapRect rp = p.boundingMapRect;
STAssertFalse(MKMapRectSpans180thMeridian(rp), nil); //Incorrect!!!
NSLog(@"\n rp: %@\n => %@",
      MKStringFromMapRect(rp), 
      MyStringCoordsFromMapRect(rp));
//rp: {{8683514.2, 22298949.6}, {144187420.8, 121650857.5}}
// => {{ -12.940300, -168.354500}, {81.669178, 25.015900}}

/*

Es sieht aus wie die Längengrade habe getauscht der falsche Weg. Asien ist {{ -12, 25}, {81, -168}}. Die daraus resultierende MKMapRect nicht passieren den test mit der MKMapRectSpans180thMeridian Funktion —und wir wissen, dass es sein sollte!

False Versucht

Also die MKPolygon nicht berechnen MKMapRect richtig, wenn die Koordinaten reichen antimeridian. OK, dann erstellen Sie die Karte rect uns. Hier sind zwei Methoden vorgeschlagen, die in Antworten auf Wie passen eine bestimmte Grenzen, die aus der NE-und SW-Koordinaten in den sichtbaren Kartenausschnitt?

... schnell Weg ist, ein leichter trick mit der MKMapRectUnion Funktion. Erstellen Sie eine null-Größe MKMapRect von jeder Koordinate und dann die Zusammenführung der beiden rects in ein großes Rechteck über die Funktion:

//https://stackoverflow.com/a/8496988/41307
MKMapPoint pNE = MKMapPointForCoordinate(ne);
MKMapPoint pSW = MKMapPointForCoordinate(sw);
MKMapRect ru = MKMapRectUnion(MKMapRectMake(pNE.x, pNE.y, 0, 0),
                              MKMapRectMake(pSW.x, pSW.y, 0, 0));
STAssertFalse(MKMapRectSpans180thMeridian(ru), nil); //Incorrect!!!
STAssertEquals(ru, rp, nil);
NSLog(@"\n ru: %@\n => %@",
      MKStringFromMapRect(ru), 
      MyStringCoordsFromMapRect(ru));
//ru: {{8683514.2, 22298949.6}, {144187420.8, 121650857.5}}
// => {{ -12.940300, -168.354500}, {81.669178, 25.015900}}

/*

Neugierig haben wir das gleiche Ergebnis wie vorher. Macht es Sinn, dass MKPolygon sollte wohl berechnen Sie seine Grenzen mit MKRectUnion sowieso.

Nun habe ich fertig, der nächste mir selbst. Berechnen Sie die MapRect Ursprung, Breite und Höhe manuell, beim Versuch, die Lust haben und sich keine sorgen über die richtige Reihenfolge der Ecken.

*/

//https://stackoverflow.com/a/8500002/41307
MKMapRect ra = MKMapRectMake(MIN(pNE.x, pSW.x), MIN(pNE.y, pSW.y), 
                             ABS(pNE.x - pSW.x), ABS(pNE.y - pSW.y));
STAssertFalse(MKMapRectSpans180thMeridian(ru), nil); //Incorrect!!!
STAssertEquals(ra, ru, nil);
NSLog(@"\n ra: %@\n => %@",
      MKStringFromMapRect(ra), 
      MyStringCoordsFromMapRect(ra));
//ra: {{8683514.2, 22298949.6}, {144187420.8, 121650857.5}}
// => {{ -12.940300, -168.354500}, {81.669178, 25.015900}}

/*

Hey! Es ist das gleiche Ergebnis wie vorher. Dies ist, wie die breiten ausgelagert, wenn die Koordinaten Kreuz den antimeridian. Und es ist wahrscheinlich, wie die MKMapRectUnion funktioniert es auch. Nicht gut...

*/

//Let's put the coordinates manually in proper slots
MKMapRect rb = MKMapRectMake(pSW.x, pNE.y, 
                             (pNE.x - pSW.x), (pSW.y - pNE.y));
STAssertFalse(MKMapRectSpans180thMeridian(rb), nil); //Incorrect!!! Still :-(
NSLog(@"\n rb: %@\n => %@",
      MKStringFromMapRect(rb), 
      MyStringCoordsFromMapRect(rb));
//rb: {{152870935.0, 22298949.6}, { -144187420.8, 121650857.5}}
// => {{ -12.940300, 25.015900}, {81.669178, -168.354500}}

/*

Denken Sie daran, den Asien ist {{ -12, 25}, {81, -168}}. Wir sind immer wieder die richtigen Koordinaten, aber die MKMapRect nicht umspannen den antimeridian nach MKMapRectSpans180thMeridian. Was zum...?!

Die Lösung

Den Tipp von MKOverlay.h sagte:

Overlays, die sich über die 180th meridian, boundingMapRect sollte entweder einen negativen MinX oder ein MaxX, der größer ist als MKMapSizeWorld.der Breite.

Keine dieser Bedingungen erfüllt ist. Was ist schlimmer, die rb.size.width ist negative 144 Millionen Euro. Das ist definitiv falsch.

Wir haben zum richtigen rect-Werte, wenn wir an den antimeridian, so dass eine dieser Voraussetzungen erfüllt ist:

*/

//Let's correct for crossing 180th meridian
double antimeridianOveflow = 
  (ne.longitude > sw.longitude) ? 0 : MKMapSizeWorld.width;    
MKMapRect rc = MKMapRectMake(pSW.x, pNE.y, 
                             (pNE.x - pSW.x) + antimeridianOveflow, 
                             (pSW.y - pNE.y));
STAssertTrue(MKMapRectSpans180thMeridian(rc), nil); //YES. FINALLY!
NSLog(@"\n rc: %@\n => %@",
      MKStringFromMapRect(rc), 
      MyStringCoordsFromMapRect(rc));
//rc: {{152870935.0, 22298949.6}, {124248035.2, 121650857.5}}
// => {{ -12.940300, 25.015900}, {81.669178, 191.645500}}

/*

Schließlich haben wir zufrieden die MKMapRectSpans180thMeridian. Karte rect Breite ist positiv. Was ist mit den Koordinaten? Nordöstlich Länge von 191.6455. Eingewickelt rund um den Globus (-360), es ist -168.3545. Q. E. D.

Haben wir berechneten die richtige MKMapRect erstreckt sich über die 180th meridian von der Erfüllung der zweiten Bedingung: die MaxX (rc.origin.x + rc.size.width = 152870935.0 + 124248035.2 = 277118970.2) größer ist dann die Breite der Welt (268 Millionen Euro).

Was über die Erfüllung der ersten Bedingung, negative MinX === origin.x?

*/

//Let's correct for crossing 180th meridian another way
MKMapRect rd = MKMapRectMake(pSW.x - antimeridianOveflow, pNE.y, 
                             (pNE.x - pSW.x) + antimeridianOveflow, 
                             (pSW.y - pNE.y));
STAssertTrue(MKMapRectSpans180thMeridian(rd), nil); //YES. AGAIN!
NSLog(@"\n rd: %@\n => %@",
      MKStringFromMapRect(rd), 
      MyStringCoordsFromMapRect(rd));
//rd: {{ -115564521.0, 22298949.6}, {124248035.2, 121650857.5}}
// => {{ -12.940300, -334.984100}, {81.669178, -168.354500}}

STAssertFalse(MKMapRectEqualToRect(rc, rd), nil);

/*

Dies geht auch bei der MKMapRectSpans180thMeridian test. Und die umgekehrte Konvertierung von geo-Koordinaten gibt uns übereinstimmen, außer für den Südwesten Längengrad: -334.9841. Aber verpackt rund um die Welt (+360), ist es 25.0159. Q. E. D.

So gibt es zwei korrekte Formen, um zu berechnen, MKMapRect, die sich über 180th meridian. Mit positive und mit negativ Herkunft.

Alternative Methode

Den negativen Ursprung Methode oben gezeigt (rd) entspricht dem Ergebnis der durch die alternative Methode vorgeschlagen, durch Anna Karenina in einer anderen Antwort auf diese Frage:

*/

//https://stackoverflow.com/a/9023921/41307
MKMapPoint points[4];
if (nw.longitude > ne.longitude) {
    points[0] = MKMapPointForCoordinate(
                  CLLocationCoordinate2DMake(nw.latitude, -nw.longitude));
    points[0].x = - points[0].x;
}
else
    points[0] = MKMapPointForCoordinate(nw);
points[1] = MKMapPointForCoordinate(ne);
points[2] = MKMapPointForCoordinate(se);
points[3] = MKMapPointForCoordinate(sw);
points[3].x = points[0].x;
MKPolygon *p2 = [MKPolygon polygonWithPoints:points count:4];
MKMapRect rp2 = p2.boundingMapRect;
STAssertTrue(MKMapRectSpans180thMeridian(rp2), nil); //Also GOOD!
NSLog(@"\n rp2: %@\n => %@",
      MKStringFromMapRect(rp2), 
      MyStringCoordsFromMapRect(rp2));
//rp2: {{ -115564521.0, 22298949.6}, {124248035.2, 121650857.5}}
// => {{ -12.940300, -334.984100}, {81.669178, -168.354500}}

/*

Wenn wir also manuell konvertieren zu MKMapPoints und fudge, die negativen Ursprungs sind, auch die MKPolygon berechnet die boundingMapRect richtig. Resultierenden map rect-entspricht der nagative Herkunft Methode oben (rd).

*/

STAssertTrue([MKStringFromMapRect(rp2) isEqualToString:
              MKStringFromMapRect(rd)], nil);

/*

Oder sollte ich sagen fast gleichwertig... weil neugierig, die folgenden Behauptungen scheitern würden:

*/

//STAssertEquals(rp2, rd, nil); //Sure, shouldn't compare floats byte-wise!
//STAssertTrue(MKMapRectEqualToRect(rp2, rd), nil);

/*

Man würde denke, Sie wissen, wie vergleichen floating-point-zahlen, aber ich schweife ab...

*/

Damit ist die test-Funktion-source-code.

Die Anzeige Von Overlay -

Als in der Frage genannten, zu Debuggen, das problem, das ich verwendet habe MKPolygons zu visualisieren, was Los war. Es stellt sich heraus, dass die beiden Formen der MKMapRects, die span antimeridian anders dargestellt werden, wenn überlagert auf der Karte. Wenn Sie nähern sich dem antimeridian von der west-Hemisphäre, nur die mit negativen Ursprungs angezeigt bekommt. Ebenso die positive origin-form wird angezeigt, wenn Sie nähern sich der 180th meridian aus der östlichen Hemisphäre. Die MKPolygonView behandelt nicht die spanning von 180th meridian für Sie. Sie müssen passen Sie die polygon-Punkte selbst.

Dies ist, wie die zum erstellen von polygon aus der Karte rect:

- (MKPolygon *)polygonFor:(MKMapRect)r 
{
    MKMapPoint p1 = r.origin, p2 = r.origin, p3 = r.origin, p4 = r.origin;
    p2.x += r.size.width;
    p3.x += r.size.width; p3.y += r.size.height;
    p4.y += r.size.height;
    MKMapPoint points[] = {p1, p2, p3, p4};
    return [MKPolygon polygonWithPoints:points count:4];
}

Habe ich einfach verwendet, brute-force und Hinzugefügt, die das polygon zweimal—eine in jeder form.

for (GGeocodeResult *location in locations) {
    MKMapRect r = location.mapRect;
    [self.debugLocationBounds addObject:[self polygonFor:r]];

    if (MKMapRectSpans180thMeridian(r)) {
        r.origin.x -= MKMapSizeWorld.width;
        [self.debugLocationBounds addObject:[self polygonFor:r]];
    }
}            
[self.mapView addOverlays:self.debugLocationBounds];

Ich hoffe, dies hilft anderen Seelen, die Wandern in das land der Drachen hinter der 180th meridian.

InformationsquelleAutor Palimondo

Kurz gesagt, wenn das polygon überquert den antimeridian, überprüfen Sie die mapPoints.
Wenn Sie die mapPoint.x ist größer als die primeMeridian.x, subtrahieren Sie die Breite der Welt aus der mapPoint.x.

Diese teilt die Karte unten der Nullmeridian. Das Luder ist negativ und die mapSize ist kleiner als die Breite der Welt. Palimondo Antwort war enorm hilfreich, herauszufinden dieses heraus.

Arbeite ich mit geodesicPolylines und verbrachte ein paar Tage auf dieser. Endlich eine Antwort gefunden!

///Note: If both the prime meridian and the antimeridian are crossed, an empty polygon will be returned
func makePolygon(lines: [LineAnnotation]) -> MKPolygon {
    let polylines = lines.map({ $0.polyline })
    let sum = polylines.reduce(0, { $0 + $1.pointCount })
    let pointer = UnsafeMutablePointer<MKMapPoint>.allocate(capacity: sum)
    var advance = 0
    let spans180thMeridian = polylines.contains(where: { $0.boundingMapRect.spans180thMeridian })
    let primeMeridianMapPoint = MKMapPoint(CLLocationCoordinate2D(latitude: 0, longitude: 0))
    let spansPrimeMeridian = polylines.contains(where: {
        return $0.boundingMapRect.minX <= primeMeridianMapPoint.x && $0.boundingMapRect.maxX >= primeMeridianMapPoint.x
    })
    guard !(spans180thMeridian && spansPrimeMeridian) else { return MKPolygon() }
    if spans180thMeridian {
        for polyline in polylines {
            //initialize the pointer with a copy of the polyline points, adjusted if needed
            let points = UnsafeMutablePointer<MKMapPoint>.allocate(capacity: polyline.pointCount)
            points.initialize(from: polyline.points(), count: polyline.pointCount)
            for i in 0..<polyline.pointCount {
                let pointPointer = points.advanced(by: i)
                if pointPointer.pointee.x > primeMeridianMapPoint.x {
                    pointPointer.pointee.x -= MKMapSize.world.width
                }
            }
            pointer.advanced(by: advance).initialize(from: points, count: polyline.pointCount)
            advance += polyline.pointCount
            points.deinitialize(count: polyline.pointCount)
            points.deallocate()
        }

    } else {
        //initialize the pointer with the polyline points
        for polyline in polylines {
            pointer.advanced(by: advance).initialize(from: polyline.points(), count: polyline.pointCount)
            advance += polyline.pointCount
        }
    }
    let polygon = MKPolygon(points: pointer, count: sum)
    print(polygon.boundingMapRect)
    pointer.deinitialize(count: sum)
    pointer.deallocate()
    return polygon
}

InformationsquelleAutor Roselle Tanner

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.