Google मैप्स V3 - किसी दिए गए सीमा के लिए ज़ूम स्तर की गणना कैसे करें

Question

मैं getBoundsZoomLevel()V2 API के समान Google मैप्स V3 API का उपयोग करके किसी दिए गए सीमा के लिए ज़ूम स्तर की गणना करने का तरीका ढूंढ रहा हूं ।

यहाँ मैं क्या करना चाहता हूँ:

// These are exact bounds previously captured from the map object
var sw = new google.maps.LatLng(42.763479, -84.338918);
var ne = new google.maps.LatLng(42.679488, -84.524313);
var bounds = new google.maps.LatLngBounds(sw, ne);
var zoom = // do some magic to calculate the zoom level

// Set the map to these exact bounds
map.setCenter(bounds.getCenter());
map.setZoom(zoom);

// NOTE: fitBounds() will not work

दुर्भाग्य से, मैं fitBounds()अपने विशेष उपयोग के मामले के लिए विधि का उपयोग नहीं कर सकता । यह मानचित्र पर फिटिंग मार्कर के लिए अच्छी तरह से काम करता है, लेकिन सटीक सीमा निर्धारित करने के लिए यह अच्छी तरह से काम नहीं करता है। यहाँ एक उदाहरण है कि मैं इस fitBounds()पद्धति का उपयोग क्यों नहीं कर सकता ।

map.fitBounds(map.getBounds()); // not what you expect

Comments

अंतिम उदाहरण उत्कृष्ट और बहुत ही चित्रण है! +1। मेरी भी यही समस्या है ।

— टीएमएस

क्षमा करें, गलत प्रश्न जुड़ा हुआ है, यह सही लिंक है ।

— टीएमएस

यह प्रश्न दूसरे प्रश्न का दोहराव नहीं है । अन्य प्रश्न का उत्तर उपयोग करना है fitBounds()। यह प्रश्न पूछता है कि क्या करना है जब fitBounds()अपर्याप्त है - या तो क्योंकि यह zooms पर है या आप ज़ूम नहीं करना चाहते हैं (यानी, आप बस ज़ूम स्तर चाहते हैं)।

— जॉन एस

@ नाइक क्लार्क: आप स्व, नी सीमा को कैसे निर्धारित कर सकते हैं? आपने उन्हें पहले कैसे पकड़ लिया?

— वरप्रकाश

Answer 1

Google समूह पर एक समान प्रश्न पूछा गया है: http://groups.google.com/group/google-maps-js-api-v3/browse_thread/thread/e6448fc197c3c892

प्रत्येक चरण में स्केल दोहरीकरण के साथ ज़ूम स्तर असतत हैं। तो सामान्य तौर पर आप उस सीमा को फिट नहीं कर सकते जो आप चाहते हैं (जब तक कि आप विशेष मानचित्र आकार के साथ बहुत भाग्यशाली न हों)।

एक और मुद्दा साइड की लंबाई के बीच का अनुपात है। उदाहरण के लिए, आप सीमा को एक वर्ग के नक्शे के अंदर एक पतली आयत के बराबर नहीं कर सकते।

सटीक सीमा को कैसे फिट किया जाए, इसके लिए कोई आसान जवाब नहीं है, क्योंकि भले ही आप मानचित्र div के आकार को बदलने के इच्छुक हों, आपको यह चुनना होगा कि आप किस आकार और संबंधित ज़ूम स्तर को बदलते हैं (मोटे तौर पर बोलते हुए, क्या आप इसे बड़ा या छोटा करते हैं? वर्तमान में यह है?)।

यदि आपको वास्तव में इसे स्टोर करने के बजाय ज़ूम की गणना करने की आवश्यकता है, तो यह चाल करना चाहिए:

