Adding another way to Create a polygon

[OrenNoy28]

Hello everyone, I want to ask if there is other way to create a polygon besides using an array.
In the present, i need to create a polygon in this way:

My problem is that my input is a big string that contains a lot of points, and to get each point i parse my string and set it to the above "Coord" array' and afterward I add it to the polygon.

Is there a way to set the string as is into the polygon without parse it?

Because what if I have a string that contains 20,000 points ? In the current way I will need to build an array with 20,000 cells and add it one by one, and in the end add it to the polygon as the example above.

If there isn't a way in the current version, can you add this ability to the next elastic API version, Please?

Best regards,
Oren Noy
GIS SoftWare Developer

[russcam]

Hey @OrenNoy28, what format are your coordinates in? WKT? GeoJSON? Some other?

[OrenNoy28]

Hey russcam, my format is in WKT, but if you have answer for GeoJSON give it to me also.

[russcam]

@OrenNoy28 There are a few options I can propose:

1. Convert WKT to GeoJSON, the current format for working with geo in Elasticsearch. You may want to use something like NetTopologySuite to do this.
2. Build a search request using the low level client, Elasticsearch.Net, incorporating the GeoJSON string into a JSON string representing the query.
3. Build a search request using the high level client, extending the serializer to handle NetTopologySuite's IGeometry types such that the serializer knows how to serialize Polygon types.

I have done something similar to 3 previously, using NEST 1.x, and started on a Nest.GeoSpatial project to build a package to make this simpler. I'd like to get back to that when I have time.

There is recent work happening to support WKT in Elasticsearch but it may be some time before it makes it into a release.

[nknize]

Committed WKT support for 6.2 release: elastic/elasticsearch#27417

Here's also a javascript library to convert from WKT to GeoJSON: https://github.com/cschwarz/wkx

And here's a simple online converter for doing it by hand (uses wkx): https://rodic.fr/blog/online-conversion-between-geometric-formats/

[OrenNoy28]

Thanks guys for the answers, but I apperently didin't understand something.

If i have a string that contains coordinates and i want to create from it a polygon, is there another way to do it beside the way that describe in my picture above? in the picture, As I understand it, I'm populating geocoordinate object (not a geojson, to my best understanding) from a string, and populating the objects into a array. That is the frustrating part I am trying to get over...

(Sorry if you feel I am describing the problem poorly, I am just a beginner in ElasticSearch)

[russcam]

Since these are more questions rather than an issue with the client, the best place to ask in future would be on the Discuss forum.

If i have a string that contains coordinates and i want to create from it a polygon, is there another way to do it beside the way that describe in my picture above?

What you're populating above is a collection of NEST specific types that represent coordinates, and when serialized, will serialize to a JSON array of coordinates.

To serialize to valid GeoJSON that the geo_shape queries accept, NEST has a collection of IGeoShape types e.g. PolygonGeoShape, that can be used to send a GeoJSON polygon to a geo_shape query

var polygon = new PolygonGeoShape(
	new [] 
	{
		new [] 
		{
			new GeoCoordinate(1, 1),
			new GeoCoordinate(1, 2),
			new GeoCoordinate(2, 2),
			new GeoCoordinate(2, 1),
			new GeoCoordinate(1, 1),
		}
	});

client.Search<MyDocument>(s => s
	.Query(q => q
		.GeoShapePolygon(g => g
			.Coordinates(polygon.Coordinates)
			.Field(f => f.Location)
		)
	)
);

which yields the following query, where coordinates is a GeoJSON representation of the polygon:

{
  "query": {
    "geo_shape": {
      "location": {
        "shape": {
          "coordinates": [
            [
              [
                1.0,
                1.0
              ],
              [
                2.0,
                1.0
              ],
              [
                2.0,
                2.0
              ],
              [
                1.0,
                2.0
              ],
              [
                1.0,
                1.0
              ]
            ]
          ],
          "type": "polygon"
        }
      }
    }
  }
}

I think your question can be boiled down to,

"how do I convert my string that contains coordinates into a structure that can be sent to the geo_shape query?"

Let's break the answer down into a few steps:

1. Elasticsearch geo_shape queries work with GeoJSON currently, so if the string representation of coordinates is not currently GeoJSON, it will need to be GeoJSON when sent to Elasticsearch

2. NEST has some basic IGeoShape types for working with geo_shape queries, which will serialize to a valid GeoJSON representation

3. If you're interacting with Elasticsearch via NEST, you'll need to get your coordinates into a format that NEST can work with. For this, you have various options

   1. Read coordinates from the string and construct a collection of GeoCoordintate types that can be sent to NEST with one of the high level GeoShape* queries e.g. GeoShapePolygon per the example above
   2. If the string representation of coordinates is a known representation of geometry objects e.g. WKT, you may consider using a library to read the string into a .NET type that represents a geometry e.g. IGeometry type from NetTopologySuite. From this, you can get the coordinates to send to Elasticsearch, similar to what nest-geospatial does
   3. Perform the conversion from the string into GeoJSON outside of NEST with a library such as @nknize recommends, construct a query with JSON that incorporates such GeoJSON, and send to Elasticsearch with the lowlevel client, exposed on the highlevel client via the .LowLevel property. The lowlevel client allows you to send a valid JSON string as the query

   client.LowLevel.Search<SearchResponse<MyDocument>>("index-name", "type-name", @"{
   	  ""query"": {
   	    ""geo_shape"": {
   	      ""location"": {
   	        ""shape"": {
   	          ""coordinates"": [
   	            [
   	              [
   	                1.0,
   	                1.0
   	              ],
   	              [
   	                2.0,
   	                1.0
   	              ],
   	              [
   	                2.0,
   	                2.0
   	              ],
   	              [
   	                1.0,
   	                2.0
   	              ],
   	              [
   	                1.0,
   	                1.0
   	              ]
   	            ]
   	          ],
   	          ""type"": ""polygon""
   	        }
   	      }
   	    }
   	  }
   	}");