private ILineString ReadLine(int dim, int lrsDim, SdoGeometry sdoGeom)
{
bool lrs = sdoGeom.LRS > 0;
decimal[] info = sdoGeom.ElemArray;
ICoordinateSequence cs = null;
int i = 0;
while (i < info.Length)
{
if (info.getElementType(i).isCompound())
{
int numCompounds = info.getNumCompounds(i);
cs = Add(cs, GetCompoundCSeq(i + 1, i + numCompounds, sdoGeom));
i += 1 + numCompounds;
}
else
{
cs = Add(cs, GetElementCSeq(i, sdoGeom, false));
i++;
}
}
LineString ls =
lrs
? factory.CreateMultiLineString(cs)
: factory.CreateLineString(cs);
ls.SRID = (int)sdoGeom.Sdo_Srid;
return(ls);
}
/// <summary>
/// Reads a stream and converts the shapefile record to an equilivent geometry object.
/// </summary>
/// <param name="file">The stream to read.</param>
/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
/// <returns>The Geometry object that represents the shape file record.</returns>
public override IGeometry Read(BigEndianBinaryReader file, IGeometryFactory geometryFactory)
{
int shapeTypeNum = file.ReadInt32();
type = (ShapeGeometryType) Enum.Parse(typeof(ShapeGeometryType), shapeTypeNum.ToString());
if (type == ShapeGeometryType.NullShape)
return geometryFactory.CreateMultiLineString(null);
if (!(type == ShapeGeometryType.LineString || type == ShapeGeometryType.LineStringM ||
type == ShapeGeometryType.LineStringZ || type == ShapeGeometryType.LineStringZM))
throw new ShapefileException("Attempting to load a non-arc as arc.");
// Read and for now ignore bounds.
int bblength = GetBoundingBoxLength();
bbox = new double[bblength];
for (; bbindex < 4; bbindex++)
{
double d = file.ReadDouble();
bbox[bbindex] = d;
}
int numParts = file.ReadInt32();
int numPoints = file.ReadInt32();
int[] partOffsets = new int[numParts];
for (int i = 0; i < numParts; i++)
partOffsets[i] = file.ReadInt32();
ILineString[] lines = new ILineString[numParts];
for (int part = 0; part < numParts; part++)
{
int start, finish, length;
start = partOffsets[part];
if (part == numParts - 1)
finish = numPoints;
else finish = partOffsets[part + 1];
length = finish - start;
CoordinateList points = new CoordinateList();
points.Capacity = length;
for (int i = 0; i < length; i++)
{
double x = file.ReadDouble();
double y = file.ReadDouble();
ICoordinate external = new Coordinate(x, y);
geometryFactory.PrecisionModel.MakePrecise(external);
points.Add(external);
}
ILineString line = geometryFactory.CreateLineString(points.ToArray());
lines[part] = line;
}
geom = geometryFactory.CreateMultiLineString(lines);
GrabZMValues(file);
return geom;
}
/// <summary>
/// Converts the GML element to multi line string.
/// </summary>
/// <param name="element">The GML element of the multi line string.</param>
/// <param name="factory">The geometry factory.</param>
/// <returns>The converted multi line string.</returns>
private static IMultiLineString ToMultiLineString(XElement element, IGeometryFactory factory)
{
if (element.Elements() == null)
{
return(factory.CreateMultiLineString());
}
List <ILineString> lineStrings = new List <ILineString>();
return(factory.CreateMultiLineString(element.Elements()
.Where(innerElement => innerElement.Name.LocalName == "LineStringMember")
.Select(innerElement => ToLineString(innerElement.Elements().FirstOrDefault(), factory))));
}
private IGeometry BuildGrid()
{
var lines = new ILineString[_numLines * 2];
int index = 0;
for (int i = 0; i < _numLines; i++)
{
Coordinate p0 = new Coordinate(GetRandOrdinate(), 0);
Coordinate p1 = new Coordinate(GetRandOrdinate(), GridWidth);
ILineString line = _geomFactory.CreateLineString(new [] { p0, p1 });
lines[index++] = line;
}
for (int i = 0; i < _numLines; i++)
{
Coordinate p0 = new Coordinate(0, GetRandOrdinate());
Coordinate p1 = new Coordinate(GridWidth, GetRandOrdinate());
ILineString line = _geomFactory.CreateLineString(new [] { p0, p1 });
lines[index++] = line;
}
IMultiLineString ml = _geomFactory.CreateMultiLineString(lines);
_grid = ml.Buffer(_lineWidth);
var wktWriter = new WKTWriter(2)
{
Formatted = true, MaxCoordinatesPerLine = 6
};
if (Verbose)
{
Console.WriteLine(wktWriter.Write(_grid));
}
return(_grid);
}
private IGeometry BuildMultiLineString()
{
var lineStrings = _ccGeometries
.ConvertAll(g => g as ILineString).ToArray();
return(_factory.CreateMultiLineString(lineStrings));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private IMultiLineString BuildEdges()
{
IGeometry temp = null;
foreach (ILineString line in strings)
{
if (temp == null)
{
temp = line;
}
else
{
temp = temp.Union(line);
}
}
IMultiLineString edges;
if (temp == null || temp.NumGeometries == 0)
{
edges = MultiLineString.Empty;
}
else if (temp.NumGeometries == 1)
{
edges = factory.CreateMultiLineString(new ILineString[] { (ILineString)temp, });
}
else
{
edges = (IMultiLineString)temp;
}
return(edges);
}
/// <summary>
/// Builds a geometry (<see cref="LineString" /> or <see cref="MultiLineString" />)
/// representing the sequence.
/// </summary>
/// <param name="sequences">
/// A <see cref="IList" /> of <see cref="IList" />s of <see cref="DirectedEdge" />s
/// with <see cref="LineMergeEdge" />s as their parent edges.
/// </param>
/// <returns>
/// The sequenced geometry, or <c>null</c> if no sequence exists.
/// </returns>
private IGeometry BuildSequencedGeometry(IEnumerable sequences)
{
IList lines = new ArrayList();
IEnumerator i1 = sequences.GetEnumerator();
while (i1.MoveNext())
{
IList seq = (IList)i1.Current;
IEnumerator i2 = seq.GetEnumerator();
while (i2.MoveNext())
{
DirectedEdge de = (DirectedEdge)i2.Current;
LineMergeEdge e = (LineMergeEdge)de.Edge;
ILineString line = e.Line;
ILineString lineToAdd = line;
if (!de.EdgeDirection && !line.IsClosed)
{
lineToAdd = Reverse(line);
}
lines.Add(lineToAdd);
}
}
if (lines.Count == 0)
{
return(factory.CreateMultiLineString(new ILineString[] { }));
}
return(factory.BuildGeometry(lines));
}
private static IMultiLineString ParseWkbMultiLineString(byte[] blob, ref int offset, IGeometryFactory factory, ReadCoordinatesFunction readCoordinates, GaiaImport gaiaImport)
{
int number = gaiaImport.GetInt32(blob, ref offset);
var lineStrings = new ILineString[number];
for (var i = 0; i < number; i++)
{
if (blob[offset++] != (byte)GaiaGeoBlobMark.GAIA_MARK_ENTITY)
{
throw new Exception();
}
var gt = gaiaImport.GetInt32(blob, ref offset);
if (ToBaseGeometryType((GaiaGeoGeometry)gt) != GaiaGeoGeometry.GAIA_LINESTRING)
{
throw new Exception();
}
//Since Uncompressed MultiGeom can contain compressed we need to set it here also
readCoordinates = SetReadCoordinatesFunction(gaiaImport, (GaiaGeoGeometry)gt);
lineStrings[i] = ParseWkbLineString(blob, ref offset, factory, factory.CreateLineString, readCoordinates, gaiaImport);
}
return(factory.CreateMultiLineString(lineStrings));
}
private IMultiLineString ReadMultiLine(SdoGeometry sdoGeom)
{
int[] elements = sdoGeom.ElemArrayOfInts;
ILineString[] lines = new ILineString[sdoGeom.ElemArray.Length / ElementTupleSize];
int i = 0;
while (i < elements.Length / ElementTupleSize)
{
ICoordinateSequence cs = null;
if (GetElementType(elements, i) == (int)SdoGeometryTypes.ETYPE_COMPOUND.FOURDIGIT)
{
int numCompounds = GetNumCompounds(elements, i);
cs = AppendCoordinateSequence(cs, GetCompoundCSeq(i + 1, i + numCompounds, sdoGeom));
ILineString line = _factory.CreateLineString(cs);
lines[i] = line;
i += 1 + numCompounds;
}
else
{
cs = AppendCoordinateSequence(cs, GetElementCoordinateSequence(i, sdoGeom, false));
ILineString line = _factory.CreateLineString(cs);
lines[i] = line;
i++;
}
}
IMultiLineString mls = _factory.CreateMultiLineString(lines);
mls.SRID = (int)sdoGeom.Sdo_Srid;
return(mls);
}
/// <summary>
/// Gets the line for the specified index
/// </summary>
/// <returns>A LineString or MultiLineString geometry created from this shape.</returns>
protected IGeometry FromLine(IGeometryFactory factory)
{
if (factory == null)
{
factory = Geometry.DefaultFactory;
}
List <IBasicLineString> lines = new List <IBasicLineString>();
foreach (PartRange part in _shapeRange.Parts)
{
int i = part.StartIndex;
List <Coordinate> coords = new List <Coordinate>();
foreach (Vertex d in part)
{
Coordinate c = new Coordinate(d.X, d.Y);
coords.Add(c);
if (M != null && M.Length > 0)
{
c.M = M[i];
}
if (Z != null && Z.Length > 0)
{
c.Z = Z[i];
}
i++;
}
lines.Add(factory.CreateLineString(coords));
}
if (lines.Count == 1)
{
return((IGeometry)lines[0]);
}
return(factory.CreateMultiLineString(lines.ToArray()));
}
/// <summary>
/// Creates a MultiLineString.
/// </summary>
/// <returns></returns>
private IGeometry CreateMultiLineString(ICoordinateSequence[] sequences)
{
var ls = new ILineString[sequences.Length];
for (var i = 0; i < sequences.Length; i++)
ls[i] = _factory.CreateLineString(sequences[i]);
return _factory.CreateMultiLineString(ls);
}
/// <summary>
/// Writes to the given stream the equilivent shape file record given a Geometry object.
/// </summary>
/// <param name="geometry">The geometry object to write.</param>
/// <param name="writer">The stream to write to.</param>
/// <param name="factory">The geometry factory to use.</param>
public override void Write(IGeometry geometry, BinaryWriter writer, IGeometryFactory factory)
{
if (geometry == null)
{
throw new ArgumentNullException("geometry");
}
var multi = geometry as IMultiLineString;
if (multi == null)
{
var ls = geometry as ILineString;
if (ls == null)
{
var err = String.Format("Expected geometry that implements 'IMultiLineString' or 'ILineString', but was '{0}'",
geometry.GetType().Name);
throw new ArgumentException(err, "geometry");
}
var arr = new[] { ls };
multi = factory.CreateMultiLineString(arr);
}
writer.Write((int)ShapeType);
var box = multi.EnvelopeInternal;
writer.Write(box.MinX);
writer.Write(box.MinY);
writer.Write(box.MaxX);
writer.Write(box.MaxY);
var numParts = multi.NumGeometries;
var numPoints = multi.NumPoints;
writer.Write(numParts);
writer.Write(numPoints);
// Write the offsets
var offset = 0;
for (var i = 0; i < numParts; i++)
{
var g = multi.GetGeometryN(i);
writer.Write(offset);
offset = offset + g.NumPoints;
}
var zList = HasZValue() ? new List <double>() : null;
var mList = HasMValue() ? new List <double>() : null;
for (var part = 0; part < numParts; part++)
{
var geometryN = (ILineString)multi.GetGeometryN(part);
var points = geometryN.CoordinateSequence;
WriteCoords(points, writer, zList, mList);
}
WriteZM(writer, numPoints, zList, mList);
}
/// <summary>
/// Computes the <see cref="IMultiLineString" /> representation of the WKB.
/// </summary>
/// <param name="geometryBytes">The WKB representation of the geometry.</param>
/// <param name="byteOrder">The byte-order of the conversion.</param>
/// <param name="geometryModel">The geometry model of the conversion.</param>
/// <param name="factory">The factory used for geometry production.</param>
/// <returns>The <see cref="IMultiLineString" /> representation of the geometry.</returns>
private static IMultiLineString ComputeMultiLineString(Byte[] geometryBytes, ByteOrder byteOrder, GeometryModel geometryModel, IGeometryFactory factory)
{
Int32 coordinateSize = (geometryModel == GeometryModel.Spatial3D) ? 24 : 16;
Int32 lineStringCount = EndianBitConverter.ToInt32(geometryBytes, 5, byteOrder);
ILineString[] lineStrings = new ILineString[lineStringCount];
Int32 lineStringStartIndex = 9;
for (Int32 i = 0; i < lineStringCount; i++)
{
Int32 coordinateCount = EndianBitConverter.ToInt32(geometryBytes, lineStringStartIndex, byteOrder);
lineStringStartIndex += 4;
Coordinate[] coordinates = new Coordinate[coordinateCount];
for (Int32 byteIndex = lineStringStartIndex, coordinateIndex = 0; coordinateIndex < coordinateCount; byteIndex += coordinateSize, coordinateIndex++)
{
coordinates[coordinateIndex] = new Coordinate(EndianBitConverter.ToDouble(geometryBytes, byteIndex, byteOrder),
EndianBitConverter.ToDouble(geometryBytes, byteIndex + 8, byteOrder),
geometryModel == GeometryModel.Spatial3D ? EndianBitConverter.ToDouble(geometryBytes, byteIndex + 16, byteOrder) : 0);
}
lineStrings[i] = factory.CreateLineString(coordinates);
}
return(factory.CreateMultiLineString(lineStrings));
}
public static IReadOnlyList <MultiLineStringEntity> CreateMultiLineStringEntities(IGeometryFactory factory)
=> new[]
{
new MultiLineStringEntity
{
Id = 1,
MultiLineString = factory.CreateMultiLineString(
new[]
{
factory.CreateLineString(
new[]
{
new Coordinate(0, 0),
new Coordinate(0, 1)
}),
factory.CreateLineString(
new[]
{
new Coordinate(1, 0),
new Coordinate(1, 1)
})
})
},
new MultiLineStringEntity
{
Id = 2,
MultiLineString = null
}
};
/// <summary>
/// Converts the Well-known Binary (WKB) to a multi line string.
/// </summary>
/// <param name="geometryBytes">The WKB representation of the multi line string.</param>
/// <param name="byteOrder">The byte-order of the conversion.</param>
/// <param name="dimension">The dimension of the geometry.</param>
/// <param name="factory">The geometry factory.</param>
/// <returns>The converted multi line string.</returns>
private static IMultiLineString ToMultiLineString(Byte[] geometryBytes, ByteOrder byteOrder, Int32 dimension, IGeometryFactory factory)
{
Int32 coordinateSize = (dimension == 3) ? 24 : 16;
Int32 lineStringCount = EndianBitConverter.ToInt32(geometryBytes, 5, byteOrder);
ILineString[] lineStrings = new ILineString[lineStringCount];
Int32 lineStringStartIndex = 9;
for (Int32 lineStringIndex = 0; lineStringIndex < lineStringCount; lineStringIndex++)
{
Int32 coordinateCount = EndianBitConverter.ToInt32(geometryBytes, lineStringStartIndex, byteOrder);
lineStringStartIndex += 4;
Coordinate[] coordinates = new Coordinate[coordinateCount];
for (Int32 byteIndex = lineStringStartIndex, coordinateIndex = 0; coordinateIndex < coordinateCount; byteIndex += coordinateSize, coordinateIndex++)
{
coordinates[coordinateIndex] = new Coordinate(EndianBitConverter.ToDouble(geometryBytes, byteIndex, byteOrder),
EndianBitConverter.ToDouble(geometryBytes, byteIndex + 8, byteOrder),
dimension == 3 ? EndianBitConverter.ToDouble(geometryBytes, byteIndex + 16, byteOrder) : 0);
}
lineStrings[lineStringIndex] = factory.CreateLineString(coordinates);
lineStringStartIndex += coordinates.Length * coordinateSize;
}
return(factory.CreateMultiLineString(lineStrings));
}
/// <summary>
/// Reads a <see cref="IMultiLineString"/> from the input stream.
/// </summary>
/// <param name="reader">The binary reader.</param>
/// <param name="factory">The geometry factory to use for geometry creation.</param>
/// <returns>The MultiLineString</returns>
protected IMultiLineString ReadMultiLineString(BinaryReader reader, IGeometryFactory factory)
{
int numGeometries = reader.ReadInt32();
var strings = new ILineString[numGeometries];
ReadGeometryArray(reader, strings);
return(factory.CreateMultiLineString(strings));
}
public object ToMultiLineString(CoordinateInfo[][] coordinates)
{
if (coordinates.Length == 0)
{
return(MultiLineString.Empty);
}
return(_geometryFactory.CreateMultiLineString(coordinates.Select(ToLineString).Cast <IBasicLineString>().ToArray()));
}
#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
#pragma warning restore CS0809 // Obsolete member overrides non-obsolete member
{
reader.Read();
if (!(reader.TokenType == JsonToken.PropertyName && (string)reader.Value == "type"))
{
throw new ArgumentException("invalid tokentype: " + reader.TokenType);
}
reader.Read();
if (reader.TokenType != JsonToken.String)
{
throw new ArgumentException("invalid tokentype: " + reader.TokenType);
}
GeoJsonObjectType geometryType = (GeoJsonObjectType)Enum.Parse(typeof(GeoJsonObjectType), (string)reader.Value);
switch (geometryType)
{
case GeoJsonObjectType.Point:
Coordinate coordinate = _geoJsonSerializer.Deserialize <Coordinate>(reader);
return(_factory.CreatePoint(coordinate));
case GeoJsonObjectType.LineString:
Coordinate[] coordinates = _geoJsonSerializer.Deserialize <Coordinate[]>(reader);
return(_factory.CreateLineString(coordinates));
case GeoJsonObjectType.Polygon:
List <Coordinate[]> coordinatess = _geoJsonSerializer.Deserialize <List <Coordinate[]> >(reader);
return(CreatePolygon(coordinatess));
case GeoJsonObjectType.MultiPoint:
coordinates = _geoJsonSerializer.Deserialize <Coordinate[]>(reader);
return(_factory.CreateMultiPoint(coordinates));
case GeoJsonObjectType.MultiLineString:
coordinatess = _geoJsonSerializer.Deserialize <List <Coordinate[]> >(reader);
List <ILineString> strings = new List <ILineString>();
for (int i = 0; i < coordinatess.Count; i++)
{
strings.Add(_factory.CreateLineString(coordinatess[i]));
}
return(_factory.CreateMultiLineString(strings.ToArray()));
case GeoJsonObjectType.MultiPolygon:
List <List <Coordinate[]> > coordinatesss = _geoJsonSerializer.Deserialize <List <List <Coordinate[]> > >(reader);
List <IPolygon> polygons = new List <IPolygon>();
foreach (List <Coordinate[]> coordinateses in coordinatesss)
{
polygons.Add(CreatePolygon(coordinateses));
}
return(_factory.CreateMultiPolygon(polygons.ToArray()));
case GeoJsonObjectType.GeometryCollection:
List <IGeometry> geoms = _geoJsonSerializer.Deserialize <List <IGeometry> >(reader);
return(_factory.CreateGeometryCollection(geoms.ToArray()));
}
return(null);
}
/// <summary>
/// Reads a stream and converts the shapefile record to an equilivent geometry object.
/// </summary>
/// <param name="file">The stream to read.</param>
/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
/// <returns>The Geometry object that represents the shape file record.</returns>
public override IGeometry Read(BigEndianBinaryReader file, IGeometryFactory geometryFactory)
{
int shapeTypeNum = file.ReadInt32();
ShapeGeometryTypes shapeType = (ShapeGeometryTypes)Enum.Parse(typeof(ShapeGeometryTypes), shapeTypeNum.ToString());
if (!(shapeType == ShapeGeometryTypes.LineString || shapeType == ShapeGeometryTypes.LineStringM ||
shapeType == ShapeGeometryTypes.LineStringZ || shapeType == ShapeGeometryTypes.LineStringZM))
{
throw new ShapefileException("Attempting to load a non-arc as arc.");
}
//read and for now ignore bounds.
double[] box = new double[4];
for (int i = 0; i < 4; i++)
{
double d = file.ReadDouble();
box[i] = d;
}
int numParts = file.ReadInt32();
int numPoints = file.ReadInt32();
int[] partOffsets = new int[numParts];
for (int i = 0; i < numParts; i++)
{
partOffsets[i] = file.ReadInt32();
}
ILineString[] lines = new LineString[numParts];
int start, finish, length;
for (int part = 0; part < numParts; part++)
{
start = partOffsets[part];
if (part == numParts - 1)
{
finish = numPoints;
}
else
{
finish = partOffsets[part + 1];
}
length = finish - start;
CoordinateList points = new CoordinateList();
points.Capacity = length;
Coordinate external;
for (int i = 0; i < length; i++)
{
external = new Coordinate(file.ReadDouble(), file.ReadDouble());
// points.Add(geometryFactory.PrecisionModel.ToInternal(external));
new PrecisionModel(geometryFactory.PrecisionModel).MakePrecise(external);
points.Add(external);
}
lines[part] = geometryFactory.CreateLineString((ICoordinate[])points.ToArray(typeof(ICoordinate)));
}
return(geometryFactory.CreateMultiLineString(lines));
}
private IMultiLineString CreateMultiLineString(List <Coordinate[]> coordinates)
{
ILineString[] strings = new ILineString[coordinates.Count];
for (int i = 0; i < coordinates.Count; i++)
{
strings[i] = _factory.CreateLineString(coordinates[i]);
}
return(_factory.CreateMultiLineString(strings));
}
private IMultiLineString CreateMultiLineString(int[][] data)
{
ILineString[] list = new ILineString[data.Length];
for (int i = 0; i < data.Length; i++)
{
list[i] = CreateLineString(data[i]);
}
return(_factory.CreateMultiLineString(list));
}
/// <summary>
/// Converts the geometry from Geography Markup Language (GML) representation.
/// </summary>
/// <param name="source">The source collection of XML elements.</param>
/// <param name="geometryFactory">The geometry factory.</param>
/// <param name="referenceSystemFactory">The reference system factory.</param>
/// <returns>The converted geometry.</returns>
/// <exception cref="System.ArgumentNullException">
/// The source is null.
/// or
/// The geometry factory is null.
/// or
/// The reference system factory is null.
/// </exception>
/// <exception cref="System.ArgumentException">The specified source is invalid.</exception>
public static IGeometry ToGeometry(this IEnumerable <XElement> source, IGeometryFactory geometryFactory, IReferenceSystemFactory referenceSystemFactory)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (geometryFactory == null)
{
throw new ArgumentNullException(nameof(geometryFactory));
}
if (referenceSystemFactory == null)
{
throw new ArgumentNullException(nameof(referenceSystemFactory));
}
try
{
List <IGeometry> geometries = new List <IGeometry>();
foreach (XElement element in source)
{
geometries.Add(ToGeometry(element, geometryFactory, referenceSystemFactory));
}
if (geometries.Count == 0)
{
return(null);
}
if (geometries.Count == 1)
{
return(geometries[0]);
}
if (geometries.All(geometry => geometry is IPoint))
{
return(geometryFactory.CreateMultiPoint(geometries.Cast <IPoint>()));
}
if (geometries.All(geometry => geometry is ILineString))
{
return(geometryFactory.CreateMultiLineString(geometries.Cast <ILineString>()));
}
if (geometries.All(geometry => geometry is IPolygon))
{
return(geometryFactory.CreateMultiPolygon(geometries.Cast <IPolygon>()));
}
return(geometryFactory.CreateGeometryCollection(geometries));
}
catch (Exception ex)
{
throw new ArgumentException(CoreMessages.SourceIsInvalid, nameof(source), ex);
}
}
private IMultiLineString ReadMultiLine(int dim, int lrsDim,
SdoGeometry sdoGeom)
{
bool lrs = sdoGeom.LRS > 0;
decimal[] info = sdoGeom.ElemArray;
ILineString[] lines =
lrs
? new MLineString[sdoGeom.ElemArray.Length]
: new LineString[sdoGeom.ElemArray.Length];
int i = 0;
while (i < info.Length)
{
ICoordinateSequence cs = null;
//if (info.getElementType(i).isCompound())
//{
// int numCompounds = info.getNumCompounds(i);
// cs = Add(cs, GetCompoundCSeq(i + 1, i + numCompounds, sdoGeom));
// LineString line =
// lrs
// ? factory.CreateMultiLineString(cs)
// : factory.CreateLineString(cs);
// lines[i] = line;
// i += 1 + numCompounds;
//}
//else
//{
cs = Add(cs, GetElementCSeq(i, sdoGeom, false));
//LineString line = lrs ? (LineString)factory.CreateMultiLineString(cs) : factory.CreateLineString(cs);
ILineString line = factory.CreateLineString(cs);
lines[i] = line;
i++;
//}
}
IMultiLineString mls = lrs
? factory.CreateMultiLineString((MLineString[])lines)
: factory.CreateMultiLineString(lines);
mls.SRID = (int)sdoGeom.Sdo_Srid;
return(mls);
}
/// <summary>
/// Creates a <see cref="IMultiLineString"/> 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 MultiLineString Text</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static IMultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreateMultiLineString(null));
}
var lineStrings = new List <ILineString>();
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateMultiLineString(lineStrings.ToArray()));
}
private IGeometry ToGeoAPIMultiLineString(SpatialLite.Core.API.IMultiLineString geometry)
{
var lst = new List <ILineString>();
foreach (var line in geometry.Geometries)
{
lst.Add((ILineString)ToGeoAPILineString(line));
}
return(_factory.CreateMultiLineString(lst.ToArray()));
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
/// </summary>
/// <param name="lines">MultiLineString to transform</param>
/// <param name="from">Source Projection</param>
/// <param name="to">Target Projection</param>
/// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
/// <returns>Transformed MultiLineString</returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var l = new ILineString[lines.Count];
for (var i = 0; i < lines.Count; i++)
{
l[i] = TransformLineString((ILineString)lines.GetGeometryN(i), from, to, toFactory);
}
return(toFactory.CreateMultiLineString(l));
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
/// </summary>
/// <param name="lines">MultiLineString to transform</param>
/// <param name="transform">MathTransform</param>
/// <param name="targetFactory">The factory to create the target geometry</param>
/// <returns>Transformed MultiLineString</returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, IMathTransform transform, IGeometryFactory targetFactory)
{
var lineList = new ILineString[lines.NumGeometries];
for (var i = 0; i < lines.NumGeometries; i++)
{
var line = (ILineString)lines[i];
lineList[i] = TransformLineString(line, transform, targetFactory);
}
return(targetFactory.CreateMultiLineString(lineList));
}
/// <summary>
/// Transforms a <see cref="MultiLineString" /> object.
/// </summary>
/// <param name="factory"></param>
/// <param name="lines"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiLineString TransformMultiLineString(IGeometryFactory factory,
IMultiLineString lines, IMathTransform transform)
{
List <ILineString> strings = new List <ILineString>(lines.Geometries.Length);
foreach (ILineString ls in lines.Geometries)
{
ILineString item = TransformLineString(factory, ls, transform);
strings.Add(item);
}
return(factory.CreateMultiLineString(strings.ToArray()));
}
internal static NTSMultiLineString ToNTSMultiLineString(Geometries.MultiLineString geom,
IGeometryFactory factory)
{
NTSLineString[] lstrings = new NTSLineString[geom.LineStrings.Count];
int index = 0;
foreach (Geometries.LineString lstring in geom.LineStrings)
{
lstrings[index++] = ToNTSLineString(lstring, factory);
}
return(factory.CreateMultiLineString(lstrings) as NTSMultiLineString);
}
public void TestIsClosed()
{
var l = (LineString)reader.Read("LINESTRING EMPTY");
Assert.IsTrue(l.IsEmpty);
Assert.IsTrue(!l.IsClosed);
var r = geometryFactory.CreateLinearRing((ICoordinateSequence)null);
Assert.IsTrue(r.IsEmpty);
Assert.IsTrue(r.IsClosed);
var m = geometryFactory.CreateMultiLineString(
new ILineString[] { l, r });
Assert.IsTrue(!m.IsClosed);
var m2 = geometryFactory.CreateMultiLineString(
new ILineString[] { r });
Assert.IsTrue(!m2.IsClosed);
}
/// <summary>
/// Creates a <c>MultiLineString</c> using the next token in the stream.
/// </summary>
/// <param name="tokens">
/// Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiLineString Text.
/// </param>
/// <returns>
/// A <c>MultiLineString</c> specified by the
/// next token in the stream.</returns>
private IMultiLineString ReadMultiLineStringText(IList tokens)
{
string nextToken = GetNextEmptyOrOpener(tokens);
if (nextToken.Equals("EMPTY"))
{
return(geometryFactory.CreateMultiLineString(new ILineString[] { }));
}
List <ILineString> lineStrings = new List <ILineString>();
ILineString lineString = ReadLineStringText(tokens);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokens);
while (nextToken.Equals(","))
{
lineString = ReadLineStringText(tokens);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokens);
}
return(geometryFactory.CreateMultiLineString(lineStrings.ToArray()));
}
/// <summary>
/// Converts a collection of <see cref="ISegmentString"/>s into a <see cref="IGeometry"/>.
/// The geometry will be either a <see cref="ILineString"/>
/// or a <see cref="IMultiLineString"/> (possibly empty).
/// </summary>
/// <param name="segStrings">A collection of <see cref="ISegmentString"/>.</param>
/// <param name="geomFact">A geometry factory</param>
/// <returns>A <see cref="ILineString"/> or a <see cref="IMultiLineString"/>.</returns>
public static IGeometry ToGeometry(IList<ISegmentString> segStrings, IGeometryFactory geomFact)
{
ILineString[] lines = new ILineString[segStrings.Count];
int index = 0;
foreach (ISegmentString ss in segStrings)
{
ILineString line = geomFact.CreateLineString(ss.Coordinates);
lines[index++] = line;
}
if (lines.Length == 1)
return lines[0];
return geomFact.CreateMultiLineString(lines);
}
/// <summary>
/// Reads a stream and converts the shapefile record to an equilivent geometry object.
/// </summary>
/// <param name="file">The stream to read.</param>
/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
/// <returns>The Geometry object that represents the shape file record.</returns>
public override IGeometry Read(BigEndianBinaryReader file, IGeometryFactory geometryFactory)
{
int shapeTypeNum = file.ReadInt32();
ShapeGeometryTypes shapeType = (ShapeGeometryTypes)Enum.Parse(typeof(ShapeGeometryTypes), shapeTypeNum.ToString());
if( ! ( shapeType == ShapeGeometryTypes.LineString || shapeType == ShapeGeometryTypes.LineStringM ||
shapeType == ShapeGeometryTypes.LineStringZ || shapeType == ShapeGeometryTypes.LineStringZM ))
throw new ShapefileException("Attempting to load a non-arc as arc.");
//read and for now ignore bounds.
double[] box = new double[4];
for (int i = 0; i < 4; i++)
{
double d= file.ReadDouble();
box[i] =d;
}
int numParts = file.ReadInt32();
int numPoints = file.ReadInt32();
int[] partOffsets = new int[numParts];
for (int i = 0; i < numParts; i++)
partOffsets[i] = file.ReadInt32();
ILineString[] lines = new ILineString[numParts];
int start, finish, length;
for (int part = 0; part < numParts; part++)
{
start = partOffsets[part];
if (part == numParts - 1)
finish = numPoints;
else finish = partOffsets[part + 1];
length = finish - start;
CoordinateList points = new CoordinateList();
points.Capacity=length;
ICoordinate external;
for (int i = 0; i < length; i++)
{
external = new Coordinate(file.ReadDouble(),file.ReadDouble());
geometryFactory.PrecisionModel.MakePrecise( external);
points.Add(external);
}
lines[part] = geometryFactory.CreateLineString(points.ToArray());
}
return geometryFactory.CreateMultiLineString(lines);
}
/// <summary>
/// Gets the geometry for the edges in the subdivision as a <see cref="IMultiLineString"/>
/// containing 2-point lines.
/// </summary>
/// <param name="geomFact">the GeometryFactory to use</param>
/// <returns>a IMultiLineString</returns>
public IMultiLineString GetEdges(IGeometryFactory geomFact)
{
var quadEdges = GetPrimaryEdges(false);
ILineString[] edges = new LineString[quadEdges.Count];
int i = 0;
foreach (var qe in quadEdges)
{
edges[i++] = geomFact.CreateLineString(new[] {
qe.Orig.Coordinate, qe.Dest.Coordinate });
}
return geomFact.CreateMultiLineString(edges);
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
/// </summary>
/// <param name="lines">MultiLineString to transform</param>
/// <param name="from">Source Projection</param>
/// <param name="to">Target Projection</param>
/// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
/// <returns>Transformed MultiLineString</returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var l = new ILineString[lines.Count];
for (var i = 0; i < lines.Count; i++)
l[i] = TransformLineString((ILineString)lines.GetGeometryN(i), from, to, toFactory);
return toFactory.CreateMultiLineString(l);
}
private static ILineal RandomLinealZ(IGeometryFactory geometryFactory)
{
switch (Random.Next(0, 2))
{
case 0:
return geometryFactory.CreateLineString(RandomCoordinatesZ(geometryFactory, 2, 10));
case 1:
var ls = new ILineString[Random.Next(2, 5)];
for (int i = 0; i < ls.Length; i++)
ls[i] = geometryFactory.CreateLineString(RandomCoordinatesZ(geometryFactory, 2, 15));
return geometryFactory.CreateMultiLineString(ls);
}
return geometryFactory.CreateLineString(RandomCoordinatesZ(geometryFactory, 2, 10));
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
/// </summary>
/// <param name="lines">MultiLineString to transform</param>
/// <param name="transform">MathTransform</param>
/// <param name="targetFactory">The factory to create the target geometry</param>
/// <returns>Transformed MultiLineString</returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, IMathTransform transform, IGeometryFactory targetFactory)
{
var lineList = new ILineString[lines.NumGeometries];
for (var i = 0; i < lines.NumGeometries; i++)
{
var line = (ILineString)lines[i];
lineList[i] = TransformLineString(line, transform, targetFactory);
}
return targetFactory.CreateMultiLineString(lineList);
}
internal static NTSMultiLineString ToNTSMultiLineString(Geometries.MultiLineString geom,
IGeometryFactory factory)
{
NTSLineString[] lstrings = new NTSLineString[geom.LineStrings.Count];
int index = 0;
foreach (Geometries.LineString lstring in geom.LineStrings)
lstrings[index++] = ToNTSLineString(lstring, factory);
return factory.CreateMultiLineString(lstrings) as NTSMultiLineString;
}
/// <summary>
/// Creates a <see cref="IMultiLineString"/> 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 MultiLineString Text</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static IMultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return factory.CreateMultiLineString(null);
var lineStrings = new List<ILineString>();
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
}
return factory.CreateMultiLineString(lineStrings.ToArray());
}
/// <summary>
/// Writes to the given stream the equilivent shape file record given a Geometry object.
/// </summary>
/// <param name="geometry">The geometry object to write.</param>
/// <param name="file">The stream to write to.</param>
/// <param name="geometryFactory">The geometry factory to use.</param>
public override void Write(IGeometry geometry, BinaryWriter file, IGeometryFactory geometryFactory)
{
// Force to use a MultiGeometry
IMultiLineString multi;
if (geometry is IGeometryCollection)
multi = (IMultiLineString) geometry;
else multi = geometryFactory.CreateMultiLineString(new ILineString[] { (ILineString) geometry });
file.Write(int.Parse(Enum.Format(typeof(ShapeGeometryType), ShapeType, "d")));
IEnvelope box = multi.EnvelopeInternal;
file.Write(box.MinX);
file.Write(box.MinY);
file.Write(box.MaxX);
file.Write(box.MaxY);
int numParts = multi.NumGeometries;
int numPoints = multi.NumPoints;
file.Write(numParts);
file.Write(numPoints);
// Write the offsets
int offset=0;
for (int i = 0; i < numParts; i++)
{
IGeometry g = multi.GetGeometryN(i);
file.Write( offset );
offset = offset + g.NumPoints;
}
for (int part = 0; part < numParts; part++)
{
CoordinateList points = new CoordinateList(multi.GetGeometryN(part).Coordinates);
for (int i = 0; i < points.Count; i++)
{
ICoordinate external = points[i];
file.Write(external.X);
file.Write(external.Y);
}
}
}
/// <summary>
/// Writes to the given stream the equilivent shape file record given a Geometry object.
/// </summary>
/// <param name="geometry">The geometry object to write.</param>
/// <param name="writer">The stream to write to.</param>
/// <param name="geometryFactory">The geometry factory to use.</param>
public override void Write(IGeometry geometry, BinaryWriter writer, IGeometryFactory geometryFactory)
{
// Force to use a MultiGeometry
IMultiLineString multi;
if (geometry is IGeometryCollection)
multi = (IMultiLineString)geometry;
else
multi = geometryFactory.CreateMultiLineString(new[] { (ILineString)geometry });
writer.Write((int)ShapeType);
var box = multi.EnvelopeInternal;
writer.Write(box.MinX);
writer.Write(box.MinY);
writer.Write(box.MaxX);
writer.Write(box.MaxY);
var numParts = multi.NumGeometries;
var numPoints = multi.NumPoints;
writer.Write(numParts);
writer.Write(numPoints);
// Write the offsets
var offset = 0;
for (var i = 0; i < numParts; i++)
{
var g = multi.GetGeometryN(i);
writer.Write(offset);
offset = offset + g.NumPoints;
}
var zList = HasZValue() ? new List<double>() : null;
var mList = HasMValue() ? new List<double>() : null;
for (var part = 0; part < numParts; part++)
{
var geometryN = (ILineString)multi.GetGeometryN(part);
var points = geometryN.CoordinateSequence;
WriteCoords(points, writer, zList, mList);
}
WriteZM(writer, numPoints, zList, mList);
}
private static IMultiLineString CreateWKBMultiLineString(BinaryReader reader, WkbByteOrder byteOrder, IGeometryFactory factory)
{
// Get the number of linestrings in this multilinestring.
var numLineStrings = (int) ReadUInt32(reader, byteOrder);
// Create a new array for the linestrings .
var lines = new ILineString[numLineStrings];
// Loop on the number of linestrings.
for (var i = 0; i < numLineStrings; i++)
{
// Read linestring header
reader.ReadByte();
ReadUInt32(reader, byteOrder);
// Create the next linestring and add it to the array.
lines[i] = CreateWKBLineString(reader, byteOrder, factory);
}
// Create and return the MultiLineString.
return factory.CreateMultiLineString(lines);
}
/// <summary>
/// Reads a stream and converts the shapefile record to an equilivent geometry object.
/// </summary>
/// <param name="file">The stream to read.</param>
/// <param name="totalRecordLength">Total length of the record we are about to read</param>
/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
/// <returns>The Geometry object that represents the shape file record.</returns>
public override IGeometry Read(BigEndianBinaryReader file, int totalRecordLength, IGeometryFactory geometryFactory)
{
int totalRead = 0;
var type = (ShapeGeometryType)ReadInt32(file, totalRecordLength, ref totalRead);
if (type == ShapeGeometryType.NullShape)
return geometryFactory.CreateMultiLineString(null);
if (type != ShapeType)
throw new ShapefileException(string.Format("Encountered a '{0}' instead of a '{1}'", type, ShapeType));
// Read and for now ignore bounds.
int bblength = GetBoundingBoxLength();
boundingBox = new double[bblength];
for (; boundingBoxIndex < 4; boundingBoxIndex++)
{
double d = ReadDouble(file, totalRecordLength, ref totalRead);
boundingBox[boundingBoxIndex] = d;
}
int numParts = ReadInt32(file, totalRecordLength, ref totalRead);
int numPoints = ReadInt32(file, totalRecordLength, ref totalRead);
int[] partOffsets = new int[numParts];
for (int i = 0; i < numParts; i++)
partOffsets[i] = ReadInt32(file, totalRecordLength, ref totalRead);
var lines = new List<ILineString>(numParts);
var buffer = new CoordinateBuffer(numPoints, NoDataBorderValue, true);
var pm = geometryFactory.PrecisionModel;
for (var part = 0; part < numParts; part++)
{
var start = partOffsets[part];
var finish = part == numParts - 1
? numPoints
: partOffsets[part + 1];
var length = finish - start;
for (var i = 0; i < length; i++)
{
var x = pm.MakePrecise(ReadDouble(file, totalRecordLength, ref totalRead));
var y = pm.MakePrecise(ReadDouble(file, totalRecordLength, ref totalRead));
buffer.AddCoordinate(x, y);
}
buffer.AddMarker();
}
// Trond Benum: We have now read all the parts, let's read optional Z and M values
// and populate Z in the coordinate before we start manipulating the segments
// We have to track corresponding optional M values and set them up in the
// Geometries via ICoordinateSequence further down.
GetZMValues(file, totalRecordLength, ref totalRead, buffer);
var sequences = new List<ICoordinateSequence>(buffer.ToSequences(geometryFactory.CoordinateSequenceFactory));
for (var s = 0; s < sequences.Count; s++)
{
var points = sequences[s];
//Skip garbage input data with 0 points
if (points.Count < 1) continue;
var createLineString = true;
if (points.Count == 1)
{
switch (GeometryInstantiationErrorHandling)
{
case GeometryInstantiationErrorHandlingOption.ThrowException:
break;
case GeometryInstantiationErrorHandlingOption.Empty:
sequences[s] = geometryFactory.CoordinateSequenceFactory.Create(0, points.Ordinates);
break;
case GeometryInstantiationErrorHandlingOption.TryFix:
sequences[s] = AddCoordinateToSequence(points, geometryFactory.CoordinateSequenceFactory,
points.GetOrdinate(0, Ordinate.X), points.GetOrdinate(0, Ordinate.Y),
points.GetOrdinate(0, Ordinate.Z), points.GetOrdinate(0, Ordinate.M));
break;
case GeometryInstantiationErrorHandlingOption.Null:
createLineString = false;
break;
}
}
if (createLineString)
{
// Grabs m values if we have them
var line = geometryFactory.CreateLineString(points);
lines.Add(line);
}
}
geom = (lines.Count != 1)
? (IGeometry)geometryFactory.CreateMultiLineString(lines.ToArray())
: lines[0];
return geom;
}
/// <summary>
/// Gets the line for the specified index
/// </summary>
/// <returns>A LineString or MultiLineString geometry created from this shape.</returns>
protected IGeometry FromLine(IGeometryFactory factory)
{
if (factory == null) factory = Geometry.DefaultFactory;
var lines = new List<IBasicLineString>();
foreach (var part in _shapeRange.Parts)
{
var coords = GetCoordinates(part);
lines.Add(factory.CreateLineString(coords));
}
if (lines.Count == 1) return (IGeometry)lines[0];
return factory.CreateMultiLineString(lines.ToArray());
}
/// <summary>
/// Reads a stream and converts the shapefile record to an equilivent geometry object.
/// </summary>
/// <param name="file">The stream to read.</param>
/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
/// <returns>The Geometry object that represents the shape file record.</returns>
public override IGeometry Read(BigEndianBinaryReader file, IGeometryFactory geometryFactory)
{
int shapeTypeNum = file.ReadInt32();
ShapeGeometryTypes shapeType = (ShapeGeometryTypes)Enum.Parse(typeof(ShapeGeometryTypes), shapeTypeNum.ToString());
if (shapeType == ShapeGeometryTypes.NullShape)
return null;
if( ! ( shapeType == ShapeGeometryTypes.LineString || shapeType == ShapeGeometryTypes.LineStringM ||
shapeType == ShapeGeometryTypes.LineStringZ || shapeType == ShapeGeometryTypes.LineStringZM ))
throw new ShapefileException("Attempting to load a non-arc as arc.");
//read and for now ignore bounds.
double[] box = new double[4];
for (int i = 0; i < 4; i++)
{
double d= file.ReadDouble();
box[i] =d;
}
int numParts = file.ReadInt32();
int numPoints = file.ReadInt32();
int[] partOffsets = new int[numParts];
for (int i = 0; i < numParts; i++)
partOffsets[i] = file.ReadInt32();
ILineString[] lines = new ILineString[numParts];
int start, finish, length;
for (int part = 0; part < numParts; part++)
{
start = partOffsets[part];
if (part == numParts - 1)
finish = numPoints;
else finish = partOffsets[part + 1];
length = finish - start;
CoordinateList points = new CoordinateList();
points.Capacity=length;
ICoordinate external;
for (int i = 0; i < length; i++)
{
external = new Coordinate(file.ReadDouble(),file.ReadDouble());
geometryFactory.PrecisionModel.MakePrecise( external);
points.Add(external);
}
if (numPoints < 2)
lines[part] = geometryFactory.CreateLineString(null as Topology.Geometries.ICoordinate[]);
else
lines[part] = geometryFactory.CreateLineString(points.ToArray());
}
//If we have Z-coordinates, read them..
if (shapeType == ShapeGeometryTypes.LineStringZ || shapeType == ShapeGeometryTypes.LineStringZM)
{
//z-Bounds
double zMin = file.ReadDouble();
double zMax = file.ReadDouble();
for (int part = 0; part < numParts; part++)
{
start = partOffsets[part];
if (part == numParts - 1)
finish = numPoints;
else finish = partOffsets[part + 1];
length = finish - start;
for (int i = 0; i < length; i++)
{
double val = file.ReadDouble();
if (numPoints > 1)
{
lines[part].Coordinates[i].Z = val;
}
}
}
}
//If we have M-coordinates, read them..
if (shapeType == ShapeGeometryTypes.LineStringM || shapeType == ShapeGeometryTypes.LineStringZM)
{
//m-Bounds
double mMin = file.ReadDouble();
double mMax = file.ReadDouble();
for (int part = 0; part < numParts; part++)
{
start = partOffsets[part];
if (part == numParts - 1)
finish = numPoints;
else finish = partOffsets[part + 1];
length = finish - start;
for (int i = 0; i < length; i++)
{
double val = file.ReadDouble();
//dont store..
}
}
}
return geometryFactory.CreateMultiLineString(lines);
}
/// <summary>
/// See http://www.gaia-gis.it/gaia-sins/BLOB-Geometry.html
/// for the specification of the spatialite BLOB geometry format
/// Derived from WKB, but unfortunately it is not practical to reuse existing
/// WKB encoding/decoding code
/// </summary>
/// <param name="spatialliteGeom">The geometry blob</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>A geometry</returns>
public static IGeometry Parse(byte[] spatialliteGeom, IGeometryFactory factory)
{
var nBytes = spatialliteGeom.Length;
if (spatialliteGeom.Length < 44
|| spatialliteGeom[0] != 0
|| spatialliteGeom[38] != 0x7C
|| spatialliteGeom[nBytes - 1] != 0xFE)
throw new ApplicationException("Corrupt SpatialLite geom");
bool isLittleEndian = spatialliteGeom[1] == 0x01;
if (spatialliteGeom[1] != 0x00 && spatialliteGeom[1] != 0x01)
throw new ApplicationException("Corrupt SpatialLite geom");
int idx = 39;
int nGType = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
if (nGType < 1 || nGType > 7)
throw new ApplicationException("Unsupported geom type!");
/* -------------------------------------------------------------------- */
/* Point */
/* -------------------------------------------------------------------- */
if (nGType == 1)
{
return factory.CreatePoint(ReadPoint(spatialliteGeom, ref idx, isLittleEndian));
}
/* -------------------------------------------------------------------- */
/* LineString */
/* -------------------------------------------------------------------- */
else if (nGType == 2)
{
return ReadLineString(spatialliteGeom, ref idx, isLittleEndian, factory);
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if (nGType == 3)
{
return ReadPolygon(spatialliteGeom, ref idx, isLittleEndian, factory);
}
/* -------------------------------------------------------------------- */
/* MultiPoint */
/* -------------------------------------------------------------------- */
else if (nGType == 4)
{
List<GeoAPI.Geometries.IPoint> pts = new List<GeoAPI.Geometries.IPoint>();
int numGeoms = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
for (int i = 0; i < numGeoms; i++)
{
if (spatialliteGeom[idx] != 0x69)
throw new ApplicationException("FormatError in SpatiaLIteGeom");
idx++;
int gt = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
if (gt != 1)
throw new ApplicationException("MultiPoint must Contain Point entities");
pts.Add(factory.CreatePoint(ReadPoint(spatialliteGeom, ref idx, isLittleEndian)));
}
return factory.CreateMultiPoint(pts.ToArray());
}
/* -------------------------------------------------------------------- */
/* MultiLineString */
/* -------------------------------------------------------------------- */
else if (nGType == 5)
{
List<GeoAPI.Geometries.ILineString> lss = new List<GeoAPI.Geometries.ILineString>();
int numGeoms = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
for (int i = 0; i < numGeoms; i++)
{
if (spatialliteGeom[idx] != 0x69)
throw new ApplicationException("FormatError in SpatiaLIteGeom");
idx++;
int gt = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
if (gt != 2)
throw new ApplicationException("MultiLineString must contain LineString Entities");
lss.Add(ReadLineString(spatialliteGeom, ref idx, isLittleEndian, factory));
}
return factory.CreateMultiLineString(lss.ToArray());
}
/* -------------------------------------------------------------------- */
/* MultiPolygon */
/* -------------------------------------------------------------------- */
else if (nGType == 6)
{
List<GeoAPI.Geometries.IPolygon> polys = new List<GeoAPI.Geometries.IPolygon>();
int numPolys = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
for (int i = 0; i < numPolys; i++)
{
if (spatialliteGeom[idx] != 0x69)
throw new ApplicationException("FormatError in SpatiaLIteGeom");
idx++;
int gt = ReadUInt32(spatialliteGeom, ref idx, isLittleEndian);
if (gt != 3)
throw new ApplicationException("Multipolygon must contain Polygon Entities");
polys.Add(ReadPolygon(spatialliteGeom, ref idx, isLittleEndian, factory));
}
return factory.CreateMultiPolygon(polys.ToArray());
}
return null;
}
private static IMultiLineString ParseWkbMultiLineString(byte[] blob, ref int offset, IGeometryFactory factory, ReadCoordinatesFunction readCoordinates, GaiaImport gaiaImport)
{
int number = gaiaImport.GetInt32(blob, ref offset);
var lineStrings = new ILineString[number];
for (var i = 0; i < number; i++)
{
if (blob[offset++] != (byte)GaiaGeoBlobMark.GAIA_MARK_ENTITY)
throw new Exception();
var gt = gaiaImport.GetInt32(blob, ref offset);
if (ToBaseGeometryType((GaiaGeoGeometry)gt) != GaiaGeoGeometry.GAIA_LINESTRING)
throw new Exception();
//Since Uncompressed MultiGeom can contain compressed we need to set it here also
readCoordinates = SetReadCoordinatesFunction(gaiaImport, (GaiaGeoGeometry)gt);
lineStrings[i] = ParseWkbLineString(blob, ref offset, factory, factory.CreateLineString, readCoordinates, gaiaImport);
}
return factory.CreateMultiLineString(lineStrings);
}
/// <summary>
/// Gets the line for the specified index
/// </summary>
/// <returns>A LineString or MultiLineString geometry created from this shape.</returns>
protected IGeometry FromLine(IGeometryFactory factory)
{
if (factory == null) factory = Geometry.DefaultFactory;
List<IBasicLineString> lines = new List<IBasicLineString>();
foreach (PartRange part in _shapeRange.Parts)
{
int i = part.StartIndex;
List<Coordinate> coords = new List<Coordinate>();
foreach (Vertex d in part)
{
Coordinate c = new Coordinate(d.X, d.Y);
coords.Add(c);
if (M != null && M.Length > 0) c.M = M[i];
if (Z != null && Z.Length > 0) c.Z = Z[i];
i++;
}
lines.Add(factory.CreateLineString(coords));
}
if (lines.Count == 1) return (IGeometry)lines[0];
return factory.CreateMultiLineString(lines.ToArray());
}
/// <summary>
/// Creates a <c>MultiLineString</c> using the next token in the stream.
/// </summary>
/// <param name="tokens">
/// Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiLineString Text.
/// </param>
/// <param name="factory"> </param>
/// <returns>
/// A <c>MultiLineString</c> specified by the
/// next token in the stream.</returns>
private IMultiLineString ReadMultiLineStringText(IEnumerator<Token> tokens, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokens);
if (nextToken.Equals("EMPTY"))
return factory.CreateMultiLineString( new ILineString[] { } );
var lineStrings = new List<ILineString>();
var lineString = ReadLineStringText(tokens, factory);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokens);
while (nextToken.Equals(",")) {
lineString = ReadLineStringText(tokens, factory);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokens);
}
return factory.CreateMultiLineString(lineStrings.ToArray());
}
/// <summary>
/// Transforms a <see cref="MultiLineString" /> object.
/// </summary>
/// <param name="factory"></param>
/// <param name="lines"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiLineString TransformMultiLineString(IGeometryFactory factory,
IMultiLineString lines, IMathTransform transform)
{
List<ILineString> strings = new List<ILineString>(lines.Geometries.Length);
foreach (ILineString ls in lines.Geometries)
{
ILineString item = TransformLineString(factory, ls, transform);
strings.Add(item);
}
return factory.CreateMultiLineString(strings.ToArray());
}
