public ICoordinateSequence Reproject(ICoordinateSequence sequence, ISpatialReference @from, ISpatialReference to) { double[] xy, z, m; ToDotSpatial(sequence, out xy, out z, out m); DotSpatial.Projections.Reproject.ReprojectPoints(xy, z, GetProjectionInfo(@from), GetProjectionInfo(to), 0, sequence.Count); return ToGeoAPI(DefaultSequenceFactory, xy, z, m); }
/// <summary> /// Reverses the coordinates in a sequence in-place. /// </summary> /// <param name="seq"></param> public static void Reverse(ICoordinateSequence seq) { int last = seq.Count - 1; int mid = last / 2; for (int i = 0; i <= mid; i++) Swap(seq, i, last - i); }
/// <summary> /// Constructs a <c>Point</c> with the given coordinate. /// </summary> /// <param name="coordinates"> /// Contains the single coordinate on which to base this <c>Point</c>, /// or <c>null</c> to create the empty point. /// </param> /// <param name="factory"></param> public Point(ICoordinateSequence coordinates, IGeometryFactory factory) : base(factory) { if (coordinates == null) coordinates = factory.CoordinateSequenceFactory.Create(new ICoordinate[] { }); Debug.Assert(coordinates.Count <= 1); this.coordinates = (ICoordinateSequence) coordinates; }
public void Filter(ICoordinateSequence seq, int i) { if (i == 0) return; seq.GetCoordinate(i - 1, p0); seq.GetCoordinate(i, p1); rcc.CountSegment(p0, p1); }
/// <summary> /// Constructs a <c>Point</c> with the given coordinate. /// </summary> /// <param name="coordinates"> /// Contains the single coordinate on which to base this <c>Point</c>, /// or <c>null</c> to create the empty point. /// </param> /// <param name="factory"></param> public Point(ICoordinateSequence coordinates, IGeometryFactory factory) : base(factory) { if (coordinates == null) coordinates = factory.CoordinateSequenceFactory.Create(new Coordinate[] { }); NetTopologySuite.Utilities.Assert.IsTrue(coordinates.Count <= 1); this._coordinates = coordinates; }
/// <summary> /// /// </summary> /// <param name="points"> /// The points of the linestring, or <c>null</c> /// to create the empty point. Consecutive points may not be equal. /// </param> /// <param name="factory"></param> public LineString(ICoordinateSequence points, IGeometryFactory factory) : base(factory) { if (points == null) points = factory.CoordinateSequenceFactory.Create(new ICoordinate[] { }); if (points.Count == 1) throw new ArgumentException("point array must contain 0 or >1 elements", "points"); this.points = points; }
// ReSharper disable InconsistentNaming /// <summary> /// Creates a wrapper projecting to the XY plane. /// </summary> /// <param name="seq">The sequence to be projected</param> /// <returns>A sequence which projects coordinates</returns> public static ICoordinateSequence ProjectToXY(ICoordinateSequence seq) { /** * This is just a no-op, but return a wrapper * to allow better testing */ return new AxisPlaneCoordinateSequence(seq, XYIndex); }
/// <summary> /// Constructs a sequence based on the given array (the array is not copied). /// </summary> /// <param name="coordSeq">The coordinate array that will be referenced.</param> public CoordinateArraySequence(ICoordinateSequence coordSeq) { if (coordSeq != null) coordinates = new ICoordinate[coordSeq.Count]; else coordinates = new ICoordinate[0]; for (int i = 0; i < coordinates.Length; i++) coordinates[i] = coordSeq.GetCoordinateCopy(i); }
private static ICoordinateSequence CopyToSequence(Coordinate[] coords, ICoordinateSequence sequence) { for (int i = 0; i < coords.Length; i++) { sequence.SetOrdinate(i, Ordinate.X, coords[i].X); sequence.SetOrdinate(i, Ordinate.Y, coords[i].Y); } return sequence; }
public static MCoordinate[] Copy(ICoordinateSequence coordSeq) { MCoordinate[] copy = new MCoordinate[coordSeq.Count]; for (int i = 0; i < coordSeq.Count; i++) { copy[i] = new MCoordinate(coordSeq.GetCoordinate(i)); } return copy; }
private ILinearRing CreateLinearRing(ICoordinateSequence coordinates, bool ccw) { if (coordinates != null && Algorithm.CGAlgorithms.IsCCW(coordinates) != ccw) { //CoordinateSequences.Reverse(coordinates); coordinates = coordinates.Reversed(); } return CreateLinearRing(coordinates); }
///<summary> /// Copies a coordinate of a <see cref="ICoordinateSequence"/> to another <see cref="ICoordinateSequence"/>. /// The sequences may have different dimensions; /// in this case only the common dimensions are copied. ///</summary> /// <param name="src">The sequence to copy coordinate from</param> /// <param name="srcPos">The index of the coordinate to copy</param> /// <param name="dest">The sequence to which the coordinate should be copied to</param> /// <param name="destPos">The index of the coordinate in <see paramref="dest"/></param> public static void CopyCoord(ICoordinateSequence src, int srcPos, ICoordinateSequence dest, int destPos) { int minDim = Math.Min(src.Dimension, dest.Dimension); for (int dim = 0; dim < minDim; dim++) { Ordinate ordinate = (Ordinate)dim; double value = src.GetOrdinate(srcPos, ordinate); dest.SetOrdinate(destPos, ordinate, value); } }
protected void WriteInterval(ICoordinateSequence sequence, Ordinate ordinate, BinaryWriter writer) { var val = GetOrdinate(sequence, ordinate, 0); var interval = Interval.Create(val); for (var i = 1; i < sequence.Count; i++) interval = interval.ExpandedByValue(GetOrdinate(sequence, ordinate, i)); writer.Write(interval.Min); writer.Write(interval.Max); }
private static ICoordinateSequence CreateClosedRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int size) { var newseq = fact.Create(size, seq.Dimension); int n = seq.Count; Copy(seq, 0, newseq, 0, n); // fill remaining coordinates with start point for (int i = n; i < size; i++) Copy(seq, 0, newseq, i, 1); return newseq; }
public PointF[] Transform(ICoordinateSequence modelSequence) { var res = new PointF[modelSequence.Count]; for (var i = 0; i < modelSequence.Count; i++) { res[i] = Transform(modelSequence.GetOrdinate(0, Ordinate.X), modelSequence.GetOrdinate(0, Ordinate.Y)); } return res; }
/// <summary> /// /// </summary> /// <param name="seq"></param> /// <param name="lines"></param> /// <returns></returns> public bool HasIntersectionWithLineStrings(ICoordinateSequence seq, ICollection<IGeometry> lines) { foreach (ILineString line in lines) { HasIntersection(seq, line.CoordinateSequence); if (_hasIntersection) break; } return _hasIntersection; }
/// <summary> /// /// </summary> /// <param name="seq"></param> /// <param name="lines"></param> /// <returns></returns> public bool HasIntersectionWithLineStrings(ICoordinateSequence seq, IList lines) { for (IEnumerator i = lines.GetEnumerator(); i.MoveNext(); ) { ILineString line = (ILineString) i.Current; HasIntersection(seq, line.CoordinateSequence); if (hasIntersection) break; } return hasIntersection; }
/// <summary> /// Swaps two coordinates in a sequence. /// </summary> /// <param name="seq"></param> /// <param name="i"></param> /// <param name="j"></param> public static void Swap(ICoordinateSequence seq, int i, int j) { if (i == j) return; for (int dim = 0; dim < seq.Dimension; dim++) { double tmp = seq.GetOrdinate(i, (Ordinates)dim); seq.SetOrdinate(i, (Ordinates)dim, seq.GetOrdinate(j, (Ordinates)dim)); seq.SetOrdinate(j, (Ordinates)dim, tmp); } }
/// <summary> /// Creates a new sequence based on a deep copy of the given <see cref="ICoordinateSequence"/>. /// </summary> /// <param name="coordSeq">The coordinate sequence that will be copied</param> public CoordinateArraySequence(ICoordinateSequence coordSeq) { if (coordSeq == null) { Coordinates = new Coordinate[0]; return; } _dimension = coordSeq.Dimension; Coordinates = new Coordinate[coordSeq.Count]; for (var i = 0; i < Coordinates.Length; i++) Coordinates[i] = coordSeq.GetCoordinateCopy(i); }
/// <summary> /// Ensures that a CoordinateSequence forms a valid ring, /// returning a new closed sequence of the correct length if required. /// If the input sequence is already a valid ring, it is returned /// without modification. /// If the input sequence is too short or is not closed, /// it is extended with one or more copies of the start point. /// </summary> /// <param name="fact">The CoordinateSequenceFactory to use to create the new sequence</param> /// <param name="seq">The sequence to test</param> /// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns> public static ICoordinateSequence EnsureValidRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq) { var n = seq.Count; // empty sequence is valid if (n == 0) return seq; // too short - make a new one if (n <= 3) return CreateClosedRing(fact, seq, 4); var isClosed = Math.Abs(seq.GetOrdinate(0, Ordinate.X) - seq.GetOrdinate(n - 1, Ordinate.X)) < double.Epsilon && Math.Abs(seq.GetOrdinate(0, Ordinate.Y) - seq.GetOrdinate(n - 1, Ordinate.Y)) < double.Epsilon; if (isClosed) return seq; // make a new closed ring return CreateClosedRing(fact, seq, n + 1); }
private ICoordinateSequence Add(ICoordinateSequence seq1, ICoordinateSequence seq2) { if (seq1 == null) { return seq2; } if (seq2 == null) { return seq1; } ICoordinate[] c1 = seq1.ToCoordinateArray(); ICoordinate[] c2 = seq2.ToCoordinateArray(); ICoordinate[] c3 = new Coordinate[c1.Length + c2.Length]; Array.Copy(c1, 0, c3, 0, c1.Length); Array.Copy(c2, 0, c3, c1.Length, c2.Length); return factory.CoordinateSequenceFactory.Create(c3); }
/// <summary> /// Determines the <see cref="Location"/> of a point in a ring. /// </summary> /// <param name="p">The point to test</param> /// <param name="ring">A coordinate sequence forming a ring</param> /// <returns>The location of the point in the ring</returns> public static Location LocatePointInRing(Coordinate p, ICoordinateSequence ring) { var counter = new RayCrossingCounter(p); var p1 = new Coordinate(); var p2 = new Coordinate(); for (var i = 1; i < ring.Count; i++) { ring.GetCoordinate(i, p1); ring.GetCoordinate(i - 1, p2); counter.CountSegment(p1, p2); if (counter.IsOnSegment) return counter.Location; } return counter.Location; }
private static void AddFacetSequences(ICoordinateSequence pts, List<FacetSequence> sections) { int i = 0; int size = pts.Count; while (i <= size - 1) { int end = i + FacetSequenceSize + 1; // if only one point remains after this section, include it in this // section if (end >= size - 1) end = size; var sect = new FacetSequence(pts, i, end); sections.Add(sect); i = i + FacetSequenceSize; } }
/// <summary> /// /// </summary> /// <param name="seq0"></param> /// <param name="seq1"></param> /// <returns></returns> public bool HasIntersection(ICoordinateSequence seq0, ICoordinateSequence seq1) { for (int i = 1; i < seq0.Count && ! hasIntersection; i++) { seq0.GetCoordinate(i - 1, pt00); seq0.GetCoordinate(i, pt01); for (int j = 1; j < seq1.Count && ! hasIntersection; j++) { seq1.GetCoordinate(j - 1, pt10); seq1.GetCoordinate(j, pt11); li.ComputeIntersection(pt00, pt01, pt10, pt11); if (li.HasIntersection) hasIntersection = true; } } return hasIntersection; }
/// <summary> /// Generates the WKT for a N-point <c>LineString</c> specified by a <see cref="ICoordinateSequence"/>. /// </summary> /// <param name="seq">The sequence to write.</param> /// <returns>The WKT</returns> public static String ToLineString(ICoordinateSequence seq) { var buf = new StringBuilder(); buf.Append("LINESTRING"); if (seq.Count == 0) buf.Append(" EMPTY"); else { buf.Append("("); for (var i = 0; i < seq.Count; i++) { if (i > 0) buf.Append(", "); buf.Append(String.Format(CultureInfo.InvariantCulture, "{0} {1}", seq.GetX(i), seq.GetY(i))); } buf.Append(")"); } return buf.ToString(); }
/// <summary> /// Generates the WKT for a N-point <c>LineString</c>. /// </summary> /// <param name="seq">The sequence to output.</param> /// <returns></returns> public static String ToLineString(ICoordinateSequence seq) { StringBuilder buf = new StringBuilder(); buf.Append("LINESTRING"); if (seq.Count == 0) buf.Append(" EMPTY"); else { buf.Append("("); for (int i = 0; i < seq.Count; i++) { if (i > 0) buf.Append(","); buf.Append(seq.GetX(i) + " " + seq.GetY(i)); } buf.Append(")"); } return buf.ToString(); }
/** * Computes an average normal vector from a list of polygon coordinates. * Uses Newell's method, which is based * on the fact that the vector with components * equal to the areas of the projection of the polygon onto * the Cartesian axis planes is normal. * * @param seq the sequence of coordinates for the polygon * @return a normal vector */ private static Vector3D AverageNormal(ICoordinateSequence seq) { var n = seq.Count; var sum = new Coordinate(0, 0, 0); var p1 = new Coordinate(0, 0, 0); var p2 = new Coordinate(0, 0, 0); for (var i = 0; i < n - 1; i++) { seq.GetCoordinate(i, p1); seq.GetCoordinate(i + 1, p2); sum.X += (p1.Y - p2.Y) * (p1.Z + p2.Z); sum.Y += (p1.Z - p2.Z) * (p1.X + p2.X); sum.Z += (p1.X - p2.X) * (p1.Y + p2.Y); } sum.X /= n; sum.Y /= n; sum.Z /= n; var norm = Vector3D.Create(sum).Normalize(); return norm; }
private static void DoTest(ICoordinateSequence forward, ICoordinateSequence reversed) { const double eps = 1e-12; Assert.AreEqual(forward.Count, reversed.Count, "Coordinate sequences don't have same size"); Assert.AreEqual(forward.Ordinates, reversed.Ordinates, "Coordinate sequences don't serve same ordinate values"); var ordinates = OrdinatesUtility.ToOrdinateArray(forward.Ordinates); var j = forward.Count; for (var i = 0; i < forward.Count; i++) { j--; foreach(var ordinate in ordinates) Assert.AreEqual(forward.GetOrdinate(i, ordinate), reversed.GetOrdinate(j, ordinate), eps, string.Format("{0} values are not within tolerance", ordinate)); var cf = forward.GetCoordinate(i); var cr = reversed.GetCoordinate(j); Assert.IsFalse(ReferenceEquals(cf, cr), "Coordinate sequences deliver same coordinate instances"); Assert.IsTrue(cf.Equals(cr), "Coordinate sequences do not provide equal coordinates"); } }
protected void WriteCoordinates(ICoordinateSequence sequence, BinaryWriter writer, Ordinates ordinates) { for (var i = 0; i < sequence.Count; i++) { writer.Write(sequence.GetX(i)); writer.Write(sequence.GetY(i)); } if ((ordinates & Ordinates.Z) == Ordinates.Z) { WriteInterval(sequence, Ordinate.Z, writer); for (var i = 0; i < sequence.Count; i++) writer.Write(GetOrdinate(sequence, Ordinate.Z, i)); } if ((ordinates & Ordinates.M) == Ordinates.M) { WriteInterval(sequence, Ordinate.M, writer); for (var i = 0; i < sequence.Count; i++) writer.Write(GetOrdinate(sequence, Ordinate.M, i)); } }
/// <summary> /// /// </summary> /// <param name="coords"></param> /// <param name="parent"></param> /// <returns></returns> protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent) { Coordinate[] srcPts = coords.ToCoordinateArray(); Coordinate[] newPts = SnapLine(srcPts, _snapPts); return(Factory.CoordinateSequenceFactory.Create(newPts)); }
/// <summary> /// Creates a <c>Point</c> using the given <c>CoordinateSequence</c>; a null or empty /// CoordinateSequence will create an empty Point. /// </summary> /// <param name="coordinates">a CoordinateSequence (possibly empty), or null</param> /// <returns>A <see cref="IPoint"/> object</returns> public IPoint CreatePoint(ICoordinateSequence coordinates) { return(new Point(coordinates, this)); }
/// <summary> /// Creates a <c>LinearRing</c> using the given <c>CoordinateSequence</c>; a null or empty CoordinateSequence /// creates an empty LinearRing. The points must form a closed and simple /// linestring. Consecutive points must not be equal. /// </summary> /// <param name="coordinates">A CoordinateSequence (possibly empty), or null.</param> /// <returns>A <see cref="ILinearRing"/> object</returns> /// <exception cref="ArgumentException"> If the ring is not closed, or has too few points</exception> public ILinearRing CreateLinearRing(ICoordinateSequence coordinates) { return(new LinearRing(coordinates, this)); }
/// <summary> /// Constructs a <c>Polygon</c> with the given exterior boundary. /// </summary> /// <param name="coordinates">the outer boundary of the new <c>Polygon</c>, or /// <c>null</c> or an empty <c>LinearRing</c> if /// the empty geometry is to be created.</param> /// <returns>A <see cref="IPolygon"/> object</returns> /// <exception cref="ArgumentException">If the boundary ring is invalid</exception> public virtual IPolygon CreatePolygon(ICoordinateSequence coordinates) { return(CreatePolygon(CreateLinearRing(coordinates))); }
/// <summary> /// Convenience method which provides statndard way of copying {CoordinateSequence}s /// </summary> /// <param name="seq">The sequence to copy.</param> /// <returns>A deep copy of the sequence.</returns> protected virtual ICoordinateSequence Copy(ICoordinateSequence seq) { return((ICoordinateSequence)seq.Clone()); }
/// <summary> /// /// </summary> /// <param name="coords"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent) { return(Copy(coords)); }
public MLineString(ICoordinateSequence points, IGeometryFactory factory) : base(points, factory) { DetermineMonotone(); }
/// <summary> /// Ensures that a CoordinateSequence forms a valid ring, /// returning a new closed sequence of the correct length if required. /// If the input sequence is already a valid ring, it is returned /// without modification. /// If the input sequence is too short or is not closed, /// it is extended with one or more copies of the start point. /// </summary> /// <param name="fact">The CoordinateSequenceFactory to use to create the new sequence</param> /// <param name="seq">The sequence to test</param> /// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns> public static ICoordinateSequence EnsureValidRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq) { var n = seq.Count; // empty sequence is valid if (n == 0) { return(seq); } // too short - make a new one if (n <= 3) { return(CreateClosedRing(fact, seq, 4)); } var isClosed = Math.Abs(seq.GetOrdinate(0, Ordinate.X) - seq.GetOrdinate(n - 1, Ordinate.X)) < double.Epsilon && Math.Abs(seq.GetOrdinate(0, Ordinate.Y) - seq.GetOrdinate(n - 1, Ordinate.Y)) < double.Epsilon; if (isClosed) { return(seq); } // make a new closed ring return(CreateClosedRing(fact, seq, n + 1)); }
/// <summary> /// /// </summary> /// <param name="iCoordinateSequence"></param> /// <returns></returns> private static bool hasZ(ICoordinateSequence coords) { if (coords == null || coords.Count == 0) return false; int dimensions = coords.Dimension; if (coords.Dimension == 3) { // CoordinateArraySequence will always return 3, so we have to // check, if the third ordinate contains NaN, then the geom is actually 2-dimensional return Double.IsNaN(coords.GetOrdinate(0, Ordinates.Z)) ? false : true; } else return false; }
public ICoordinateSequence Create(ICoordinateSequence coordSeq) { throw new NotImplementedException(); }