public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var geom = serializer.Deserialize <JToken>(reader);
GeoJsonObjectType type = serializer.Deserialize <GeoJsonObjectType>(geom.SelectToken("type").CreateReader());
var coordReader = geom.SelectToken("coordinates").CreateReader();
switch (type)
{
case GeoJsonObjectType.MultiPolygon:
return(new MultiPolygonJsonConverter().ReadJson(coordReader, typeof(MultiPolygon), geom, serializer));
case GeoJsonObjectType.Polygon:
return(new PolygonJsonConverter().ReadJson(coordReader, typeof(MultiPolygon), geom, serializer));
case GeoJsonObjectType.MultiLineString:
return(new MultiLineStringJsonConverter().ReadJson(coordReader, typeof(MultiLineString), geom, serializer));
case GeoJsonObjectType.LineString:
return(new LineStringJsonConverter().ReadJson(coordReader, typeof(LineString), geom, serializer));
case GeoJsonObjectType.MultiPoint:
return(new MultiPointJsonConverter().ReadJson(coordReader, typeof(MultiPoint), geom, serializer));
case GeoJsonObjectType.Point:
return(new PointJsonConverter().ReadJson(coordReader, typeof(Point), geom, serializer));
default:
throw new InvalidFormatException(string.Format("Not a valid GeoSon geometry type: {0}", type.ToString()));
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
reader.Read();
if (!(reader.TokenType == JsonToken.PropertyName && (string)reader.Value == "type"))
{
throw new Exception();
}
reader.Read();
if (reader.TokenType != JsonToken.String)
{
throw new Exception();
}
GeoJsonObjectType geometryType = (GeoJsonObjectType)Enum.Parse(typeof(GeoJsonObjectType), (string)reader.Value);
switch (geometryType)
{
case GeoJsonObjectType.Point:
Coordinate coordinate = serializer.Deserialize <Coordinate>(reader);
return(this._factory.CreatePoint(coordinate));
case GeoJsonObjectType.LineString:
Coordinate[] coordinates = serializer.Deserialize <Coordinate[]>(reader);
return(this._factory.CreateLineString(coordinates));
case GeoJsonObjectType.Polygon:
List <Coordinate[]> coordinatess = serializer.Deserialize <List <Coordinate[]> >(reader);
return(this.CreatePolygon(coordinatess));
case GeoJsonObjectType.MultiPoint:
coordinates = serializer.Deserialize <Coordinate[]>(reader);
return(this._factory.CreateMultiPoint(coordinates));
case GeoJsonObjectType.MultiLineString:
coordinatess = serializer.Deserialize <List <Coordinate[]> >(reader);
List <ILineString> strings = new List <ILineString>();
for (int i = 0; i < coordinatess.Count; i++)
{
strings.Add(this._factory.CreateLineString(coordinatess[i]));
}
return(this._factory.CreateMultiLineString(strings.ToArray()));
case GeoJsonObjectType.MultiPolygon:
List <List <Coordinate[]> > coordinatesss = serializer.Deserialize <List <List <Coordinate[]> > >(reader);
List <IPolygon> polygons = new List <IPolygon>();
foreach (List <Coordinate[]> coordinateses in coordinatesss)
{
polygons.Add(this.CreatePolygon(coordinateses));
}
return(this._factory.CreateMultiPolygon(polygons.ToArray()));
case GeoJsonObjectType.GeometryCollection:
List <IGeometry> geoms = serializer.Deserialize <List <IGeometry> >(reader);
return(this._factory.CreateGeometryCollection(geoms.ToArray()));
//ReadJson(reader,)
}
return(null);
}
public static Type GetType(GeoJsonObjectType type)
{
if (!typeMapping.ContainsKey(type))
{
return(null);
}
return(typeMapping[type]);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
reader.Read();
if (!(reader.TokenType == JsonToken.PropertyName && (string)reader.Value == "geometries"))
{
throw new Exception();
}
reader.Read();
if (reader.TokenType != JsonToken.StartArray)
{
throw new Exception();
}
reader.Read();
List <IGeometry> geoms = new List <IGeometry>();
while (reader.TokenType != JsonToken.EndArray)
{
JObject obj = (JObject)serializer.Deserialize(reader);
GeoJsonObjectType geometryType = (GeoJsonObjectType)Enum.Parse(typeof(GeoJsonObjectType), obj.Value <string>("type"));
switch (geometryType)
{
case GeoJsonObjectType.Point:
geoms.Add(this._factory.CreatePoint(ToCoordinate(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.LineString:
geoms.Add(this._factory.CreateLineString(ToCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.Polygon:
geoms.Add(this.CreatePolygon(ToListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiPoint:
geoms.Add(this._factory.CreateMultiPoint(ToCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiLineString:
geoms.Add(this.CreateMultiLineString(ToListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiPolygon:
geoms.Add(this.CreateMultiPolygon(ToListOfListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.GeometryCollection:
throw new NotSupportedException();
}
reader.Read();
}
return(geoms);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = this.ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
serializer.Serialize(writer, geom.Coordinate);
break;
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
serializer.Serialize(writer, geom.Coordinates);
break;
case GeoJsonObjectType.Polygon:
IPolygon poly = geom as IPolygon;
Debug.Assert(poly != null);
serializer.Serialize(writer, PolygonCoordiantes(poly));
break;
case GeoJsonObjectType.MultiPolygon:
IMultiPolygon mpoly = geom as IMultiPolygon;
Debug.Assert(mpoly != null);
List <List <Coordinate[]> > list = new List <List <Coordinate[]> >();
foreach (IPolygon mempoly in mpoly.Geometries)
{
list.Add(PolygonCoordiantes(mempoly));
}
serializer.Serialize(writer, list);
break;
case GeoJsonObjectType.GeometryCollection:
IGeometryCollection gc = geom as IGeometryCollection;
Debug.Assert(gc != null);
serializer.Serialize(writer, gc.Geometries);
break;
default:
List <Coordinate[]> coordinates = new List <Coordinate[]>();
foreach (IGeometry geometry in ((IGeometryCollection)geom).Geometries)
{
coordinates.Add(geometry.Coordinates);
}
serializer.Serialize(writer, coordinates);
break;
}
writer.WriteEndObject();
}
private void SerializeType(BsonSerializationContext context, GeoJsonObjectType type)
{
context.Writer.WriteString("type", type.ToString());
}
private void SerializeType(BsonWriter bsonWriter, GeoJsonObjectType type)
{
bsonWriter.WriteString("type", type.ToString());
}
/// <summary>
/// Writes a geometry to its JSON representation
/// </summary>
/// <param name="writer">The writer</param>
/// <param name="value">The value</param>
/// <param name="serializer">The serializer</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
writer.WriteNull();
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
if (serializer.NullValueHandling == NullValueHandling.Include || geom.Coordinate != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, geom.Coordinate);
}
break;
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
var linealCoords = geom.Coordinates;
if (serializer.NullValueHandling == NullValueHandling.Include || linealCoords != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, linealCoords);
}
break;
case GeoJsonObjectType.Polygon:
IPolygon poly = geom as IPolygon;
Debug.Assert(poly != null);
var polygonCoords = PolygonCoordinates(poly);
if (serializer.NullValueHandling == NullValueHandling.Include || polygonCoords != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, polygonCoords);
}
break;
case GeoJsonObjectType.MultiPolygon:
IMultiPolygon mpoly = geom as IMultiPolygon;
Debug.Assert(mpoly != null);
var list = new List <List <Coordinate[]> >();
for (var i = 0; i < mpoly.NumGeometries; i++)
{
list.Add(PolygonCoordinates((IPolygon)mpoly.GetGeometryN(i)));
}
if (serializer.NullValueHandling == NullValueHandling.Include || list.Count > 0)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, list);
}
break;
case GeoJsonObjectType.GeometryCollection:
IGeometryCollection gc = geom as IGeometryCollection;
Debug.Assert(gc != null);
serializer.Serialize(writer, gc.Geometries);
break;
default:
List <Coordinate[]> coordinates = new List <Coordinate[]>();
foreach (IGeometry geometry in ((IGeometryCollection)geom).Geometries)
{
coordinates.Add(geometry.Coordinates);
}
if (serializer.NullValueHandling == NullValueHandling.Include || coordinates.Count > 0)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, coordinates);
}
break;
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
{
serializer.Serialize(writer, geom.Coordinate);
break;
}
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
{
serializer.Serialize(writer, geom.Coordinates);
break;
}
case GeoJsonObjectType.Polygon:
{
IPolygon poly = (IPolygon)geom;
List <Coordinate[]> coords = PolygonCoords(poly);
serializer.Serialize(writer, coords);
break;
}
case GeoJsonObjectType.MultiPolygon:
{
IMultiPolygon mpoly = (IMultiPolygon)geom;
List <List <Coordinate[]> > list = new List <List <Coordinate[]> >();
foreach (IPolygon poly in mpoly.Geometries)
{
List <Coordinate[]> coords = PolygonCoords(poly);
list.Add(coords);
}
serializer.Serialize(writer, list);
break;
}
case GeoJsonObjectType.GeometryCollection:
{
IGeometryCollection coll = (IGeometryCollection)geom;
serializer.Serialize(writer, coll.Geometries);
break;
}
default:
{
List <Coordinate[]> list = new List <Coordinate[]>();
IGeometryCollection coll = (IGeometryCollection)geom;
foreach (IGeometry geometry in coll.Geometries)
{
Coordinate[] coords = geometry.Coordinates;
list.Add(coords);
}
serializer.Serialize(writer, list);
break;
}
}
writer.WriteEndObject();
}
