/// <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);
 }

 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>
 /// 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>
 /// 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 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);
 }

 /// <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);
 }

 private ILinearRing CreateLinearRing(ICoordinateSequence coordinates, bool ccw)
 {
     if (coordinates != null && Algorithm.CGAlgorithms.IsCCW(coordinates) != ccw)
     {
         //CoordinateSequences.Reverse(coordinates);
         coordinates = coordinates.Reversed();
     }
     return CreateLinearRing(coordinates);
 }

 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;
		}

 /// <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;
 }

 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;
 }

 ///<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);
        }

 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, 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);
        }