.NET: Reverse Geocode

Being online is not required as it is with most reverse geocoding API, plus there is no need to pay a service.

To minimize memory usage, use only the service required. the time zone database is the largest and requires the most memory.

Note: this code was inspired by GeoTimeZone originally written by Matt Johnson-Pint and Simon Bartlett.

Download these files including the compiled assembly and geocode data files: REVERSEGEOCODE.zip.

Example usage:

using ReverseGeocode;

string ReverseGeo(double lat, double lng)
{
	var co = CountryLookup.GetCountry(lat, lng);
	return lat.ToString().PadRight(12, ' ') + ' ' + lng.ToString().PadRight(12, ' ') + ' ' + (co == null ? "Nearest: " + CountryLookup.GetNearestCountry(lat, lng) : (co == "United States of America" ? co + " (" + UsStateLookup.GetUsState(lat,lng) + ')' : (co == "Canada" ? co + " (" + CaProvinceLookup.GetCaProvince(lat, lng) + ')' : co))).PadRight(50, ' ') + TimeZoneLookup.GetTimeZone(lat, lng)?.Result;
}


while (true)
{
    Console.Write("Enter Lat:");
    string _lat = Console.ReadLine() ?? "0";
    Console.Write("Enter Lng:");
    string _lng = Console.ReadLine() ?? "0";
    Console.WriteLine(ReverseGeo(double.Parse(_lat), double.Parse(_lng)));
}




// (49, -124)               // Canada
// (48.287043, -124.581337) // United States of America
// (34.034145, 65.964733)   // Islamic State of Afghanistan
// (50.449864, -105.077861) // Canada
// (30, -97)                // United States of America
// (10, -50)                // French Republic
// (-30, -50)               // Federative Republic of Brazil
// (20, -100)               // United Mexican States
// (-15, 75)                // Democratic Socialist Republic of Sri Lanka
// (10.243853, -61.148837)  // Republic of Trinidad and Tobago
// (57.229295, -101.879814) // Canada

Now, the class files for the assembly:

// CountryLookup.cs

using System.IO.Compression;

namespace ReverseGeocode;

/// <summary>
/// Provides the country lookup functionality.
/// </summary>
public static class CountryLookup
{
	internal class Properties
	{
		public string? formal_en { get; set; }
		public string? name_sort { get; set; }
	}
	internal class Geometry
	{
		public List<List<double[]>> coordinates { get; set; }
	}
	internal class Country
	{
		public Properties properties { get; set; }
		public Geometry geometry { get; set; }
	}
	internal class Find
	{
		public string? name;
		public double proximity;
	}

	private static readonly Lazy<List<Country>> LazyData = new(LoadData);

	private static List<Country> LoadData()
	{
		var assembly = typeof(CountryLookup).Assembly;
		using var compressedStream = assembly.GetManifestResourceStream("ReverseGeocode.COUNTRIES.json.gz");
		using var stream = new GZipStream(compressedStream!, CompressionMode.Decompress);

		using (var ms = new MemoryStream())
		{
			stream.CopyTo(ms);
			ms.Seek(0, SeekOrigin.Begin);
			return System.Text.Json.JsonSerializer.Deserialize<List<Country>>(System.Text.Encoding.UTF8.GetString(ms.ToArray())) ?? new List<Country>();
		}
	}

    private static string? FormatCountryName(Country country)
    {
        if (country.properties.formal_en != null && country.properties.name_sort != null && country.properties.formal_en != country.properties.name_sort)
            return country.properties.formal_en + '/' + country.properties.name_sort;
        else
            return country.properties.formal_en ?? country.properties.name_sort;

    }
    
	/// <summary>
    /// Determines the country for given location coordinates.
    /// </summary>
    /// <param name="latitude">The latitude of the location.</param>
    /// <param name="longitude">The longitude of the location.</param>
    /// <returns>A <string?>, which contains the result of the operation or null if not found.</returns>
    public static string? GetCountry(double latitude, double longitude)
	{
		var p = new double[2] { latitude, longitude };
		foreach (var country in LazyData.Value)
		{
			foreach (var list in country.geometry.coordinates)
			{
				if (Common.IsCoordInsideArrayOfCoords(list, p))
					return FormatCountryName(country);
			}
		}
		return null;
	}

