दिलचस्प पोस्ट
Library.apk नहीं मिला! कुकीज का उपयोग करने के लिए मैं वेबमेल कैसे पा सकता हूं? सरणी का क्षय क्या है? जावास्क्रिप्ट regex multiline झंडा काम नहीं करता है एंड्रॉइड – पोस्ट डेलाइड () कॉल का उपयोग करके समय-समय पर एक विधि चलाया जा रहा है स्प्रिंग सुरक्षा में @Secured और @PreAuthorize के बीच अंतर क्या है? जावा में एक्स, वाई निर्देशांक का उपयोग करके एक क्लिक को अनुकरण कैसे करें? कौन सा। NET निर्भरता इंजेक्शन फ़्रेमवर्क तलाश में लायक हैं? किसी मंडली में अंकों की स्थिति की गणना करना पायथन में एक स्क्रिप्ट से स्टडआउट कैप्चर करें एंड्रॉइड के लिए चौड़ाई और ऊंचाई कैसे प्राप्त करें I एनजी-वी बनाम एनजी-शो / एनजी-छिपाने के लिए कब? int a = {1,2,}; अजीब अल्पविराम की अनुमति कोई विशेष कारण है? कैसे दो अक्षर के बीच एक स्ट्रिंग पाने के लिए? पृष्ठ स्क्रॉल किए जाने के बाद jQuery के ड्रैगएबल गलत जगह में सहायक दिखाता है

एंड्रॉइड: मै मैप दृश्य के ज़ूम स्तर को अपने वर्तमान स्थान के आसपास 1 किमी त्रिज्या कैसे सेट करूं?

मैं नक्शा दृश्य को 1 किमी त्रिज्या तक ज़ूम करना चाहता हूं, लेकिन यह कैसे पता लगा सकता है कि कैसे?

डॉक्टर का कहना है कि ज़ूम स्तर 1 पृथ्वी के भूमध्य रेखा को 256 पिक्सल में मैप करेगा। तो मैं किस ज़ूम स्तर की गणना कर सकता हूं जिससे मुझे निर्धारित करने की जरूरत है ताकि मैप दृश्य 1 के एम त्रिज्या में क्षेत्र दिखाए?

अद्यतन करें:
कुछ ब्लॉग पोस्ट पढ़ने के बाद मैंने निम्न कोड लिखा था:

private int calculateZoomLevel() { double equatorLength = 6378140; // in meters double widthInPixels = screenWidth; double metersPerPixel = equatorLength / 256; int zoomLevel = 1; while ((metersPerPixel * widthInPixels) > 2000) { metersPerPixel /= 2; ++zoomLevel; } Log.i("ADNAN", "zoom level = "+zoomLevel); return zoomLevel; } 

विचार यह है कि पहले मैं ज़ूम स्तर 1 में मीटर प्रति पिक्सेल का अनुमान लगाता हूं, जो कि Google के अनुसार 256 पिक्सल का उपयोग कर पृथ्वी के भूमध्य रेखा का पता चलता है। अब प्रत्येक बाद के ज़ूम स्तर 2 के स्तर से बढ़ाता है इसलिए प्रत्येक ज़ूम स्तर के लिए प्रत्येक पिक्सेल के आधा मीटर मी। जब तक मेरे पास ज़ूम स्तर नहीं होता, तब तक मैं स्क्रीन पर चौड़ाई से गुणा पिक्सेल मीटर की दूरी देता हूं, मुझे 2,000 से भी ज्यादा अर्थात् 2 किमी भर में देता है।

लेकिन मुझे नहीं लगता है कि ज़ूम स्तर मुझे मिल रहा है 2km त्रिज्या का नक्शा दिखा रहा है। क्या कोई मुझे बता सकता है कि मैं यहाँ क्या गलत कर रहा हूं?

वेब के समाधान से एकत्रित समाधान "एंड्रॉइड: मै मैप दृश्य के ज़ूम स्तर को अपने वर्तमान स्थान के आसपास 1 किमी त्रिज्या कैसे सेट करूं?"

हालांकि यह जवाब तार्किक है और मैं इसे काम कर रहा हूं लेकिन परिणाम सही नहीं हैं मुझे पता नहीं क्यों है, लेकिन मैं इस दृष्टिकोण को थकाऊ हूं और यह तकनीक बहुत अधिक सटीक है

1) वांछित त्रिज्या के साथ ऑब्जेक्ट पर एक सर्कल बनाएं

 Circle circle = mGoogleMap.addCircle(new CircleOptions().center(new LatLng(latitude, longitude)).radius(getRadiusInMeters()).strokeColor(Color.RED)); circle.setVisible(true); getZoomLevel(circle); 

