एंड्रॉइड - नक्शे पर फिल्टर पिन, एक दूसरे से दूरी के आधार पर

मुझे हाल ही में Google मानचित्र का उपयोग करके एक प्रोजेक्ट करने का मौका मिला। एक बिंदु पर, मैंने यह चित्र देखा:






ऐसा हुआ, आपने इसका अनुमान लगाया, जब आस-पास बहुत सारे स्थान थे जिन्हें प्रदर्शित करने की आवश्यकता थी। ठीक है, कुछ भी नहीं - समस्या एक तरह का मानक है - बहुत सारे लोगों को यह मिलना चाहिए, शायद डेवलपर्स को ग्रुपिंग और फ़िल्टरिंग के लिए प्रदान किया गया ... हाँ, यह वहाँ नहीं था! दस्तावेज़ीकरण की समीक्षा करने के बाद (मैं तुरंत स्वीकार करता हूं कि मैं केवल धाराप्रवाह - शायद मुझे याद आया कि मुझे क्या चाहिए) और Google से पूछा - अपने आश्चर्य के लिए, मुझे जल्दी से कुछ भी नहीं मिला। खैर, कुछ भी नहीं - देवताओं ने बर्तनों को नहीं जलाया - फिर हम इसे स्वयं लिखेंगे।

सबसे पहले, एक प्रोजेक्ट बनाएं और उसमें गूगल मैप्स एपी से कनेक्ट करें। यहां मुझे लगता है कि कुछ भी समझाने की आवश्यकता नहीं है - इसके बारे में पहले ही बहुत कुछ लिखा जा चुका है, वैसे, हब के लिंक एक , दो , तीन हैं ।

पहले हम तय करते हैं कि उसे क्या और कैसे काम करना चाहिए। आइए जाने ...

जाहिर है, हमें कुछ एल्गोरिदम के साथ आने की जरूरत है जिसके द्वारा सभी पिन स्क्रीन पर प्रदर्शित नहीं होंगे, लेकिन केवल एक दूसरे से निश्चित दूरी पर। और आपको यह भी सीखना होगा कि उन्हें समूहों में कैसे संयोजित किया जाए। निम्नलिखित होने के लिए इस सभी अर्थव्यवस्था का एक तालमेल आवश्यक है:

1) कार्ड पर पिन के प्रारंभिक लोडिंग पर।
2) ज़ूम बदलते समय

पहले पैराग्राफ के साथ, सिद्धांत रूप में, सब कुछ स्पष्ट है - चलो दूसरे पर फैसला करते हैं। इंटरफ़ेस घोषित करें:

public interface IOnZoomListener { void onZoomChanged(); } 

और हम अपने MapView को इस तरह से संशोधित करते हैं:

 public class MyMapView extends MapView { int oldZoomLevel = -1; IOnZoomListener onZoomListener; public MyMapView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public MyMapView(Context context, String apiKey) { super(context, apiKey); } public MyMapView(Context context, AttributeSet attrs) { super(context, attrs); } public void setOnZoomListener(IOnZoomListener onZoomListener) { this.onZoomListener = onZoomListener; } @Override public void dispatchDraw(Canvas canvas) { super.dispatchDraw(canvas); int newZoom = this.getZoomLevel(); if (newZoom != oldZoomLevel) { if (oldZoomLevel != -1 && onZoomListener != null) { onZoomListener.onZoomChanged(); } oldZoomLevel = getZoomLevel(); } } } 

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

अब हम तय करेंगे कि हम नक्शे पर पिंस कैसे प्रदर्शित करेंगे और उन्हें समूहों में कैसे संयोजित करेंगे। ऐसा करने के लिए, निम्न जोड़ के साथ OverlayItem से विरासत में मिली MyOverlayItem श्रेणी बनाएं:

 public class MyOverlayItem extends OverlayItem { private String name; private ArrayList<MyOverlayItem> list = new ArrayList<MyOverlayItem>(); public MyOverlayItem(GeoPoint point, String name) { super(point, "", ""); this.name = name; } public String getName() { if (list.size() > 0) { return "There are " + (list.size() + 1) + " places."; } else { return name; } } public void addList(MyOverlayItem item) { list.add(item); } public ArrayList<MyOverlayItem> getList() { return list; } } 

समूहबद्ध पिन की एक सूची ArrayList सूची में संग्रहीत की जाएगी, और getName विधि हमें या तो समूह में ऑब्जेक्ट का नाम या उनकी संख्या वापस कर देगी।