	/// <summary>
	/// Determines the nearest country for given location coordinates.
	/// </summary>
	/// <param name="latitude">The latitude of the location.</param>
	/// <param name="longitude">The longitude of the location.</param>
	/// <returns>A <string>, which contains the result of the operation.</returns>
	public static string GetNearestCountry(double latitude, double longitude)
	{
		var finds = new List<Find>();
		foreach (var country in LazyData.Value)
		{
			foreach (var list in country.geometry.coordinates)
			{
				foreach (var coords in list)
					finds.Add(new Find { name = FormatCountryName(country), proximity = (coords[0] - latitude) * (coords[0] - latitude) + (coords[1] - longitude) * (coords[1] - longitude) });
			}
		}
		var find = finds.OrderBy(x => x.proximity).First();
		return find.name ?? "n/a";
	}
}

// UsStateLookup.cs

using System.IO.Compression;

namespace ReverseGeocode;

/// <summary>
/// Provides the US state lookup functionality.
/// </summary>
public static class UsStateLookup
{
	internal class Geometry
	{
		public List<List<double[]>> coordinates { get; set; }
	}
	internal class UsState
	{
		public string name { get; set; }
		public Geometry geometry { get; set; }
	}

	private static readonly Lazy<List<UsState>> LazyData = new(LoadData);

	private static List<UsState> LoadData()
	{
		var assembly = typeof(UsStateLookup).Assembly;
		using var compressedStream = assembly.GetManifestResourceStream("ReverseGeocode.USSTATES.json.gz");
		using var stream = new GZipStream(compressedStream!, CompressionMode.Decompress);

		using (var ms = new MemoryStream())
		{
			stream.CopyTo(ms);
			ms.Seek(0, SeekOrigin.Begin);
			return System.Text.Json.JsonSerializer.Deserialize<List<UsState>>(System.Text.Encoding.UTF8.GetString(ms.ToArray())) ?? new List<UsState>();
		}
	}

	/// <summary>
	/// Determines the US state for given location coordinates.
	/// </summary>
	/// <param name="latitude">The latitude of the location.</param>
	/// <param name="longitude">The longitude of the location.</param>
	/// <returns>A <string?>, which contains the result of the operation or null if not found.</returns>
	public static string? GetUsState(double latitude, double longitude)
	{
		var p = new double[2] { latitude, longitude };
		foreach (var state in LazyData.Value)
		{
			foreach (var list in state.geometry.coordinates)
			{
				if (Common.IsCoordInsideArrayOfCoords(list, p))
					return state.name;
			}
		}
		return null;
	}
}

// CaProvinceLookup.cs

using System.IO.Compression;

namespace ReverseGeocode;

/// <summary>
/// Provides the Canadian province lookup functionality.
/// </summary>
public static class CaProvinceLookup
{
	internal class Geometry
	{
		public List<List<double[]>> coordinates { get; set; }
	}
	internal class CaProvince
	{
        public string name_en { get; set; }
        public string prov_type { get; set; }
        public Geometry geometry { get; set; }
	}

	private static readonly Lazy<List<CaProvince>> LazyData = new(LoadData);

	private static List<CaProvince> LoadData()
	{
		var assembly = typeof(CaProvinceLookup).Assembly;
		using var compressedStream = assembly.GetManifestResourceStream("ReverseGeocode.CAPROVINCES.json.gz");
		using var stream = new GZipStream(compressedStream!, CompressionMode.Decompress);

		using (var ms = new MemoryStream())
		{
			stream.CopyTo(ms);
			ms.Seek(0, SeekOrigin.Begin);
			return System.Text.Json.JsonSerializer.Deserialize<List<CaProvince>>(System.Text.Encoding.UTF8.GetString(ms.ToArray())) ?? new List<CaProvince>();
		}
	}

	/// <summary>
	/// Determines the Canadian province/territory for given location coordinates.
	/// </summary>
	/// <param name="latitude">The latitude of the location.</param>
	/// <param name="longitude">The longitude of the location.</param>
	/// <returns>A <string?>, which contains the result of the operation or null if not found.</returns>
	public static string? GetCaProvince(double latitude, double longitude)
	{
		var p = new double[2] { latitude, longitude };
		foreach (var state in LazyData.Value)
		{
			foreach (var list in state.geometry.coordinates)
			{
				if (Common.IsCoordInsideArrayOfCoords(list, p))
					return state.name_en;
			}
		}
		return null;
	}
}

// Geohash.cs

namespace ReverseGeocode;

internal static class Geohash
{
    internal const int Precision = 5;
    
    private const string Base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
    private static readonly int[] Bits = {16, 8, 4, 2, 1};

