दिलचस्प पोस्ट
त्रुटि: कनेक्शन रिजल्ट {statusCode = INTERNAL_ERROR, रिज़ॉल्यूशन = शून्य} UIPageViewController और स्टोरीबोर्ड स्ट्रिंग और अर्रेबफर के बीच परिवर्तित करना कैसे जांचें कि क्या किसी गतिविधि से कुछ गतिविधि को नियंत्रित किया जा सकता है? फ़ाइल नाम में बैच आदेश दिनांक और समय घुमाओ JToolbar बटन दबाने यूनिक्स शेल कमांड का सामान्य सिंटैक्स क्या है? एक सी पॉइंटर वास्तव में क्या नहीं है, तो मेमोरी एड्रेस क्या है? एक्सएमएल में अन्य कॉन्फ़िग फाइल्स की सेटिंग्स को शामिल करने के लिए app.config में शामिल हैं या कॉन्फ़िगर संदर्भ स्वचालित स्वच्छ और एसईओ दोस्ताना यूआरएल (slugs) उचित codeigniter आधार url कैसे सेट करें? बिना ज़्यादा शून्य के स्वरूपण अजगर में पायथन स्थापना के दौरान नेट कॉन्फ़िग फ़ाइलों को कैसे संशोधित करें? मेरी फ़ाइल सामग्री / उपयोगकर्ता इनपुट क्यों मेल नहीं खाता? (लापता क्रोम कैनोनिकल) वास्तविक .NET 4.5 संस्करण को कैसे स्थापित किया जा सके?

मैपफ्रैग्मेंट पर सर्कल का Google मानचित्र एपीआई v2 खींचना

मुझे ऐसा कुछ आकर्षित करना होगा जो चित्रित किया जाएगा और इसमें थोड़ा पारदर्शिता है

इसके अलावा इसे क्लिक करने योग्य (ऑन-टच इवेंट आदि) की आवश्यकता है

यहां छवि विवरण दर्ज करें

मुझे पता है कि एपीआई वी 1 में आपको ओवरले का उपयोग करना होगा और इसे कैनवास और कुछ गणित का उपयोग करना होगा। Google मानचित्र एपीआई v2 में यह सबसे आसान तरीका क्या है?

PS: त्रिज्या चर है

(आगे संदर्भ के लिए) 1 संपादित करें:

मैंने कैनवासटाइल प्रोवाइडर उपवर्ग को कार्यान्वित किया है और इसके ऑनडा () विधि को ओवरराइड किया है:

