谷歌地图集群与方向

时间:2014-07-09 06:36:45

标签: android google-maps

我们有一个Google map library来显示群集中的多个标记。

我有两个问题:

1.我们可以在Google地图上显示多个方向,如下图所示吗?

2.我们可以在群集标记中显示多个方向细节吗?

enter image description here

集群如下所示:

我将举例说明:来自国家印度我在我的数据库中保存了不同的方向。

艾哈迈达巴德到德里

德里到阿格拉

艾哈迈达巴德要轰炸

jaypur to delhi

我必须显示以上方向的集群取决于缩放级别, 当用户缩放谷歌地图而不是群集时,谷歌地图上会显示多个方向。

我想知道它是否可能?如果是,那么如何?

2 个答案:

答案 0 :(得分:1)

您可以使用Directions API实现目标。您提供起点和终点(可以是纬度/经度或地点名称)。另一个必填字段是旅行模式(默认驾驶)。

现在,方向返回顶点,顶点可以转换为折线,然后在地图上绘制。 This answer做得非常好,我将使用它的代码。

package com.example.simon.maps;

import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Document;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapFragment;
import com.google.android.gms.maps.model.CameraPosition;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.Polyline;
import com.google.android.gms.maps.model.PolylineOptions;
import android.graphics.Color;
import android.os.Bundle;
import android.os.StrictMode;
import android.support.v4.app.FragmentActivity;
import android.util.Log;
import android.util.SparseArray;

/**
 * Created by Simon on 2014 Jul 25.
 */

public class MainActivity extends FragmentActivity {

    final static String TAG = "MainActivity";
    GoogleMap mMap;
    GMapV2Direction md;
    int mZoomLevel;
    final float STARTING_ZOOM = 5.0f;
    // List of polylines for each zoom level
    SparseArray<List<Polyline>> mPolylines = new SparseArray<List<Polyline>>();

    public class direction {
        String start, end;
        int zoomLevel;

        direction(String pStart, String pEnd, int pZoomLevel) {
            start = pStart;
            end = pEnd;
            zoomLevel = pZoomLevel;
        }
    }

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (android.os.Build.VERSION.SDK_INT > 9) {
            StrictMode.ThreadPolicy p = new StrictMode.ThreadPolicy.Builder().permitAll().build();
            StrictMode.setThreadPolicy(p);
        }

        md = new GMapV2Direction();
        mMap = ((MapFragment)getFragmentManager().findFragmentById(R.id.map)).getMap();

        List<direction> directions = new ArrayList<direction>();
        directions.add(new direction("Ahmedabad,Gujarat,India", "delhi,India", 4));
        directions.add(new direction("Ahmedabad,Gujarat,India","Bombay,Maharashtra,India", 4));
        directions.add(new direction("Jeypore,Odisha,India", "delhi,India", 5));
        for (MainActivity.direction direction : directions) {
            // Query
            Document doc = md.getDocument(direction.start, direction.end);
            // Parse the xml
            if (doc == null) {
                Log.e(TAG, "Failed to get the route from " + direction.start
                        + " to " + direction.end);
                continue;
            }
            // Get points
            ArrayList<LatLng> directionPoint = md.getDirection(doc);
            // Convert vertexes to a polyline
            PolylineOptions rectLine = new PolylineOptions().width(3).color(Color.RED);
            for (LatLng aDirectionPoint : directionPoint) {
                rectLine.add(aDirectionPoint);
            }
            // Add poly to the map
            addPolyline(rectLine, direction.zoomLevel);
        }
        // Get the starting point of the first direction
        LatLng start = mPolylines.valueAt(0).get(0).getPoints().get(0);
        mMap.animateCamera(CameraUpdateFactory.newLatLngZoom(start, STARTING_ZOOM), 1000, null);
        // Set the initial zoom level and show the necessary polylines
        mZoomLevel = (int) STARTING_ZOOM;
        initPolylines(mZoomLevel);

