private Coordinate GetCoordinate(StreamTokenizer tokenizer)
{
Coordinate coord = null;
double dX = GetNextNumber(tokenizer);
double dY = GetNextNumber(tokenizer);
if (m_bMeasured)
{
double dT = GetNextNumber(tokenizer);
if (IsNumberNext(tokenizer))
{
double dM = GetNextNumber(tokenizer);
coord = new Coordinate3DM(dX, dY, dT, dM);
}
else
{
coord = new CoordinateM(dX, dY, dT);
}
}
else
{
if (IsNumberNext(tokenizer))
{
double dZ = GetNextNumber(tokenizer);
coord = new Coordinate3D(dX, dY, dZ);
}
else
{
coord = new Coordinate(dX, dY);
}
}
return(coord);
}
private void WritePostGIS(Coordinate coord)
{
m_objWriter.WriteDouble(coord.X);
m_objWriter.WriteDouble(coord.Y);
CoordinateType CoordType = coord.CoordinateType;
if (coord.Dimension == 2)
{
if (CoordType == CoordinateType.Measured)
{
CoordinateM measured = (CoordinateM)coord;
m_objWriter.WriteDouble(measured.Measure);
}
}
else
{
// write the Z-value
m_objWriter.WriteDouble(coord.GetOrdinate(2));
// check and write the Measure
if (CoordType == CoordinateType.Measured)
{
Coordinate3DM measured = (Coordinate3DM)coord;
m_objWriter.WriteDouble(measured.Measure);
}
}
}
/// <inheritdoc cref="CoordinateSequence.ToCoordinateArray"/>>
public override Coordinate[] ToCoordinateArray()
{
var ret = GetCachedCoords();
if (ret != null)
{
return(ret);
}
ret = new Coordinate[Count];
if (_z != null)
{
if (_m != null)
{
for (int i = 0; i < ret.Length; i++)
{
ret[i] = new CoordinateZM(_points[i].X, _points[i].Y, _z[i], _m[i]);
}
}
else
{
for (int i = 0; i < ret.Length; i++)
{
ret[i] = new CoordinateZ(_points[i].X, _points[i].Y, _z[i]);
}
}
}
else
{
if (_m != null)
{
for (int i = 0; i < ret.Length; i++)
{
ret[i] = new CoordinateM(_points[i].X, _points[i].Y, _m[i]);
}
}
else
{
for (int i = 0; i < ret.Length; i++)
{
ret[i] = new Coordinate(_points[i].X, _points[i].Y);
}
}
}
_coordinateArrayRef = new WeakReference <Coordinate[]>(ret);
return(ret);
}
public void TestMixedCoordinates()
{
var factory = CsFactory;
var coord1 = new CoordinateZ(1.0, 1.0, 1.0);
var coord2 = new Coordinate(2.0, 2.0);
var coord3 = new CoordinateM(3.0, 3.0, 3.0);
var array = new Coordinate[] { coord1, coord2, coord3, null };
var seq = factory.Create(array);
Assert.That(seq.Dimension, Is.EqualTo(4));
Assert.That(seq.Measures, Is.EqualTo(1));
Assert.That(seq.GetCoordinate(0), Is.EqualTo(coord1));
Assert.That(seq.GetCoordinate(1), Is.EqualTo(coord2));
Assert.That(seq.GetCoordinate(2), Is.EqualTo(coord3));
Assert.That(seq.GetCoordinate(3), Is.Null);
}
public void LineStringElmtBasedWrapperTest()
{
ICoordinate[] coordinates = new ICoordinate[4];
coordinates[0] = new CoordinateM(1, 2, 0, 0);
coordinates[1] = new CoordinateM(3, 4, 0, 1);
coordinates[2] = new CoordinateM(5, 6, -5, 2);
coordinates[3] = new CoordinateM(7, 8, 0, 3.5);
LineString lineString = new LineString()
{
Coordinates = coordinates,
HasZ = false,
IsNodeBased = false,
};
LineStringWrapper wrapper = new LineStringWrapper(lineString);
Assert.AreEqual(ElementType.PolyLine, wrapper.ElementType);
Assert.AreEqual(3, wrapper.ElementCount);
Assert.AreEqual(2, wrapper.GetVertexCount(0));
Assert.AreEqual(2, wrapper.GetVertexCount(1));
Assert.AreEqual(2, wrapper.GetVertexCount(2));
Assert.AreEqual(1, wrapper.GetVertexXCoordinate(0, 0));
Assert.AreEqual(2, wrapper.GetVertexYCoordinate(0, 0));
Assert.AreEqual(0, wrapper.GetVertexMCoordinate(0, 0));
Assert.AreEqual(3, wrapper.GetVertexXCoordinate(0, 1));
Assert.AreEqual(4, wrapper.GetVertexYCoordinate(0, 1));
Assert.AreEqual(1, wrapper.GetVertexMCoordinate(0, 1));
Assert.AreEqual(3, wrapper.GetVertexXCoordinate(1, 0));
Assert.AreEqual(4, wrapper.GetVertexYCoordinate(1, 0));
Assert.AreEqual(1, wrapper.GetVertexMCoordinate(1, 0));
Assert.AreEqual(5, wrapper.GetVertexXCoordinate(1, 1));
Assert.AreEqual(6, wrapper.GetVertexYCoordinate(1, 1));
Assert.AreEqual(2, wrapper.GetVertexMCoordinate(1, 1));
Assert.AreEqual(5, wrapper.GetVertexXCoordinate(2, 0));
Assert.AreEqual(6, wrapper.GetVertexYCoordinate(2, 0));
Assert.AreEqual(2, wrapper.GetVertexMCoordinate(2, 0));
Assert.AreEqual(7, wrapper.GetVertexXCoordinate(2, 1));
Assert.AreEqual(8, wrapper.GetVertexYCoordinate(2, 1));
Assert.AreEqual(3.5, wrapper.GetVertexMCoordinate(2, 1));
}
public void TestCoordinateXYM()
{
var xym = new CoordinateM();
CheckZUnsupported(xym);
xym.M = 1.0;
Assert.That(xym.M, Is.EqualTo(1.0));
var coord = new CoordinateZ(xym); // copy
Assert.That(coord, Is.EqualTo(xym));
Assert.That(coord.Z, Is.NaN);
Assert.That(coord.M, Is.NaN);
coord = new CoordinateZ(1.0, 1.0, 1.0); // 2.5d
xym = new CoordinateM(coord); // copy
Assert.That(xym, Is.EqualTo(coord));
}
/// <summary>
/// Converts a Coordinate to <Point> format, then appends
/// it to the writer.
/// </summary>
/// <param name="coordinate">The Coordinate to process.</param>
/// <param name="writer">The output writer to append to.</param>
private void AppendCoordinate(Coordinate coordinate, TextWriter writer)
{
if (m_bIsMeasured)
{
if (coordinate.Dimension > 2)
{
Coordinate3DM measured = (Coordinate3DM)(coordinate);
writer.Write(WriteNumber(measured.X) + " "
+ WriteNumber(measured.Y) + " "
+ WriteNumber(measured.Z) + " "
+ WriteNumber(measured.Measure));
}
else
{
CoordinateM measured = (CoordinateM)(coordinate);
writer.Write(WriteNumber(measured.X) + " "
+ WriteNumber(measured.Y) + " "
+ WriteNumber(measured.Measure));
}
}
else
{
if (coordinate.Dimension > 2)
{
double dZ = coordinate.GetOrdinate(2);
writer.Write(WriteNumber(coordinate.X) + " "
+ WriteNumber(coordinate.Y) + " "
+ WriteNumber(dZ));
}
else
{
writer.Write(WriteNumber(coordinate.X) + " "
+ WriteNumber(coordinate.Y));
}
}
}
private Coordinate ReadCoordinate(bool hasZ, bool hasM)
{
double x = m_objReader.ReadDouble();
double y = m_objReader.ReadDouble();
Coordinate coord = null;
if (hasZ)
{
double z = m_objReader.ReadDouble();
if (hasM)
{
double m = m_objReader.ReadDouble();
coord = new Coordinate3DM(x, y, z, m);
}
else
{
coord = new Coordinate3D(x, y, y);
}
}
else
{
if (hasM)
{
double m = m_objReader.ReadDouble();
coord = new CoordinateM(x, y, m);
}
else
{
coord = new Coordinate(x, y);
}
}
coord.MakePrecise(m_objPrecision);
return(coord);
}
/// <summary>
///
/// </summary>
/// <param name="coordinate"></param>
/// <param name="writer"></param>
/// <param name="usePrefix"></param>
/// <param name="coordPrefix"></param>
private void WriteCoord(Coordinate coordinate, XmlWriter writer,
bool usePrefix, string coordPrefix)
{
if (usePrefix)
{
writer.WriteStartElement(m_strPrefix, GeometryGml2.GmlCoord, null);
}
else
{
writer.WriteStartElement(GeometryGml2.GmlCoord);
}
// write the X and Y
if (usePrefix)
{
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordX,
WriteNumber(coordinate.X));
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordY,
WriteNumber(coordinate.Y));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordX,
WriteNumber(coordinate.X));
writer.WriteElementString(GeometryGml2.GmlCoordY,
WriteNumber(coordinate.Y));
}
// if available, write the Z
if (coordinate.Dimension > 2)
{
double dZ = coordinate.GetOrdinate(2);
if (usePrefix)
{
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordZ,
WriteNumber(dZ));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordZ,
WriteNumber(dZ));
}
}
// if available, add the M
if (m_bIsMeasured)
{
if (coordinate.Dimension > 2)
{
Coordinate3DM measured = (Coordinate3DM)(coordinate);
if (usePrefix)
{
writer.WriteElementString(coordPrefix +
GeometryGml2.GmlCoordM, WriteNumber(measured.Measure));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordM,
WriteNumber(measured.Measure));
}
}
else
{
CoordinateM measured = (CoordinateM)(coordinate);
if (usePrefix)
{
writer.WriteElementString(coordPrefix +
GeometryGml2.GmlCoordM, WriteNumber(measured.Measure));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordM,
WriteNumber(measured.Measure));
}
}
}
writer.WriteEndElement();
}
/// <summary>
///
/// </summary>
/// <param name="coordinate"></param>
/// <param name="writer"></param>
private void Write(Coordinate coordinate, XmlWriter writer)
{
bool usePrefix = false;
string coordPrefix = null;
if (m_bUsePrefix && (m_strPrefix != null && m_strPrefix.Length != 0))
{
usePrefix = true;
coordPrefix = m_strPrefix + ":";
}
// if used to use the "coord" coordinates option or we have the
// measured coordinate type...
if (m_bUseCoord || m_bIsMeasured)
{
if (usePrefix)
{
writer.WriteStartElement(m_strPrefix, GeometryGml2.GmlCoord, null);
}
else
{
writer.WriteStartElement(GeometryGml2.GmlCoord);
}
// write the X and Y
if (usePrefix)
{
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordX,
WriteNumber(coordinate.X));
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordY,
WriteNumber(coordinate.Y));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordX,
WriteNumber(coordinate.X));
writer.WriteElementString(GeometryGml2.GmlCoordY,
WriteNumber(coordinate.Y));
}
// if available, write the Z
if (coordinate.Dimension > 2)
{
double dZ = coordinate.GetOrdinate(2);
if (usePrefix)
{
writer.WriteElementString(coordPrefix + GeometryGml2.GmlCoordZ,
WriteNumber(dZ));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordZ,
WriteNumber(dZ));
}
}
// if available, add the M
if (m_bIsMeasured)
{
if (coordinate.Dimension > 2)
{
Coordinate3DM measured = (Coordinate3DM)(coordinate);
if (usePrefix)
{
writer.WriteElementString(coordPrefix +
GeometryGml2.GmlCoordM, WriteNumber(measured.Measure));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordM,
WriteNumber(measured.Measure));
}
}
else
{
CoordinateM measured = (CoordinateM)(coordinate);
if (usePrefix)
{
writer.WriteElementString(coordPrefix +
GeometryGml2.GmlCoordM, WriteNumber(measured.Measure));
}
else
{
writer.WriteElementString(GeometryGml2.GmlCoordM,
WriteNumber(measured.Measure));
}
}
}
writer.WriteEndElement();
}
else
{
if (usePrefix)
{
writer.WriteStartElement(m_strPrefix,
GeometryGml2.GmlCoordinates, null);
}
else
{
writer.WriteStartElement(GeometryGml2.GmlCoordinates);
}
if (coordinate.Dimension > 2)
{
double dZ = coordinate.GetOrdinate(2);
writer.WriteString(WriteNumber(coordinate.X) +
GeometryGml2.GmlCoordinateSeparator
+ WriteNumber(coordinate.Y) + GeometryGml2.GmlCoordinateSeparator
+ WriteNumber(dZ));
}
else
{
writer.WriteString(WriteNumber(coordinate.X) +
GeometryGml2.GmlCoordinateSeparator
+ WriteNumber(coordinate.Y));
}
writer.WriteEndElement();
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
private Coordinate ReadCoord(XmlReader reader)
{
Coordinate coordinate = null;
double x = 0, y = 0, z = Double.NaN, m = Double.NaN;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == GeometryGml2.GmlCoordX)
{
x = Convert.ToDouble(reader.ReadString());
}
else if (reader.Name == GeometryGml2.GmlCoordY)
{
y = Convert.ToDouble(reader.ReadString());
}
else if (reader.Name == GeometryGml2.GmlCoordZ)
{
z = Convert.ToDouble(reader.ReadString());
}
else if (reader.Name == GeometryGml2.GmlCoordM)
{
m = Convert.ToDouble(reader.ReadString());
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == GeometryGml2.GmlCoord)
{
break;
}
}
}
if (Double.IsNaN(z) || Double.IsInfinity(z))
{
if ((Double.IsNaN(m) || Double.IsInfinity(m)))
{
coordinate = new Coordinate(x, y);
}
else
{
coordinate = new CoordinateM(x, y, m);
}
}
else
{
if ((Double.IsNaN(m) || Double.IsInfinity(m)))
{
coordinate = new Coordinate3D(x, y, z);
}
else
{
coordinate = new Coordinate3DM(x, y, z, m);
}
}
return(coordinate);
}