मर्केटर प्रोजेक्शन अक्षांश को चेतावनी देता है, लेकिन देशांतर में कोई भी अंतर हमेशा मानचित्र की चौड़ाई के समान अंश (डिग्री / 360 में कोण अंतर) का प्रतिनिधित्व करता है। ज़ूम शून्य पर, पूरे विश्व का नक्शा 256x256 पिक्सेल है, और प्रत्येक स्तर को ज़ूम करने से चौड़ाई और ऊंचाई दोनों दोगुनी हो जाती है। इसलिए थोड़ा बीजगणित के बाद हम ज़ूम की गणना निम्नानुसार कर सकते हैं, बशर्ते हम पिक्सेल में मानचित्र की चौड़ाई जानते हों। ध्यान दें कि क्योंकि देशांतर चारों ओर घूमता है, इसलिए हमें यह सुनिश्चित करना होगा कि कोण सकारात्मक है।

var GLOBE_WIDTH = 256; // a constant in Google's map projection
var west = sw.lng();
var east = ne.lng();
var angle = east - west;
if (angle < 0) {
  angle += 360;
}
var zoom = Math.round(Math.log(pixelWidth * 360 / angle / GLOBE_WIDTH) / Math.LN2);

Comments

क्या आपको लैट के लिए इसे दोहराना नहीं होगा और फिर 2 के परिणाम का मिनट चुनना होगा? मुझे नहीं लगता कि यह एक लंबी संकीर्ण सीमा के लिए काम करेगा .....

— व्हाइटटॉम

Math.floor के लिए Math.round के बदलाव के साथ मेरे लिए बहुत अच्छा काम करता है। बहुत - बहुत धन्यवाद।

— पीट

यदि यह अक्षांश को ध्यान में नहीं रखता है तो यह सही कैसे हो सकता है? भूमध्य रेखा के पास यह ठीक होना चाहिए लेकिन अक्षांश के आधार पर किसी दिए गए ज़ूम स्तर में नक्शे का पैमाना बदल जाता है!

— ईयाल

@ अच्छा अंक प्राप्त करें, सामान्य तौर पर आप शायद ज़ूम स्तर को कम करना चाहेंगे ताकि आप मानचित्र में वांछित से थोड़ा अधिक फिट हो सकें, बजाय थोड़ा कम। मैंने Math.round का उपयोग किया क्योंकि ओपी की स्थिति में गोलाई से पहले का मूल्य लगभग अभिन्न होना चाहिए।

— जाइल्स गार्डम

PixWidth के लिए क्या मूल्य है

— अल्बर्ट जिगनी

Answer 2

उनके उत्तर के लिए जाइल्स गार्डम का धन्यवाद, लेकिन यह केवल देशांतर को संबोधित करता है न कि अक्षांश को। एक पूर्ण समाधान को अक्षांश के लिए आवश्यक ज़ूम स्तर और देशांतर के लिए आवश्यक ज़ूम स्तर की गणना करनी चाहिए, और फिर दोनों के छोटे (आगे बाहर) ले जाना चाहिए।

यहाँ एक फ़ंक्शन है जो अक्षांश और देशांतर दोनों का उपयोग करता है:

function getBoundsZoomLevel(bounds, mapDim) {
    var WORLD_DIM = { height: 256, width: 256 };
    var ZOOM_MAX = 21;

    function latRad(lat) {
        var sin = Math.sin(lat * Math.PI / 180);
        var radX2 = Math.log((1 + sin) / (1 - sin)) / 2;
        return Math.max(Math.min(radX2, Math.PI), -Math.PI) / 2;
    }

    function zoom(mapPx, worldPx, fraction) {
        return Math.floor(Math.log(mapPx / worldPx / fraction) / Math.LN2);
    }

    var ne = bounds.getNorthEast();
    var sw = bounds.getSouthWest();

    var latFraction = (latRad(ne.lat()) - latRad(sw.lat())) / Math.PI;

    var lngDiff = ne.lng() - sw.lng();
    var lngFraction = ((lngDiff < 0) ? (lngDiff + 360) : lngDiff) / 360;

    var latZoom = zoom(mapDim.height, WORLD_DIM.height, latFraction);
    var lngZoom = zoom(mapDim.width, WORLD_DIM.width, lngFraction);

    return Math.min(latZoom, lngZoom, ZOOM_MAX);
}

