संपादित करें: वाह, मुझे अभी एहसास हुआ कि यह प्रश्न लगभग दो साल पुराना है। उसके लिए माफ़ करना।
ठीक है तो मुझे लगता है कि यहां कुछ चीजें चल रही हैं। सबसे महत्वपूर्ण यह है कि आप दिए गए लिंक में उल्लिखित मर्केटर प्रक्षेपण नहीं कर रहे हैं। आप इसे Google मानचित्र API दस्तावेज़ों में code sample के साथ कार्रवाई में देख सकते हैं। मुझे लगता है कि आप कुछ हद तक करीब आ रहे हैं कि ज़ूम स्तर 20 पर स्केल फैक्टर इतना बड़ा है कि यह समस्या के विवरण को डूबता है।
सीमाएं प्राप्त करने के लिए, आपको केंद्र लेट/लॉन लेना होगा, इसे पिक्सेल निर्देशांक में परिवर्तित करना होगा, जो कोनों के पिक्सेल निर्देशांक प्राप्त करने के लिए जोड़ें/घटाएं, और फिर वापस लेट/लॉन में कनवर्ट करें। पहले लिंक में कोड प्रक्षेपण और उलटा प्रक्षेपण कर सकता है। नीचे मैंने इसे सी # में अनुवादित किया है।
उपरोक्त आपके समाधान में, आप लैट/लॉन निर्देशांक ले रहे हैं और विश्व समन्वय (पिक्सेल कॉर्ड/स्केल) जोड़/घटाना चाहते हैं, ताकि आप दो अलग समन्वय प्रणालियों को जोड़ रहे हों।
यह पता लगाने की कोशिश करते समय मैं एक समस्या में भाग गया यह है कि आपकी Coordinate
कक्षा थोड़ा उलझन में है। उम्मीद है कि मेरे पास यह पीछे नहीं है, लेकिन ऐसा लगता है कि आप पीछे अक्षांश और देशांतर में डाल रहे हैं। यह महत्वपूर्ण है क्योंकि अन्य कारणों से मर्केटर प्रक्षेपण प्रत्येक दिशा में अलग है। आपका एक्स/वाई मानचित्रण पीछे भी लगता है, क्योंकि अक्षांश आपकी उत्तर/दक्षिण स्थिति है, जो प्रक्षेपित होने पर वाई समन्वय होना चाहिए, और रेखांश आप पूर्व/पश्चिम स्थिति है, जो प्रक्षेपित होने पर एक्स समन्वय होना चाहिए।
सीमाएं खोजने के लिए, three coordinate systems आवश्यक हैं: रेखांश/अक्षांश, विश्व समन्वय और पिक्सेल समन्वय। प्रक्रिया केंद्र लेट/लोन - (मर्केटर प्रक्षेपण) -> केंद्र विश्व समन्वय -> केंद्र पिक्सेल समन्वय -> एनई/एसड पिक्सेल समन्वय -> एनई/एसडब्ल्यू विश्व समन्वय - (उलटा मर्केटर प्रक्षेपण) -> एनई/एसडब्ल्यू लेट/लोन ।
आपको छवि/2 के आयामों को जोड़/घटाकर पिक्सेल निर्देशांक मिलते हैं। पिक्सेल समन्वय प्रणाली ऊपरी बाएं कोने से शुरू होती है, इसलिए एनई कोने प्राप्त करने के लिए आपको x से चौड़ाई/2 जोड़ने और y से ऊंचाई/2 घटाएं। एसडब्ल्यू कोने के लिए आपको एक्स से चौड़ाई/2 घटाएं और ऊंचाई/2 को y में जोड़ें।
static GoogleMapsAPI()
{
OriginX = TileSize/2;
OriginY = TileSize/2;
PixelsPerLonDegree = TileSize/360.0;
PixelsPerLonRadian = TileSize/(2 * Math.PI);
}
public static int TileSize = 256;
public static double OriginX, OriginY;
public static double PixelsPerLonDegree;
public static double PixelsPerLonRadian;
public static double DegreesToRadians(double deg)
{
return deg * Math.PI/180.0;
}
public static double RadiansToDegrees(double rads)
{
return rads * 180.0/Math.PI;
}
public static double Bound(double value, double min, double max)
{
value = Math.Min(value, max);
return Math.Max(value, min);
}
//From Lat, Lon to World Coordinate X, Y. I'm being explicit in assigning to
//X and Y properties.
public static Coordinate Mercator(double latitude, double longitude)
{
double siny = Bound(Math.Sin(DegreesToRadians(latitude)), -.9999, .9999);
Coordinate c = new Coordinate(0,0);
c.X = OriginX + longitude*PixelsPerLonDegree;
c.Y = OriginY + .5 * Math.Log((1 + siny)/(1 - siny)) * -PixelsPerLonRadian;
return c;
}
//From World Coordinate X, Y to Lat, Lon. I'm being explicit in assigning to
//Latitude and Longitude properties.
public static Coordinate InverseMercator(double x, double y)
{
Coordinate c = new Coordinate(0, 0);
c.Longitude = (x - OriginX)/PixelsPerLonDegree;
double latRadians = (y - OriginY)/-PixelsPerLonRadian;
c.Latitude = RadiansToDegrees(Math.Atan(Math.Sinh(latRadians)));
return c;
}
आप अधिक विस्तृत टिप्पणी के लिए मूल जावास्क्रिप्ट कोड की जाँच कर सकते हैं:
यहाँ (अपने GoogleMapsAPI वर्ग का हिस्सा के रूप में) सी # में प्रक्षेपण कोड, अनुवाद जावास्क्रिप्ट ऊपर पहली कड़ी से है।
मैंने सीमाओं को मैन्युअल रूप से अनुमानित करके और फिर दिए गए कोड के उत्तर की तुलना करके इसका परीक्षण किया। एनई कोने के लिए मेरा मैनुअल अनुमान (51.15501, 4.7 9 66 9 5) था और कोड (51.155005..., 4.797038...) थूक गया जो बहुत करीब लगता है। एसडब्ल्यू कोने अनुमानित था (51.154572, 4.796007), कोड (51.154574..., 4.796006...) बाहर थूक गया।
यह एक मजेदार था, मुझे आशा है कि इससे मदद मिलेगी!
संपादित करें: एहसास मैं नए GetBounds
समारोह शामिल नहीं किया था:
var result = GoogleMapsAPI.GetBounds(new Coordinate(51.15479, 4.79635), 20, 512, 512);
मुझे पता है:
public static MapCoordinates GetBounds(Coordinate center, int zoom, int mapWidth, int mapHeight)
{
var scale = Math.Pow(2, zoom);
var centerWorld = Mercator(center.Latitude, center.Longitude);
var centerPixel = new Coordinate(0, 0);
centerPixel.X = centerWorld.X * scale;
centerPixel.Y = centerWorld.Y * scale;
var NEPixel = new Coordinate(0, 0);
NEPixel.X = centerPixel.X + mapWidth/2.0;
NEPixel.Y = centerPixel.Y - mapHeight/2.0;
var SWPixel = new Coordinate(0, 0);
SWPixel.X = centerPixel.X - mapWidth/2.0;
SWPixel.Y = centerPixel.Y + mapHeight/2.0;
var NEWorld = new Coordinate(0, 0);
NEWorld.X = NEPixel.X/scale;
NEWorld.Y = NEPixel.Y/scale;
var SWWorld = new Coordinate(0, 0);
SWWorld.X = SWPixel.X/scale;
SWWorld.Y = SWPixel.Y/scale;
var NELatLon = InverseMercator(NEWorld.X, NEWorld.Y);
var SWLatLon = InverseMercator(SWWorld.X, SWWorld.Y);
return new MapCoordinates() { NorthEast = NELatLon, SouthWest = SWLatLon };
}
बस इतना ध्यान रखें सुनिश्चित करें कि आप अक्षांश और देशांतर वहाँ में सही मिल गया है बनाने के लिए कोड सबसे महान नहीं है, लेकिन मुझे उम्मीद है कि यह स्पष्ट है।
अच्छी तरह से लिखित उत्तर के लिए बहुत बहुत धन्यवाद, दुख की बात है कि वास्तव में यह 2 साल बहुत देर हो चुकी है :) – FrieK
वोट के लिए धन्यवाद :) – peterjb
जब तक मैं 'Math.Pow (2, ज़ूम)' गुणा नहीं करता तब तक मैं बहुत दूर हूं 2. मैंने अन्य स्रोतों की तुलना में भी तुलना की और सभी छोटे बदलावों की कोशिश की। कोई विचार क्यों है? – clankill3r