如何使用沿折线的实时位置更新标记？

Posted 2023-04-14

【中文标题】如何使用沿折线的实时位置更新标记？

【英文标题】：How to update marker using live location along a polyline?

【发布时间】：2019-07-21 01:32:12

【问题描述】：

我的问题标题似乎是现有的，但这是我的完整场景。

我有一个基于地图的操作的活动，我正在沿着道路绘制一条折线，假设是两个位置之间的路线。基本上，该应用程序会跟踪用户的当前位置（开车旅行）。因此，直到部分一切正常，如路线正确显示，设备位置 API 正在提供位置更新（有点精确），而且我能够顺利更改位置更新，

所以问题是，位置更新有时是曲折的，有时可能不会触及道路，位置更新会遍布整个地方。

我也研究了 ROAD api，但没有得到正确的帮助，即使是以前提出的一些问题也是如此。

是否可以让标记仅沿道路移动？

我们将不胜感激。

【问题讨论】：

您是否使用 FINE_LOCATION 作为权限？

尝试使用Snap to Road from Roads API 并查看this 的答案。

@ManojPerumarath 是的，我已经完成了配置位置请求以接收最高精度值的所有工作。

@AndriiOmelchenko 是的，我已经检查过了，但问题是我必须让标记沿着折线移动。绘制的折线是准确的，这不是问题。该链接表明与我的要求不同。

你的意思是SphericalUtil.interpolate()？我想使用interpolate() 来计算路径部分的坐标？

【参考方案1】：

您可以通过在最近的路径段上投影标记来将标记捕捉到路径。您可以通过PolyUtil.isLocationOnPath()找到最近的段：

PolyUtil.isLocationOnPath(carPos, segment, true, 30)

以及标记到该段的投影，您可以通过将测地球坐标转换为正交屏幕坐标来计算投影正交坐标并将其转换回球坐标 (WGS84 LatLng -> Screen x,y -> WGS84 LatLng)：

Point carPosOnScreen = projection.toScreenLocation(carPos);
Point p1 = projection.toScreenLocation(segment.get(0));
Point p2 = projection.toScreenLocation(segment.get(1));
Point carPosOnSegment = new Point();

float denominator = (p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y);
// p1 and p2 are the same
if (Math.abs(denominator) <= 1E-10) 
    markerProjection = segment.get(0);
 else 
    float t = (carPosOnScreen.x * (p2.x - p1.x) - (p2.x - p1.x) * p1.x
            + carPosOnScreen.y * (p2.y - p1.y) - (p2.y - p1.y) * p1.y) / denominator;
    carPosOnSegment.x = (int) (p1.x + (p2.x - p1.x) * t);
    carPosOnSegment.y = (int) (p1.y + (p2.y - p1.y) * t);
    markerProjection = projection.fromScreenLocation(carPosOnSegment);

完整的源代码：

public class MainActivity extends AppCompatActivity implements OnMapReadyCallback 

    private GoogleMap mGoogleMap;
    private MapFragment mapFragment;

    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mapFragment = (MapFragment) getFragmentManager()
                .findFragmentById(R.id.map_fragment);
        mapFragment.getMapAsync(this);

        mButton = (Button) findViewById(R.id.button);
        mButton.setOnClickListener(new View.OnClickListener() 
            @Override
            public void onClick(View v) 

            
        );
    

    @Override
    public void onMapReady(GoogleMap googleMap) 
        mGoogleMap = googleMap;
        mGoogleMap.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() 
            @Override
            public void onMapLoaded() 
                List<LatLng> sourcePoints = new ArrayList<>();
                PolylineOptions polyLineOptions;
                LatLng carPos;

                sourcePoints.add(new LatLng(-35.27801,149.12958));
                sourcePoints.add(new LatLng(-35.28032,149.12907));
                sourcePoints.add(new LatLng(-35.28099,149.12929));
                sourcePoints.add(new LatLng(-35.28144,149.12984));
                sourcePoints.add(new LatLng(-35.28194,149.13003));
                sourcePoints.add(new LatLng(-35.28282,149.12956));
                sourcePoints.add(new LatLng(-35.28302,149.12881));
                sourcePoints.add(new LatLng(-35.28473,149.12836));

                polyLineOptions = new PolylineOptions();
                polyLineOptions.addAll(sourcePoints);
                polyLineOptions.width(10);
                polyLineOptions.color(Color.BLUE);
                mGoogleMap.addPolyline(polyLineOptions);

                carPos = new LatLng(-35.281120, 149.129721);
                addMarker(carPos);
                mGoogleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(sourcePoints.get(0), 15));

                for (int i = 0; i < sourcePoints.size() - 1; i++) 
                    LatLng segmentP1 = sourcePoints.get(i);
                    LatLng segmentP2 = sourcePoints.get(i+1);
                    List<LatLng> segment = new ArrayList<>(2);
                    segment.add(segmentP1);
                    segment.add(segmentP2);

                    if (PolyUtil.isLocationOnPath(carPos, segment, true, 30)) 
                        polyLineOptions = new PolylineOptions();
                        polyLineOptions.addAll(segment);
                        polyLineOptions.width(10);
                        polyLineOptions.color(Color.RED);
                        mGoogleMap.addPolyline(polyLineOptions);
                        LatLng snappedToSegment = getMarkerProjectionOnSegment(carPos, segment, mGoogleMap.getProjection());
                        addMarker(snappedToSegment);
                        break;
                    
                
            
        );
        mGoogleMap.animateCamera(CameraUpdateFactory.newLatLngZoom(sourcePoints.get(0), 15));
    

    private LatLng getMarkerProjectionOnSegment(LatLng carPos, List<LatLng> segment, Projection projection) 
        LatLng markerProjection = null;

        Point carPosOnScreen = projection.toScreenLocation(carPos);
        Point p1 = projection.toScreenLocation(segment.get(0));
        Point p2 = projection.toScreenLocation(segment.get(1));
        Point carPosOnSegment = new Point();

        float denominator = (p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y);
        // p1 and p2 are the same
        if (Math.abs(denominator) <= 1E-10) 
            markerProjection = segment.get(0);
         else 
            float t = (carPosOnScreen.x * (p2.x - p1.x) - (p2.x - p1.x) * p1.x
                    + carPosOnScreen.y * (p2.y - p1.y) - (p2.y - p1.y) * p1.y) / denominator;
            carPosOnSegment.x = (int) (p1.x + (p2.x - p1.x) * t);
            carPosOnSegment.y = (int) (p1.y + (p2.y - p1.y) * t);
            markerProjection = projection.fromScreenLocation(carPosOnSegment);
            
        return markerProjection;
    

    public void addMarker(LatLng latLng) 
        mGoogleMap.addMarker(new MarkerOptions()
                .position(latLng)
        );
    