Demo on jsfiddle

पैरामीटर:

"सीमा" पैरामीटर मान google.maps.LatLngBoundsऑब्जेक्ट होना चाहिए ।

"मैपडिम" पैरामीटर मान "ऊंचाई" और "चौड़ाई" गुणों के साथ एक ऑब्जेक्ट होना चाहिए जो मानचित्र को प्रदर्शित करने वाले DOM तत्व की ऊंचाई और चौड़ाई का प्रतिनिधित्व करता है। यदि आप पैडिंग सुनिश्चित करना चाहते हैं तो आप इन मूल्यों को कम कर सकते हैं। यही है, हो सकता है कि आप नक्शे के मार्करों को सीमा के भीतर मैप के किनारे के बहुत करीब न चाहें।

यदि आप jQuery लाइब्रेरी का उपयोग कर रहे हैं, तो mapDimमूल्य निम्नानुसार प्राप्त किया जा सकता है:

var $mapDiv = $('#mapElementId');
var mapDim = { height: $mapDiv.height(), width: $mapDiv.width() };

यदि आप प्रोटोटाइप लाइब्रेरी का उपयोग कर रहे हैं, तो मैपडिम वैल्यू निम्नानुसार प्राप्त की जा सकती है:

var mapDim = $('mapElementId').getDimensions();

प्रतिलाभ की मात्रा:

वापसी मूल्य अधिकतम ज़ूम स्तर है जो अभी भी पूरे सीमा को प्रदर्शित करेगा। यह मान 0अधिकतम और ज़ूम स्तर के बीच , समावेशी होगा।

अधिकतम ज़ूम स्तर 21 है। (मेरा मानना ​​है कि यह Google मैप्स एपीआई v2 के लिए केवल 19 था।)

---

स्पष्टीकरण:

Google मानचित्र एक Mercator प्रक्षेपण का उपयोग करता है। एक मर्केटर प्रोजेक्शन में देशांतर की रेखाएँ समान रूप से फैली होती हैं, लेकिन अक्षांश की रेखाएँ नहीं होती हैं। जैसे ही वे भूमध्य रेखा से ध्रुवों तक जाते हैं अक्षांशों की रेखाओं के बीच की दूरी बढ़ जाती है। वास्तव में दूरी अनंत की ओर झुकती है क्योंकि यह ध्रुवों तक पहुंचती है। हालाँकि, Google मैप्स का नक्शा लगभग 85 डिग्री उत्तर से ऊपर या लगभग -85 डिग्री दक्षिण में अक्षांश नहीं दिखाता है। ( संदर्भ ) (मैं वास्तविक कटऑफ की गणना +/- 85.05112877980658 डिग्री पर करता हूं।)

यह देशांतर के लिए अक्षांशों के लिए अंशों की गणना को देशांतर की तुलना में अधिक जटिल बनाता है। मैंने अक्षांश अंश की गणना करने के लिए विकिपीडिया से एक सूत्र का उपयोग किया । मैं Google मानचित्र द्वारा उपयोग किए गए प्रक्षेपण से यह मेल खाता हूं। आखिरकार, मैं ऊपर दिए गए Google मैप्स प्रलेखन पृष्ठ पर उसी विकिपीडिया पृष्ठ का लिंक शामिल करता हूं।

अन्य नोट:

1. ज़ूम स्तर 0 से अधिकतम ज़ूम स्तर तक होता है। ज़ूम स्तर 0 मानचित्र पूरी तरह से ज़ूम आउट है। उच्च स्तर नक्शे को और आगे बढ़ाते हैं। ( संदर्भ )
2. ज़ूम स्तर 0 पर पूरी दुनिया को एक ऐसे क्षेत्र में प्रदर्शित किया जा सकता है जो 256 x 256 पिक्सेल है। ( संदर्भ )
3. प्रत्येक उच्च जूम स्तर के लिए चौड़ाई और ऊंचाई दोनों में समान क्षेत्र को प्रदर्शित करने के लिए आवश्यक पिक्सेल की संख्या। ( संदर्भ )
4. मानचित्र अनुदैर्ध्य दिशा में लपेटते हैं, लेकिन अक्षांशीय दिशा में नहीं।