        // Listen for the camera zoom level changes
        mMap.setOnCameraChangeListener(new GoogleMap.OnCameraChangeListener() {
            @Override
            public void onCameraChange(CameraPosition cameraPosition) {
                // Note that because we are casting the zoomLevel to int,
                // it will be considered as changed only when it reaches
                // a new integer when rounded (e.g. 5.0, 6.0 etc.)
                int newZoomLevel = (int) cameraPosition.zoom;
                if (newZoomLevel != mZoomLevel) {
                    Log.d(TAG, "New zoom level: " + newZoomLevel);
                    // Loop all the changed zoom levels
                    // E.g. zoomed-out from 15 to 13, then hide [14, 15]
                    if (newZoomLevel < mZoomLevel) { // Zoomed out
                        for (int i=1; i<=mZoomLevel-newZoomLevel; i++)
                            hidePolylines(mPolylines.get(newZoomLevel+i));
                    } else { // Zoomed-in
                        for (int i=1; i<=newZoomLevel-mZoomLevel; i++)
                            showPolylines(mPolylines.get(mZoomLevel + i));
                    }
                    mZoomLevel = newZoomLevel;
                }
            }
        });
    }

    private void addPolyline(PolylineOptions polyOpts, int zoomLevel) {
        List<Polyline> polylines = mPolylines.get(zoomLevel);
        // Create polyline list for this zoom level, if it still doesn't exist
        if (polylines == null) {
            polylines = new ArrayList<Polyline>();
            mPolylines.put(zoomLevel, polylines);
        }
        // Append a new item to this poly list
        Polyline polyline = mMap.addPolyline(polyOpts);
        polyline.setVisible(false);
        polylines.add(polyline);
    }

    private void initPolylines(int zoomLevel) {
        for(int i=0; i<mPolylines.size(); i++) {
            // Loop until zoom level is reached
            if  (mPolylines.keyAt(i) > zoomLevel) break;

            showPolylines(mPolylines.get(mPolylines.keyAt(i)));
        }
    }

    private void showPolylines(List<Polyline> polylines) {
        if (polylines != null)
            for (Polyline polyline : polylines) polyline.setVisible(true);
    }

    private void hidePolylines(List<Polyline> polylines) {
        if (polylines != null)
            for (Polyline polyline : polylines) polyline.setVisible(false);
    }

}

此代码将折线添加到SparseArray,该SparseArray保存每个缩放级别的折线。所有polies都默认隐藏,仅在达到特定缩放级别时显示(同样在initPolylines)。

