已知两地理坐标及间距，如何获取直线上每隔3米的点？

Hey there! I totally get your frustration—converting JavaScript geographic code to C# can trip you up if you don’t account for small differences in math handling or coordinate logic. Let’s fix this by building a reliable C# solution that generates accurate points every 3 meters along the line between your two points A and B (using the known distance D).

Important Background #

First, a critical note: geographic coordinates (lat/lon) live on a spherical Earth, so you can’t just linearly interpolate latitude and longitude values directly. That’s probably why your initial conversion was off—we need to use spherical trigonometry to calculate each 3-meter step correctly.

Step-by-Step C# Solution #

Here’s a complete implementation with clear explanations:

1. Define a Coordinate Class #

Let’s start with a simple class to hold latitude and longitude values (in decimal degrees, the standard format for geographic data):

public class Coordinate
{
    public double Latitude { get; set; } // In decimal degrees
    public double Longitude { get; set; } // In decimal degrees

    public Coordinate(double lat, double lon)
    {
        Latitude = lat;
        Longitude = lon;
    }

    public override string ToString()
    {
        return $"Lat: {Latitude:F6}, Lon: {Longitude:F6}";
    }
}

2. Core Geographic Calculation Methods #

We’ll need helper methods to handle unit conversions, bearing calculation (direction from A to B), and destination point calculation for each 3-meter step.

public static class GeographicCalculator
{
    private const double EarthRadiusMeters = 6371000; // Average Earth radius in meters

    // Convert degrees to radians (required for C# Math library functions)
    public static double ToRadians(double degrees)
    {
        return degrees * Math.PI / 180;
    }

    // Convert radians back to degrees
    public static double ToDegrees(double radians)
    {
        return radians * 180 / Math.PI;
    }

    // Calculate the bearing (direction) from point A to point B (in radians)
    public static double CalculateBearing(Coordinate start, Coordinate end)
    {
        var startLatRad = ToRadians(start.Latitude);
        var startLonRad = ToRadians(start.Longitude);
        var endLatRad = ToRadians(end.Latitude);
        var endLonRad = ToRadians(end.Longitude);

        var deltaLon = endLonRad - startLonRad;

        var y = Math.Sin(deltaLon) * Math.Cos(endLatRad);
        var x = Math.Cos(startLatRad) * Math.Sin(endLatRad) -
                Math.Sin(startLatRad) * Math.Cos(endLatRad) * Math.Cos(deltaLon);

        var bearingRad = Math.Atan2(y, x);
        // Normalize bearing to 0-2π radians (0-360 degrees)
        bearingRad = (bearingRad + 2 * Math.PI) % (2 * Math.PI);

        return bearingRad;
    }

    // Calculate a destination point given a start point, bearing, and distance (meters)
    public static Coordinate CalculateDestinationPoint(Coordinate start, double bearingRad, double distanceMeters)
    {
        var startLatRad = ToRadians(start.Latitude);
        var startLonRad = ToRadians(start.Longitude);

        var angularDistance = distanceMeters / EarthRadiusMeters;

        var destLatRad = Math.Asin(Math.Sin(startLatRad) * Math.Cos(angularDistance) +
                                   Math.Cos(startLatRad) * Math.Sin(angularDistance) * Math.Cos(bearingRad));

        var destLonRad = startLonRad + Math.Atan2(Math.Sin(bearingRad) * Math.Sin(angularDistance) * Math.Cos(startLatRad),
                                                  Math.Cos(angularDistance) - Math.Sin(startLatRad) * Math.Sin(destLatRad));

        // Normalize longitude to -180 to 180 degrees
        destLonRad = (destLonRad + 3 * Math.PI) % (2 * Math.PI) - Math.PI;

        return new Coordinate(ToDegrees(destLatRad), ToDegrees(destLonRad));
    }

    // Generate all points every 3 meters along the line from start to end
    public static List<Coordinate> GenerateIntervalPoints(Coordinate start, Coordinate end, double totalDistanceMeters)
    {
        var points = new List<Coordinate>();
        points.Add(start); // Add starting point A

        var bearing = CalculateBearing(start, end);
        const double interval = 3.0; // 3-meter step size

        // Calculate how many full 3-meter steps fit in the total distance
        int numberOfSteps = (int)Math.Floor(totalDistanceMeters / interval);

        for (int i = 1; i <= numberOfSteps; i++)
        {
            double distance = i * interval;
            var point = CalculateDestinationPoint(start, bearing, distance);
            points.Add(point);
        }

        // Optional: Add end point B if total distance isn't a perfect multiple of 3
        if (totalDistanceMeters % interval != 0)
        {
            points.Add(end);
        }

        return points;
    }
}

3. How to Use the Code #

Here’s an example of calling the method with sample coordinates and a known distance:

public static void Main()
{
    // Replace these with your actual A and B coordinates
    var pointA = new Coordinate(40.7128, -74.0060); // New York City
    var pointB = new Coordinate(40.7308, -73.9976); // Nearby point
    double totalDistanceD = 200; // Known distance in meters (replace with your D)

    var intervalPoints = GeographicCalculator.GenerateIntervalPoints(pointA, pointB, totalDistanceD);

    Console.WriteLine("Generated points every 3 meters:");
    foreach (var point in intervalPoints)
    {
        Console.WriteLine(point);
    }
}

Why This Works #

• We use spherical trigonometry (derived from the Haversine formula) to account for Earth’s curvature, ensuring each 3-meter step is accurate.
• The bearing calculation ensures we follow the shortest great-circle path between A and B.
• Normalizing longitude and bearing values prevents invalid coordinate ranges (like longitude outside -180 to 180 degrees).

Troubleshooting Tips #

• Double-check that your input coordinates are in decimal degrees (not degrees-minutes-seconds).
• Ensure your total distance D is in meters (the code uses meters for all distance calculations).
• If you see small discrepancies, verify the Earth radius value matches your original JavaScript code (some implementations use 6378137 for equatorial radius—adjust EarthRadiusMeters if needed).

内容的提问来源于stack exchange，提问作者Manish Jain