private MultiLineString ReadMultiLineString() { int nPolylines = m_objReader.ReadInt32(); if (nPolylines <= 0) { return(null); } LineString[] lines = new LineString[nPolylines]; for (int i = 0; i < nPolylines; i++) { BytesOrder byteOrder = (BytesOrder)m_objReader.ReadByte(); // handle the byte order m_objReader.Order = byteOrder; int geomType = m_objReader.ReadInt32(); if (geomType != 2) { throw new GeometryIOException("The data is badly formed. " + "A LineString geometry is expected"); } lines[i] = ReadLineString(); } return(m_objFactory.CreateMultiLineString(lines)); }
public void test_IsSimple() { //create a geomerty collection MultiLineString multiLS = CreateMLS(); Assertion.AssertEquals("IsSimple-1: ", false, multiLS.IsSimple()); //now try it with a null geometry collection GeometryFactory gf = new GeometryFactory(_precMod, _sRID); multiLS = gf.CreateMultiLineString(null); Assertion.AssertEquals("IsSimple-2: ", true, multiLS.IsSimple()); //now try it with a different geometry collection multiLS = CreateMLS1(); //TODO: This is really slow!!!!!!!!! Why? //Assertion.AssertEquals("IsSimple-3: ", false, multiLS.IsSimple()); //now try it with a mixed geometry collection multiLS = nonSimpleMLS(); Assertion.AssertEquals("IsSimple-4: ", false, multiLS.IsSimple()); //now try it with a closed geometry collection multiLS = closedMLS(); //TODO: Uncomment when IsSimple is working. Assertion.AssertEquals("IsSimple-5: ", true, multiLS.IsSimple()); }
public void test_Geometry() { LineString[] linestrings = new LineString[2]; Coordinates coords1 = new Coordinates(); Coordinate coord = new Coordinate(5, 3); coords1.Add(coord); coord = new Coordinate(4, 5); coords1.Add(coord); coord = new Coordinate(3, 4); coords1.Add(coord); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); LineString ls = gf.CreateLineString(coords1); linestrings[0] = ls; Coordinates coords2 = new Coordinates(); coord = new Coordinate(2, 7); coords2.Add(coord); coord = new Coordinate(9, 2); coords2.Add(coord); coord = new Coordinate(7, 9); coords2.Add(coord); ls = gf.CreateLineString(coords2); linestrings[1] = ls; MultiLineString mls = gf.CreateMultiLineString(linestrings); Assertion.AssertEquals("Geometry-1: ", "LineString:(5, 3, NaN),(4, 5, NaN),(3, 4, NaN)", mls.GetGeometryN(0).ToString()); Assertion.AssertEquals("Geometry-2: ", "LineString:(2, 7, NaN),(9, 2, NaN),(7, 9, NaN)", mls.GetGeometryN(1).ToString()); }
private MultiLineString CreateMLS() { Coordinates coords = new Coordinates(); Coordinate coord = new Coordinate(); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); LineString lineString = gf.CreateLineString(coords); LineString[] ls = new LineString[10]; for (int i = 0; i < 10; i++) { coords = new Coordinates(); for (int j = i; j < i + 10; j++) { coord = new Coordinate(); coord.X = (double)j; coord.Y = (double)j + 5; coords.Add(coord); } lineString = gf.CreateLineString(coords); ls[i] = lineString; } MultiLineString multiLS = gf.CreateMultiLineString(ls); return(multiLS); }
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))); }
public static IReadOnlyList <MultiLineStringEntity> CreateMultiLineStringEntities(GeometryFactory 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 } };
public override MultiLineString CreateGeometry( object?coordinates, int?crs) { if (!(coordinates is Coordinate[][] parts)) { throw Serializer_Parse_CoordinatesIsInvalid(); } var lineCount = parts.Length; var geometries = new LineString[lineCount]; for (var i = 0; i < lineCount; i++) { geometries[i] = GeoJsonLineStringSerializer.Default .CreateGeometry(parts[i], crs); } if (crs is not null) { GeometryFactory factory = NtsGeometryServices.Instance.CreateGeometryFactory(crs.Value); return(factory.CreateMultiLineString(geometries)); } return(new MultiLineString(geometries)); }
/// <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(Geometry geometry, BinaryWriter writer, GeometryFactory factory) { if (geometry == null) { throw new ArgumentNullException("geometry"); } var multi = geometry as MultiLineString; if (multi == null) { var ls = geometry as LineString; if (ls == null) { string err = string.Format("Expected geometry that implements 'MultiLineString' or 'LineString', 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); int numParts = multi.NumGeometries; int numPoints = multi.NumPoints; writer.Write(numParts); writer.Write(numPoints); // Write the offsets int offset = 0; for (int 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 (int part = 0; part < numParts; part++) { var geometryN = (LineString)multi.GetGeometryN(part); var points = geometryN.CoordinateSequence; WriteCoords(points, writer, zList, mList); } WriteZM(writer, numPoints, zList, mList); }
/// <summary> /// Reads a <see cref="MultiLineString"/> 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 MultiLineString ReadMultiLineString(BinaryReader reader, GeometryFactory factory) { int numGeometries = reader.ReadInt32(); var strings = new LineString[numGeometries]; ReadGeometryArray(reader, strings); return(factory.CreateMultiLineString(strings)); }
static IMultiLineString ParseFlatbufMultiLineStringSinglePart(double[] coords, byte dimensions) { var sequenceFactory = new PackedCoordinateSequenceFactory(); var factory = new GeometryFactory(sequenceFactory); var lineString = factory.CreateLineString(sequenceFactory.Create(coords, dimensions)); return(factory.CreateMultiLineString(new [] { lineString })); }
/// <summary> /// Creates a MultiLineString. /// </summary> /// <returns></returns> private Geometry CreateMultiLineString(CoordinateSequence[] sequences) { var ls = new LineString[sequences.Length]; for (int i = 0; i < sequences.Length; i++) { ls[i] = _factory.CreateLineString(sequences[i]); } return(_factory.CreateMultiLineString(ls)); }
/// <summary> /// Transforms a <see cref="GisSharpBlog.NetTopologySuite.Geometries.MultiLineString"/>. /// </summary> /// <param name="lines">MultiLineString to transform</param> /// <param name="transform">MathTransform</param> /// <returns>Transformed MultiLineString</returns> public static IMultiLineString TransformMultiLineString(IMultiLineString lines, IMathTransform transform) { List <ILineString> strings = new List <ILineString>(lines.Geometries.Length); foreach (ILineString ls in lines.Geometries) { strings.Add(TransformLineString(ls, transform)); } return(GeometryFactory.CreateMultiLineString(strings.ToArray())); }
private static IMultiLineString SqlGeometryToGeometryMultiLineString(SqlGeometry geometry, GeometryFactory factory) { ILineString[] lineStrings = new ILineString[geometry.STNumGeometries().Value]; for (int i = 1; i <= lineStrings.Length; i++) { lineStrings[i - 1] = SqlGeometryToGeometryLineString(geometry.STGeometryN(i), factory); } return(factory.CreateMultiLineString(lineStrings)); }
/// <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 Geometry Read(BigEndianBinaryReader file, GeometryFactory geometryFactory) { int shapeTypeNum = file.ReadInt32(); ShapeType shapeType = (ShapeType)Enum.Parse(typeof(ShapeType), shapeTypeNum.ToString()); if (shapeType != ShapeType.Arc) { 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(); } LineString[] 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; Coordinates points = new Coordinates(); 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)); } lines[part] = geometryFactory.CreateLineString(points); } return(geometryFactory.CreateMultiLineString(lines)); }
/// <summary> /// Creates a <see cref="MultiLineString"/> 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 MultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer, GeometryFactory factory) { string nextToken = GetNextEmptyOrOpener(tokenizer); if (nextToken == "EMPTY") { return(factory.CreateMultiLineString(null)); } var lineStrings = new List <LineString>(); lineStrings.Add(ReadLineStringText(tokenizer, factory)); nextToken = GetNextCloserOrComma(tokenizer); while (nextToken == ",") { lineStrings.Add(ReadLineStringText(tokenizer, factory)); nextToken = GetNextCloserOrComma(tokenizer); } return(factory.CreateMultiLineString(lineStrings.ToArray())); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.MultiLineString"/>. /// </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 MultiLineString TransformMultiLineString(MultiLineString lines, MathTransform transform, GeometryFactory targetFactory) { var lineList = new LineString[lines.NumGeometries]; for (var i = 0; i < lines.NumGeometries; i++) { var line = (LineString)lines[i]; lineList[i] = TransformLineString(line, transform, targetFactory); } return(targetFactory.CreateMultiLineString(lineList)); }
public void CreateEmptyMultiLineStringSucceeds() { GeometryFactory factory = new GeometryFactory( new BufferedCoordinate2DFactory(), new BufferedCoordinate2DSequenceFactory()); IMultiLineString l = factory.CreateMultiLineString(); Assert.IsNotNull(l); Assert.IsTrue(l.IsEmpty); }
private MultiLineString CreateMultiLineString(IEnumerable <IEnumerable <Coordinate> > coordinates) { var strings = new List <LineString>(); foreach (var seq in coordinates) { strings.Add(_factory.CreateLineString(seq as Coordinate[] ?? seq.ToArray())); } return(_factory.CreateMultiLineString(strings.ToArray())); }
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(); } }
internal static MultiLineString ToNTSMultiLineString(Geometries.MultiLineString multiLineString, GeometryFactory factory) { LineString[] lstrings = new LineString[multiLineString.LineStrings.Count]; int index = 0; foreach (Geometries.LineString lstring in multiLineString.LineStrings) { lstrings[index++] = ToNTSLineString(lstring, factory); } return(factory.CreateMultiLineString(lstrings) as MultiLineString); }
private static MultiLineString ToMultiLineString(ICollection <LineSegment> segs, GeometryFactory factory) { var lines = new LineString[segs.Count]; int i = 0; foreach (var seg in segs) { lines[i++] = seg.ToGeometry(factory); } return(factory.CreateMultiLineString(lines)); }
public void TestIsClosed() { var l = (LineString)reader.Read("LINESTRING EMPTY"); Assert.IsTrue(l.IsEmpty); Assert.IsTrue(!l.IsClosed); var r = geometryFactory.CreateLinearRing((CoordinateSequence)null); Assert.IsTrue(r.IsEmpty); Assert.IsTrue(r.IsClosed); var m = geometryFactory.CreateMultiLineString( new LineString[] { l, r }); Assert.IsTrue(!m.IsClosed); var m2 = geometryFactory.CreateMultiLineString( new LineString[] { 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 MultiLineString ReadMultiLineStringText(IList tokens) { string nextToken = GetNextEmptyOrOpener(tokens); if (nextToken.Equals("EMPTY")) //NOXLATE { return(geometryFactory.CreateMultiLineString(Array.Empty <LineString>())); } var lineStrings = new List <LineString>(); var lineString = ReadLineStringText(tokens); lineStrings.Add(lineString); nextToken = GetNextCloserOrComma(tokens); while (nextToken.Equals(",")) //NOXLATE { lineString = ReadLineStringText(tokens); lineStrings.Add(lineString); nextToken = GetNextCloserOrComma(tokens); } return(geometryFactory.CreateMultiLineString(lineStrings.ToArray())); }
private MultiLineString nonSimpleMLS() { Coordinates coords = new Coordinates(); Coordinate coord = new Coordinate(); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); LineString lineString = gf.CreateLineString(coords); LineString[] ls = new LineString[1]; coord = new Coordinate(2, 2); coords.Add(coord); coord = new Coordinate(3, 3); coords.Add(coord); coord = new Coordinate(4, 4); coords.Add(coord); coord = new Coordinate(5, 5); coords.Add(coord); coord = new Coordinate(6, 6); coords.Add(coord); coord = new Coordinate(7, 7); coords.Add(coord); coord = new Coordinate(8, 8); coords.Add(coord); coord = new Coordinate(9, 7); coords.Add(coord); coord = new Coordinate(10, 6); coords.Add(coord); coord = new Coordinate(10, 5); coords.Add(coord); coord = new Coordinate(9, 4); coords.Add(coord); coord = new Coordinate(8, 3); coords.Add(coord); coord = new Coordinate(7, 4); coords.Add(coord); coord = new Coordinate(7, 5); coords.Add(coord); coord = new Coordinate(6, 6); coords.Add(coord); coord = new Coordinate(5, 7); coords.Add(coord); coord = new Coordinate(4, 8); coords.Add(coord); coord = new Coordinate(3, 9); coords.Add(coord); ls[0] = gf.CreateLineString(coords); MultiLineString multiLS = gf.CreateMultiLineString(ls); return(multiLS); }
private static Geometry CreateMultiLineString(Ordinates ordinates, bool empty) { if (empty) { Factory.CreateMultiLineString(null); } int numLineStrings = Rnd.Next(0, 11); if (numLineStrings <= 2) { numLineStrings = 0; } var lineString = new LineString[numLineStrings]; for (int i = 0; i < numLineStrings; i++) { lineString[i] = (LineString)CreateLineString(ordinates, false); } return(Factory.CreateMultiLineString(lineString)); }
/// <summary> /// Gets the geometry for the edges in the subdivision as a <see cref="MultiLineString"/> /// containing 2-point lines. /// </summary> /// <param name="geomFact">the GeometryFactory to use</param> /// <returns>a MultiLineString</returns> public MultiLineString GetEdges(GeometryFactory geomFact) { var quadEdges = GetPrimaryEdges(false); var 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)); }
private static Geometry ToLines(IList <Coordinate[]> sections, GeometryFactory factory) { var lines = new LineString[sections.Count]; int i = 0; foreach (var pts in sections) { lines[i++] = factory.CreateLineString(pts); } if (lines.Length == 1) { return(lines[0]); } return(factory.CreateMultiLineString(lines)); }
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> /// Converts a collection of <see cref="ISegmentString"/>s into a <see cref="Geometry"/>. /// The geometry will be either a <see cref="LineString"/> /// or a <see cref="MultiLineString"/> (possibly empty). /// </summary> /// <param name="segStrings">A collection of <see cref="ISegmentString"/>.</param> /// <param name="geomFact">A geometry factory</param> /// <returns>A <see cref="LineString"/> or a <see cref="MultiLineString"/>.</returns> public static Geometry ToGeometry(IList <ISegmentString> segStrings, GeometryFactory geomFact) { var lines = new LineString[segStrings.Count]; int index = 0; foreach (var ss in segStrings) { var line = geomFact.CreateLineString(ss.Coordinates); lines[index++] = line; } if (lines.Length == 1) { return(lines[0]); } return(geomFact.CreateMultiLineString(lines)); }
private MultiLineString CreateMultiLine(int dim, int lrs, Decimal[] elemInfo, int elemIndex, List <Coordinate> coords, int numGeom) { int sOffset = StartingOffset(elemInfo, elemIndex); SdoEType etype = EType(elemInfo, elemIndex); int interpretation = Interpretation(elemInfo, elemIndex); int length = coords.Count * dim; if (!(sOffset >= 1) || !(sOffset <= length)) { throw new ArgumentException("ELEM_INFO STARTING_OFFSET " + sOffset + " inconsistent with ORDINATES length " + coords.Count); } if (!(etype == SdoEType.Line)) { throw new ArgumentException("ETYPE " + etype + " inconsistent with expected LINE"); } if (!(interpretation == 1)) { // we cannot represent INTERPRETATION > 1 return(null); } int endTriplet = (numGeom != -1) ? (elemIndex + numGeom) : (elemInfo.Length / 3); var list = new List <LineString>(); Boolean cont = true; for (int i = elemIndex; cont && i < endTriplet && (etype = EType(elemInfo, i)) != SdoEType.Unknown; i++) { if (etype == SdoEType.Line) { list.Add(CreateLine(dim, lrs, elemInfo, i, coords)); } else { // not a LineString - get out of here cont = false; } } var lines = _factory.CreateMultiLineString(list.ToArray()); return(lines); }