2) उस ऑब्जेक्ट को इस फ़ंक्शन को पास करें और ज़ूम स्तर सेट करें यहां एक लिंक है

 public int getZoomLevel(Circle circle) { if (circle != null){ double radius = circle.getRadius(); double scale = radius / 500; zoomLevel =(int) (16 - Math.log(scale) / Math.log(2)); } return zoomLevel; } 

निम्न कोड का उपयोग करके समाप्त हो गया है। स्क्रीन की चौड़ाई और तथ्य यह है कि ज़ूम स्तर 1 पर पृथ्वी का भूमध्य रेखा 256 पिक्सल लंबा है और प्रत्येक बाद के ज़ूम स्तर पृथ्वी की भूमध्य रेखा का प्रतिनिधित्व करने के लिए आवश्यक पिक्सल की संख्या में डबल्स है, निम्नलिखित फ़ंक्शन ज़ूम स्तर लौटाता है जहां स्क्रीन एक क्षेत्र दिखाएगा 2 किलो चौड़ाई का

 private int calculateZoomLevel(int screenWidth) { double equatorLength = 40075004; // in meters double widthInPixels = screenWidth; double metersPerPixel = equatorLength / 256; int zoomLevel = 1; while ((metersPerPixel * widthInPixels) > 2000) { metersPerPixel /= 2; ++zoomLevel; } Log.i("ADNAN", "zoom level = "+zoomLevel); return zoomLevel; } 

मैं से utils का उपयोग कर समाप्त हो गया:

https://github.com/googlemaps/android-maps-utils

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

वास्तव में 1 किलोमीटर दिखाने के लिए कोड:

 animateToMeters(1000); private void animateToMeters(int meters){ int mapHeightInDP = 200; Resources r = getResources(); int mapSideInPixels = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, mapHeightInDP, r.getDisplayMetrics()); LatLng point = new LatLng(0, 0); LatLngBounds latLngBounds = calculateBounds(point, meters); if(latLngBounds != null){ cameraUpdate = CameraUpdateFactory.newLatLngBounds(latLngBounds, mapSideInPixels, mapSideInPixels, MARKER_BOUNDS); if(mMap != null) mMap.animateCamera(cameraUpdate); } } private LatLngBounds calculateBounds(LatLng center, double radius) { return new LatLngBounds.Builder(). include(SphericalUtil.computeOffset(center, radius, 0)). include(SphericalUtil.computeOffset(center, radius, 90)). include(SphericalUtil.computeOffset(center, radius, 180)). include(SphericalUtil.computeOffset(center, radius, 270)).build(); } 