Comments

उत्कृष्ट उत्तर, यह शीर्ष मतदान होना चाहिए क्योंकि यह देशांतर और अक्षांश दोनों के लिए जिम्मेदार है। अभी तक पूरी तरह से काम किया।

— पीटर वोस्टर

@ जॉन एस - यह एक शानदार समाधान है और मैं इसे देशी गूगल मैप्स फिटबाउंड विधि पर उपयोग करने पर विचार कर रहा हूं जो मेरे लिए भी उपलब्ध है। मैंने देखा कि फिटबाउंड्स कभी-कभी एक ज़ूम लेवल बैक (जूम आउट) होता है, लेकिन मुझे लगता है कि यह पैडिंग से है जो इसे जोड़ रहा है। क्या एकमात्र अंतर है तो इस और फिटबॉइड्स विधि के बीच, बस आप दोनों के बीच ज़ूम स्तर में परिवर्तन के लिए कौन से खातों को जोड़ना चाहते हैं?

— जॉन्थप्रन्योर

@johntrepreneur - एडवांटेज # 1: आप मैप बनाने से पहले भी इस विधि का उपयोग कर सकते हैं, इसलिए आप प्रारंभिक मैप सेटिंग्स को इसका परिणाम प्रदान कर सकते हैं। इसके साथ fitBounds, आपको मानचित्र बनाने की आवश्यकता है और फिर "सीमा_बना हुआ" घटना की प्रतीक्षा करें।

— जॉन एस

@ MarianPa Mardzioch - यह उस सीमा के लिए काम करता है, यहाँ देखें । क्या आप ज़ूम करने में सक्षम होने की उम्मीद कर रहे हैं ताकि वे अंक मानचित्र के सटीक कोनों पर हों? यह संभव नहीं है क्योंकि ज़ूम स्तर पूर्णांक मान हैं। फ़ंक्शन उच्चतम ज़ूम स्तर देता है जिसमें अभी भी मानचित्र पर संपूर्ण सीमा शामिल होगी।

— जॉन एस

@CarlMeyer - मैं अपने उत्तर में इसका उल्लेख नहीं करता, लेकिन ऊपर एक टिप्पणी में मैंने कहा है कि इस फ़ंक्शन का एक फायदा यह है कि "आप नक्शे बनाने से पहले भी इस विधि का उपयोग कर सकते हैं।" उपयोग map.getProjection()करने से कुछ गणित (और प्रक्षेपण के बारे में धारणा) को खत्म कर दिया जाएगा, लेकिन इसका मतलब यह होगा कि मानचित्र बनाए जाने के बाद तक फ़ंक्शन को नहीं बुलाया जा सकता है और "प्रोजेक्शन_चेंज" घटना को निकाल दिया गया है।

— जॉन एस

Answer 3

एपीआई के संस्करण 3 के लिए, यह सरल और काम कर रहा है:

var latlngList = [];
latlngList.push(new google.maps.LatLng(lat, lng));

var bounds = new google.maps.LatLngBounds();
latlngList.each(function(n) {
    bounds.extend(n);
});

map.setCenter(bounds.getCenter()); //or use custom center
map.fitBounds(bounds);

और कुछ वैकल्पिक ट्रिक्स:

//remove one zoom level to ensure no marker is on the edge.
map.setZoom(map.getZoom() - 1); 

// set a minimum zoom 
// if you got only 1 marker or all markers are on the same address map will be zoomed too much.
if(map.getZoom() > 15){
    map.setZoom(15);
}

Comments

