private static IMultiPoint ParseWkbMultiPoint(byte[] blob, ref int offset, IGeometryFactory factory, ReadCoordinatesFunction readCoordinates, GaiaImport gaiaImport)
{
var getInt32 = gaiaImport.GetInt32;
var getDouble = gaiaImport.GetDouble;
var number = getInt32(blob, ref offset);
var coords = new Coordinate[number];
for (var i = 0; i < number; i++)
{
if (blob[offset++] != (byte)GaiaGeoBlobMark.GAIA_MARK_ENTITY)
{
throw new Exception();
}
var gt = getInt32(blob, ref offset);
if (ToBaseGeometryType((GaiaGeoGeometry)gt) != GaiaGeoGeometry.GAIA_POINT)
{
throw new Exception();
}
coords[i] = new Coordinate(getDouble(blob, ref offset),
getDouble(blob, ref offset));
if (gaiaImport.HasZ)
{
coords[i].Z = getDouble(blob, ref offset);
}
if (gaiaImport.HasM)
{
/*coords[i].M =*/
getDouble(blob, ref offset);
}
}
return(factory.CreateMultiPointFromCoords(coords));
}
private IMultiPoint CreateMultiPoint(int dim, int lrs, Decimal[] elemInfo, int elemIndex, List <Coordinate> coords)
{
int sOffset = StartingOffset(elemInfo, elemIndex);
SdoEType etype = EType(elemInfo, elemIndex);
int interpretation = Interpretation(elemInfo, elemIndex);
if (!(sOffset >= 1) || !(sOffset <= coords.Count))
{
throw new ArgumentException("ELEM_INFO STARTING_OFFSET " + sOffset +
" inconsistent with ORDINATES length " + coords.Count);
}
if (etype != SdoEType.Coordinate)
{
throw new ArgumentException("ETYPE " + etype + " inconsistent with expected POINT");
}
if (!(interpretation > 1))
{
return(null);
}
int len = dim + lrs;
int start = (sOffset - 1) / len;
int end = start + interpretation;
var points = _factory.CreateMultiPointFromCoords(SubArray(coords, start, end));
return(points);
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static IMultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreateMultiPointFromCoords((Coordinate[])null));
}
var points = new List <Coordinate>();
points.Add(new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
points.Add(new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateMultiPointFromCoords(points.ToArray()));
}
/// <summary>
/// Reads an array of <see cref="IGeometry"/>s from JSON
/// </summary>
/// <param name="reader">The reader</param>
/// <param name="objectType">The object type</param>
/// <param name="existingValue">The existing value</param>
/// <param name="serializer">The serializer</param>
/// <returns>The geometry array read</returns>
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"), true);
switch (geometryType)
{
case GeoJsonObjectType.Point:
geoms.Add(_factory.CreatePoint(ToCoordinate(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.LineString:
geoms.Add(_factory.CreateLineString(ToCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.Polygon:
geoms.Add(CreatePolygon(ToListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiPoint:
geoms.Add(_factory.CreateMultiPointFromCoords(ToCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiLineString:
geoms.Add(CreateMultiLineString(ToListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.MultiPolygon:
geoms.Add(CreateMultiPolygon(ToListOfListOfCoordinates(obj.Value <JArray>("coordinates"))));
break;
case GeoJsonObjectType.GeometryCollection:
throw new NotSupportedException();
}
reader.Read();
}
return(geoms);
}
public void ParseMultiPoint()
{
string multipoint = "MULTIPOINT ((20.564 346.3493254), (45 32), (23 54))";
var geom = GeomFromText(multipoint) as IMultiPoint;
Assert.IsNotNull(geom);
Assert.AreEqual(20.564, ((IPoint)geom[0]).X);
Assert.AreEqual(54, ((IPoint)geom[2]).Y);
Assert.AreEqual(multipoint, geom.AsText());
Assert.IsTrue(GeomFromText("MULTIPOINT EMPTY").IsEmpty);
Assert.AreEqual("MULTIPOINT EMPTY", Factory.CreateMultiPointFromCoords((Coordinate[])null).AsText());
}
private IGeometry BoundaryMultiLineString(IMultiLineString mLine)
{
if (_geom.IsEmpty)
{
return(GetEmptyMultiPoint());
}
var bdyPts = ComputeBoundaryCoordinates(mLine);
// return Point or MultiPoint
if (bdyPts.Length == 1)
{
return(_geomFact.CreatePoint(bdyPts[0]));
}
// this handles 0 points case as well
return(_geomFact.CreateMultiPointFromCoords(bdyPts));
}
private IGeometry ParseGeometry(JsonReader reader, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (reader.TokenType != JsonToken.StartObject)
{
throw new JsonReaderException("Expected Start object '{' Token");
}
// advance
bool read = reader.Read();
Utility.SkipComments(reader);
GeoJsonObjectType?geometryType = null;
List <object> coords = null;
while (reader.TokenType == JsonToken.PropertyName)
{
//read the tokens, type may come before coordinates or geometries as pr spec
if (reader.TokenType == JsonToken.PropertyName)
{
string prop = (string)reader.Value;
switch (prop)
{
case "type":
if (geometryType == null)
{
reader.Read();
geometryType = GetType(reader);
}
break;
case "geometries":
//only geom collection has "geometries"
reader.Read(); //read past start array tag
coords = ParseGeomCollection(reader, serializer);
break;
case "coordinates":
reader.Read(); //read past start array tag
coords = ReadCoordinates(reader);
break;
case "bbox":
// Read, but can't do anything with it, assigning Envelopes is impossible without reflection
/*var bbox = */
serializer.Deserialize <Envelope>(reader);
break;
default:
reader.Read();
/*var item = */
serializer.Deserialize(reader);
reader.Read();
break;
}
}
Utility.SkipComments(reader);
}
if (read && reader.TokenType != JsonToken.EndObject)
{
throw new ArgumentException("Expected token '}' not found.");
}
if (coords == null || geometryType == null)
{
return(null);
}
switch (geometryType)
{
case GeoJsonObjectType.Point:
return(_factory.CreatePoint(GetPointCoordinate(coords)));
case GeoJsonObjectType.LineString:
return(_factory.CreateLineString(GetLineStringCoordinates(coords)));
case GeoJsonObjectType.Polygon:
return(CreatePolygon(GetPolygonCoordinates(coords)));
case GeoJsonObjectType.MultiPoint:
return(_factory.CreateMultiPointFromCoords(GetLineStringCoordinates(coords)));
case GeoJsonObjectType.MultiLineString:
var strings = new List <ILineString>();
foreach (var multiLineStringCoordinate in GetPolygonCoordinates(coords))
{
strings.Add(_factory.CreateLineString(multiLineStringCoordinate));
}
return(_factory.CreateMultiLineString(strings.ToArray()));
case GeoJsonObjectType.MultiPolygon:
var polygons = new List <IPolygon>();
foreach (var multiPolygonCoordinate in GetMultiPolygonCoordinates(coords))
{
polygons.Add(CreatePolygon(multiPolygonCoordinate));
}
return(_factory.CreateMultiPolygon(polygons.ToArray()));
case GeoJsonObjectType.GeometryCollection:
return(_factory.CreateGeometryCollection(GetGeometries(coords)));
}
return(null);
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiPoint"/>.
/// </summary>
/// <param name="points">MultiPoint to transform</param>
/// <param name="transform">MathTransform</param>
/// <param name="targetFactory">The factory to create the target geometry</param>
/// <returns>Transformed MultiPoint</returns>
public static IMultiPoint TransformMultiPoint(IMultiPoint points, IMathTransform transform, IGeometryFactory targetFactory)
{
return(targetFactory.CreateMultiPointFromCoords(TransformCoordinates(points.Coordinates, transform)));
}