    public static void Encode(double latitude, double longitude, Span<byte> geohash)
    {
        var even = true;
        var bit = 0;
        var ch = 0;
        var length = 0;

        Span<double> lat = stackalloc[] {-90.0, 90.0};
        Span<double> lon = stackalloc[] {-180.0, 180.0};

        while (length < Precision)
        {
            if (even)
            {
                var mid = (lon[0] + lon[1]) / 2;
                if (longitude > mid)
                {
                    ch |= Bits[bit];
                    lon[0] = mid;
                }
                else
                {
                    lon[1] = mid;
                }
            }
            else
            {
                var mid = (lat[0] + lat[1]) / 2;
                if (latitude > mid)
                {
                    ch |= Bits[bit];
                    lat[0] = mid;
                }
                else
                {
                    lat[1] = mid;
                }
            }

            even = !even;

            if (bit < 4)
            {
                bit++;
            }
            else
            {
                geohash[length] = (byte) Base32[ch];
                length++;
                bit = 0;
                ch = 0;
            }
        }
    }
}

// TimezoneFileReader.cs

using System.IO.Compression;

namespace ReverseGeocode;

internal static class TimezoneFileReader
{
    private const int LineLength = 8;
    private const int LineEndLength = 1;

    private static readonly Lazy<MemoryStream> LazyData = new(LoadData);
    private static readonly Lazy<int> LazyCount = new(GetCount);


	private static MemoryStream LoadData()
    {
        var assembly = typeof(TimezoneFileReader).Assembly;
        using var compressedStream = assembly.GetManifestResourceStream("ReverseGeocode.TZ.txt.gz");
        using var stream = new GZipStream(compressedStream!, CompressionMode.Decompress);

        var ms = new MemoryStream();
        stream.CopyTo(ms);
        ms.Seek(0, SeekOrigin.Begin);
        return ms;
    }

    private static int GetCount() => (int) (LazyData.Value.Length / (LineLength + LineEndLength));

    public static int Count => LazyCount.Value;

    public static ReadOnlySpan<byte> GetGeohash(int line) => GetLine(line, 0, Geohash.Precision);

    public static int GetLineNumber(int line)
    {
        var digits = GetLine(line, Geohash.Precision, LineLength - Geohash.Precision);
        return GetDigit(digits[2]) + ((GetDigit(digits[1]) + (GetDigit(digits[0]) * 10)) * 10);
    }

    private static int GetDigit(byte b) => b - '0';

    private static ReadOnlySpan<byte> GetLine(int line, int start, int count)
    {
        var index = ((LineLength + LineEndLength) * (line - 1)) + start;
        var stream = LazyData.Value;

        return new ReadOnlySpan<byte>(stream.GetBuffer(), index, count);
    }
}

// TimeZoneLookup.cs

using System.IO.Compression;

namespace ReverseGeocode;

/// <summary>
/// Provides the time zone lookup functionality.
/// </summary>
public static class TimeZoneLookup
{
    /// <summary>
    /// Determines the IANA time zone for given location coordinates.
    /// </summary>
    /// <param name="latitude">The latitude of the location.</param>
    /// <param name="longitude">The longitude of the location.</param>
    /// <returns>A <see cref="TimeZoneResult"/> object, which contains the result(s) of the operation.</returns>
    public static TimeZoneResult GetTimeZone(double latitude, double longitude)
    {

        Span<byte> geohash = stackalloc byte[Geohash.Precision];

        Geohash.Encode(latitude, longitude, geohash);

        var lineNumbers = GetTzDataLineNumbers(geohash);
        if (lineNumbers.Length != 0)
        {
            var timeZones = GetTimeZonesFromData(lineNumbers);
            return new TimeZoneResult(timeZones);
        }

        var offsetHours = CalculateOffsetHoursFromLongitude(longitude);
        return new TimeZoneResult(GetTimeZoneId(offsetHours));
    }
    
    private static int[] GetTzDataLineNumbers(ReadOnlySpan<byte> geohash)
    {
        var seeked = SeekTimeZoneFile(geohash);
        if (seeked == 0)
            return Array.Empty<int>();

        int min = seeked, max = seeked;
        var seekedGeohash = TimezoneFileReader.GetGeohash(seeked);

        while (true)
        {
            var prevGeohash = TimezoneFileReader.GetGeohash(min - 1);
            if (GeohashEquals(seekedGeohash, prevGeohash))
                min--;
            else
                break;
        }

        while (true)
        {
            var nextGeohash = TimezoneFileReader.GetGeohash(max + 1);
            if (GeohashEquals(seekedGeohash, nextGeohash))
                max++;
            else
                break;
        }

        var lineNumbers = new int[max - min + 1];
        for (var i = 0; i < lineNumbers.Length; i++)
            lineNumbers[i] = TimezoneFileReader.GetLineNumber(i + min);

        return lineNumbers;
    }