@Override void onDraw(Canvas canvas, TileProjection projection) { // TODO Auto-generated method stub LatLng tempLocation = moveByDistance(mSegmentLocation, mSegmentRadius, mSegmentAngle); DoublePoint segmentLocationPoint = new DoublePoint(0, 0); DoublePoint tempLocationPoint = new DoublePoint(0, 0); projection.latLngToPoint(mSegmentLocation, segmentLocationPoint); projection.latLngToPoint(tempLocationPoint, tempLocationPoint); float radiusInPoints = FloatMath.sqrt((float) (Math.pow( (segmentLocationPoint.x - tempLocationPoint.x), 2) + Math.pow( (segmentLocationPoint.y - tempLocationPoint.y), 2))); RectF segmentArea = new RectF(); segmentArea.set((float)segmentLocationPoint.x - radiusInPoints, (float)segmentLocationPoint.y - radiusInPoints, (float)segmentLocationPoint.x + radiusInPoints, (float)segmentLocationPoint.y + radiusInPoints); canvas.drawArc(segmentArea, getAdjustedAngle(mSegmentAngle), getAdjustedAngle(mSegmentAngle + 60), true, getOuterCirclePaint()); } 

इसके अलावा, मैंने इसे MapActivity से जोड़ा है:

 private void loadSegmentTiles() { TileProvider tileProvider; TileOverlay tileOverlay = mMap.addTileOverlay( new TileOverlayOptions().tileProvider(new SegmentTileProvider(new LatLng(45.00000,15.000000), 250, 30))); } 

अब मैं सोच रहा हूँ कि मेरा चाप मानचित्र पर क्यों नहीं है?

वेब के समाधान से एकत्रित समाधान "मैपफ्रैग्मेंट पर सर्कल का Google मानचित्र एपीआई v2 खींचना"

सर्कल सेगमेंट को ड्राइंग करने के लिए, मैं एक टाइल प्रोवाइडर को पंजीकृत करूँगा, यदि खंड मुख्य रूप से स्थिर हैं I (टाइलें आमतौर पर केवल एक बार लोड की जाती हैं और फिर कैश की जाती हैं।) क्लिक ईवेंट की जांच के लिए, आप अपने सेगमेंट पर एक onMapClickListener और लूप को पंजीकृत कर सकते हैं यह जांचने के लिए कि क्या क्लिक किए गए LatLng आपके एक सेगमेंट के अंदर है या नहीं। (अधिक जानकारी के लिए नीचे देखें।)

यहां एक टाइलप्रदाता का उदाहरण है, जो आप उप-वर्ग और बस डायोड विधि को लागू कर सकते हैं।
एक महत्वपूर्ण नोट: उपवर्ग को थ्रेड सुरक्षित होना चाहिए! ऑनडाव विधि को एक साथ कई थ्रेड्स के द्वारा बुलाया जाएगा। इसलिए किसी भी ग्लोबल्स से बचें, जो कि डरे के अंदर बदल जाते हैं!

 /* imports should be obvious */ public abstract class CanvasTileProvider implements TileProvider { private static int TILE_SIZE = 256; private BitMapThreadLocal tlBitmap; @SuppressWarnings("unused") private static final String TAG = CanvasTileProvider.class.getSimpleName(); public CanvasTileProvider() { super(); tlBitmap = new BitMapThreadLocal(); } @Override // Warning: Must be threadsafe. To still avoid creation of lot of bitmaps, // I use a subclass of ThreadLocal !!! public Tile getTile(int x, int y, int zoom) { TileProjection projection = new TileProjection(TILE_SIZE, x, y, zoom); byte[] data; Bitmap image = getNewBitmap(); Canvas canvas = new Canvas(image); onDraw(canvas, projection); data = bitmapToByteArray(image); Tile tile = new Tile(TILE_SIZE, TILE_SIZE, data); return tile; } /** Must be implemented by a concrete TileProvider */ abstract void onDraw(Canvas canvas, TileProjection projection); /** * Get an empty bitmap, which may however be reused from a previous call in * the same thread. * * @return */ private Bitmap getNewBitmap() { Bitmap bitmap = tlBitmap.get(); // Clear the previous bitmap bitmap.eraseColor(Color.TRANSPARENT); return bitmap; } private static byte[] bitmapToByteArray(Bitmap bm) { ByteArrayOutputStream bos = new ByteArrayOutputStream(); bm.compress(Bitmap.CompressFormat.PNG, 100, bos); byte[] data = bos.toByteArray(); return data; } class BitMapThreadLocal extends ThreadLocal<Bitmap> { @Override protected Bitmap initialValue() { Bitmap image = Bitmap.createBitmap(TILE_SIZE, TILE_SIZE, Config.ARGB_8888); return image; } } } 

प्रक्षेपण का उपयोग करें, जिसे ट्रायल की पहली सीमा पर प्राप्त करने के लिए ओपन विधि में पारित किया गया है। यदि कोई सेगमेंट सीमा के अंदर नहीं है, तो बस वापस लौटें अन्यथा कैनवास में अपना seqment डालें। विधि प्रोजेक्शन। LatLngToPoint आपको कैटलैंड के लेट लाँग से पिक्सल में कनवर्ट करने में मदद करता है।

 /** Converts between LatLng coordinates and the pixels inside a tile. */ public class TileProjection { private int x; private int y; private int zoom; private int TILE_SIZE; private DoublePoint pixelOrigin_; private double pixelsPerLonDegree_; private double pixelsPerLonRadian_; TileProjection(int tileSize, int x, int y, int zoom) { this.TILE_SIZE = tileSize; this.x = x; this.y = y; this.zoom = zoom; pixelOrigin_ = new DoublePoint(TILE_SIZE / 2, TILE_SIZE / 2); pixelsPerLonDegree_ = TILE_SIZE / 360d; pixelsPerLonRadian_ = TILE_SIZE / (2 * Math.PI); } /** Get the dimensions of the Tile in LatLng coordinates */ public LatLngBounds getTileBounds() { DoublePoint tileSW = new DoublePoint(x * TILE_SIZE, (y + 1) * TILE_SIZE); DoublePoint worldSW = pixelToWorldCoordinates(tileSW); LatLng SW = worldCoordToLatLng(worldSW); DoublePoint tileNE = new DoublePoint((x + 1) * TILE_SIZE, y * TILE_SIZE); DoublePoint worldNE = pixelToWorldCoordinates(tileNE); LatLng NE = worldCoordToLatLng(worldNE); return new LatLngBounds(SW, NE); } /** * Calculate the pixel coordinates inside a tile, relative to the left upper * corner (origin) of the tile. */ public void latLngToPoint(LatLng latLng, DoublePoint result) { latLngToWorldCoordinates(latLng, result); worldToPixelCoordinates(result, result); result.x -= x * TILE_SIZE; result.y -= y * TILE_SIZE; } private DoublePoint pixelToWorldCoordinates(DoublePoint pixelCoord) { int numTiles = 1 << zoom; DoublePoint worldCoordinate = new DoublePoint(pixelCoord.x / numTiles, pixelCoord.y / numTiles); return worldCoordinate; } /** * Transform the world coordinates into pixel-coordinates relative to the * whole tile-area. (ie the coordinate system that spans all tiles.) * * * Takes the resulting point as parameter, to avoid creation of new objects. */ private void worldToPixelCoordinates(DoublePoint worldCoord, DoublePoint result) { int numTiles = 1 << zoom; result.x = worldCoord.x * numTiles; result.y = worldCoord.y * numTiles; } private LatLng worldCoordToLatLng(DoublePoint worldCoordinate) { DoublePoint origin = pixelOrigin_; double lng = (worldCoordinate.x - origin.x) / pixelsPerLonDegree_; double latRadians = (worldCoordinate.y - origin.y) / -pixelsPerLonRadian_; double lat = Math.toDegrees(2 * Math.atan(Math.exp(latRadians)) - Math.PI / 2); return new LatLng(lat, lng); } /** * Get the coordinates in a system describing the whole globe in a * coordinate range from 0 to TILE_SIZE (type double). * * Takes the resulting point as parameter, to avoid creation of new objects. */ private void latLngToWorldCoordinates(LatLng latLng, DoublePoint result) { DoublePoint origin = pixelOrigin_; result.x = origin.x + latLng.longitude * pixelsPerLonDegree_; // Truncating to 0.9999 effectively limits latitude to 89.189. This is // about a third of a tile past the edge of the world tile. double siny = bound(Math.sin(Math.toRadians(latLng.latitude)), -0.9999, 0.9999); result.y = origin.y + 0.5 * Math.log((1 + siny) / (1 - siny)) * -pixelsPerLonRadian_; }; /** Return value reduced to min and max if outside one of these bounds. */ private double bound(double value, double min, double max) { value = Math.max(value, min); value = Math.min(value, max); return value; } /** A Point in an x/y coordinate system with coordinates of type double */ public static class DoublePoint { double x; double y; public DoublePoint(double x, double y) { this.x = x; this.y = y; } } } 

अंत में आपको कुछ की जांच करने की ज़रूरत है, चाहे LatLng-Coordinate पर एक क्लिक आपके सेगमेंट के अंदर है इसलिए मैं LatLng- निर्देशांक की एक सूची से खंड का अनुमान लगाता हूं, जहां आपके मामले में एक साधारण त्रिकोण पर्याप्त हो सकता है लेटलेंग निर्देशांक की प्रत्येक सूची के लिए, यानी प्रत्येक खंड के लिए, आप निम्न की तरह कुछ कॉल कर सकते हैं:

 private static boolean isPointInsidePolygon(List<LatLng> vertices, LatLng point) { /** * Test is based on a horizontal ray, starting from point to the right. * If the ray is crossed by an even number of polygon-sides, the point * is inside the polygon, otherwise it is outside. */ int i, j; boolean inside = false; int size = vertices.size(); for (i = 0, j = size - 1; i < size; j = i++) { LatLng vi = vertices.get(i); LatLng vj = vertices.get(j); if ((vi.latitude > point.latitude) != (vj.latitude > point.latitude)) { /* The polygonside crosses the horizontal level of the ray. */ if (point.longitude <= vi.longitude && point.longitude <= vj.longitude) { /* * Start and end of the side is right to the point. Side * crosses the ray. */ inside = !inside; } else if (point.longitude >= vi.longitude && point.longitude >= vj.longitude) { /* * Start and end of the side is left of the point. No * crossing of the ray. */ } else { double crossingLongitude = (vj.longitude - vi.longitude) * (point.latitude - vi.latitude) / (vj.latitude - vi.latitude) + vi.longitude; if (point.longitude < crossingLongitude) { inside = !inside; } } } } return inside; } 

जैसा कि आप देख सकते हैं, मुझे हल करने का एक बहुत ही समान कार्य था 🙂

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