मैप को इनिशियलाइज़ करते समय न्यूनतम ज़ूम स्तर सेट क्यों नहीं किया जाता है, कुछ इस तरह है: var mapOptions = {maxZoom: 15,};

— कुश

@ कुश, अच्छी बात है। लेकिन maxZoomउपयोगकर्ता को मैन्युअल ज़ूमिंग से रोक देगा । मेरा उदाहरण केवल डिफॉल्ट को बदलता है और यदि आवश्यक हो तो ही।

— d.raev

जब आप फ़िटबाउंड करते हैं, तो यह केवल वर्तमान दृश्य से वहां एनिमेशन करने के बजाय सीमा को फिट करने के लिए कूदता है। भयानक समाधान पहले से ही उल्लेख किया गया है getBoundsZoomLevel। इस तरह, जब आप सेटज़ूम कहते हैं, तो यह इच्छित ज़ूम स्तर पर एनिमेट करता है। वहाँ से यह पैनटो करने के लिए कोई समस्या नहीं है और आप एक सुंदर मानचित्र एनीमेशन के साथ समाप्त होते हैं जो सीमा पर फिट बैठता है

— user151496

एनीमेशन न तो सवाल पर चर्चा की जाती है और न ही मेरे जवाब में। यदि आपके पास विषय पर उपयोगी उदाहरण हैं, तो बस एक रचनात्मक उत्तर बनाएं, उदाहरण के साथ और कैसे और कब इसका उपयोग किया जा सकता है।

— d.raev

किसी कारण के लिए, Google मैप, map.fitBounds () कॉल के तुरंत बाद सेटज़ूम () कॉल करते समय ज़ूम नहीं करता है। (gmaps वर्तमान में v3.25 है)

— kashiraja

Answer 4

यहाँ फ़ंक्शन का एक कोटलिन संस्करण:

fun getBoundsZoomLevel(bounds: LatLngBounds, mapDim: Size): Double {
        val WORLD_DIM = Size(256, 256)
        val ZOOM_MAX = 21.toDouble();

        fun latRad(lat: Double): Double {
            val sin = Math.sin(lat * Math.PI / 180);
            val radX2 = Math.log((1 + sin) / (1 - sin)) / 2;
            return max(min(radX2, Math.PI), -Math.PI) /2
        }

        fun zoom(mapPx: Int, worldPx: Int, fraction: Double): Double {
            return floor(Math.log(mapPx / worldPx / fraction) / Math.log(2.0))
        }

        val ne = bounds.northeast;
        val sw = bounds.southwest;

        val latFraction = (latRad(ne.latitude) - latRad(sw.latitude)) / Math.PI;

        val lngDiff = ne.longitude - sw.longitude;
        val lngFraction = if (lngDiff < 0) { (lngDiff + 360) } else { (lngDiff / 360) }

        val latZoom = zoom(mapDim.height, WORLD_DIM.height, latFraction);
        val lngZoom = zoom(mapDim.width, WORLD_DIM.width, lngFraction);

        return minOf(latZoom, lngZoom, ZOOM_MAX)
    }

Answer 5

धन्यवाद, जिसने मुझे पॉलीलाइन को सही ढंग से प्रदर्शित करने के लिए सबसे उपयुक्त ज़ूम कारक खोजने में बहुत मदद की। मुझे उन बिंदुओं के बीच अधिकतम और न्यूनतम निर्देशांक मिलते हैं जिन्हें मुझे ट्रैक करना है और, यदि मार्ग बहुत "ऊर्ध्वाधर" है, तो मैंने कोड की कुछ पंक्तियाँ जोड़ीं:

var GLOBE_WIDTH = 256; // a constant in Google's map projection
var west = <?php echo $minLng; ?>;
var east = <?php echo $maxLng; ?>;
*var north = <?php echo $maxLat; ?>;*
*var south = <?php echo $minLat; ?>;*
var angle = east - west;
if (angle < 0) {
    angle += 360;
}
*var angle2 = north - south;*
*if (angle2 > angle) angle = angle2;*
var zoomfactor = Math.round(Math.log(960 * 360 / angle / GLOBE_WIDTH) / Math.LN2);

