public static string ToGeoJson(this IGeometry geometry, int srId, KeyValuePair <string, object>[] attributes = null)
{
var attributesTable = new AttributesTable();
if (attributes != null)
{
foreach (var attribute in attributes)
{
attributesTable.AddAttribute(attribute.Key, attribute.Value);
}
}
var feature = new Feature(geometry, attributesTable);
var featureCollection = new FeatureCollection()
{
CRS = new NamedCRS(string.Format("EPSG:{0}", srId)),
Features = { feature }
};
var geoJsonSerializer = new GeoJsonSerializer(geometry.Factory);
var stringBuilder = new StringBuilder();
using (var sw = new StringWriter(stringBuilder))
geoJsonSerializer.Serialize(sw, featureCollection);
return(stringBuilder.ToString());
}
protected override IGeometry Read(byte[] b)
{
string json;
using (var ms = new MemoryStream(b))
{
using (var r = new StreamReader(ms))
json = r.ReadToEnd();
}
var gjs = new GeoJsonSerializer();
var j = (JObject) gjs.Deserialize(new JsonTextReader(new StringReader(json)));
switch (j.Value<string>("type"))
{
case "Point":
return gjs.Deserialize<Point>(new JsonTextReader(new StringReader(json)));
case "LineString":
return gjs.Deserialize<LineString>(new JsonTextReader(new StringReader(json)));
case "Polygon":
return gjs.Deserialize<Polygon>(new JsonTextReader(new StringReader(json)));
case "MultiPoint":
return gjs.Deserialize<MultiPoint>(new JsonTextReader(new StringReader(json)));
case "MultiLineString":
return gjs.Deserialize<MultiLineString>(new JsonTextReader(new StringReader(json)));
case "MultiPolygon":
return gjs.Deserialize<MultiPolygon>(new JsonTextReader(new StringReader(json)));
case "GeometryCollection":
return gjs.Deserialize<GeometryCollection>(new JsonTextReader(new StringReader(json)));
default:
throw new InvalidOperationException();
}
}
static void ReadTest1Shp(string shpPath)
{
IFeatureSet fs = FeatureSet.Open(shpPath);
var ntsFec = fs.ToNtsFeatureCollection();
var newShpPath = Path.Combine(
Path.GetDirectoryName(shpPath),
Path.GetFileNameWithoutExtension(shpPath) + "_new.shp");
var newFs = ntsFec.ToCsFeatureSet();
newFs.Save(newShpPath);
var sb = new StringBuilder();
var writer = new StringWriter(sb);
var serializer = GeoJsonSerializer.CreateDefault();
serializer.NullValueHandling = NullValueHandling.Ignore;
serializer.Serialize(writer, ntsFec);
writer.Flush();
Console.WriteLine(writer.ToString());
writer.Dispose();
Console.WriteLine();
}
/// <summary>
/// Returns a list of municipalities in GeoJSON format
/// </summary>
/// <returns></returns>
public HttpResponseMessage Get()
{
var session = SessionManager.Session;
var municipalities = session.Query <Municipality>().ToList();
FeatureCollection collection = new FeatureCollection();
foreach (var municipality in municipalities)
{
var feature = new Feature
{
Geometry = municipality.Geom,
Attributes = new AttributesTable(),
};
feature.Attributes.AddAttribute("id", municipality.Id);
feature.Attributes.AddAttribute("name", municipality.Name);
feature.Attributes.AddAttribute("no", municipality.MunicipalityNo);
feature.Attributes.AddAttribute("type", "municipality");
collection.Add(feature);
}
var jsonSerializer = new GeoJsonSerializer();
var sw = new StringWriter();
jsonSerializer.Serialize(sw, collection);
return(Response(sw.ToString()));
}
/// <summary>
/// Returns the county closes to the given municipality
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage GetCounty(int id)
{
var session = SessionManager.Session;
var county =
(from c in session.Query <County>()
from m in session.Query <Municipality>()
where m.Id == id
orderby m.Geom.Centroid.Distance(c.Geom) ascending
select c)
.Take(1)
.ToList()
.FirstOrDefault();
var feature = new Feature
{
Geometry = county.Geom,
Attributes = new AttributesTable()
};
feature.Attributes.AddAttribute("id", county.Id);
feature.Attributes.AddAttribute("name", county.Name);
feature.Attributes.AddAttribute("no", county.CountyNo);
feature.Attributes.AddAttribute("type", "county");
var jsonSerializer = new GeoJsonSerializer();
var sw = new StringWriter();
jsonSerializer.Serialize(sw, feature);
return(Response(sw.ToString()));
}
public Geometry Convert(string sourceMember, ResolutionContext context)
{
var serializer = GeoJsonSerializer.CreateDefault();
var feature = (Feature)serializer.Deserialize(new StringReader(sourceMember), typeof(Feature));
return(feature.Geometry);
}
public void TestIssue83()
{
var geoJson = @"{ ""type"": ""Feature"",
""geometry"": { ""type"": ""Point"", ""coordinates"": [10.0, 60.0] },
""id"": 1,
""properties"": { ""Name"": ""test"" } }";
var s = new GeoJsonSerializer();
Feature f = null;
Assert.DoesNotThrow(() =>
f = s.Deserialize <Feature>(new JsonTextReader(new StringReader(geoJson)))
);
Assert.IsNotNull(f, "f != null");
Assert.IsTrue(FeatureExtensions.HasID(f), "f.HasID()");
Assert.AreEqual(1, FeatureExtensions.ID(f), "f.ID != 1");
var sb = new StringBuilder();
var tw = new JsonTextWriter(new StringWriter(sb));
s.Serialize(tw, f);
var geoJsonRes = sb.ToString();
CompareJson(geoJson, geoJsonRes);
}
public void TestIssue83()
{
var geoJson = "{ \"type\": \"Feature\", " +
"\"geometry\": { \"type\": \"Point\", \"coordinates\": [10.0, 60.0] }, " +
"\"id\": 1, " +
"\"properties\": { \"Name\": \"test\" } }";
var s = new GeoJsonSerializer();
Feature f = null;
Assert.DoesNotThrow(() =>
f = s.Deserialize <Feature>(new JsonTextReader(new StringReader(geoJson)))
);
Assert.IsNotNull(f, "f != null");
Assert.IsTrue(f.HasID(), "f.HasID()");
Assert.AreEqual(1, f.ID(), "f.ID != 1");
var sb = new StringBuilder();
var tw = new JsonTextWriter(new StringWriter(sb));
s.Serialize(tw, f);
var geoJsonRes = sb.ToString();
CompareJson(geoJson, geoJsonRes);
}
public void TestIssue88WithFlatProperties()
{
const string expectedJson = @"
{
""id"" : ""00000000-0000-0000-0000-000000000000"",
""type"" : ""Feature"",
""geometry"" : null,
""properties"" : {
""yesNo 1"" : false,
""date 1"" : ""2016-02-16T00:00:00""
},
""collection_userinfo"" : ""()"",
""collection_timestamp"" : ""2016-02-25T14:38:01.9087672"",
""collection_todoid"" : """",
""collection_templateid"" : ""nj7Glv-AqV0"",
""collection_layerid"" : ""nj7Glv-AqV0""
}
";
var serializer = GeoJsonSerializer.CreateDefault(new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
Feature feat = null;
Assert.That(() =>
{
using (JsonReader reader = new JsonTextReader(new StringReader(expectedJson)))
{
feat = serializer.Deserialize <Feature>(reader);
}
}, Throws.Nothing);
Assert.That(feat, Is.Not.Null);
Assert.That(feat.Geometry, Is.Null);
}
public static List <CoordinateZ> CoordinateListFromGeoJsonFeatureCollectionWithLinestring(string geoJson)
{
if (string.IsNullOrWhiteSpace(geoJson))
{
return(new List <CoordinateZ>());
}
var serializer = GeoJsonSerializer.Create(Wgs84GeometryFactory(), 3);
using var stringReader = new StringReader(geoJson);
using var jsonReader = new JsonTextReader(stringReader);
var featureCollection = serializer.Deserialize <FeatureCollection>(jsonReader);
if (featureCollection == null || featureCollection.Count < 1)
{
return(new List <CoordinateZ>());
}
var possibleLine = featureCollection.FirstOrDefault(x => x.Geometry is LineString);
if (possibleLine == null)
{
return(new List <CoordinateZ>());
}
var geoLine = (LineString)possibleLine.Geometry;
return(geoLine.Coordinates.Select(x => new CoordinateZ(x.X, x.Y, x.Z)).ToList());
}
public void Test3DPointSerialization()
{
var factory = GeometryFactory.Default;
var point1 = factory.CreatePoint(new CoordinateZM(1, 2, 3, 4));
var feature1 = new Feature(point1, null);
Feature feature2;
using (var ms = new MemoryStream())
{
var serializer = GeoJsonSerializer.Create(factory, 3);
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
using (var jsonWriter = new JsonTextWriter(writer))
{
serializer.Serialize(jsonWriter, feature1);
}
ms.Position = 0;
using (var reader = new StreamReader(ms, Encoding.UTF8, true, 1024, true))
using (var jsonReader = new JsonTextReader(reader))
{
feature2 = serializer.Deserialize <Feature>(jsonReader);
}
}
Assert.That(feature2.Geometry, Is.InstanceOf <Point>());
var point2 = (Point)feature2.Geometry;
Assert.That(point2.CoordinateSequence.HasZ);
Assert.That(CoordinateSequences.IsEqual(point1.CoordinateSequence, point2.CoordinateSequence));
// GeoJSON doesn't support M, so there should NOT be an M present in round-trip.
Assert.That(!point2.CoordinateSequence.HasM);
}
public void TestIssue88WithoutAdditionalProperties()
{
string expectedJson = @"
{
""id"" : ""00000000-0000-0000-0000-000000000000"",
""type"" : ""Feature"",
""geometry"" : null,
""properties"" : {
""yesNo 1"" : false,
""date 1"" : ""2016-02-16T00:00:00""
}
}
";
GeoJsonSerializer serializer = new GeoJsonSerializer();
Feature feat = null;
Assert.DoesNotThrow(() =>
{
using (JsonReader reader = new JsonTextReader(new StringReader(expectedJson)))
feat = serializer.Deserialize<Feature>(reader);
});
Assert.IsNotNull(feat);
Assert.IsTrue(FeatureExtensions.HasID(feat));
Assert.AreEqual("00000000-0000-0000-0000-000000000000", FeatureExtensions.ID(feat));
IGeometry geometry = feat.Geometry;
Assert.IsNull(geometry);
IAttributesTable attributes = feat.Attributes;
Assert.IsNotNull(attributes);
Assert.AreEqual(3, attributes.Count);
Assert.AreEqual(FeatureExtensions.ID(feat), attributes["id"]);
Assert.AreEqual(false, attributes["yesNo 1"]);
Assert.AreEqual(DateTime.Parse("2016-02-16T00:00:00", CultureInfo.InvariantCulture), attributes["date 1"]);
}
public void TestGeometryConverterAttribute()
{
var myModelItem = new MyModelItem();
myModelItem.Geom = new global::NetTopologySuite.Geometries.MultiLineString(
new NetTopologySuite.Geometries.LineString[]
{
new global::NetTopologySuite.Geometries.LineString(new[]
{ new NetTopologySuite.Geometries.Coordinate(10, 10), new NetTopologySuite.Geometries.Coordinate(20, 10) }),
new global::NetTopologySuite.Geometries.LineString(new[]
{ new NetTopologySuite.Geometries.Coordinate(10, 11), new NetTopologySuite.Geometries.Coordinate(20, 11) }),
new global::NetTopologySuite.Geometries.LineString(new[]
{ new NetTopologySuite.Geometries.Coordinate(10, 12), new NetTopologySuite.Geometries.Coordinate(20, 12) })
});
var s = GeoJsonSerializer.Create(new Newtonsoft.Json.JsonSerializerSettings(),
NtsGeometryServices.Instance.CreateGeometryFactory(31467));
var sb = new System.Text.StringBuilder();
s.Serialize(new Newtonsoft.Json.JsonTextWriter(new System.IO.StringWriter(sb)), myModelItem);
System.Console.WriteLine(sb.ToString());
var myModelItem2 =
s.Deserialize <MyModelItem>(
new Newtonsoft.Json.JsonTextReader(new System.IO.StringReader(sb.ToString())));
}
public void TestOutputDimension()
{
var coords = new[]
{
new Coordinate(0.001, 0.001, 3),
new Coordinate(10.1, 0.002, 3),
new Coordinate(10, 10.1, 3),
new Coordinate(0.05, 9.999, 3),
new Coordinate(0.001, 0.001, 3)
};
// Create a factory with scale = 10
var factory = new GeometryFactory(new PrecisionModel(10), 4326);
// Creating the polygon with the above factory
var polygon = factory.CreatePolygon(coords);
var serializer2 = GeoJsonSerializer.Create(factory, 2);
var serializer3 = GeoJsonSerializer.Create(factory, 3);
var writer = new StringWriter();
serializer2.Serialize(writer, polygon);
string json2 = writer.ToString();
Assert.That(json2, Is.EqualTo("{\"type\":\"Polygon\",\"coordinates\":[[[0.0,0.0],[10.1,0.0],[10.0,10.1],[0.1,10.0],[0.0,0.0]]]}"));
writer = new StringWriter();
serializer3.Serialize(writer, polygon);
string json3 = writer.ToString();
Assert.That(json3, Is.EqualTo("{\"type\":\"Polygon\",\"coordinates\":[[[0.0,0.0,3.0],[10.1,0.0,3.0],[10.0,10.1,3.0],[0.1,10.0,3.0],[0.0,0.0,3.0]]]}"));
}
public void TestIssue88WithFlatProperties()
{
string expectedJson = @"
{
""id"" : ""00000000-0000-0000-0000-000000000000"",
""type"" : ""Feature"",
""geometry"" : null,
""properties"" : {
""yesNo 1"" : false,
""date 1"" : ""2016-02-16T00:00:00""
},
""collection_userinfo"" : ""()"",
""collection_timestamp"" : ""2016-02-25T14:38:01.9087672"",
""collection_todoid"" : """",
""collection_templateid"" : ""nj7Glv-AqV0"",
""collection_layerid"" : ""nj7Glv-AqV0""
}
";
GeoJsonSerializer serializer = new GeoJsonSerializer();
Feature feat = null;
Assert.DoesNotThrow(() =>
{
using (JsonReader reader = new JsonTextReader(new StringReader(expectedJson)))
feat = serializer.Deserialize <Feature>(reader);
});
Assert.IsNotNull(feat);
Assert.IsNull(feat.Geometry);
}
public void GeoJsonWriterWriteAnyObjectTest()
{
AttributesTable attributes = new AttributesTable();
DateTime Date = new DateTime(2012, 8, 8).Date;
JsonSerializer g = new GeoJsonSerializer {
NullValueHandling = NullValueHandling.Ignore
};
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
g.Serialize(sw, Date);
string expectedDateString = sb.ToString();
string expectedResult = "{\"featureCollection\":{\"type\":\"FeatureCollection\",\"features\":[{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[23.0,56.0]},\"properties\":{\"test1\":\"value1\"}}],\"crs\":{\"type\":\"name\",\"properties\":{\"name\":\"name1\"}}},\"Date\":" + expectedDateString + "}";
attributes.AddAttribute("test1", "value1");
IFeature feature = new Feature(new Point(23, 56), attributes);
FeatureCollection featureCollection = new FeatureCollection(new Collection <IFeature> {
feature
})
{
CRS = new NamedCRS("name1")
};
var gjw = new GeoJsonWriter();
gjw.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
string actual = gjw.Write(new { featureCollection, Date = Date });
Assert.AreEqual(expectedResult, actual);
}
public void TestInputDimension()
{
var coords = new[]
{
new Coordinate(0.001, 0.001),
new Coordinate(10.1, 0.002),
new Coordinate(10, 10.1),
new Coordinate(0.05, 9.999),
new Coordinate(0.001, 0.001)
};
// Create a factory with scale = 10
var factory = new GeometryFactory(new PrecisionModel(10), 4326);
var serializer3 = GeoJsonSerializer.Create(factory, 3);
var reader = new JsonTextReader(new StringReader("{\"type\":\"Polygon\",\"coordinates\":[[[0.001,0.001,3.0],[10.1,0.002,3.0],[10.0,10.1,3.0],[0.05,9.999,3.0],[0.001,0.001,3.0]]]}"));
var geom = serializer3.Deserialize <IGeometry>(reader);
Assert.That(geom.AsText(), Is.EqualTo("POLYGON ((0 0 3, 10.1 0 3, 10 10.1 3, 0.1 10 3, 0 0 3))"));
var serializer2 = GeoJsonSerializer.Create(factory, 2);
reader = new JsonTextReader(new StringReader("{\"type\":\"Polygon\",\"coordinates\":[[[0.001,0.001,3.0],[10.1,0.002,3.0],[10.0,10.1,3.0],[0.05,9.999,3.0],[0.001,0.001,3.0]]]}"));
geom = serializer2.Deserialize <IGeometry>(reader);
Assert.That(geom.AsText(), Is.EqualTo("POLYGON ((0 0, 10.1 0, 10 10.1, 0.1 10, 0 0))"));
}
public void deserialize_geojson_from_osm()
{
const string resourceName = "NetTopologySuite.IO.GeoJSON.Test.World_AL6.GeoJson";
var assembly = Assembly.GetExecutingAssembly();
using (var stream = assembly.GetManifestResourceStream(resourceName))
{
Assert.IsNotNull(stream);
{
var serializer = GeoJsonSerializer.CreateDefault();
using (var reader = new StreamReader(stream))
using (var textReader = new JsonTextReader(reader))
{
var collection = serializer.Deserialize <FeatureCollection>(textReader);
Assert.IsNotNull(collection);
Assert.AreEqual(4, collection.Count);
foreach (var feature in collection.Features)
{
Assert.IsNotNull(feature.Geometry);
Assert.IsNull(feature.BoundingBox);
var attributes = feature.Attributes;
Assert.IsNotNull(attributes);
var names = attributes.GetNames();
foreach (var name in names)
{
Console.WriteLine("{0}: {1}", name, attributes[name]);
}
}
}
}
}
}
public void deserialize_a_json_fragment_should_throws_an_error()
{
var reader = new JsonTextReader(new StringReader(serializedGeometries));
var serializer = GeoJsonSerializer.Create(factory);
Assert.Throws <JsonReaderException>(() => serializer.Deserialize <Geometry[]>(reader));
}
/// <summary>
/// Creates a GeoJson from all ProjectGeometries in the current project (session has to be set)
/// </summary>
/// <returns>GeoJson string</returns>
private string createGeoJson()
{
string projectId = HttpContext.Session.GetString("Project");
if (projectId == null)
{
return("");
}
//TODO chb
//Project myProject = db.Projects.Include(m => m.Geometries).Where(m => m.ProjectId == new Guid(projectId)).FirstOrDefault();
Project myProject = db.Projects
.Include(p => p.ProjectGroups).ThenInclude(m => m.Geometries)
.Where(m => m.ProjectId == new Guid(projectId)).FirstOrDefault();
if (myProject == null)
{
return("");
}
if (myProject != null)
{
NetTopologySuite.Features.FeatureCollection featureCollection = new NetTopologySuite.Features.FeatureCollection();
//TODO chb
//foreach (ReferenceGeometry g in myProject.Geometries.Where(m => m.StatusId != StatusEnum.deleted))
foreach (ReferenceGeometry g in myProject.ProjectGroups.SelectMany(pg => pg.Geometries).Where(g => g.StatusId != StatusEnum.deleted))
{
NetTopologySuite.Features.Feature f = null;
if (g.Point != null)
{
f = getFeature(g, GeomType.Point);
}
if (g.Line != null)
{
f = getFeature(g, GeomType.Line);
}
if (g.Polygon != null)
{
f = getFeature(g, GeomType.Polygon);
}
if (f != null)
{
featureCollection.Add(f);
}
}
var jsonSerializer = GeoJsonSerializer.Create();
var sw = new System.IO.StringWriter();
jsonSerializer.Serialize(sw, featureCollection);
return(sw.ToString());
}
else
{
return(null);// "No project found";
}
}
/// <summary>
///
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddApiVersioning(
options =>
{
options.ReportApiVersions = true;
});
services.AddVersionedApiExplorer(
options =>
{
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
});
services.AddControllers()
.AddControllersAsServices()
.AddMvcOptions(config =>
{
config.CacheProfiles.Add("Default1hr", new Microsoft.AspNetCore.Mvc.CacheProfile()
{
Duration = 3600,
Location = Microsoft.AspNetCore.Mvc.ResponseCacheLocation.Any,
NoStore = true
});
//Filtros
config.Filters.Add(typeof(HttpGlobalExceptionFilter));
config.Filters.Add(typeof(ValidateModelStateFilter));
config.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(Point)));
config.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(LineString)));
config.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(MultiLineString)));
config.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(MultiPolygon)));
})
.AddFluentValidation()
.AddNewtonsoftJson(options =>
{
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
foreach (var converter in GeoJsonSerializer.Create(new GeometryFactory(new PrecisionModel())).Converters)
{
options.SerializerSettings.Converters.Add(converter);
}
});
services.AddRedisCache(Configuration.GetSection("Redis:ConnectionString").Get <string>());
services.AddOpenTracingAndJaeger();
services.AddSwagger();
AddAuthentication(services);
RegisterDbContexts(services);
services.AddMediatR(typeof(Startup).Assembly);
}
public static string GetGeojson(FeatureCollection features)
{
var serializer = GeoJsonSerializer.Create();
var writer = new StringWriter();
serializer.Serialize(writer, features);
return(writer.ToString());
}
public void GeoJsonDeserializePolygonTest()
{
StringBuilder sb = new StringBuilder();
JsonSerializer serializer = new GeoJsonSerializer();
var s = "{\"type\": \"Polygon\",\"coordinates\": [[[-180,-67.8710140098964],[-180,87.270282879440586],[180,87.270282879440586],[180,-67.8710140098964],[-180,-67.8710140098964]]],\"rect\": {\"min\": [-180,-67.8710140098964],\"max\": [180,87.270282879440586]}}";
var poly = serializer.Deserialize <Polygon>(JObject.Parse(s).CreateReader());
}
public T DeSerialise <T>(string payload)
{
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
var serializer = GeoJsonSerializer.Create(geometryFactory);
var data = serializer.Deserialize <T>(new JsonTextReader(new StringReader(payload)));
return(data);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value != null)
{
var feature = new Feature(value as Geometry, new AttributesTable());
GeoJsonSerializer.Create(new GeometryFactory(new PrecisionModel(), SRID)).Serialize(writer, feature);
}
}
public void TestCoordinateDeserialize()
{
string json = "{coordinates:[1.0, 1.0]}";
JsonSerializer s = GeoJsonSerializer.CreateDefault();
Coordinate c = s.Deserialize <Coordinate>(new JsonTextReader(new StringReader(json)));
Console.WriteLine(c.ToString());
}
public void deserialize_a_json_fragment_should_throws_an_error()
{
JsonTextReader reader = new JsonTextReader(new StringReader(serializedGeometries));
JsonSerializer serializer = new GeoJsonSerializer(factory);
IGeometry[] actual = serializer.Deserialize<IGeometry[]>(reader);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.EqualTo(geometries));
}
public void deserialize_a_valid_json_should_return_a_geometrycollection()
{
JsonTextReader reader = new JsonTextReader(new StringReader(serializedCollection));
JsonSerializer serializer = new GeoJsonSerializer(factory);
IGeometryCollection actual = serializer.Deserialize<GeometryCollection>(reader);
Assert.That(actual, Is.Not.Null);
Assert.That(actual.EqualsExact(collection), Is.True);
}
public void deserialize_a_json_fragment_should_throws_an_error()
{
JsonTextReader reader = new JsonTextReader(new StringReader(serializedGeometries));
JsonSerializer serializer = new GeoJsonSerializer(factory);
IGeometry[] actual = serializer.Deserialize <IGeometry[]>(reader);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.EqualTo(geometries));
}
public string Convert(Geometry sourceMember, ResolutionContext context)
{
var serializer = GeoJsonSerializer.Create();
var sw = new StringWriter();
var geofeature = new Feature(sourceMember, new AttributesTable());
serializer.Serialize(sw, geofeature, typeof(Feature));
return(sw.ToString());
}
public string Serialise <T>(GeometryFactory geometryFactory, T tripStatusMessage)
{
var stringBuilder = new StringBuilder();
var serializer = GeoJsonSerializer.Create(geometryFactory);
serializer.Serialize(new JsonTextWriter(new StringWriter(stringBuilder)), tripStatusMessage,
typeof(T));
return(stringBuilder.ToString());
}
public void GeoJsonSerializerGeometryTest()
{
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
GeoJsonSerializer serializer = new GeoJsonSerializer();
serializer.Serialize(writer, new Point(23, 56));
writer.Flush();
Assert.AreEqual("{\"type\":\"Point\",\"coordinates\":[23.0,56.0]}", sb.ToString());
}
public void GeoJsonDeserializePolygonTest()
{
var serializer = GeoJsonSerializer.CreateDefault();
const string s = "{\"type\": \"Polygon\",\"coordinates\": [[[-180,-67.8710140098964],[-180,87.270282879440586],[180,87.270282879440586],[180,-67.8710140098964],[-180,-67.8710140098964]]],\"rect\": {\"min\": [-180,-67.8710140098964],\"max\": [180,87.270282879440586]}}";
var poly = serializer.Deserialize <Polygon>(JObject.Parse(s).CreateReader());
Assert.IsNotNull(poly);
}
public void deserialize_a_valid_json_should_return_a_geometrycollection()
{
JsonTextReader reader = new JsonTextReader(new StringReader(serializedCollection));
JsonSerializer serializer = new GeoJsonSerializer(factory);
IGeometryCollection actual = serializer.Deserialize <GeometryCollection>(reader);
Assert.That(actual, Is.Not.Null);
Assert.That(actual.EqualsExact(collection), Is.True);
}
public static string GetPolygonAsGeoJSON()
{
var poly = GetAPolygon();
var jsonSerializer = new GeoJsonSerializer();
var sw = new System.IO.StringWriter();
jsonSerializer.Serialize(sw, poly);
return(sw.ToString());
}
public void PerformGeometryTest(IGeometry geom)
{
GeoJsonSerializer s = new GeoJsonSerializer();
StringBuilder sb = new StringBuilder();
s.Serialize(new JsonTextWriter(new StringWriter(sb)), geom);
string result = sb.ToString();
Console.WriteLine(result);
Deserialize(result, geom);
}
public void serialize_a_geometrycollection_should_return_a_valid_json()
{
StringBuilder sb = new StringBuilder();
JsonTextWriter writer = new JsonTextWriter(new StringWriter(sb));
JsonSerializer serializer = new GeoJsonSerializer(factory);
serializer.Serialize(writer, collection);
string actual = sb.ToString();
Console.WriteLine(actual);
Assert.That(actual, Is.EqualTo(serializedCollection));
}
public void serialize_an_array_of_geometries_should_return_a_json_fragment()
{
StringBuilder sb = new StringBuilder();
JsonTextWriter writer = new JsonTextWriter(new StringWriter(sb));
JsonSerializer serializer = new GeoJsonSerializer(factory);
serializer.Serialize(writer, geometries);
string actual = sb.ToString();
Console.WriteLine(actual);
Assert.That(actual, Is.EqualTo(serializedGeometries));
}
public void GeoJsonSerializerAttributesTest()
{
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
AttributesTable attributes = new AttributesTable();
attributes.AddAttribute("test1", "value1");
GeoJsonSerializer serializer = new GeoJsonSerializer();
serializer.Serialize(writer, attributes);
writer.Flush();
Assert.AreEqual("\"properties\":{\"test1\":\"value1\"}", sb.ToString());
}
public void GeoJsonSerializerFeatureTest()
{
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
AttributesTable attributes = new AttributesTable();
attributes.AddAttribute("test1", "value1");
IFeature feature = new Feature(new Point(23, 56), attributes);
GeoJsonSerializer serializer = new GeoJsonSerializer();
serializer.Serialize(writer, feature);
writer.Flush();
Assert.AreEqual("{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[23.0,56.0]},\"properties\":{\"test1\":\"value1\"}}", sb.ToString());
}
public void WriteJsonWithArrayTest()
{
FeatureConverter target = new FeatureConverter();
StringBuilder sb = new StringBuilder();
JsonTextWriter writer = new JsonTextWriter(new StringWriter(sb));
AttributesTable attributes = new AttributesTable();
attributes.AddAttribute("test1", new [] { "value1", "value2" });
IFeature value = new Feature(new Point(23, 56), attributes);
JsonSerializer serializer = new GeoJsonSerializer();
target.WriteJson(writer, value, serializer);
writer.Flush();
Assert.AreEqual("{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[23.0,56.0]},\"properties\":{\"test1\":[\"value1\",\"value2\"]}}", sb.ToString());
}
public void GeoJsonSerializerFeatureCollectionTest()
{
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
AttributesTable attributes = new AttributesTable();
attributes.AddAttribute("test1", "value1");
IFeature feature = new Feature(new Point(23, 56), attributes);
FeatureCollection featureCollection = new FeatureCollection(new Collection<IFeature> {feature})
{CRS = new NamedCRS("name1")};
GeoJsonSerializer serializer = new GeoJsonSerializer();
serializer.Serialize(writer, featureCollection);
writer.Flush();
Assert.AreEqual("{\"features\":[{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[23.0,56.0]},\"properties\":{\"test1\":\"value1\"}}],\"type\":\"FeatureCollection\",\"crs\":{\"type\":\"name\",\"properties\":{\"name\":\"name1\"}}}", sb.ToString());
}
public void GeoJsonWriterWriteAnyObjectTest()
{
AttributesTable attributes = new AttributesTable();
DateTime Date = new DateTime(2012, 8, 8).Date;
GeoJsonSerializer g = new GeoJsonSerializer();
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
g.Serialize(sw, Date);
string expectedDateString = sb.ToString();
string expectedResult = "{\"featureCollection\":{\"features\":[{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[23.0,56.0]},\"properties\":{\"test1\":\"value1\"}}],\"type\":\"FeatureCollection\",\"crs\":{\"type\":\"name\",\"properties\":{\"name\":\"name1\"}}},\"Date\":" + expectedDateString + "}";
attributes.AddAttribute("test1", "value1");
IFeature feature = new Feature(new Point(23, 56), attributes);
FeatureCollection featureCollection = new FeatureCollection(new Collection<IFeature> { feature }) { CRS = new NamedCRS("name1") };
string actual = new GeoJsonWriter().Write(new { featureCollection, Date = Date });
Assert.AreEqual(expectedResult, actual);
}
public void TestIssue83()
{
var geoJson = "{ \"type\": \"Feature\", " +
"\"geometry\": { \"type\": \"Point\", \"coordinates\": [10.0, 60.0] }, " +
"\"id\": 1, " +
"\"properties\": { \"Name\": \"test\" } }";
var s = new GeoJsonSerializer();
Feature f = null;
Assert.DoesNotThrow(() =>
f = s.Deserialize<Feature>(new JsonTextReader(new StringReader(geoJson)))
);
Assert.IsNotNull(f, "f != null");
Assert.IsTrue(FeatureExtensions.HasID(f), "f.HasID()");
Assert.AreEqual(1, FeatureExtensions.ID(f), "f.ID != 1");
var sb = new StringBuilder();
var tw = new JsonTextWriter(new StringWriter(sb));
s.Serialize(tw, f);
var geoJsonRes = sb.ToString();
CompareJson(geoJson, geoJsonRes);
}
public void GeoJsonDeserializePolygonTest()
{
StringBuilder sb = new StringBuilder();
JsonSerializer serializer = new GeoJsonSerializer();
var s = "{\"type\": \"Polygon\",\"coordinates\": [[[-180,-67.8710140098964],[-180,87.270282879440586],[180,87.270282879440586],[180,-67.8710140098964],[-180,-67.8710140098964]]],\"rect\": {\"min\": [-180,-67.8710140098964],\"max\": [180,87.270282879440586]}}";
var poly = serializer.Deserialize<Polygon>(JObject.Parse(s).CreateReader());
}
public void TestIssue88WithFlatProperties()
{
string expectedJson = @"
{
""id"" : ""00000000-0000-0000-0000-000000000000"",
""type"" : ""Feature"",
""geometry"" : null,
""properties"" : {
""yesNo 1"" : false,
""date 1"" : ""2016-02-16T00:00:00""
},
""collection_userinfo"" : ""()"",
""collection_timestamp"" : ""2016-02-25T14:38:01.9087672"",
""collection_todoid"" : """",
""collection_templateid"" : ""nj7Glv-AqV0"",
""collection_layerid"" : ""nj7Glv-AqV0""
}
";
GeoJsonSerializer serializer = new GeoJsonSerializer();
Feature feat = null;
Assert.DoesNotThrow(() =>
{
using (JsonReader reader = new JsonTextReader(new StringReader(expectedJson)))
feat = serializer.Deserialize<Feature>(reader);
});
Assert.IsNotNull(feat);
Assert.IsNull(feat.Geometry);
}
public void TestCoordinateSerialize()
{
Coordinate coordinate = new Coordinate(1, 1);
GeoJsonSerializer g = new GeoJsonSerializer();
StringBuilder sb = new StringBuilder();
g.Serialize(new JsonTextWriter(new StringWriter(sb)), coordinate);
Console.WriteLine(sb.ToString());
}
public void TestCoordinatesSerialize()
{
Coordinate[] coordinates = new Coordinate[4];
for (int i = 0; i < coordinates.Length; i++)
{
coordinates[i] = new Coordinate(i, i, i);
}
StringBuilder sb = new StringBuilder();
GeoJsonSerializer g = new GeoJsonSerializer();
g.Serialize(new JsonTextWriter(new StringWriter(sb)), coordinates);
Console.WriteLine(sb.ToString());
}
public void TestCoordinateDeserialize()
{
string json = "{coordinates:[1.0, 1.0]}";
GeoJsonSerializer s = new GeoJsonSerializer();
Coordinate c = s.Deserialize<Coordinate>(new JsonTextReader(new StringReader(json)));
Console.WriteLine(c.ToString());
}
private static void Deserialize(string result, IGeometry geom)
{
GeoJsonSerializer s = new GeoJsonSerializer();
JsonTextReader r = new JsonTextReader(new StringReader(result));
IGeometry des;
if (geom is IPoint)
des = s.Deserialize<Point>(r);
else if (geom is ILineString)
des = s.Deserialize<LineString>(r);
else if (geom is IPolygon)
des = s.Deserialize<Polygon>(r);
else if (geom is IMultiPoint)
des = s.Deserialize<MultiPoint>(r);
else if (geom is IMultiLineString)
des = s.Deserialize<MultiLineString>(r);
else if (geom is IMultiPolygon)
des = s.Deserialize<MultiPolygon>(r);
else if (geom is IGeometryCollection)
des = s.Deserialize<GeometryCollection>(r);
else
throw new Exception();
Console.WriteLine(des.AsText());
Assert.IsTrue(des.EqualsExact(geom));
}