这里有几点需要注意:

  1. 因为缩放可以同时改变几个级别,我们会循环每个级别以隐藏/显示特定的方向。
  2. 位置名称必须精确或者找不到它们,您可能会在代码中收到一堆错误(我只添加了一个Log.e)
  3. 如果您想创建标记,让我们说方向的起点和终点,您可以使用以下代码来获取坐标:

    List<LatLng> points = mPolylines.valueAt(0).get(0).getPoints();
    LatLng start = points.get(0);
    LatLng end = points.get(points.size()-1);
    
  4. 可以在特定缩放级别添加/删除标记,就像使用折线一样。
  5. 这是xml解析器的代码(GMapV2Direction):

    package com.example.simon.maps;
    
    import java.io.InputStream;
    import java.util.ArrayList;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import org.apache.http.HttpResponse;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.protocol.BasicHttpContext;
    import org.apache.http.protocol.HttpContext;
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import com.google.android.gms.maps.model.LatLng;
    
    public class GMapV2Direction {
    
        public GMapV2Direction() { }
    
        public Document getDocument(String start, String end) {
            String url = "http://maps.googleapis.com/maps/api/directions/xml?"
                    + "origin="+start+"&destination="+end+"&units=metric&mode=driving";
            try {
                HttpClient httpClient = new DefaultHttpClient();
                HttpContext localContext = new BasicHttpContext();
                HttpPost httpPost = new HttpPost(url);
                HttpResponse response = httpClient.execute(httpPost, localContext);
                InputStream in = response.getEntity().getContent();
                DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
                return builder.parse(in);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public ArrayList<LatLng> getDirection (Document doc) {
            NodeList nl1, nl2, nl3;
            ArrayList<LatLng> listGeopoints = new ArrayList<LatLng>();
            nl1 = doc.getElementsByTagName("step");
            if (nl1.getLength() > 0) {
                for (int i = 0; i < nl1.getLength(); i++) {
                    Node node1 = nl1.item(i);
                    nl2 = node1.getChildNodes();
    
                    Node locationNode = nl2.item(getNodeIndex(nl2, "start_location"));
                    nl3 = locationNode.getChildNodes();
                    Node latNode = nl3.item(getNodeIndex(nl3, "lat"));
                    double lat = Double.parseDouble(latNode.getTextContent());
                    Node lngNode = nl3.item(getNodeIndex(nl3, "lng"));
                    double lng = Double.parseDouble(lngNode.getTextContent());
                    listGeopoints.add(new LatLng(lat, lng));
    
                    locationNode = nl2.item(getNodeIndex(nl2, "polyline"));
                    nl3 = locationNode.getChildNodes();
                    latNode = nl3.item(getNodeIndex(nl3, "points"));
                    ArrayList<LatLng> arr = decodePoly(latNode.getTextContent());
                    for (LatLng anArr : arr) {
                        listGeopoints.add(new LatLng(anArr.latitude, anArr.longitude));
                    }
    
                    locationNode = nl2.item(getNodeIndex(nl2, "end_location"));
                    nl3 = locationNode.getChildNodes();
                    latNode = nl3.item(getNodeIndex(nl3, "lat"));
                    lat = Double.parseDouble(latNode.getTextContent());
                    lngNode = nl3.item(getNodeIndex(nl3, "lng"));
                    lng = Double.parseDouble(lngNode.getTextContent());
                    listGeopoints.add(new LatLng(lat, lng));
                }
            }
    
            return listGeopoints;
        }
    
        private int getNodeIndex(NodeList nl, String nodename) {
            for(int i = 0 ; i < nl.getLength() ; i++) {
                if(nl.item(i).getNodeName().equals(nodename))
                    return i;
            }
            return -1;
        }
    
        private ArrayList<LatLng> decodePoly(String encoded) {
            ArrayList<LatLng> poly = new ArrayList<LatLng>();
            int index = 0, len = encoded.length();
            int lat = 0, lng = 0;
            while (index < len) {
                int b, shift = 0, result = 0;
                do {
                    b = encoded.charAt(index++) - 63;
                    result |= (b & 0x1f) << shift;
                    shift += 5;
                } while (b >= 0x20);
                int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
                lat += dlat;
                shift = 0;
                result = 0;
                do {
                    b = encoded.charAt(index++) - 63;
                    result |= (b & 0x1f) << shift;
                    shift += 5;
                } while (b >= 0x20);
                int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
                lng += dlng;
    
                LatLng position = new LatLng((double) lat / 1E5, (double) lng / 1E5);
                poly.add(position);
            }
            return poly;
        }
    }
    

    最后的一些说明:

    • 如果你有很多方向将它们加载到initPolylinesshowPolylines中并在hidePolylines
    • 中卸载它们
    • 如果要在地图上显示的方向不变,最好的方法是在特定缩放级别上使用具有折线的切片。一个好的免费工具是 Maperitive ,它可以将图块导出到您想要的任意数量的缩放级别。然后,您将在线存储图块并使用UrlTileProvider在地图上显示它们。

答案 1 :(得分:-1)

我不知道我是否理解你的问题,但无论如何我都会试着回答。 您可以创建多个polylines并从google maps direction API的JSON响应添加到地图。这样,您就可以在一个地图中添加多条路线。

据我所知,第二个问题是,您希望群集标记提供您正在绘制的路线的详细信息。为此,我猜您可以对API返回的点进行聚类,并使用custom marker clusters来显示您想要的信息。

希望有所帮助

CNC中 如果您想在Android应用中绘制路线,则不会获得任何可以使用的DirectionRenderer。您需要使用折线渲染路线。这就是我在上面的答案中提到创建折线的原因。作为对Direction请求的响应,您将获得一个包含多个坐标点的JSON,这些坐标点可以通过绘制折线来连接。 您可以在地图上(从任何点到任何点)拥有多个此类折线。 案例1:您想要从Bombay到Goa的2条路线,将alternative参数设置为true。 案例2:你想要两条不同的路线,班加罗尔到孟买,果阿到德里,向API发出两个不同的请求。您将获得两条不同的路线并在地图上绘制。

对于第二个问题,由于路径(折线)没有内置的聚类,您必须编写显示在地图中的聚类图标的逻辑。要获得当前缩放级别,请使用以下内容。

GoogleMap map;    
float zoom = map.getCameraPosition().zoom;

用于显示和隐藏折线

Polyline line = map.addPolyline(new PolylineOptions()
 .add(new LatLng(51.5, -0.1), new LatLng(40.7, -74.0))

 // multiple points that you get from the response of directions API

 .width(5)
 .color(Color.RED));

//your logic for visibility
if(zoom<=5){
  line.setVisible(true);
}

我在API中找不到任何方法来使用代码隐藏群集图标。我猜它应该在某个缩放级别后隐藏自己。