अब हम वर्णन करेंगे कि वास्तव में, यह सब किसके बारे में था - हमारा संशोधित ItemizedOverlay।
फ़िल्टरिंग एल्गोरिथ्म का सार काफी सरल है: हम बस सभी मौजूदा तत्वों पर लूप के माध्यम से चलते हैं और तत्वों के मौजूदा समूह के साथ निकट दूरी के लिए प्रत्येक तत्व की जांच करते हैं। यदि हमें ऐसा कोई समूह मिला है - तत्व को इसमें जोड़ा जाता है, यदि नहीं - इस तत्व के साथ एक नया समूह बनाया जाता है:

  boolean isImposition; for (MyOverlayItem itemFromAll : myOverlaysAll) { isImposition = false; for (MyOverlayItem item : myOverlays) { if (itemFromAll == item) { isImposition = true; break; } if (isImposition(itemFromAll, item)) { item.addList(itemFromAll); isImposition = true; break; } } if (!isImposition) { myOverlays.add(itemFromAll); } } 

सबसे पहले, दूरी की जांच करने के लिए, मैं सिर्फ पिन के निर्देशांक का उपयोग करना चाहता था (अक्षांश के आधार पर होने वाली त्रुटि को उपेक्षित किया जा सकता है, क्योंकि दूरी बड़ी नहीं है), लेकिन फिर मुझे ज़ूमलेवल को भी नियंत्रित करना होगा।
MapView.getLatitudeSpan विधि, जो हमें उस समन्वय प्रणाली में स्क्रीन की दृश्यमान चौड़ाई की दूरी लौटाती है, जिसकी मुझे आवश्यकता है, मेरे कार्यों के लिए काफी उपयुक्त थी। यह केवल एक निश्चित कारक (कितने अधिकतम पिन स्क्रीन में "फिट" होना चाहिए) द्वारा इस दूरी को विभाजित करने के लिए बनी हुई है - यह पिन के बीच न्यूनतम दूरी होगी:

 private boolean isImposition(MyOverlayItem item1, MyOverlayItem item2) { int latspan = mapView.getLatitudeSpan(); int delta = latspan / KOEFF; int dx = item1.getPoint().getLatitudeE6() - item2.getPoint().getLatitudeE6(); int dy = item1.getPoint().getLongitudeE6() - item2.getPoint().getLongitudeE6(); double dist = Math.sqrt(dx * dx + dy * dy); if (dist < delta) { return true; } else { return false; } } 

यहाँ, केवल मामले में, पूर्ण वर्ग स्रोत:

 public class PlaceOverlay extends ItemizedOverlay<MyOverlayItem> { private static final int KOEFF = 20; private ArrayList<MyOverlayItem> myOverlaysAll = new ArrayList<MyOverlayItem>(); private ArrayList<MyOverlayItem> myOverlays = new ArrayList<MyOverlayItem>(); private MapView mapView; public PlaceOverlay(Drawable defaultMarker, MapView mapView) { super(boundCenterBottom(defaultMarker)); this.mapView = mapView; populate(); } public void addOverlay(MyOverlayItem overlay) { myOverlaysAll.add(overlay); myOverlays.add(overlay); } public void doPopulate() { populate(); setLastFocusedIndex(-1); } @Override protected MyOverlayItem createItem(int i) { return myOverlays.get(i); } @Override public int size() { return myOverlays.size(); } private boolean isImposition(MyOverlayItem item1, MyOverlayItem item2) { int latspan = mapView.getLatitudeSpan(); int delta = latspan / KOEFF; int dx = item1.getPoint().getLatitudeE6() - item2.getPoint().getLatitudeE6(); int dy = item1.getPoint().getLongitudeE6() - item2.getPoint().getLongitudeE6(); double dist = Math.sqrt(dx * dx + dy * dy); if (dist < delta) { return true; } else { return false; } } public void clear() { myOverlaysAll.clear(); myOverlays.clear(); } public void calculateItems() { myOverlaysClear(); boolean isImposition; for (MyOverlayItem itemFromAll : myOverlaysAll) { isImposition = false; for (MyOverlayItem item : myOverlays) { if (itemFromAll == item) { isImposition = true; break; } if (isImposition(itemFromAll, item)) { item.addList(itemFromAll); isImposition = true; break; } } if (!isImposition) { myOverlays.add(itemFromAll); } } doPopulate(); } private void myOverlaysClear() { for (MyOverlayItem item : myOverlaysAll) { item.getList().clear(); } myOverlays.clear(); } @Override protected boolean onTap(int index) { Toast.makeText(mapView.getContext(), myOverlays.get(index).getName(), Toast.LENGTH_SHORT).show(); return true; } } 

अरे हाँ - onTap पद्धति में हम टोस्ट को समूह के नाम से आउटपुट करते हैं - एल्गोरिदम के संचालन को स्पष्ट रूप से प्रदर्शित करने के लिए।

मैं जोड़ना चाहता हूं कि यह एल्गोरिथ्म अंतिम सत्य नहीं है - यह सुधार किया जा सकता है और उदाहरण के लिए - समूह के पहले तत्व की साइट पर नहीं एक पिन खींचें, लेकिन इसकी सामग्री के आधार पर इसके स्थान की गणना करें। लेकिन आप पहले से ही अपनी परियोजनाओं में खुद को महसूस करते हैं।

