/// <summary>
/// Calculates the elevation of a point using a preloaded data, using intepolation of 3 points in a plane:
/// 3
/// | p
/// |
/// 1______2
/// </summary>
/// <param name="latLng">The point to calculate elevation for</param>
/// <returns>A task with the elevation results</returns>
public async Task <double> GetElevation(Coordinate latLng)
{
var key = new Coordinate(Math.Floor(latLng.X), Math.Floor(latLng.Y));
if (_initializationTaskPerLatLng.ContainsKey(key) == false)
{
return(0);
}
await _initializationTaskPerLatLng[key];
if (_elevationData.ContainsKey(key) == false)
{
return(0);
}
var array = _elevationData[key];
var lat = (array.GetLength(0) - 1) - Math.Abs(latLng.Y - key.Y) * array.GetLength(0);
var lng = Math.Abs(latLng.X - key.X) * array.GetLength(1);
if ((lat >= array.GetLength(0) - 1) || (lng >= array.GetLength(1) - 1))
{
return(array[(int)lat, (int)lng]);
}
var coordinate1 = new CoordinateZ((int)lng, (int)lat, array[(int)lat, (int)lng]);
var coordinate2 = new CoordinateZ((int)lng + 1, (int)lat, array[(int)lat, (int)lng + 1]);
var coordinate3 = new CoordinateZ((int)lng, (int)lat + 1, array[(int)lat + 1, (int)lng]);
return(Vertex.InterpolateZ(new Coordinate(lng, lat), coordinate1, coordinate2, coordinate3));
}
// see: https://github.com/NetTopologySuite/NetTopologySuite/issues/111
public void issue_111_polygonhandler_with_invalid_values()
{
var factory = GeometryFactory.Default;
var points = new Coordinate[5];
points[0] = new CoordinateZ(0, 0);
points[1] = new CoordinateZ(1, 0);
points[2] = new CoordinateZ(1, 1);
points[3] = new CoordinateZ(0, 1);
points[4] = new CoordinateZ(0, 0);
var poly = factory.CreatePolygon(points);
var mpoly = factory.CreateMultiPolygon(new[] { poly });
Geometry[] arr = new[] { mpoly, GeometryCollection.Empty };
var geometries = factory.CreateGeometryCollection(arr);
var shapeType = Shapefile.GetShapeType(geometries);
Assert.AreEqual(ShapeGeometryType.PolygonZM, shapeType);
string tempPath = Path.GetTempFileName();
var sfw = new ShapefileWriter(Path.GetFileNameWithoutExtension(tempPath), shapeType);
Assert.Throws <ArgumentException>(() => sfw.Write(geometries));
}
public void TestToString()
{
const string expectedResult = "(100, 200, 50)";
string actualResult = new CoordinateZ(100, 200, 50).ToString();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestEqualsInZ()
{
var c = new CoordinateZ(100.0, 200.0, 50.0);
var withSameZ = new CoordinateZ(100.1, 200.1, 50.1);
Assert.IsTrue(c.EqualInZ(withSameZ, 0.2));
}
private bool TryParseCoordinate(JsonArray coordinates, out Coordinate result)
{
result = null;
if (coordinates == null || coordinates.Count < 2)
{
return(false);
}
var valid = coordinates.All(x => x is double || x is long);
if (!valid)
{
return(false);
}
if (coordinates.Count == 2)
{
result = new Coordinate(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]));
}
else if (coordinates.Count == 3)
{
result = new CoordinateZ(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]), Convert.ToDouble(coordinates[2]));
}
else
{
result = new CoordinateZM(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]), Convert.ToDouble(coordinates[2]), Convert.ToDouble(coordinates[3]));
}
return(true);
}
public void TestEquals2DWithinTolerance()
{
var c = new CoordinateZ(100.0, 200.0, 50.0);
var aBitOff = new CoordinateZ(100.1, 200.1, 50.0);
Assert.IsTrue(c.Equals2D(aBitOff, 0.2));
}
public async Task <List <Feature> > GetByBoundingBox(Coordinate sourthWest, Coordinate northEast, string language)
{
for (int retryIndex = 0; retryIndex < 3; retryIndex++)
{
try
{
var geoSearchGenerator = new GeoSearchGenerator(_wikiSites[language])
{
BoundingRectangle = GeoCoordinateRectangle.FromBoundingCoordinates(sourthWest.X, sourthWest.Y, northEast.X, northEast.Y),
PaginationSize = 500
};
var results = await geoSearchGenerator.EnumItemsAsync().ToListAsync();
var features = new List <Feature>();
foreach (var geoSearchResultItem in results)
{
var coordinate = new CoordinateZ(geoSearchResultItem.Coordinate.Longitude, geoSearchResultItem.Coordinate.Latitude);
var attributes = GetAttributes(coordinate, geoSearchResultItem.Page.Title,
geoSearchResultItem.Page.Id.ToString(), language);
features.Add(new Feature(new Point(coordinate), attributes));
}
return(features);
}
catch
{
// this is used since this function throws an unrelated timeout error...
}
}
_logger.LogError($"All Retries failed while trying to get data from {language}.wikipedia");
return(new List <Feature>());
}
public void LineString3D()
{
const int size = 10;
var points = new Coordinate[size];
for (int i = 0; i < size; i++)
{
// just some arbitrary values
points[i] = new CoordinateZ(100 * Math.Sin(i), 200 * Math.Cos(i), 300 * Math.Tan(i));
}
var source = new LineString(points);
var pgWriter = new PostGisWriter()
{
HandleOrdinates = Ordinates.XYZ
};
byte[] bytes = pgWriter.Write(source);
var target = (LineString) new PostGisReader().Read(bytes);
for (int i = 0; i < size; i++)
{
Assert.AreEqual(source.Coordinates[i].X, target.Coordinates[i].X);
Assert.AreEqual(source.Coordinates[i].Y, target.Coordinates[i].Y);
Assert.AreEqual(source.Coordinates[i].Z, target.Coordinates[i].Z);
}
}
public void TestClone()
{
var c = new CoordinateZ(100.0, 200.0, 50.0);
var clone = (CoordinateZ)c.Copy();
Assert.IsTrue(c.Equals3D(clone));
}
/// <summary>
/// Initializes a new instance of the <see cref="Vector"/> class where the X, Y and Z terms are the same as the specified coordinate.
/// </summary>
/// <param name="coord">The ICoordinate to use.</param>
public Vector(CoordinateZ coord)
{
X = coord.X;
Y = coord.Y;
Z = coord.Z;
RemoveNan();
}
public void TestDistance3D()
{
var coord1 = new CoordinateZ(0.0, 0.0, 0.0);
var coord2 = new CoordinateZ(100.0, 200.0, 50.0);
double distance = coord1.Distance3D(coord2);
Assert.AreEqual(229.128784747792, distance, 0.000001);
}
public void TestGetOrdinate()
{
var c = new CoordinateZ(350.2, 4566.8, 5266.3);
Assert.AreEqual(c[Ordinate.X], 350.2);
Assert.AreEqual(c[Ordinate.Y], 4566.8);
Assert.AreEqual(c[Ordinate.Z], 5266.3);
}
public void TestDistance()
{
var coord1 = new CoordinateZ(0.0, 0.0, 0.0);
var coord2 = new CoordinateZ(100.0, 200.0, 50.0);
double distance = coord1.Distance(coord2);
Assert.AreEqual(distance, 223.60679774997897, 0.00001);
}
public void TestConstructor2D()
{
var c = new CoordinateZ(350.2, 4566.8);
Assert.AreEqual(c.X, 350.2);
Assert.AreEqual(c.Y, 4566.8);
Assert.AreEqual(c.Z, Coordinate.NullOrdinate);
}
public void TestDefaultConstructor()
{
var c = new CoordinateZ();
Assert.AreEqual(c.X, 0.0);
Assert.AreEqual(c.Y, 0.0);
Assert.AreEqual(c.Z, Coordinate.NullOrdinate);
}
public void TestConstructor3D()
{
var c = new CoordinateZ(350.2, 4566.8, 5266.3);
Assert.AreEqual(c.X, 350.2);
Assert.AreEqual(c.Y, 4566.8);
Assert.AreEqual(c.Z, 5266.3);
}
/// <summary>
/// Computes the normal vector to the triangle p0-p1-p2. In order to compute the normal each
/// triangle coordinate must have a Z value. If this is not the case, the returned Coordinate
/// will have NaN values. The returned vector has unit length.
/// </summary>
/// <param name="p0">A point</param>
/// <param name="p1">A point</param>
/// <param name="p2">A point</param>
/// <returns>The normal vector to the triangle <paramref name="p0"/>-<paramref name="p1"/>-<paramref name="p2"/></returns>
public static Coordinate NormalToTriangle(Coordinate p0, Coordinate p1, Coordinate p2)
{
var v1 = new CoordinateZ(p1.X - p0.X, p1.Y - p0.Y, p1.Z - p0.Z);
var v2 = new CoordinateZ(p2.X - p0.X, p2.Y - p0.Y, p2.Z - p0.Z);
var cp = CrossProduct(v1, v2);
Normalize(cp);
return(cp);
}
public virtual void New_pointZ_should_be_written()
{
var coord = new CoordinateZ(11.11, 22.22, 33.33);
var point = GeometryFactory.Default.CreatePoint(coord);
DoTest(conn =>
{
using (var cmd = conn.CreateCommand())
{
const string sql = @"
DELETE FROM [sample_feature_table_z];
INSERT INTO [sample_feature_table_z] ([id], [geometry])
VALUES (1, @pbytes);";
cmd.CommandText = sql;
var writer = new GeoPackageGeoWriter
{
HandleOrdinates = Ordinates.XYZ
};
byte[] bytes = writer.Write(point);
cmd.Parameters.AddWithValue("pbytes", bytes);
int ret = cmd.ExecuteNonQuery();
Assert.AreEqual(1, ret);
}
using (var cmd = conn.CreateCommand())
{
const string sql = @"
SELECT
geometry
,ST_Is3D(geometry)
,ST_IsMeasured(geometry)
,ST_AsText(GeomFromGPB(geometry))
FROM [sample_feature_table_z]
WHERE [id] = 1;";
cmd.CommandText = sql;
using (var rdr = cmd.ExecuteReader())
{
Assert.IsTrue(rdr.Read());
byte[] blob = rdr.GetFieldValue <byte[]>(0);
var reader = new GeoPackageGeoReader
{
HandleOrdinates = Ordinates.XYZ
};
var geom = reader.Read(blob);
Assert.AreEqual(point, geom);
Assert.AreEqual(point.AsBinary(), geom.AsBinary());
Assert.IsTrue(rdr.GetBoolean(1));
Assert.IsFalse(rdr.GetBoolean(2));
string wkt = rdr.GetString(3);
Assert.IsFalse(string.IsNullOrEmpty(wkt));
Assert.AreEqual("POINT Z(11.11 22.22 33.33)", wkt);
}
}
});
}
public void TestEquals3D()
{
var c1 = new CoordinateZ(1, 2, 3);
var c2 = new CoordinateZ(1, 2, 3);
Assert.IsTrue(c1.Equals3D(c2));
var c3 = new CoordinateZ(1, 22, 3);
Assert.IsFalse(c1.Equals3D(c3));
}
public void TestSetCoordinate()
{
var orig = new CoordinateZ(350.2, 4566.8, 5266.3);
var c = new CoordinateZ {
CoordinateValue = orig
};
Assert.AreEqual(c.X, 350.2);
Assert.AreEqual(c.Y, 4566.8);
Assert.AreEqual(c.Z, 5266.3);
}
private static CoordinateZ[] Reversed(CoordinateZ[] coordinates)
{
var reversed = new CoordinateZ[coordinates.Length];
int maxIndex = coordinates.Length - 1;
for (int i = 0; i < coordinates.Length; i++)
{
reversed[i] = coordinates[maxIndex - i];
}
return(reversed);
}
public void TrySerialize_With_Valid_3dCoordinate()
{
var type = new GeoJSONPositionScalar();
var input = new CoordinateZ(1, 2, 100);
var result = type.TrySerialize(input, out var value);
Assert.True(result);
Assert.Equal(3, Assert.IsType <double[]>(value).Length);
Assert.Equal(new [] { 1D, 2D, 100D }, Assert.IsType <double[]>(value));
}
public void TestSetOrdinate()
{
var c = new CoordinateZ();
c[Ordinate.X] = 111;
c[Ordinate.Y] = 222;
c[Ordinate.Z] = 333;
Assert.AreEqual(c[Ordinate.X], 111.0);
Assert.AreEqual(c[Ordinate.Y], 222.0);
Assert.AreEqual(c[Ordinate.Z], 333.0);
}
// TODO: This private method was marked as protected to allow PackedCoordinateSequenceTest to override Test2DZOrdinate
// The method should not be marked as protected, and should be altered when the correct PackedCoordinateSequence.GetCoordinate result is migrated to NTS
protected Coordinate[] CreateArray(int size)
{
var coords = new Coordinate[size];
for (int i = 0; i < size; i++)
{
double baseUnits = 2 * 1;
coords[i] = new CoordinateZ(baseUnits, baseUnits + 1, baseUnits + 2);
}
return(coords);
}
public void ParseValue_With_3Valid_Coordinates()
{
var type = new GeoJSONPositionScalar();
var coordinate = new CoordinateZ(1.1, 2.2, 3.3);
var result = type.ParseValue(coordinate);
Assert.Equal("1.10", Assert.IsType <ListValueNode>(result).Items[0].Value);
Assert.Equal("2.20", Assert.IsType <ListValueNode>(result).Items[1].Value);
Assert.Equal("3.30", Assert.IsType <ListValueNode>(result).Items[2].Value);
}
private async Task <Feature> ConvertPageToFeature(WikiPage page, string language)
{
await page.RefreshAsync(new WikiPageQueryProvider
{
Properties =
{
new ExtractsPropertyProvider {
AsPlainText = true, IntroductionOnly = true, MaxSentences = 1
},
new PageImagesPropertyProvider {
QueryOriginalImage = true
},
new GeoCoordinatesPropertyProvider {
QueryPrimaryCoordinate = true
},
new RevisionsPropertyProvider {
FetchContent = false
}
}
});
if (page.Exists == false)
{
return(null);
}
var geoCoordinate = page.GetPropertyGroup <GeoCoordinatesPropertyGroup>().PrimaryCoordinate;
if (geoCoordinate.IsEmpty)
{
return(null);
}
var coordinate = new CoordinateZ(geoCoordinate.Longitude, geoCoordinate.Latitude, double.NaN);
var attributes = GetAttributes(coordinate, page.Title, page.Id.ToString(), language);
attributes.Add(FeatureAttributes.DESCRIPTION + ":" + language, page.GetPropertyGroup <ExtractsPropertyGroup>().Extract ?? string.Empty);
var imageUrl = page.GetPropertyGroup <PageImagesPropertyGroup>().OriginalImage.Url ?? string.Empty;
if (!string.IsNullOrWhiteSpace(imageUrl) &&
(imageUrl.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
imageUrl.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase) ||
imageUrl.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
imageUrl.EndsWith(".bmp", StringComparison.OrdinalIgnoreCase)))
{
attributes.Add(FeatureAttributes.IMAGE_URL, imageUrl);
}
attributes.Add(FeatureAttributes.POI_USER_NAME + ":" + language, page.LastRevision.UserName);
attributes.Add(FeatureAttributes.POI_USER_ADDRESS + ":" + language, _wikiSites[language].SiteInfo.MakeArticleUrl($"User:{Uri.EscapeUriString(page.LastRevision.UserName)}"));
attributes.Add(FeatureAttributes.POI_LAST_MODIFIED + ":" + language, page.LastRevision.TimeStamp.ToString("o"));
var feature = new Feature(new Point(coordinate), attributes);
feature.SetTitles();
feature.SetId();
return(feature);
}
public void TrySerialize_With_Nan_3dCoordinate()
{
var type = new GeoJsonPositionType();
var input = new CoordinateZ(1, 2, double.NaN);
var result = type.TrySerialize(input, out object?value);
Assert.True(result);
Assert.Equal(2, Assert.IsType <double[]>(value).Length);
Assert.Equal(new[] { 1D, 2D }, Assert.IsType <double[]>(value));
}
public void ParseValue_With_3Valid_Coordinates()
{
var type = new GeoJsonPositionType();
var coordinate = new CoordinateZ(1.1, 2.2, 3.3);
IValueNode result = type.ParseValue(coordinate);
Assert.Equal("1.1", Assert.IsType <ListValueNode>(result).Items[0].Value);
Assert.Equal("2.2", Assert.IsType <ListValueNode>(result).Items[1].Value);
Assert.Equal("3.3", Assert.IsType <ListValueNode>(result).Items[2].Value);
}
public void TestCompareTo()
{
var lowest = new CoordinateZ(10.0, 100.0, 50.0);
var highest = new CoordinateZ(20.0, 100.0, 50.0);
var equalToHighest = new CoordinateZ(20.0, 100.0, 50.0);
var higherStill = new CoordinateZ(20.0, 200.0, 50.0);
Assert.AreEqual(-1, lowest.CompareTo(highest));
Assert.AreEqual(1, highest.CompareTo(lowest));
Assert.AreEqual(-1, highest.CompareTo(higherStill));
Assert.AreEqual(0, highest.CompareTo(equalToHighest));
}
public void TrySerialize_With_Valid_3dCoordinate()
{
// arrange
var type = new GeoJsonPositionType();
var input = new CoordinateZ(1, 2, 100);
// act
var result = type.TrySerialize(input, out object?value);
// assert
Assert.True(result);
Assert.Equal(3, Assert.IsType <double[]>(value).Length);
Assert.Equal(new[] { 1D, 2D, 100D }, Assert.IsType <double[]>(value));
}
public GeomagnetismResult(CoordinateZ coordinate, DateTime date, double x, double y, double z)
{
Date = date;
Coordinate = coordinate;
if ((Math.Abs(x - 0.0) < double.Epsilon * 2 || Math.Abs(y - 0.0) < double.Epsilon * 2))
return;
X = x;
Y = y;
Z = z;
HorizontalIntensity = Math.Sqrt(x * x + y * y);
TotalIntensity = Math.Sqrt(x * x + y * y + z * z);
Declination = Math.Atan2(y, x).ToDegrees();
Inclination = Math.Atan2(z, HorizontalIntensity).ToDegrees();
}
private bool TryParseCoordinate(JsonArray coordinates, out Coordinate result)
{
result = null;
if (coordinates == null || coordinates.Count < 2)
return false;
var valid = coordinates.All(x => x is double || x is long);
if (!valid)
return false;
if (coordinates.Count == 2)
result = new Coordinate(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]));
else if (coordinates.Count == 3)
result = new CoordinateZ(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]), Convert.ToDouble(coordinates[2]));
else
result = new CoordinateZM(Convert.ToDouble(coordinates[1]), Convert.ToDouble(coordinates[0]), Convert.ToDouble(coordinates[2]), Convert.ToDouble(coordinates[3]));
return true;
}
public Circle(double latitiude, double longitude, double elevation, double radius)
{
Center = new CoordinateZ(latitiude, longitude, elevation);
Radius = radius;
}
public Point(double latitude, double longitude, double elevation)
{
Coordinate = new CoordinateZ(latitude, longitude, elevation);
}
public Fix(double latitude, double longitude, double elevation, DateTime dateTime)
{
Coordinate = new CoordinateZ(latitude, longitude, elevation);
TimeUtc = dateTime;
}
