/// <summary> /// Reads a stream and converts the shapefile record to an equilivant 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="factory">The geometry factory to use when making the object.</param> /// <returns>The Geometry object that represents the shape file record.</returns> public override Geometry Read(BigEndianBinaryReader file, int totalRecordLength, GeometryFactory factory) { int totalRead = 0; int shapeTypeNum = ReadInt32(file, totalRecordLength, ref totalRead); var type = (ShapeGeometryType)EnumUtility.Parse(typeof(ShapeGeometryType), shapeTypeNum.ToString()); if (type == ShapeGeometryType.NullShape) { return(factory.CreateMultiPoint()); } 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; } // Read points int numPoints = ReadInt32(file, totalRecordLength, ref totalRead); var buffer = new CoordinateBuffer(numPoints, NoDataBorderValue, true); var points = new Point[numPoints]; var pm = factory.PrecisionModel; for (int i = 0; i < numPoints; i++) { double x = pm.MakePrecise(ReadDouble(file, totalRecordLength, ref totalRead)); double y = pm.MakePrecise(ReadDouble(file, totalRecordLength, ref totalRead)); buffer.AddCoordinate(x, y); buffer.AddMarker(); } // Trond Benum: We have now read all the points, let's read optional Z and M values GetZMValues(file, totalRecordLength, ref totalRead, buffer); var sequences = buffer.ToSequences(factory.CoordinateSequenceFactory); for (int i = 0; i < numPoints; i++) { points[i] = factory.CreatePoint(sequences[i]); } geom = factory.CreateMultiPoint(points); return(geom); }
public static IGeometry FromFlatbuf(Feature feature, GeometryType type, byte dimensions) { var coords = feature.GetCoordsArray(); var lengths = feature.GetLengthsArray(); var ringLengths = feature.GetRingLengthsArray(); var ringCounts = feature.GetRingCountsArray(); var sequenceFactory = new PackedCoordinateSequenceFactory(); var factory = new GeometryFactory(); switch (type) { case GeometryType.Point: return(factory.CreatePoint(sequenceFactory.Create(coords, dimensions))); case GeometryType.MultiPoint: return(factory.CreateMultiPoint(sequenceFactory.Create(coords, dimensions))); case GeometryType.LineString: return(factory.CreateLineString(sequenceFactory.Create(coords, dimensions))); case GeometryType.MultiLineString: return(ParseFlatbufMultiLineString(lengths, coords, dimensions)); case GeometryType.Polygon: return(ParseFlatbufPolygon(ringLengths, coords, dimensions)); case GeometryType.MultiPolygon: return(ParseFlatbufMultiPolygon(lengths, ringLengths, ringCounts, coords, dimensions)); default: throw new ApplicationException("FromFlatbuf: Unsupported geometry type"); } }
/// <summary> /// Method to create a MultiPoint for testing purposes /// </summary> /// <returns>A MultiPoint</returns> private MultiPoint CreateTester2() { Point[] points = new Point[18]; GeometryFactory gf = new GeometryFactory(_precMod, _sRID); points[0] = gf.CreatePoint(new Coordinate(2, 2)); points[1] = gf.CreatePoint(new Coordinate(3, 3)); points[2] = gf.CreatePoint(new Coordinate(4, 4)); points[3] = gf.CreatePoint(new Coordinate(5, 5)); points[4] = gf.CreatePoint(new Coordinate(6, 6)); points[5] = gf.CreatePoint(new Coordinate(7, 7)); points[6] = gf.CreatePoint(new Coordinate(8, 8)); points[7] = gf.CreatePoint(new Coordinate(9, 7)); points[8] = gf.CreatePoint(new Coordinate(10, 6)); points[9] = gf.CreatePoint(new Coordinate(10, 5)); points[10] = gf.CreatePoint(new Coordinate(9, 4)); points[11] = gf.CreatePoint(new Coordinate(8, 3)); points[12] = gf.CreatePoint(new Coordinate(7, 4)); points[13] = gf.CreatePoint(new Coordinate(7, 5)); points[14] = gf.CreatePoint(new Coordinate(6, 6)); points[15] = gf.CreatePoint(new Coordinate(5, 7)); points[16] = gf.CreatePoint(new Coordinate(4, 8)); points[17] = gf.CreatePoint(new Coordinate(3, 9)); MultiPoint mp = gf.CreateMultiPoint(points); return(mp); }
private Feature ConvertRelation(CompleteRelation relation) { if (IsMultipolygon(relation)) { return(ConvertToMultipolygon(relation)); } var nodes = relation.Members.Select(m => m.Member).OfType <Node>().ToList(); if (nodes.Any()) { var multiPoint = _geometryFactory.CreateMultiPoint(nodes.Select(n => _geometryFactory.CreatePoint(ConvertNode(n))).ToArray()); return(new Feature(multiPoint, ConvertTags(relation))); } var geometries = GetGeometriesFromWays(GetAllWays(relation)); if (!geometries.Any()) { return(null); } var jointLines = geometries.OfType <LineString>().ToList(); jointLines.AddRange(geometries.OfType <Polygon>().Select(p => _geometryFactory.CreateLineString(p.ExteriorRing.Coordinates.ToArray()) as LineString)); var multiLineString = _geometryFactory.CreateMultiLineString(jointLines.ToArray()); return(new Feature(multiLineString, ConvertTags(relation))); }
/// <summary> /// Method to create a MultiPoint for testing purposes /// </summary> /// <returns>A MultiPoint</returns> private MultiPoint CreateTester3() { Point[] points = new Point[21]; GeometryFactory gf = new GeometryFactory(_precMod, _sRID); points[0] = gf.CreatePoint(new Coordinate(10, 13)); points[1] = gf.CreatePoint(new Coordinate(11, 13)); points[2] = gf.CreatePoint(new Coordinate(12, 13)); points[3] = gf.CreatePoint(new Coordinate(13, 14)); points[4] = gf.CreatePoint(new Coordinate(14, 15)); points[5] = gf.CreatePoint(new Coordinate(15, 16)); points[6] = gf.CreatePoint(new Coordinate(15, 17)); points[7] = gf.CreatePoint(new Coordinate(15, 18)); points[8] = gf.CreatePoint(new Coordinate(14, 19)); points[9] = gf.CreatePoint(new Coordinate(13, 20)); points[10] = gf.CreatePoint(new Coordinate(12, 21)); points[11] = gf.CreatePoint(new Coordinate(11, 21)); points[12] = gf.CreatePoint(new Coordinate(10, 21)); points[13] = gf.CreatePoint(new Coordinate(9, 20)); points[14] = gf.CreatePoint(new Coordinate(8, 19)); points[15] = gf.CreatePoint(new Coordinate(7, 18)); points[16] = gf.CreatePoint(new Coordinate(7, 17)); points[17] = gf.CreatePoint(new Coordinate(7, 16)); points[18] = gf.CreatePoint(new Coordinate(8, 15)); points[19] = gf.CreatePoint(new Coordinate(9, 14)); points[20] = gf.CreatePoint(new Coordinate(10, 13)); MultiPoint mp = gf.CreateMultiPoint(points); return(mp); }
public void TopoJsonWriterWrittenContentTest() { GeometryFactory factory = new GeometryFactory(); IMultiPolygon mp = factory.CreateMultiPolygon ( new List <IPolygon> { factory.CreatePolygon(factory.CreatePoint(10, 10), factory.CreatePoint(20, 10), factory.CreatePoint(25, 17), factory.CreatePoint(10, 10)), factory.CreatePolygon(factory.CreatePoint(50, 30), factory.CreatePoint(40, 20), factory.CreatePoint(20, 10), factory.CreatePoint(25, 17), factory.CreatePoint(30, 30), factory.CreatePoint(50, 30)) } ); Assert.AreEqual(2, mp.Count); IMultiPoint p = factory.CreateMultiPoint( new IPoint[2] { factory.CreatePoint(10, 10), factory.CreatePoint(23, 23) }); ILineString lstr = factory.CreateLineString( factory.CreatePoint(50, 60), factory.CreatePoint(55, 60), factory.CreatePoint(71, 71) ); List <IGeometry> geo = new List <IGeometry>() { p, lstr }; string outFileName = _outputPath + ".topojson"; TopoJsonWriter writer = new TopoJsonWriter(outFileName); writer.Write(mp as IGeometry); writer.Write(geo); writer.Close(); TopoJsonReader reader = new TopoJsonReader(outFileName); IList <IGeometry> geometries = reader.ReadToEnd(); reader.Close(); GeometryComparer comp = new GeometryComparer(); Assert.AreEqual(0, comp.Compare(geometries[0], mp)); Assert.AreEqual(0, comp.Compare(geometries[1], p)); Assert.AreEqual(0, comp.Compare(geometries[2], lstr)); }
/// <summary> /// Method to create a MultiPoint for testing purposes /// </summary> /// <returns>A MultiPoint</returns> private MultiPoint CreateTester1() { GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Point[] points = new Point[23]; for (int i = 0; i < 12; i++) { points[i] = gf.CreatePoint(new Coordinate(i, i)); } points[12] = gf.CreatePoint(new Coordinate(11, 12)); points[13] = gf.CreatePoint(new Coordinate(10, 13)); points[14] = gf.CreatePoint(new Coordinate(9, 14)); points[15] = gf.CreatePoint(new Coordinate(8, 15)); points[16] = gf.CreatePoint(new Coordinate(9, 16)); points[17] = gf.CreatePoint(new Coordinate(10, 17)); points[18] = gf.CreatePoint(new Coordinate(11, 18)); points[19] = gf.CreatePoint(new Coordinate(12, 19)); points[20] = gf.CreatePoint(new Coordinate(11, 20)); points[21] = gf.CreatePoint(new Coordinate(10, 21)); points[22] = gf.CreatePoint(new Coordinate(9, 22)); MultiPoint mp = gf.CreateMultiPoint(points); return(mp); }
/// <summary> /// Reads a <see cref="MultiPoint"/> 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 MultiPoint</returns> protected MultiPoint ReadMultiPoint(BinaryReader reader, GeometryFactory factory) { int numGeometries = reader.ReadInt32(); var points = new Point[numGeometries]; ReadGeometryArray(reader, points); return(factory.CreateMultiPoint(points)); }
public override object?ParseLiteral(IValueNode literal) { if (literal is NullValueNode) { return(null); } if (!(literal is ObjectValueNode obj) || obj.Fields.Count < 2) { throw ThrowHelper.InvalidInputObjectStructure(_geometryType); } (int typeIndex, int coordinateIndex, int crsIndex)indices = ParseLiteralHelper.GetFieldIndices(obj, _typeFieldName, _coordinatesFieldName, _crsFieldName); if (indices.typeIndex == -1) { throw ThrowHelper.InvalidInputObjectStructure(_geometryType); } var type = (GeoJSONGeometryType) _typeField.Type.ParseLiteral(obj.Fields[indices.typeIndex].Value); if (type != _geometryType || indices.coordinateIndex == -1) { throw ThrowHelper.InvalidInputObjectStructure(_geometryType); } var coordinates = (IList <Coordinate>) _coordinatesField.Type.ParseLiteral(obj.Fields[indices.coordinateIndex].Value); if (coordinates.Count < 1) { throw ThrowHelper.InvalidInputObjectStructure(_geometryType); } var pointCount = coordinates.Count; var points = new Point[pointCount]; for (var i = 0; i < pointCount; i++) { points[i] = new Point(coordinates[i]); } if (indices.crsIndex == -1) { return(new MultiPoint(points)); } var srid = (int)_crsField.Type.ParseLiteral(obj.Fields[indices.crsIndex].Value); GeometryFactory factory = NtsGeometryServices.Instance.CreateGeometryFactory(srid); return(factory.CreateMultiPoint(points)); }
private static IGeometry SqlGeometryToGeometryMultiPoint(SqlGeometry geometry, GeometryFactory factory) { IPoint[] points = new IPoint[geometry.STNumGeometries().Value]; for (int i = 1; i <= points.Length; i++) { points[i - 1] = SqlGeometryToGeometryPoint(geometry.STGeometryN(i), factory); } return(factory.CreateMultiPoint(points)); }
private static Geometry CreateMultiPoint(Ordinates ordinates, bool empty) { if (empty) { return(Factory.CreateMultiPoint((CoordinateSequence)null)); } int numPoints = Rnd.Next(75, 101); var seq = CsFactory.Create(numPoints, ordinates); for (int i = 0; i < numPoints; i++) { foreach (var o in ToOrdinateArray(ordinates)) { seq.SetOrdinate(i, o, RandomOrdinate(o, Factory.PrecisionModel)); } } return(Factory.CreateMultiPoint(seq)); }
/// <summary> /// Function to read a <see cref="MultiPoint"/> from a ShapeFile stream using the specified <paramref name="reader"/>. /// </summary> /// <param name="reader">The reader to use</param> /// <param name="ordinates">The ordinates to read</param> /// <returns>The read polygonal geometry</returns> public Geometry ReadMultiPoint(BinaryReader reader, Ordinates ordinates) { /*var bbox = */ ReadBoundingBox(reader); // jump boundingbox int numPoints = ReadNumPoints(reader); var buffer = new CoordinateBuffer(numPoints, ShapeFileConstants.NoDataBorder, true); ReadCoordinates(reader, numPoints, new[] { numPoints - 1 }, ordinates, buffer); return(_factory.CreateMultiPoint(buffer.ToSequence())); }
public void TestWriteMultiPoint() { Point[] points = { _factory.CreatePoint(new CoordinateZ(10, 10, 0)), _factory.CreatePoint(new CoordinateZ(20, 20, 0)) }; var multiPoint = _factory.CreateMultiPoint(points); Assert.AreEqual("MULTIPOINT ((10 10), (20 20))", _writer.Write(multiPoint)); }
public void TestMultiPoint1() { Coordinates coordinates = new Coordinates(); coordinates.Add(new Coordinate(1, 2)); coordinates.Add(new Coordinate(1.2, 2.3)); MultiPoint multipoint = _factory.CreateMultiPoint(coordinates); string wkt = _writer.WriteFormatted(multipoint); Assertion.AssertEquals("multi point", "MULTIPOINT (1 2, 1.2 2.3)", wkt); }
public void CreateEmptyMultiPointSucceeds() { GeometryFactory factory = new GeometryFactory( new BufferedCoordinate2DFactory(), new BufferedCoordinate2DSequenceFactory()); IMultiPoint p = factory.CreateMultiPoint(); Assert.IsNotNull(p); Assert.IsTrue(p.IsEmpty); }
private void SimplifyGeometriesCollection(List <Feature> results) { foreach (var feature in results) { if (!(feature.Geometry is GeometryCollection geometryCollection)) { continue; } if (geometryCollection.Geometries.All(g => g is Point || g is MultiPoint)) { var points = geometryCollection.Geometries .OfType <MultiPoint>() .SelectMany(mls => mls.Geometries.OfType <Point>()) .Concat(geometryCollection.Geometries.OfType <Point>()) .ToArray(); feature.Geometry = _geometryFactory.CreateMultiPoint(points); continue; } var nonPointGeometries = geometryCollection.Geometries.Where(g => !(g is Point)); if (nonPointGeometries.Count() == 1) { feature.Geometry = nonPointGeometries.First(); continue; } if (nonPointGeometries.All(g => g is LineString || g is MultiLineString)) { var lines = nonPointGeometries .OfType <MultiLineString>() .SelectMany(mls => mls.Geometries.OfType <LineString>()) .Concat(nonPointGeometries.OfType <LineString>()) .ToArray(); feature.Geometry = _geometryFactory.CreateMultiLineString(lines); continue; } if (nonPointGeometries.All(g => g is Polygon || g is MultiPolygon)) { var polygons = nonPointGeometries .OfType <MultiPolygon>() .SelectMany(mls => mls.Geometries.OfType <Polygon>()) .Concat(nonPointGeometries.OfType <Polygon>()) .ToArray(); feature.Geometry = _geometryFactory.CreateMultiPolygon(polygons); if (!feature.Geometry.IsValid) { feature.Attributes.AddOrUpdate(FeatureAttributes.POI_CONTAINER, false); _reportLogger.LogWarning("There was a problem merging the following feature " + feature.GetTitle(Languages.HEBREW) + " (" + feature.GetId() + ") "); } continue; } _reportLogger.LogWarning("The following merge created a weird geometry: " + feature.GetTitle(Languages.HEBREW) + " (" + feature.GetId() + ") " + string.Join(", ", geometryCollection.Geometries.Select(g => g.GeometryType))); feature.Geometry = nonPointGeometries.FirstOrDefault(); } }
private void Run(int nPts) { var randPts = CreateRandomPoints(nPts); IGeometry mp = _geomFact.CreateMultiPoint(randPts); var mbc = new MinimumBoundingCircle(mp); var centre = mbc.GetCentre(); double radius = mbc.GetRadius(); Console.WriteLine("Testing " + nPts + " random points. Radius = " + radius); checkWithinCircle(randPts, centre, radius, 0.0001); }
public void ParseMultiPoint() { string multipoint = "MULTIPOINT(20.564 346.3493254,45 32,23 54)"; IMultiPoint geom = GeometryFromWKT.Parse(multipoint) as IMultiPoint; Assert.IsNotNull(geom); Assert.AreEqual(20.564, (geom.Geometries[0] as IPoint).X); Assert.AreEqual(54, (geom.Geometries[2] as IPoint).Y); Assert.AreEqual(multipoint, geom.AsText()); Assert.IsTrue(GeometryFromWKT.Parse("MULTIPOINT EMPTY").IsEmpty); Assert.AreEqual("MULTIPOINT EMPTY", GeometryFactory.CreateMultiPoint(null).AsText()); }
private MultiPoint ReadMultiPoint() { int nPoints = m_objReader.ReadInt32(); Point[] points = new Point[nPoints]; for (int i = 0; i < nPoints; i++) { BytesOrder byteOrder = (BytesOrder)m_objReader.ReadByte(); // handle the byte order m_objReader.Order = byteOrder; int geomType = m_objReader.ReadInt32(); if (geomType != 1) { throw new GeometryIOException("The data is badly formed. " + "A Point geometry is expected"); } points[i] = ReadPoint(); } return(m_objFactory.CreateMultiPoint(points)); }
internal static MultiPoint ToNTSMultiPoint(Geometries.MultiPoint multiPoint, GeometryFactory factory) { GisSharpBlog.NetTopologySuite.Geometries.Point[] points = new GisSharpBlog.NetTopologySuite.Geometries.Point[multiPoint.Points.Count]; int index = 0; foreach (Point point in multiPoint.Points) { points[index++] = ToNTSPoint(point, factory); } return(factory.CreateMultiPoint(points) as MultiPoint); }
public void test_IsEmpty() { //create a new multipoint MultiPoint mp = CreateTester1(); Assertion.AssertEquals("IsEmpty1: ", false, mp.IsEmpty()); //Set multipoint to be empty to test the else GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Coordinates coords = new Coordinates(); MultiPoint mp2 = gf.CreateMultiPoint(coords); Assertion.AssertEquals("IsEmpty2: ", true, mp2.IsEmpty()); }
private Geometry CreatePointResult(IReadOnlyCollection <Point> points) { if (points.Count == 0) { return(_geometryFactory.CreateEmpty(0)); } if (points.Count == 1) { return(points.First()); } var pointsArray = GeometryFactory.ToPointArray(points); return(_geometryFactory.CreateMultiPoint(pointsArray)); }
public void TestCreateEmpty() { CheckEmpty(Factory.CreateEmpty(Dimension.Point), typeof(Point)); CheckEmpty(Factory.CreateEmpty(Dimension.Curve), typeof(LineString)); CheckEmpty(Factory.CreateEmpty(Dimension.Surface), typeof(Polygon)); CheckEmpty(Factory.CreatePoint(), typeof(Point)); CheckEmpty(Factory.CreateLineString(), typeof(LineString)); CheckEmpty(Factory.CreatePolygon(), typeof(Polygon)); CheckEmpty(Factory.CreateMultiPoint(), typeof(MultiPoint)); CheckEmpty(Factory.CreateMultiLineString(), typeof(MultiLineString)); CheckEmpty(Factory.CreateMultiPolygon(), typeof(MultiPolygon)); CheckEmpty(Factory.CreateGeometryCollection(), typeof(GeometryCollection)); }
/// <summary> /// Creates a new MultiPoint geometry from a MultiPoint shape. /// </summary> /// <param name="factory">The GeometryFactory to use to create the new shape.</param> /// <returns>The resulting multipoint.</returns> protected Geometry FromMultiPoint(GeometryFactory factory) { if (factory == null) { factory = Geometry.DefaultFactory; } var coords = new List <Coordinate>(); foreach (var part in Range.Parts) { GetCoordinates(part, coords); } return(factory.CreateMultiPoint(coords.CastToPointArray())); }
public void test_CompareToSameClass() { LineString ls = SimpleOpen(); LineString ls2 = SimpleOpen(); LineString ls3 = SimpleClosed(); Point[] coords = new Point[] {}; GeometryFactory gf = new GeometryFactory(_precMod, _sRID); MultiPoint mp = gf.CreateMultiPoint(coords); Assertion.AssertEquals("CompareToSameClass-1: ", 0, ls.CompareToSameClass(ls2)); Assertion.AssertEquals("CompareToSameClass-2: ", 1, ls.CompareToSameClass(ls3)); Assertion.AssertEquals("CompareToSameClass-3: ", 1, ls.CompareToSameClass(mp)); Assertion.AssertEquals("CompareToSameClass-4: ", -1, ls3.CompareToSameClass(ls)); Assertion.AssertEquals("CompareToSameClass-5: ", -1, mp.CompareToSameClass(ls)); }
/// <summary> /// Transforms a <see cref="GisSharpBlog.NetTopologySuite.Geometries.MultiPoint"/>. /// </summary> /// <param name="points">MultiPoint to transform</param> /// <param name="transform">MathTransform</param> /// <returns>Transformed MultiPoint</returns> public static IMultiPoint TransformMultiPoint(IMultiPoint points, IMathTransform transform) { List <double[]> pointList = new List <double[]>(points.Geometries.Length); foreach (IPoint p in points.Geometries) { pointList.Add(ToLightStruct(p.X, p.Y)); } pointList = transform.TransformList(pointList); IPoint[] array = new IPoint[pointList.Count]; for (int i = 0; i < pointList.Count; i++) { array[i] = ToNTS(pointList[i][0], pointList[i][1]); } return(GeometryFactory.CreateMultiPoint(array)); }
public static void main(string[] args) { // create a factory using default values (e.g. floating precision) var fact = new GeometryFactory(); var p1 = fact.CreatePoint(new Coordinate(0, 0)); Console.WriteLine(p1); var p2 = fact.CreatePoint(new Coordinate(1, 1)); Console.WriteLine(p1); var mpt = fact.CreateMultiPoint(new Coordinate[] { new Coordinate(0, 0), new Coordinate(1, 1), }); Console.WriteLine(mpt); }
public static IGeometry FromFlatbuf(Geometry geometry, GeometryType type) { byte dimensions = 2; var factory = new GeometryFactory(); if (type == GeometryType.Unknown) { type = geometry.Type; } switch (type) { case GeometryType.MultiPolygon: int partsLength = geometry.PartsLength; Polygon[] polygons = new Polygon[partsLength]; for (int i = 0; i < geometry.PartsLength; i++) { polygons[i] = (Polygon)FromFlatbuf(geometry.Parts(i).Value, GeometryType.Polygon); } return(factory.CreateMultiPolygon(polygons)); } var coords = geometry.GetXyArray(); var ends = geometry.GetEndsArray(); var sequenceFactory = new PackedCoordinateSequenceFactory(); switch (type) { case GeometryType.Point: return(factory.CreatePoint(sequenceFactory.Create(coords, dimensions))); case GeometryType.MultiPoint: return(factory.CreateMultiPoint(sequenceFactory.Create(coords, dimensions))); case GeometryType.LineString: return(factory.CreateLineString(sequenceFactory.Create(coords, dimensions))); case GeometryType.MultiLineString: return(ParseFlatbufMultiLineString(ends, coords, dimensions)); case GeometryType.Polygon: return(ParseFlatbufPolygon(ends, coords, dimensions)); default: throw new ApplicationException("FromFlatbuf: Unsupported geometry type"); } }
public void test_NumPoints() { //create a new multipoint MultiPoint mp = CreateTester1(); Assertion.AssertEquals("NumPoints1: ", 23, mp.GetNumPoints()); //Create a null coordinate to test with Coordinates testCoords = new Coordinates(); //create a multipoint with a null coordinate to test else case GeometryFactory gf = new GeometryFactory(_precMod, _sRID); testCoords = new Coordinates(); MultiPoint mp2 = gf.CreateMultiPoint(testCoords); Assertion.AssertEquals("NumPoints2: ", 0, mp2.GetNumPoints()); }
/// <summary> /// Method to create a MultiPoint for testing purposes /// </summary> /// <returns>A MultiPoint</returns> private MultiPoint CreateTester4() { Point[] points = new Point[32]; GeometryFactory gf = new GeometryFactory(_precMod, _sRID); points[0] = gf.CreatePoint(new Coordinate(2, 2)); points[1] = gf.CreatePoint(new Coordinate(3, 1)); points[2] = gf.CreatePoint(new Coordinate(4, 2)); points[3] = gf.CreatePoint(new Coordinate(5, 3)); points[4] = gf.CreatePoint(new Coordinate(6, 4)); points[5] = gf.CreatePoint(new Coordinate(7, 5)); points[6] = gf.CreatePoint(new Coordinate(7, 6)); points[7] = gf.CreatePoint(new Coordinate(7, 7)); points[8] = gf.CreatePoint(new Coordinate(7, 8)); points[9] = gf.CreatePoint(new Coordinate(7, 9)); points[10] = gf.CreatePoint(new Coordinate(6, 10)); points[11] = gf.CreatePoint(new Coordinate(5, 11)); points[12] = gf.CreatePoint(new Coordinate(6, 12)); points[13] = gf.CreatePoint(new Coordinate(7, 13)); points[14] = gf.CreatePoint(new Coordinate(8, 14)); points[15] = gf.CreatePoint(new Coordinate(9, 13)); points[16] = gf.CreatePoint(new Coordinate(10, 12)); points[17] = gf.CreatePoint(new Coordinate(10, 11)); points[18] = gf.CreatePoint(new Coordinate(10, 10)); points[19] = gf.CreatePoint(new Coordinate(10, 9)); points[20] = gf.CreatePoint(new Coordinate(9, 8)); points[21] = gf.CreatePoint(new Coordinate(8, 7)); points[22] = gf.CreatePoint(new Coordinate(7, 7)); points[23] = gf.CreatePoint(new Coordinate(6, 7)); points[24] = gf.CreatePoint(new Coordinate(5, 8)); points[25] = gf.CreatePoint(new Coordinate(4, 8)); points[26] = gf.CreatePoint(new Coordinate(3, 7)); points[27] = gf.CreatePoint(new Coordinate(2, 6)); points[28] = gf.CreatePoint(new Coordinate(1, 5)); points[29] = gf.CreatePoint(new Coordinate(2, 4)); points[30] = gf.CreatePoint(new Coordinate(1, 3)); points[31] = gf.CreatePoint(new Coordinate(2, 2)); MultiPoint mp = gf.CreateMultiPoint(points); return(mp); }