Serializer ignores the IPrecisionModel of geometries

[janruo]

When serializing a geometry, the serializer seems to ignore the IPrecisionModel of the IGeometry. The coordinates in the JSON are not formatted according to the precision model, but are outputted as is.

Example:

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)
};

// Creating the polygon with PrecisionModels.Fixed
var polygon = GeometryFactory.Fixed.CreatePolygon(coords);

var serializer = GeoJsonSerializer.CreateDefault();
var writer = new StringWriter();
serializer.Serialize(writer, polygon);

var str = polygon.ToString();
// The precision is one decimal place as expected
// POLYGON ((0 0, 10.1 0, 10 10.1, 0.1 10, 0 0))

var json = writer.ToString();
// The precision is ignored
// {"type":"Polygon","coordinates":[[[0.001,0.001],[10.1,0.002],[10.0,10.1],[0.05,9.999],[0.001,0.001]]]}

Version: 1.15.2

[DGuidi]

try with GeoJsonSerializer.Create(GeometryFactory.Fixed); see GeoJsonSerializer.Create(IGeometryFactory)

[janruo]

That doesn't seem to work. After a quick look at the source code, the serializer seems to only use the factory when reading GeoJSON into geometries, not when writing geometries into GeoJSON.

It could also be possible that someone wants to serialize a FeatureCollection with multiple geometries with different IPrecisionModels. In this case passing the precision when creating the serializer wouldn't work.

[DGuidi]

actually this makes sense to me. precision model obviously can't be stored as a defined property inside geojson because of specs violation (but you can maybe add a custom attribute in each feature) and in json geometry looks correct to store info with the maximum precision viable. so, this is a correct behavior to me.

[janruo]

I'm not sure you understood the issue completely. I'm not saying that the precision model itself should be included in the output GeoJSON. I'm saying that the serializer should probably format the coordinates according to the geometry's defined precision model.

In my example, the geometry was created with a one decimal point precision model, and thus the WKT of the geometry was POLYGON ((0 0, 10.1 0, 10 10.1, 0.1 10, 0 0)) as expected.

However, the serializer doesn't respect the precision, and outputs the coordinates too precisely:
{"type":"Polygon","coordinates":[[[0.001,0.001],[10.1,0.002],[10.0,10.1],[0.05,9.999],[0.001,0.001]]]}

What I would expect is that the serializer respects the precision and outputs this:
{"type":"Polygon","coordinates":[[[0,0],[10.1,0],[10,10.1],[0.1,10],[0,0]]]},
which would match the WKT.

---

The reason why I noticed this issue is that I'm creating 2D polygons with a lot of coordinates, and applying transformations to them. The transformation causes the coordinates to be very precise and it also adds the Z component, e.g. (2321643.8753857632, 87332567.0012466452, 0.0002155952). Because the polygons are very large and the coordinates are too precise, I would be wasting storage space by storing the serialized GeoJSON in a database.

If the serializer respected the precision model, I could create a custom IPrecisionModel implementation that would format the coordinates to three decimal places and throw away the Z component (2321643.875, 87332567.001), and this would save ~50% storage space.

For now I just created a workaround that manually goes through each geometry and formats the coordinates before serialization. It works, but it's not very elegant.

[FObermaier]

According to the GeoJSON spec your coordinates are out of bounds.

You can use NetTopologySuite.Precision.GeometryPrecisionReducer to reduce the precision used in your geometries.

To handle that on the GeoJsonWriter we could

• use the PrecisionModel of the geometry (like WKTWriter)
• use the PrecisionModel of the GeometryFactory of the serializer

Additionally we can add an OutputDimension property with valid values 2 or 3 to ditch z-ordinate if that is not required.