अब आइए जानें कि यह सब एक साथ कैसे रखा जाए।
चलिए कई PinsProjectActivity बनाते हैं जो हमें MapActivity से विरासत में मिलेगा और हम निम्नलिखित इंटरफेस को लागू करेंगे: LocationListener, IOnZoomListener। हालांकि, मैं सब कुछ विस्तार से नहीं चित्रित करूंगा - स्रोत मेरे लिए सब कुछ बताएगा:

 public class ManyPinsProjectActivity extends MapActivity implements LocationListener, IOnZoomListener { private static final int DEFAULT_ZOOM = 15; private MyMapView mapView = null; private Drawable myCurrentMarker = null; private Drawable placeMarker = null; private List<Overlay> mapOverlays; private PlaceOverlay placeOverlay; private MyCurrentLocationOverlay myCurrentLocationOverlay; double currentLatitude, currentLongitude; private MapController mapController; private LocationManager locationManager; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE); mapView = (MyMapView) findViewById(R.id.mapview); myCurrentMarker = this.getResources().getDrawable(R.drawable.my_pin_red); placeMarker = this.getResources().getDrawable(R.drawable.my_pin); myCurrentLocationOverlay = new MyCurrentLocationOverlay(myCurrentMarker, mapView); placeOverlay = new PlaceOverlay(placeMarker, mapView); mapOverlays = mapView.getOverlays(); mapController = mapView.getController(); mapView.setBuiltInZoomControls(true); mapView.setOnZoomListener(this); } private void animateToPlaceOnMap(final GeoPoint geopoint) { mapView.post(new Runnable() { @Override public void run() { mapView.invalidate(); mapController.animateTo(geopoint); mapController.setZoom(DEFAULT_ZOOM); } }); } private void setCurrentGeopoint(double myLatitude, double myLongitude) { currentLatitude = myLatitude; currentLongitude = myLongitude; final GeoPoint myCurrentGeoPoint = new GeoPoint((int) (myLatitude * 1E6), (int) (myLongitude * 1E6)); MyOverlayItem myCurrentItem = new MyOverlayItem(myCurrentGeoPoint, "Current Location"); myCurrentLocationOverlay.addOverlay(myCurrentItem); mapOverlays.add(myCurrentLocationOverlay); animateToPlaceOnMap(myCurrentGeoPoint); } @Override protected void onPause() { super.onPause(); locationManager.removeUpdates(this); } @Override protected void onResume() { super.onResume(); locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 5000, 100, this); } private ArrayList<PlaceInfo> generatePlaces(){ Random random = new Random(); int x, y; ArrayList<PlaceInfo> places = new ArrayList<PlaceInfo>(); PlaceInfo p; for(int i = 0; i < 100; i++){ x = random.nextInt(2000); y = random.nextInt(2000); p = new PlaceInfo(); p.setLatitude(currentLatitude + x/100000f); p.setLongitude(currentLongitude - y/100000f); p.setName("Place № " + i); places.add(p); } return places; } private void displayPlacesOnMap() { ArrayList<PlaceInfo> places = generatePlaces(); mapOverlays.remove(placeOverlay); GeoPoint point = null; MyOverlayItem overlayitem = null; placeOverlay.clear(); for (PlaceInfo place : places) { point = new GeoPoint((int) (place.getLatitude() * 1E6), (int) (place.getLongitude() * 1E6)); overlayitem = new MyOverlayItem(point, place.getName()); placeOverlay.addOverlay(overlayitem); } placeOverlay.calculateItems(); placeOverlay.doPopulate(); if (placeOverlay.size() > 0) { mapOverlays.add(placeOverlay); mapView.postInvalidate(); } } @Override public void onLocationChanged(Location location) { locationManager.removeUpdates(this); double myLatitude = location.getLatitude(); double myLongitude = location.getLongitude(); setCurrentGeopoint(myLatitude, myLongitude); displayPlacesOnMap(); } @Override public void onStatusChanged(String provider, int status, Bundle extras) { } @Override public void onProviderEnabled(String provider) { } @Override public void onProviderDisabled(String provider) { } @Override protected boolean isRouteDisplayed() { return false; } @Override public void onZoomChanged() { if (placeOverlay != null) { placeOverlay.calculateItems(); } } } 

यह जोड़ने योग्य है कि MyCurrentLocationOverlay एक तत्व के साथ एक सामान्य ItemizedOverlay है, और PlaceInfo एक साधारण आवरण वर्ग युक्त है:

  private String name; private double latitude; private double longitude; 

इन सभी जोड़तोड़ के बाद - यह है कि पिन के साथ हमारा नक्शा कैसे दिखना शुरू हुआ:






मुझे उम्मीद है कि लेख आपके लिए उपयोगी होगा।

पूरी परियोजना यहां पाई जा सकती है ।