वर्ग ने लिब से (थोड़ा बदल दिया) निकाला:

 public class SphericalUtil { static final double EARTH_RADIUS = 6371009; /** * Returns hav() of distance from (lat1, lng1) to (lat2, lng2) on the unit sphere. */ static double havDistance(double lat1, double lat2, double dLng) { return hav(lat1 - lat2) + hav(dLng) * cos(lat1) * cos(lat2); } /** * Returns haversine(angle-in-radians). * hav(x) == (1 - cos(x)) / 2 == sin(x / 2)^2. */ static double hav(double x) { double sinHalf = sin(x * 0.5); return sinHalf * sinHalf; } /** * Computes inverse haversine. Has good numerical stability around 0. * arcHav(x) == acos(1 - 2 * x) == 2 * asin(sqrt(x)). * The argument must be in [0, 1], and the result is positive. */ static double arcHav(double x) { return 2 * asin(sqrt(x)); } private SphericalUtil() {} /** * Returns the heading from one LatLng to another LatLng. Headings are * expressed in degrees clockwise from North within the range [-180,180). * @return The heading in degrees clockwise from north. */ public static double computeHeading(LatLng from, LatLng to) { // http://williams.best.vwh.net/avform.htm#Crs double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double toLat = toRadians(to.latitude); double toLng = toRadians(to.longitude); double dLng = toLng - fromLng; double heading = atan2( sin(dLng) * cos(toLat), cos(fromLat) * sin(toLat) - sin(fromLat) * cos(toLat) * cos(dLng)); return wrap(toDegrees(heading), -180, 180); } /** * Returns the LatLng resulting from moving a distance from an origin * in the specified heading (expressed in degrees clockwise from north). * @param from The LatLng from which to start. * @param distance The distance to travel. * @param heading The heading in degrees clockwise from north. */ public static LatLng computeOffset(LatLng from, double distance, double heading) { distance /= EARTH_RADIUS; heading = toRadians(heading); // http://williams.best.vwh.net/avform.htm#LL double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double cosDistance = cos(distance); double sinDistance = sin(distance); double sinFromLat = sin(fromLat); double cosFromLat = cos(fromLat); double sinLat = cosDistance * sinFromLat + sinDistance * cosFromLat * cos(heading); double dLng = atan2( sinDistance * cosFromLat * sin(heading), cosDistance - sinFromLat * sinLat); return new LatLng(toDegrees(asin(sinLat)), toDegrees(fromLng + dLng)); } /** * Returns the location of origin when provided with a LatLng destination, * meters travelled and original heading. Headings are expressed in degrees * clockwise from North. This function returns null when no solution is * available. * @param to The destination LatLng. * @param distance The distance travelled, in meters. * @param heading The heading in degrees clockwise from north. */ public static LatLng computeOffsetOrigin(LatLng to, double distance, double heading) { heading = toRadians(heading); distance /= EARTH_RADIUS; // http://lists.maptools.org/pipermail/proj/2008-October/003939.html double n1 = cos(distance); double n2 = sin(distance) * cos(heading); double n3 = sin(distance) * sin(heading); double n4 = sin(toRadians(to.latitude)); // There are two solutions for b. b = n2 * n4 +/- sqrt(), one solution results // in the latitude outside the [-90, 90] range. We first try one solution and // back off to the other if we are outside that range. double n12 = n1 * n1; double discriminant = n2 * n2 * n12 + n12 * n12 - n12 * n4 * n4; if (discriminant < 0) { // No real solution which would make sense in LatLng-space. return null; } double b = n2 * n4 + sqrt(discriminant); b /= n1 * n1 + n2 * n2; double a = (n4 - n2 * b) / n1; double fromLatRadians = atan2(a, b); if (fromLatRadians < -PI / 2 || fromLatRadians > PI / 2) { b = n2 * n4 - sqrt(discriminant); b /= n1 * n1 + n2 * n2; fromLatRadians = atan2(a, b); } if (fromLatRadians < -PI / 2 || fromLatRadians > PI / 2) { // No solution which would make sense in LatLng-space. return null; } double fromLngRadians = toRadians(to.longitude) - atan2(n3, n1 * cos(fromLatRadians) - n2 * sin(fromLatRadians)); return new LatLng(toDegrees(fromLatRadians), toDegrees(fromLngRadians)); } /** * Returns the LatLng which lies the given fraction of the way between the * origin LatLng and the destination LatLng. * @param from The LatLng from which to start. * @param to The LatLng toward which to travel. * @param fraction A fraction of the distance to travel. * @return The interpolated LatLng. */ public static LatLng interpolate(LatLng from, LatLng to, double fraction) { // http://en.wikipedia.org/wiki/Slerp double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double toLat = toRadians(to.latitude); double toLng = toRadians(to.longitude); double cosFromLat = cos(fromLat); double cosToLat = cos(toLat); // Computes Spherical interpolation coefficients. double angle = computeAngleBetween(from, to); double sinAngle = sin(angle); if (sinAngle < 1E-6) { return from; } double a = sin((1 - fraction) * angle) / sinAngle; double b = sin(fraction * angle) / sinAngle; // Converts from polar to vector and interpolate. double x = a * cosFromLat * cos(fromLng) + b * cosToLat * cos(toLng); double y = a * cosFromLat * sin(fromLng) + b * cosToLat * sin(toLng); double z = a * sin(fromLat) + b * sin(toLat); // Converts interpolated vector back to polar. double lat = atan2(z, sqrt(x * x + y * y)); double lng = atan2(y, x); return new LatLng(toDegrees(lat), toDegrees(lng)); } /** * Returns distance on the unit sphere; the arguments are in radians. */ private static double distanceRadians(double lat1, double lng1, double lat2, double lng2) { return arcHav(havDistance(lat1, lat2, lng1 - lng2)); } /** * Returns the angle between two LatLngs, in radians. This is the same as the distance * on the unit sphere. */ static double computeAngleBetween(LatLng from, LatLng to) { return distanceRadians(toRadians(from.latitude), toRadians(from.longitude), toRadians(to.latitude), toRadians(to.longitude)); } /** * Returns the distance between two LatLngs, in meters. */ public static double computeDistanceBetween(LatLng from, LatLng to) { return computeAngleBetween(from, to) * EARTH_RADIUS; } /** * Returns the length of the given path, in meters, on Earth. */ public static double computeLength(List<LatLng> path) { if (path.size() < 2) { return 0; } double length = 0; LatLng prev = path.get(0); double prevLat = toRadians(prev.latitude); double prevLng = toRadians(prev.longitude); for (LatLng point : path) { double lat = toRadians(point.latitude); double lng = toRadians(point.longitude); length += distanceRadians(prevLat, prevLng, lat, lng); prevLat = lat; prevLng = lng; } return length * EARTH_RADIUS; } /** * Returns the area of a closed path on Earth. * @param path A closed path. * @return The path's area in square meters. */ public static double computeArea(List<LatLng> path) { return abs(computeSignedArea(path)); } /** * Returns the signed area of a closed path on Earth. The sign of the area may be used to * determine the orientation of the path. * "inside" is the surface that does not contain the South Pole. * @param path A closed path. * @return The loop's area in square meters. */ public static double computeSignedArea(List<LatLng> path) { return computeSignedArea(path, EARTH_RADIUS); } /** * Returns the signed area of a closed path on a sphere of given radius. * The computed area uses the same units as the radius squared. * Used by SphericalUtilTest. */ static double computeSignedArea(List<LatLng> path, double radius) { int size = path.size(); if (size < 3) { return 0; } double total = 0; LatLng prev = path.get(size - 1); double prevTanLat = tan((PI / 2 - toRadians(prev.latitude)) / 2); double prevLng = toRadians(prev.longitude); // For each edge, accumulate the signed area of the triangle formed by the North Pole // and that edge ("polar triangle"). for (LatLng point : path) { double tanLat = tan((PI / 2 - toRadians(point.latitude)) / 2); double lng = toRadians(point.longitude); total += polarTriangleArea(tanLat, lng, prevTanLat, prevLng); prevTanLat = tanLat; prevLng = lng; } return total * (radius * radius); } /** * Returns the signed area of a triangle which has North Pole as a vertex. * Formula derived from "Area of a spherical triangle given two edges and the included angle" * as per "Spherical Trigonometry" by Todhunter, page 71, section 103, point 2. * See http://books.google.com/books?id=3uBHAAAAIAAJ&pg=PA71 * The arguments named "tan" are tan((pi/2 - latitude)/2). */ private static double polarTriangleArea(double tan1, double lng1, double tan2, double lng2) { double deltaLng = lng1 - lng2; double t = tan1 * tan2; return 2 * atan2(t * sin(deltaLng), 1 + t * cos(deltaLng)); } /** * Wraps the given value into the inclusive-exclusive interval between min and max. * @param n The value to wrap. * @param min The minimum. * @param max The maximum. */ static double wrap(double n, double min, double max) { return (n >= min && n < max) ? n : (mod(n - min, max - min) + min); } /** * Returns the non-negative remainder of x / m. * @param x The operand. * @param m The modulus. */ static double mod(double x, double m) { return ((x % m) + m) % m; } } 

Google मानचित्र मील / पिक्सेल से नज़दीक से काम करने लगता है ज़ूम = 13 पर, 1 मील = 100 पिक्सल 2 मील = 200 पिक्सल प्रत्येक ज़ूम लीएन 2 के एक फैक्टर द्वारा बढ़ता है या घटता है। इसलिए, ज़ूम 14 पर, 1 मील = 200 पिक्सल और ज़ूम 12 पर, 1 मील = 50 पिक्सल

मैंने एक दोहरा मान वापस करने के लिए स्वीकार किए गए उत्तर को परिवर्तित किया है, क्योंकि एंड्रॉइड Google मैप्स लाइब्रेरी फ़्लोटिंग पॉइंट ज़ूम स्तर का उपयोग करती है, और भूमध्य रेखा से अक्षांश के लिए भी खाते हैं I

 public static double getZoomForMetersWide ( final double desiredMeters, final double mapWidth, final double latitude ) { final double latitudinalAdjustment = Math.cos( Math.PI * latitude / 180.0 ); final double arg = EQUATOR_LENGTH * mapWidth * latitudinalAdjustment / ( desiredMeters * 256.0 ); return Math.log( arg ) / Math.log( 2.0 ); } 

एक तरफ, एंड्रॉइड पर सर्वश्रेष्ठ परिणाम देखने के असली पिक्सेल गिनती नहीं देते, लेकिन डिवाइस के पिक्सेल घनत्व के लिए आयाम आयाम

 DisplayMetrics metrics = getResources().getDisplayMetrics(); float mapWidth = mapView.getWidth() / metrics.scaledDensity; 

उम्मीद है कि यह किसी को मदद करता है