你会得到类似的东西：

但更好的方法是计算从路径起点的汽车距离并通过SphericalUtil.interpolate() 找到它在路径上的位置，因为如果多个路径段彼此靠近（例如在同一道路的不同车道上），就像这样：

到当前汽车位置可能是最接近“错误”的路段。因此，计算汽车距离路线起点的距离，并使用SphericalUtil.interpolate() 确定路径上的准确点。

【讨论】：

抱歉回复晚了，被其他工作冲昏了头脑，是的，一定会试试这个，会让你知道的。谢谢:)

只有一个疑问，捕捉到最近段的标记是否可定制？我问的原因是，在开始到路线的过程中，汽车的位置可能不在折线附近，汽车可能需要行驶大约 500 米或 1 公里才能到达路线路径（折线）

@Sanoop 30 in PolyUtil.isLocationOnPath(carPos, segment, true, 30); 行是检测“最近”段的最大距离（以米为单位）。因此，如果当前汽车位置距离路径小于 30 米，则将找到“最近”段。折线。在其他情况下，任何折线段都有 o 投影。

似乎该解决方案对我有用。非常感谢:)

在尝试实施 SphericalUtil.interpolate() 解决方案数小时后，我发现“分数”是线段起点与当前位置之间的距离除以线段长度。它比地图投影的解决方案效果更好，但它并不总是有助于避免平行道路的问题，因为如果 isLocationOnPath() 方法为错误的路段返回“true”，插值仍然会不正确。解决方案是对 isLocationOnPath() 方法使用较小的容差

【参考方案2】：

我知道这个问题很老了，但以防万一有人需要它，添加到 Andrii Omelchenko 的答案中，这是您可以使用 SphericalUtil.interpolate() 准确找到片段上的点的一种方式：

private LatLng getMarkerProjectionOnSegment(LatLng carPos, List<LatLng> segment, Projection projection) 
        Point a = projection.toScreenLocation(segment.get(0));
        Point b = projection.toScreenLocation(segment.get(1));
        Point p = projection.toScreenLocation(carPos);

        if(a.equals(b.x, b.y)) return segment.get(0); // Projected points are the same, segment is very short
        if(p.equals(a.x, a.y) || p.equals(b.x, b.y)) return carPos;

        /*
        If you're interested in the math (d represents point on segment you are trying to find):
        
        angle between 2 vectors = inverse cos of (dotproduct of 2 vectors / product of the magnitudes of each vector)
        angle = arccos(ab.ap/|ab|*|ap|)
        ad magnitude = magnitude of vector ap multiplied by cos of (angle).
        ad = ap*cos(angle) --> basic trig adj = hyp * cos(opp)
        below implementation is just a simplification of these equations
         */

        float dotproduct = ((b.x-a.x)*(p.x-a.x)) + ((b.y-a.y)*(p.y-a.y));
        float absquared = (float) (Math.pow(a.x-b.x, 2) + Math.pow(a.y-b.y, 2)); // Segment magnitude squared

        // Get the fraction for SphericalUtil.interpolate
        float fraction = dotproduct / absquared;

        if(fraction > 1) return segment.get(1);
        if(fraction < 0) return segment.get(0);
        return SphericalUtil.interpolate(segment.get(0), segment.get(1), fraction);