दरअसल, आदर्श जूम फैक्टर zoomfactor-1 है।

Comments

मुझे अच्छा लगा var zoomfactor = Math.floor(Math.log(960 * 360 / angle / GLOBE_WIDTH) / Math.LN2)-1;। फिर भी, बहुत मददगार।

— मोजोवेन

Answer 6

चूँकि अन्य सभी उत्तर मेरे लिए एक या किसी अन्य परिस्थिति (मानचित्र की चौड़ाई / ऊँचाई, सीमा चौड़ाई / ऊँचाई, आदि) के साथ समस्याएँ प्रतीत होते हैं। मुझे लगा कि मैं यहाँ अपना उत्तर रखूँगा ...

यहाँ एक बहुत उपयोगी जावास्क्रिप्ट फ़ाइल थी: http://www.polyarc.us/adjust.js

मैंने इसके लिए आधार के रूप में इस्तेमाल किया:

var com = com || {};
com.local = com.local || {};
com.local.gmaps3 = com.local.gmaps3 || {};

com.local.gmaps3.CoordinateUtils = new function() {

   var OFFSET = 268435456;
   var RADIUS = OFFSET / Math.PI;

   /**
    * Gets the minimum zoom level that entirely contains the Lat/Lon bounding rectangle given.
    *
    * @param {google.maps.LatLngBounds} boundary the Lat/Lon bounding rectangle to be contained
    * @param {number} mapWidth the width of the map in pixels
    * @param {number} mapHeight the height of the map in pixels
    * @return {number} the minimum zoom level that entirely contains the given Lat/Lon rectangle boundary
    */
   this.getMinimumZoomLevelContainingBounds = function ( boundary, mapWidth, mapHeight ) {
      var zoomIndependentSouthWestPoint = latLonToZoomLevelIndependentPoint( boundary.getSouthWest() );
      var zoomIndependentNorthEastPoint = latLonToZoomLevelIndependentPoint( boundary.getNorthEast() );
      var zoomIndependentNorthWestPoint = { x: zoomIndependentSouthWestPoint.x, y: zoomIndependentNorthEastPoint.y };
      var zoomIndependentSouthEastPoint = { x: zoomIndependentNorthEastPoint.x, y: zoomIndependentSouthWestPoint.y };
      var zoomLevelDependentSouthEast, zoomLevelDependentNorthWest, zoomLevelWidth, zoomLevelHeight;
      for( var zoom = 21; zoom >= 0; --zoom ) {
         zoomLevelDependentSouthEast = zoomLevelIndependentPointToMapCanvasPoint( zoomIndependentSouthEastPoint, zoom );
         zoomLevelDependentNorthWest = zoomLevelIndependentPointToMapCanvasPoint( zoomIndependentNorthWestPoint, zoom );
         zoomLevelWidth = zoomLevelDependentSouthEast.x - zoomLevelDependentNorthWest.x;
         zoomLevelHeight = zoomLevelDependentSouthEast.y - zoomLevelDependentNorthWest.y;
         if( zoomLevelWidth <= mapWidth && zoomLevelHeight <= mapHeight )
            return zoom;
      }
      return 0;
   };

   function latLonToZoomLevelIndependentPoint ( latLon ) {
      return { x: lonToX( latLon.lng() ), y: latToY( latLon.lat() ) };
   }

   function zoomLevelIndependentPointToMapCanvasPoint ( point, zoomLevel ) {
      return {
         x: zoomLevelIndependentCoordinateToMapCanvasCoordinate( point.x, zoomLevel ),
         y: zoomLevelIndependentCoordinateToMapCanvasCoordinate( point.y, zoomLevel )
      };
   }

   function zoomLevelIndependentCoordinateToMapCanvasCoordinate ( coordinate, zoomLevel ) {
      return coordinate >> ( 21 - zoomLevel );
   }

   function latToY ( lat ) {
      return OFFSET - RADIUS * Math.log( ( 1 + Math.sin( lat * Math.PI / 180 ) ) / ( 1 - Math.sin( lat * Math.PI / 180 ) ) ) / 2;
   }

   function lonToX ( lon ) {
      return OFFSET + RADIUS * lon * Math.PI / 180;
   }

};

