public static Map2DModel GeoJsonFeaureToMap2DModel(GeoJsonFeature <GeoJsonGeometry> feature, List <double> minMaxLatLong)
{
double longLenth = minMaxLatLong[1] - minMaxLatLong[0];
double latLength = minMaxLatLong[3] - minMaxLatLong[2];
Map2DModel map2D = new Map2DModel(); map2D.Id = feature.Id;
map2D.Name = feature.Properties == null ? "" : feature.Properties.Name;
map2D.CapitalLocation = feature.Properties == null ? default(Point) : feature.Properties.CapitalLocationPoint;
map2D.MinLongitude = minMaxLatLong[0];
map2D.MaxLongitude = minMaxLatLong[1];
map2D.MinLatitude = minMaxLatLong[2];
map2D.MaxLatitude = minMaxLatLong[3];
List <List <Point> > areaList = new List <List <Point> >();
foreach (List <Point> area in feature.Geometry.PointList)
{
List <Point> pointList = new List <Point>();
areaList.Add(pointList);
foreach (Point point in area)
{
Point newPoint = LongLatPointToNormalPoint(minMaxLatLong, point);
pointList.Add(newPoint);
}
}
map2D.GeometryPointList = areaList;
return(map2D);
}
private void TestRoundTrip <TCoordinates>(string expected, GeoJsonFeature <TCoordinates> feature) where TCoordinates : GeoJsonCoordinates
{
var json = feature.ToJson();
Assert.AreEqual(expected, json);
var rehydrated = BsonSerializer.Deserialize <GeoJsonFeature <TCoordinates> >(json);
Assert.AreEqual(expected, rehydrated.ToJson());
}
/// <summary>
/// Parses the specified <paramref name="json"/> object into an instance deriving from <see cref="GeoJsonObject"/>.
///
/// As the GeoJSON format specified the type of a
/// </summary>
/// <param name="json">The JSON object.</param>
/// <returns>An instance that derives from <see cref="GeoJsonObject"/>.</returns>
private static GeoJsonObject Parse(JObject json)
{
if (json == null)
{
return(null);
}
// Get the value of the "type" property
string type = json.GetString("type");
if (string.IsNullOrWhiteSpace(type))
{
throw new GeoJsonParseException("The JSON object doesn't specify a type", json);
}
// Parse the type into an enum
if (EnumUtils.TryParseEnum(type, out GeoJsonType result) == false)
{
throw new GeoJsonParseException($"Unknown type {type}", json);
}
switch (result)
{
case GeoJsonType.Feature:
return(GeoJsonFeature.Parse(json));
case GeoJsonType.FeatureCollection:
return(GeoJsonFeatureCollection.Parse(json));
case GeoJsonType.Point:
return(GeoJsonPoint.Parse(json));
case GeoJsonType.LineString:
return(GeoJsonLineString.Parse(json));
case GeoJsonType.Polygon:
return(GeoJsonPolygon.Parse(json));
case GeoJsonType.MultiPoint:
return(GeoJsonMultiPoint.Parse(json));
//case GeoJsonType.MultiLineString:
// return GeoJsonMultiLineString.Parse(obj);
case GeoJsonType.MultiPolygon:
return(GeoJsonMultiPolygon.Parse(json));
case GeoJsonType.GeometryCollection:
return(GeoJsonGeometryCollection.Parse(json));
default:
throw new GeoJsonParseException($"Unknown type {type}", json);
}
}
public virtual GeoJsonFeature ConvertPlacemark(KmlPlacemark placemark, IStyleProvider provider)
{
// Initialize a new feature
GeoJsonFeature feature = new GeoJsonFeature();
// Convert the name and description
if (placemark.Name.HasValue())
{
feature.Properties.Name = placemark.Name;
}
if (placemark.Description.HasValue())
{
feature.Properties.Description = placemark.Description;
}
switch (placemark.Geometry)
{
case KmlPoint point:
feature.Geometry = Convert(point);
break;
case KmlLineString lineString:
feature.Geometry = Convert(lineString);
break;
case KmlPolygon polygon:
feature.Geometry = Convert(polygon);
break;
default:
throw new KmlException("Geometry type " + placemark.Geometry.GetType() + " not supported");
}
if (string.IsNullOrWhiteSpace(placemark.StyleUrl) == false && provider != null)
{
if (provider.TryGetStyleMapById(placemark.StyleUrl.Substring(1), out KmlStyleMap styleMap))
{
if (styleMap.Normal != null && provider.TryGetStyleById(styleMap.Normal.StyleUrl.Substring(1), out KmlStyle style))
{
ConvertProperties(style, feature.Properties);
}
}
else
{
if (provider.TryGetStyleById(placemark.StyleUrl.Substring(1), out KmlStyle style))
{
ConvertProperties(style, feature.Properties);
}
}
}
return(feature);
}
public void ToJson1()
{
// Initialize a new feature
GeoJsonFeature feature = new GeoJsonFeature(
new GeoJsonPoint(9.536067, 55.708116)
);
// Convert the feature to a JSON string
string json = feature.ToJson(Formatting.None);
Assert.AreEqual("{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[9.536067,55.708116]}}", json);
}
public void ToJson2()
{
GeoJsonFeature feature = new GeoJsonFeature(
new GeoJsonPoint(9.536067, 55.708116),
new GeoJsonProperties {
Name = "My feature"
}
);
// Convert the point to a JSON string
string json = feature.ToJson(Formatting.None);
Assert.AreEqual("{\"type\":\"Feature\",\"properties\":{\"name\":\"My feature\"},\"geometry\":{\"type\":\"Point\",\"coordinates\":[9.536067,55.708116]}}", json);
}
public static GeoJson <GeoJsonGeometry> DecodeGeoJson(string geoJson)
{
string dealedGeoJson = geoJson.Replace("coordinates\":[[", "coordinates\":[").Replace("\"]],", "\"],").Replace("encodeOffsets\":[[[", "encodeOffsets\":[[").Replace("]]]},\"properties", "]]},\"properties");
GeoJson <GeoJsonGeometryCoded> geoJsonCodedModel = JsonConvert.DeserializeObject <GeoJson <GeoJsonGeometryCoded> >(dealedGeoJson);
List <GeoJsonFeature <GeoJsonGeometryCoded> > features = geoJsonCodedModel.Features;
foreach (GeoJsonFeature <GeoJsonGeometryCoded> feature in features)
{
if (feature != null && feature.Properties != null && feature.Properties.CapitalLocation != null && feature.Properties.CapitalLocation.Count == 2)
{
feature.Properties.CapitalLocationPoint = new Point()
{
X = feature.Properties.CapitalLocation[0], Y = feature.Properties.CapitalLocation[1]
};
}
}
GeoJson <GeoJsonGeometry> geoJsonModel = new GeoJson <GeoJsonGeometry>();
geoJsonModel.Type = geoJsonCodedModel.Type;
geoJsonModel.Features = new List <GeoJsonFeature <GeoJsonGeometry> >();
//解压
foreach (GeoJsonFeature <GeoJsonGeometryCoded> feature in features)
{
GeoJsonGeometryCoded geometry = feature.Geometry;
List <string> coordinates = geometry.Coordinates;
List <List <double> > encodeOffsets = geometry.EncodeOffsets;
List <List <Point> > gemeryPointList = new List <List <Point> >();
for (int i = 0; i < coordinates.Count; i++)
{
List <Point> pointList = DecodePolygon(coordinates[i], encodeOffsets[i]);
gemeryPointList.Add(pointList);
}
GeoJsonFeature <GeoJsonGeometry> geojsonFeature = new GeoJsonFeature <GeoJsonGeometry>();
geojsonFeature.Id = feature.Id;
geojsonFeature.Type = feature.Type;
geojsonFeature.Properties = feature.Properties;
geojsonFeature.Geometry = new GeoJsonGeometry();
geojsonFeature.Geometry.Type = geometry.Type;
geojsonFeature.Geometry.PointList = gemeryPointList;
geoJsonModel.Features.Add(geojsonFeature);
}
return(geoJsonModel);
}
private static Graphic CreateRoadGraphic(GeoJsonFeature <GeoJsonPolygon> roadFeature, Esri.ArcGISRuntime.Geometry.SpatialReference originalSpatialReference, Esri.ArcGISRuntime.Geometry.SpatialReference targetSpatialReference)
{
var roadPolyline = CreatePolyline(roadFeature.Geometry.Coordinates, originalSpatialReference);
if (!originalSpatialReference.IsEqual(targetSpatialReference))
{
// In den Raumbezug der Karte projezieren
roadPolyline = (Esri.ArcGISRuntime.Geometry.Polyline)GeometryEngine.Project(roadPolyline, targetSpatialReference);
}
var roadGraphic = new Graphic(roadPolyline, roadFeature.Properties);
return(roadGraphic);
}
/// <inheritdoc />
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (reader.TokenType != JsonToken.StartObject)
{
return(null);
}
JObject obj = JObject.Load(reader);
string type = obj.Value <string>("type");
switch (type?.ToLower())
{
case "feature":
return(GeoJsonFeature.Parse(obj));
case "featurecollection":
return(GeoJsonFeatureCollection.Parse(obj));
case "point":
return(GeoJsonPoint.Parse(obj));
case "multipoint":
return(GeoJsonMultiPoint.Parse(obj));
case "linestring":
return(GeoJsonLineString.Parse(obj));
case "multilinestring":
return(GeoJsonMultiLineString.Parse(obj));
case "polygon":
return(GeoJsonPolygon.Parse(obj));
case "multipolygon":
return(GeoJsonMultiPolygon.Parse(obj));
default:
if (objectType == typeof(GeoJsonProperties))
{
return(ReadJsonProperties(reader));
}
throw new GeoJsonParseException($"Unknown shape: {type}", obj);
}
}
public void Constructor1()
{
GeoJsonFeature feature = new GeoJsonFeature(new GeoJsonPoint(9.536067, 55.708116));
Assert.IsNotNull(feature.Geometry);
Assert.IsNotNull(feature.Properties);
GeoJsonPoint point = feature.Geometry as GeoJsonPoint;
Assert.IsNotNull(point);
Assert.AreEqual(9.536067, point.X, "X");
Assert.AreEqual(55.708116, point.Y, "Y");
Assert.AreEqual(0, point.Altitude, "Altitude");
}
public void Parse1()
{
const string json = "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[9.536067,55.708116]}}";
GeoJsonFeature feature = GeoJsonFeature.Parse(json);
Assert.IsNotNull(feature);
Assert.IsNotNull(feature.Geometry);
Assert.IsNotNull(feature.Properties);
GeoJsonPoint point = feature.Geometry as GeoJsonPoint;
Assert.IsNotNull(point);
Assert.AreEqual(9.536067, point.X, "X");
Assert.AreEqual(55.708116, point.Y, "Y");
Assert.AreEqual(0, point.Altitude, "Altitude");
}
public void Parse2()
{
const string json = "{\"type\":\"Feature\",\"properties\":{\"name\":\"My feature\"},\"geometry\":{\"type\":\"Point\",\"coordinates\":[9.536067,55.708116,100]}}";
GeoJsonFeature feature = GeoJsonFeature.Parse(json);
Assert.IsNotNull(feature);
Assert.IsNotNull(feature.Geometry);
Assert.IsNotNull(feature.Properties);
GeoJsonPoint point = feature.Geometry as GeoJsonPoint;
Assert.IsNotNull(point);
Assert.AreEqual(9.536067, point.X, "X");
Assert.AreEqual(55.708116, point.Y, "Y");
Assert.AreEqual(100, point.Altitude, "Altitude");
Assert.AreEqual("My feature", feature.Properties.Name);
Assert.AreEqual(null, feature.Properties.Description);
}
public static GeoJson <GeoJsonGeometry> DecodeStandardGeoJson(string geoJson)
{
GeoJson <GeoJsonGeometryStandard> geoJsonCodedModel = JsonConvert.DeserializeObject <GeoJson <GeoJsonGeometryStandard> >(geoJson);
GeoJson <GeoJsonGeometry> geoJsonModel = new GeoJson <GeoJsonGeometry>();
geoJsonModel.Type = geoJsonCodedModel.Type;
geoJsonModel.Features = new List <GeoJsonFeature <GeoJsonGeometry> >();
List <GeoJsonFeature <GeoJsonGeometryStandard> > features = geoJsonCodedModel.Features;
foreach (GeoJsonFeature <GeoJsonGeometryStandard> feature in features)
{
List <List <List <double> > > coordinates = feature.Geometry.Coordinates;
List <List <Point> > geometryPointsList = new List <List <Point> >();
for (int k = 0; k < coordinates.Count; k++)
{
List <Point> pointList = new List <Point>();
geometryPointsList.Add(pointList);
for (int i = 0; i < coordinates[0].Count; i++)
{
Point point = new Point();
point.X = coordinates[k][i][0];
point.Y = coordinates[k][i][1];
pointList.Add(point);
}
}
GeoJsonGeometry geoJsonGeometry = new GeoJsonGeometry();
geoJsonGeometry.PointList = geometryPointsList;
GeoJsonFeature <GeoJsonGeometry> geoJsonFeature = new GeoJsonFeature <GeoJsonGeometry>();
geoJsonFeature.Geometry = geoJsonGeometry;
geoJsonModel.Features.Add(geoJsonFeature);
}
return(geoJsonModel);
}
/// <inheritdoc cref="IMapFactory{TDrawingContext}.ConvertToPathShape(GeoJsonFeature, MapContext{TDrawingContext})"/>
public IEnumerable <IDrawable <SkiaSharpDrawingContext> > ConvertToPathShape(
GeoJsonFeature feature, MapContext <SkiaSharpDrawingContext> context)
{
var projector = context.Projector;
var paths = new List <HeatPathShape>();
var d = new double[0][][][];
foreach (var geometry in feature.Geometry?.Coordinates ?? d)
{
foreach (var segment in geometry)
{
var path = new HeatPathShape {
IsClosed = true
};
var isFirst = true;
foreach (var point in segment)
{
var p = projector.ToMap(point);
if (isFirst)
{
isFirst = false;
path.AddCommand(new MoveToPathCommand {
X = p[0], Y = p[1]
});
continue;
}
path.AddCommand(new LineSegment {
X = p[0], Y = p[1]
});
}
paths.Add(path);
}
}
return(paths);
}
public void GeoJson_SerializationOfSampleGeometryPoint_ShouldWork()
{
var point = new GeoJsonFeature
{
Type = GeoJsonType.Feature.ToString(),
Geometry = new GeoJsonGeometry
{
Type = GeoJsonType.Point.ToString(),
Coordinates = (new double[] { 125.6, 10.1 }).Select(c => c as object).ToList()
},
Properties = new
{
name = "Dinagat Islands"
}
};
var thisJToken = JObject.Parse(JsonConvert.SerializeObject(point));
var smpleJToken = JObject.Parse(JsonGeometryPointStringSample);
Assert.IsTrue(JToken.DeepEquals(thisJToken, smpleJToken));
}
/// <summary>
/// Returns an instance of <see cref="IRectangle"/> representing the bounding box of the GeoJSON specified <paramref name="feature."/>
/// </summary>
/// <param name="feature">The feature.</param>
/// <returns>An instance of <see cref="IRectangle"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="feature"/> is <c>null</c>.</exception>
public static IRectangle GetBoundingBox(GeoJsonFeature feature)
{
if (feature == null)
{
throw new ArgumentNullException(nameof(feature));
}
IGeometry geometry = Convert(feature.Geometry);
switch (geometry)
{
case IPoint point:
return(new Rectangle(point, point));
case IShape shape:
return(shape.GetBoundingBox());
default:
throw new GeoJsonException($"Unsupported geometry {geometry.GetType()}");
}
}
// ***************** Export As GeoJson *******
// *******************************************
public static ILegendCommand CreateExportDrawingItemLayerAsGeoJson(MapPresenter map, DrawingItemLayer layer)
{
var result = new LegendCommand()
{
PathMarkup = IRI.Jab.Common.Assets.ShapeStrings.Others.json,
Layer = layer,
ToolTip = _saveAsGeoJsonToolTip,
};
result.Command = new RelayCommand(async param =>
{
try
{
var file = map.DialogService.ShowSaveFileDialog("*.json|*.json", null, layer.LayerName);
if (string.IsNullOrWhiteSpace(file))
{
return;
}
var feature = GeoJsonFeature.Create(layer.Geometry.Project(SrsBases.GeodeticWgs84).AsGeoJson());
GeoJsonFeatureSet featureSet = new GeoJsonFeatureSet()
{
Features = new List <GeoJsonFeature>()
{
feature
}, TotalFeatures = 1
};
featureSet.Save(file, false, false);
}
catch (Exception ex)
{
await map.DialogService.ShowMessageAsync(null, ex.Message, null, null);
}
});
return(result);
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The value.</param>
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, GeoJsonFeature <TCoordinates> value)
{
_helper.SerializeMembers(context, value, SerializeDerivedMembers);
}
private void SerializeDerivedMembers(BsonSerializationContext context, GeoJsonFeature <TCoordinates> value)
{
SerializeGeometry(context, value.Geometry);
SerializeId(context, value.Id);
SerializeProperties(context, value.Properties);
}
private void ConvertFeature(List <VectorTileFeature> features, GeoJsonFeature feature, double tolerance)
{
if (feature.Geometry == null)
{
return;
}
var geom = feature.Geometry;
var type = geom.Type;
if (type == GeoJsonObject.GeoJsonPointType)
{
var point = geom as Point;
features.Add(Create(feature.Properties, 1, new[] { new VectorTileGeometry {
ProjectPoint(point.Coordinates)
} }));
}
else if (type == GeoJsonObject.GeoJsonMultiPointType)
{
var multiPoint = geom as MultiPoint;
features.Add(Create(feature.Properties, 1, new[] { Project(multiPoint.Coordinates) }));
}
else if (type == GeoJsonObject.GeoJsonLineStringType)
{
var linestring = geom as LineString;
features.Add(Create(feature.Properties, 2, new[] { Project(linestring.Coordinates, tolerance) }));
}
else if (type == GeoJsonObject.GeoJsonMultiLineStringType || type == GeoJsonObject.GeoJsonPolygonType)
{
var coords = (geom as MultiLineStringPolygonGeometry).Coordinates;
var rings = new List <VectorTileGeometry>();
for (var i = 0; i < coords.Length; i++)
{
rings.Add(Project(coords[i], tolerance));
}
features.Add(Create(feature.Properties, type == GeoJsonObject.GeoJsonPolygonType ? 3 : 2, rings.ToArray()));
}
else if (type == GeoJsonObject.GeoJsonMultiPolygonType)
{
var coords = (geom as MultiPolygon).Coordinates;
var rings = new List <VectorTileGeometry>();
for (var i = 0; i < coords.Length; i++)
{
for (var j = 0; j < coords[i].Length; j++)
{
rings.Add(Project(coords[i][j], tolerance));
}
}
features.Add(Create(feature.Properties, 3, rings.ToArray()));
}
else if (type == GeoJsonObject.GeoJsonGeometryCollectionType)
{
var collection = geom as GeometryCollection;
for (var i = 0; i < collection.Geometries.Length; i++)
{
ConvertFeature(features, new GeoJsonFeature
{
Geometry = collection.Geometries[i],
Properties = feature.Properties,
}, tolerance);
}
}
else
{
throw new Exception("Input data is not a valid GeoJSON object.");
}
}
