using SharpMap;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Reflection;

using NetTopologySuite.Geometries;

using SharpMap.Rendering;

using SharpMap.Utilities;

namespace GeoAPI.Geometries

{

/// <summary>

/// Set of extension methods for use of GeoAPI within SharpMap

/// </summary>

public static class GeoAPIEx

{

/// <summary>

/// Gets the minimum coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The minimum coordinate</returns>

public static Coordinate Min(this Envelope self)

{

return new Coordinate(self.MinX, self.MinY);

}

/// <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 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 section 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 coordinates from</param>

/// <param name="srcPos">The starting index of the coordinates to copy</param>

/// <param name="dest">The sequence to which the coordinates should be copied to</param>

/// <param name="destPos">The starting index of the coordinates in <see paramref="dest"/></param>

/// <param name="length">The number of coordinates to copy</param>

public static void Copy(ICoordinateSequence src, int srcPos, ICoordinateSequence dest, int destPos, int length)

{

for (int i = 0; i < length; i++)

CopyCoord(src, srcPos + i, dest, destPos + i);

}

///<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++)

{

var ordinate = (Ordinate)dim;

double value = src.GetOrdinate(srcPos, ordinate);

dest.SetOrdinate(destPos, ordinate, value);

}

}

/// <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="coordinates">List of coordinates</param>

/// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns>

public static void EnsureValidRing(this List<Coordinate> coordinates)

{

var seq = GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory.Create(coordinates.ToArray());

seq = EnsureValidRing(GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory, seq);

if (seq.Count != coordinates.Count)

{

for (int i = coordinates.Count; i < seq.Count; i++)

{

coordinates.Add(seq.GetCoordinate(i));

}

}

}

/// <summary>

/// Gets the maximum coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The maximum coordinate</returns>

public static Coordinate Max(this Envelope self)

{

return new Coordinate(self.MaxX, self.MaxY);

}

/// <summary>

/// Adds to coordinate's

/// </summary>

/// <param name="self">the first coordinate</param>

/// <param name="summand">The second coordinate</param>

public static Coordinate Add(this Coordinate self, Coordinate summand)

{

if (self == null && summand == null)

return null;

if (summand == null)

return self;

if (self == null)

return summand;

// for now we only care for 2D

return new Coordinate(self.X + summand.X, self.Y + summand.Y);

}

/// <summary>

/// Subtracts two coordinates from one another

/// </summary>

/// <param name="self">The first coordinate</param>

/// <param name="summand">The second coordinate</param>

public static Coordinate Subtract(this Coordinate self, Coordinate summand)

{

if (self == null && summand == null)

return null;

if (summand == null)

return self;

if (self == null)

return new Coordinate(-summand.X, -summand.Y);

// for now we only care for 2D

return new Coordinate(self.X - summand.X, self.Y - summand.Y);

}

/// <summary>

/// Gets the axis of the longest axis

/// </summary>

/// <param name="self"></param>

/// <returns></returns>

public static Ordinate LongestAxis(this Envelope self)

{

if (self.MaxExtent == self.Width)

return Ordinate.X;

return Ordinate.Y;

}

/// <summary>

/// Gets the bottom-left coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The bottom-left coordinate</returns>

public static Coordinate BottomLeft(this Envelope self)

{

return self.Min();

}

/// <summary>

/// Gets the bottom-right coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The bottom-right coordinate</returns>

public static Coordinate BottomRight(this Envelope self)

{

return new Coordinate(self.MaxX, self.MinY);

}

/// <summary>

/// Gets the top-left coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The top-left coordinate</returns>

public static Coordinate TopLeft(this Envelope self)

{

return new Coordinate(self.MinX, self.MaxY);

}

/// <summary>

/// Gets the top-right coordinate of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The top-right coordinate</returns>

public static Coordinate TopRight(this Envelope self)

{

return self.Max();

}

/// <summary>

/// Gets the minimum y-value of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The minimum y-value</returns>

public static double Bottom(this Envelope self)

{

return self.MinY;

}

/// <summary>

/// Gets the maximum y-value of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The maximum y-value</returns>

public static double Top(this Envelope self)

{

return self.MaxY;

}

/// <summary>

/// Gets the minimum x-value of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The minimum x-value</returns>

public static double Left(this Envelope self)

{

return self.MinX;

}

/// <summary>

/// Gets the maximum x-value of the <see cref="Envelope"/>

/// </summary>

/// <param name="self">The envelope</param>

/// <returns>The maximum x-value</returns>

public static double Right(this Envelope self)

{

return self.MaxX;

}

/// <summary>

/// Transforms a <see cref="ILineString"/> to an array of <see cref="PointF"/>s.

/// </summary>

/// <param name="self">The linestring</param>

/// <param name="map">The mapviewport defining transformation parameters</param>

/// <returns>The array of <see cref="PointF"/>s</returns>

public static PointF[] TransformToImage(this ILineString self, MapViewport map)

{

if (map.MapTransformRotation.Equals(0f))

return Transform.WorldToMap(self.Coordinates, map.Left, map.Top, map.PixelWidth, map.PixelHeight);

return Transform.WorldToMap(self.Coordinates,map.WorldToMapTransform(false));

}

/// <summary>

/// Converts a <see cref="Coordinate"/> to an array of <see cref="double"/>s.

/// </summary>

/// <param name="self">The coordinate</param>

/// <returns>An array of doubles</returns>

public static double [] ToDoubleArray(this Coordinate self)

{

return new[] { self.X, self.Y /*, self.Z */};

}

/// <summary>

/// Abbreviation to counter clockwise function

/// </summary>

/// <param name="self">The ring</param>

/// <returns><c>true</c> if the ring is oriented counter clockwise</returns>

public static bool IsCCW(this ILinearRing self)

{

return NetTopologySuite.Algorithm.Orientation.IsCCW(self.Coordinates);

}

/// <summary>

/// Increases the size of the boundingbox by the given amount in all directions

/// </summary>

/// <param name="self">The envelope to grow</param>

/// <param name="amount">Amount to grow in all directions</param>

public static Envelope Grow(this Envelope self, double amount)

{

return new Envelope(self.MinX - amount, self.MaxX + amount,

self.MinY - amount, self.MaxY + amount);

}

/// <summary>

/// Increases the size of the boundingbox by the given amount in horizontal and vertical directions

/// </summary>

/// <param name="self">The envelope</param>

/// <param name="amountInX">Amount to grow in horizontal direction</param>

/// <param name="amountInY">Amount to grow in vertical direction</param>

public static Envelope Grow(this Envelope self, double amountInX, double amountInY)

{

return new Envelope(self.MinX - amountInX, self.MaxX + amountInX,

self.MinY - amountInY, self.MaxY + amountInY);

}

/// <summary>

/// Transforms a <see cref="IPolygon"/> to an array of <see cref="PointF"/>s

/// </summary>

/// <param name="self">The polygon</param>

/// <param name="map">The map that defines the affine coordinate transformation.</param>

/// <param name="useClipping">Use clipping for the polygon</param>

/// <returns>An array of PointFs</returns>

public static GraphicsPath TransformToImage(this IPolygon self, MapViewport map, bool useClipping = false)

{

var res = new GraphicsPath(FillMode.Alternate);

if (useClipping)

{

res.AddPolygon(VectorRenderer.ClipPolygon(

VectorRenderer.LimitValues(self.ExteriorRing.TransformToImage(map), VectorRenderer.ExtremeValueLimit),

map.Size.Width, map.Size.Height));

for (var i = 0; i < self.NumInteriorRings; i++)

res.AddPolygon(VectorRenderer.ClipPolygon(

VectorRenderer.LimitValues(self.GetInteriorRingN(i).TransformToImage(map),VectorRenderer.ExtremeValueLimit),

map.Size.Width, map.Size.Height));

}

else

{

res.AddPolygon(self.ExteriorRing.TransformToImage(map));

for (var i = 0; i < self.NumInteriorRings; i++)

res.AddPolygon(self.GetInteriorRingN(i).TransformToImage(map));

}

return res;

}

/// <summary>

/// Tests if a coordinate is empty

/// </summary>

/// <param name="c">The coordinate</param>

public static bool IsEmpty(this Coordinate c)

{

if (c == null) return true;

if (!double.IsNaN(c.X)) return false;

if (!double.IsNaN(c.Y)) return false;

return true;

}

/// <summary>

///

/// </summary>

/// <param name="self"></param>

/// <param name="wkt"></param>

/// <returns></returns>

public static IGeometry GeomFromText(this IGeometry self, string wkt)

{

var factory = self == null ? new NetTopologySuite.Geometries.GeometryFactory() : self.Factory;

var reader = new NetTopologySuite.IO.WKTReader(factory);

return reader.Read(wkt);

}

private static readonly FieldInfo _envFi;

static GeoAPIEx()

{

try

{

_envFi = typeof(Geometry).GetField("_envelope", BindingFlags.Instance | BindingFlags.NonPublic);

}

catch{}

}

/// <summary>

/// Utility function to set the <see cref="Geometry.EnvelopeInternal"/> when it is known.

/// </summary>

/// <param name="geom">The geometry</param>

/// <param name="envelope">The envelope of <paramref name="geom"/></param>.

public static void SetExtent(Geometry geom, Envelope envelope)

{

if (geom == null)

return;

if (_envFi != null)

_envFi.SetValue(geom, envelope);

}

}

}