आप निश्चित रूप से इसे साफ कर सकते हैं या यदि आवश्यक हो तो इसे छोटा कर सकते हैं, लेकिन मैंने चर नामों को लंबे समय तक समझने की कोशिश में रखा।

अगर आप सोच रहे हैं कि OFFSET कहां से आया है, तो जाहिर तौर पर 268435456 ज़ूम लेवल 21 ( http://www.appelsiini.net/2008/11/introduction-to-marker-clustering-with-google के अनुसार पिक्सल में पृथ्वी की परिधि का आधा है) -मप्स )।

Answer 7

वेलेरियो अपने समाधान के साथ लगभग सही है, लेकिन कुछ तार्किक गलती है।

360 पर नकारात्मक जोड़ने से पहले, आपको सबसे पहले wether angle2 को कोण से बड़ा देखना होगा।

अन्यथा आपके पास हमेशा कोण से बड़ा मूल्य होता है

तो सही समाधान है:

var west = calculateMin(data.longitudes);
var east = calculateMax(data.longitudes);
var angle = east - west;
var north = calculateMax(data.latitudes);
var south = calculateMin(data.latitudes);
var angle2 = north - south;
var zoomfactor;
var delta = 0;
var horizontal = false;

if(angle2 > angle) {
    angle = angle2;
    delta = 3;
}

if (angle < 0) {
    angle += 360;
}

zoomfactor = Math.floor(Math.log(960 * 360 / angle / GLOBE_WIDTH) / Math.LN2) - 2 - delta;

डेल्टा वहां है, क्योंकि मेरे पास ऊंचाई की तुलना में बड़ी चौड़ाई है।

Answer 8

map.getBounds()क्षणिक संचालन नहीं है, इसलिए मैं इसी तरह के मामले में हैंडलर का उपयोग करता हूं। यहाँ Coffeescript में मेरा उदाहरण है

@map.fitBounds(@bounds)
google.maps.event.addListenerOnce @map, 'bounds_changed', =>
  @map.setZoom(12) if @map.getZoom() > 12

Answer 9

प्रतिक्रिया-गूगल-मानचित्र पर औसत डिफ़ॉल्ट केंद्र खोजने के लिए कार्य उदाहरण ES6:

const bounds = new google.maps.LatLngBounds();
paths.map((latLng) => bounds.extend(new google.maps.LatLng(latLng)));
const defaultCenter = bounds.getCenter();
<GoogleMap
 defaultZoom={paths.length ? 12 : 4}
 defaultCenter={defaultCenter}
>
 <Marker position={{ lat, lng }} />
</GoogleMap>

Answer 10

जाइल्स गार्डम के देशांतरों के लिए ज़ूम स्तर की गणना मेरे लिए ठीक काम करती है। यदि आप अक्षांश के लिए ज़ूम कारक की गणना करना चाहते हैं, तो यह एक आसान समाधान है जो ठीक काम करता है:

double minLat = ...;
double maxLat = ...;
double midAngle = (maxLat+minLat)/2;
//alpha is the non-negative angle distance of alpha and beta to midangle
double alpha  = maxLat-midAngle;
//Projection screen is orthogonal to vector with angle midAngle
//portion of horizontal scale:
double yPortion = Math.sin(alpha*Math.pi/180) / 2;
double latZoom = Math.log(mapSize.height / GLOBE_WIDTH / yPortion) / Math.ln2;

//return min (max zoom) of both zoom levels
double zoom = Math.min(lngZoom, latZoom);