    private static bool GeohashEquals (ReadOnlySpan<byte> a, ReadOnlySpan<byte> b)
    {
        var equals = true;
        for (var i = Geohash.Precision - 1; i >= 0; i--)
            equals &= a[i] == b[i];

        return equals;
    }
    
    private static int SeekTimeZoneFile(ReadOnlySpan<byte> hash)
    {
        var min = 1;
        var max = TimezoneFileReader.Count;
        var converged = false;

        while (true)
        {
            var mid = ((max - min) / 2) + min;
            var midLine = TimezoneFileReader.GetGeohash(mid);

            for (var i = 0; i < hash.Length; i++)
            {
                if (midLine[i] == '-')
                    return mid;

                if (midLine[i] > hash[i])
                {
                    max = mid == max ? min : mid;
                    break;
                }

                if (midLine[i] < hash[i])
                {
                    min = mid == min ? max : mid;
                    break;
                }

                if (i == 4)
                    return mid;

                if (min == mid)
                {
                    min = max;
                    break;
                }
            }

            if (min == max)
            {
                if (converged)
                    break;

                converged = true;
            }
        }

        return 0;
    }

    private static readonly Lazy<IList<string>> LookupData = new(LoadLookupData);

    private static IList<string> LoadLookupData()
    {
        var assembly = typeof(TimeZoneLookup).Assembly;
        using var compressedStream = assembly.GetManifestResourceStream("ReverseGeocode.TZL.txt.gz");
        using var stream = new GZipStream(compressedStream!, CompressionMode.Decompress);
		using var reader = new StreamReader(stream);

        var list = new List<string>();
        while (reader.ReadLine() is { } line)
            list.Add(line);

        return list;
    }

    private static List<string> GetTimeZonesFromData(int[] lineNumbers)
    {
        var lookupData = LookupData.Value;
        var timezones = new List<string>(lineNumbers.Length);
        Array.Sort(lineNumbers);

        foreach (var lineNumber in lineNumbers)
            timezones.Add(lookupData[lineNumber - 1]);

        return timezones;
    }

    private static int CalculateOffsetHoursFromLongitude(double longitude)
    {
        var dir = longitude < 0 ? -1 : 1;
        var posNo = Math.Abs(longitude);
        if (posNo <= 7.5)
            return 0;

        posNo -= 7.5;
        var offset = posNo / 15;
        if (posNo % 15 > 0)
        {
            offset++;
        }

        return dir * (int) Math.Floor(offset);
    }

    private static string GetTimeZoneId(int offsetHours)
    {
        if (offsetHours == 0)
            return "UTC";

        var reversed = (offsetHours >= 0 ? "-" : "+") + Math.Abs(offsetHours);
        return "Etc/GMT" + reversed;
    }
}

// TimeZoneResult.cs

using System.Collections.ObjectModel;

namespace ReverseGeocode;

/// <summary>
/// Contains the result of a time zone lookup operation.
/// </summary>
public class TimeZoneResult
{
    internal TimeZoneResult(List<string> timeZones)
    {
        Result = timeZones[0];
        AlternativeResults = new ReadOnlyCollection<string>(timeZones.GetRange(1, timeZones.Count - 1));
    }

    internal TimeZoneResult(string timeZone)
    {
        Result = timeZone;
        AlternativeResults = new ReadOnlyCollection<string>(new List<string>());
    }

    /// <summary>
    /// Gets the primary result of the time zone lookup operation.
    /// </summary>
    public string Result { get; }

    /// <summary>
    /// Gets any alternative results of the time zone lookup operation.
    /// This usually happens very close to borders between time zones.
    /// </summary>
    public ReadOnlyCollection<string> AlternativeResults { get; }
}

// Common.cs

namespace ReverseGeocode;

public class Common
{
	public static bool IsCoordInsideArrayOfCoords(List<double[]> polygon, double[] p)
	{
		int counter = 0;
		int i, N = polygon.Count;
		double xinters;
		double[] p1, p2;
		const int x = 0, y = 1;

		p1 = polygon[0];
		for (i = 1; i <= N; i++)
		{
			p2 = polygon[i % N];
			if (p[y] > Math.Min(p1[y], p2[y]))
			{
				if (p[y] <= Math.Max(p1[y], p2[y]))
				{
					if (p[x] <= Math.Max(p1[x], p2[x]))
					{
						if (p1[y] != p2[y])
						{
							xinters = (p[y] - p1[y]) * (p2[x] - p1[x]) / (p2[y] - p1[y]) + p1[x];
							if (p1[x] == p2[x] || p[x] <= xinters)
								counter++;
						}
					}
				}
			}
			p1 = p2;
		}

		return (counter % 2 != 0);
	}
}

Comment