public static IGeometry Project(IGeometry geometry, ProjectionInfo pStart, ProjectionInfo pEnd)
 {
     var featureSet = new FeatureSet();
     featureSet.AddFeature(geometry.ToDotSpatial());
     featureSet.Projection = pStart;
     featureSet.Reproject(pEnd);
     return
         GeometryConverter.ToGeoAPI(
             ((featureSet.Features[0].BasicGeometry as DotSpatial.Topology.IGeometry)));
 }

        /// <summary>
        /// This method reprojects the affine transform coefficients.  This is used for projection on the fly,
        /// where image transforms can take advantage of an affine projection, but does not have the power of
        /// a full projective transform and gets less and less accurate as the image covers larger and larger
        /// areas.  Since most image layers represent small rectangular areas, this should not be a problem in
        /// most cases.  the affine array should be ordered as follows:
        /// X' = [0] + [1] * Column + [2] * Row
        /// Y' = [3] + [4] * Column + [5] * Row
        /// </summary>
        /// <param name="affine">The array of double affine coefficients.</param>
        /// <param name="numRows">The number of rows to use for the lower bounds.  Value of 0 or less will be set to 1.</param>
        /// <param name="numCols">The number of columns to use to get the right bounds.  Values of 0 or less will be set to 1.</param>
        /// <param name="source"></param>
        /// <param name="dest"></param>
        /// <returns>The transformed coefficients</returns>
        public static double[] ReprojectAffine(double[] affine, double numRows, double numCols, ProjectionInfo source, ProjectionInfo dest)
        {
            if (numRows <= 0) numRows = 1;
            if (numCols <= 0) numCols = 1;

            double[] vertices = new double[6];
            // Top left
            vertices[0] = affine[0];
            vertices[1] = affine[3];
            // Top right
            vertices[2] = affine[0] + affine[1] * numCols;
            vertices[3] = affine[3] + affine[4] * numCols;
            // Bottom Left
            vertices[4] = affine[0] + affine[2] * numRows;
            vertices[5] = affine[3] + affine[5] * numRows;
            double[] z = new double[3];
            ReprojectPoints(vertices, z, source, dest, 0, 3);
            double[] affineResult = new double[6];

            affineResult[0] = vertices[0];
            affineResult[1] = (vertices[2] - vertices[0]) / numCols;
            affineResult[2] = (vertices[4] - vertices[0]) / numRows;

            affineResult[3] = vertices[1];
            affineResult[4] = (vertices[3] - vertices[1]) / numCols;
            affineResult[5] = (vertices[5] - vertices[1]) / numRows;

            return affineResult;
        }

 public ReprojectSqlServer(ProjectionInfo source, int sourceSRID, ProjectionInfo target, int targetSRID)
 {
     _proj_source = source;
     _proj_target = target;
     _srid_source = sourceSRID;
     _srid_target = targetSRID;
 }

 public static Coordinate Reproject(this Coordinate c, ProjectionInfo source, ProjectionInfo target)
 {
     var ordinates = new[] { c.X, c.Y };
     var z = new[] {double.IsNaN(c.Z) ? 0 : c.Z};
     Projections.Reproject.ReprojectPoints(ordinates, z, source, target, 0, 1);
     return new Coordinate(ordinates);
 }

        /// <summary>
        /// This function creates the HDR of Gridfile
        /// </summary>
        /// <param name="inExtents"> Extension of grid</param>
        /// <param name="cellSize">Size cell of the grid</param>
        /// <param name="projection">Projection (the same that shapefile)</param>
        /// <param name="noDataValue">No value definition</param>
        /// <param name="outGridPath">Path of the output</param>
        /// <param name="outGrid">Name of the output grid</param>
        public static void CreateGridFromExtents(
            Extent inExtents, double cellSize, ProjectionInfo projection, double noDataValue, string outGridPath, out IRaster outGrid)
        {

            double height = Math.Abs(inExtents.MaxY - inExtents.MinY);
            double width = Math.Abs(inExtents.MaxX - inExtents.MinX);
            int numberRows = Convert.ToInt32(Math.Ceiling(height / cellSize)) + 1;
            int numberCols = Convert.ToInt32(Math.Ceiling(width / cellSize)) + 1;

            // outGrid = Raster.CreateRaster(@outGridPath, null, demRaster.NumColumns, demRaster.NumRows, 1, demRaster.DataType, rasterOptions);
            outGrid = Raster.CreateRaster(@outGridPath, null, numberCols, numberRows, 1, typeof(float), new String[] { });
            outGrid.NoDataValue = noDataValue;
            outGrid.Projection = projection;
            outGrid.CellHeight = cellSize;
            outGrid.CellWidth = cellSize;
            //if (inExtents.MinX < 0)
            //    outGrid.Xllcenter = inExtents.MinX + (cellSize / 2.0);
            //else
            outGrid.Xllcenter = inExtents.MinX;// -(cellSize / 2.0);

            //if (inExtents.MinY < 0)
            //    outGrid.Yllcenter = inExtents.MinY + (cellSize / 2.0);
            //else
            outGrid.Yllcenter = inExtents.MinY;// -(cellSize / 2.0);
        }

        /// <summary>
        /// Creates an instance of this class
        /// </summary>
        public DotSpatialSpatialReference(ProjectionInfo projectionInfo)
        {
            _oid = projectionInfo.ToProj4String();
            Definition = projectionInfo.ToProj4String();
            ProjectionInfo = projectionInfo;

        }

		private static double[] ReprojectPoint(double[] sourcePoint, double z, ProjectionInfo sourceProj, ProjectionInfo destProj)
		{
			// Calls the reproject function that will transform the input location to the output locaiton
			Reproject.ReprojectPoints(sourcePoint, new double[] { z }, sourceProj, destProj, 0, 1);

			return sourcePoint;
		}

        /// <summary>
        /// Transforms a <see cref="SharpMap.Geometries.BoundingBox"/>
        /// </summary>
        /// <param name="box">Geometry to transform</param>
        /// <param name="from">Source Projection</param>
        /// <param name="to">Target Projection</param>
        /// <returns>Transformed BoundingBox</returns>
        public static BoundingBox TransformBox(BoundingBox box, ProjectionInfo from, ProjectionInfo to)
        {
            var corners = new[] { box.Left, box.Bottom, box.Left, box.Top, box.Right, box.Top, box.Right, box.Bottom };
            Reproject.ReprojectPoints(corners, null, from, to, 0, 4);

            return new BoundingBox(corners[0], corners[1], corners[4], corners[5]).Join(
                   new BoundingBox(corners[2], corners[3], corners[6], corners[7]));
        }

 /// <summary>
 /// Creates a new instance of a Projection Param with the specified name
 /// and the specified projection as the default projection that will
 /// appear if no changes are made.
 /// </summary>
 /// <param name="name"></param>
 /// <param name="defaultProjection"></param>
 public ProjectionParam(string name, ProjectionInfo defaultProjection)
 {
     Name = name;
     Value = defaultProjection;
     ParamVisible = ShowParamInModel.No;
     ParamType = "DotSpatial String Param";
     DefaultSpecified = true;
 }

 /// <summary>
 /// use the mapFrame with this dialog
 /// </summary>
 /// <param name="mapFrame"></param>
 public MapFrameProjectionDialog(IMapFrame mapFrame)
 {
     InitializeComponent();
     _mapFrame = mapFrame;
     _projection = new ProjectionInfo();
     _projection.CopyProperties(_mapFrame.Projection);
     UpdateProjectionStrings();
 }

static Extent Reproject(Extent extent, ProjectionInfo source, ProjectionInfo target, int depth = 0)
{
    var xy = ToSequence(extent);
    DotSpatial.Projections.Reproject.ReprojectPoints(xy, null, source, target, 0, xy.Length / 2);
    var res = ToExtent(xy);

    return res;
}

 public static ShapeFileModel OpenFile(string file, ProjectionInfo projection)
 {
     var res = new ShapeFileModel();
     res.File = file;
     res.Shape = Shapefile.OpenFile(file);
     if (projection != null) res.Shape.Reproject(projection);
     return res;
 }

 public void SetAreaRectangle(Extent extent, ProjectionInfo rectangleProjection)
 {
     var xMin = extent.MinX;
     var yMin = extent.MinY;
     var xMax = extent.MaxX;
     var yMax = extent.MaxY;
     var box = new Box(xMin, xMax, yMin, yMax);
     SetAreaRectangle(box, rectangleProjection);
 }

        /// <summary>
        /// Transforms a <see cref="GeoAPI.Geometries.Coordinate"/>.
        /// </summary>
        /// <param name="c">Point to transform</param>
        /// <param name="from">Source Projection</param>
        /// <param name="to">Target Projection</param>
        /// <returns>Transformed coordinate</returns>
        public static Coordinate TransformCoordinate(Coordinate c, ProjectionInfo from, ProjectionInfo to)
        {
            var xy = c.ToDoubleArray();
            double[] z = !Double.IsNaN(c.Z) ? new double[1] : null;

            Reproject.ReprojectPoints(xy, z, from, to, 0, 1);
            return new Coordinate(xy[0], xy[1]) {Z = z != null ? z[0] : Coordinate.NullOrdinate};

        }

 public static string ToGeoJson(System.Data.Entity.Spatial.DbGeometry location, ProjectionInfo pStart,
     ProjectionInfo pEnd)
 {
     var wktReader = new WKTReader();
     var geometry = wktReader.Read(location.WellKnownValue.WellKnownText);
     geometry = Project(geometry, pStart, pEnd);
     var geoJsonWriter = new GeoJsonWriter();
     return geoJsonWriter.Write(geometry);
 }

        /// <summary>
        /// Transforms a <see cref="BoundingBox"/>
        /// </summary>
        /// <param name="box">Geometry to transform</param>
        /// <param name="from">Source Projection</param>
        /// <param name="to">Target Projection</param>
        /// <returns>Transformed BoundingBox</returns>
        public static BoundingBox TransformBox(BoundingBox box, ProjectionInfo from, ProjectionInfo to)
        {
            var corners = new[] { box.MinX, box.MinY, box.MinX, box.MaxY, box.MaxX, box.MaxY, box.MaxX, box.MinY };
            Reproject.ReprojectPoints(corners, null, from, to, 0, 4);

            var res = new BoundingBox(corners[0], corners[4], corners[1], corners[5]);
            res.ExpandToInclude(new BoundingBox(corners[2], corners[6], corners[3], corners[7]));
            return res;
        }

        public static Proj4Crs Wrap(ProjectionInfo projectionInfo)
        {
            if (projectionInfo == null) throw new ArgumentNullException("projectionInfo");
            Contract.EndContractBlock();

            if (projectionInfo.Transform == null || projectionInfo.IsLatLon) {
                return new Proj4CrsGeographic(projectionInfo.GeographicInfo);
            }

            return new Proj4CrsProjected(projectionInfo);
        }

 public WmsInfo(string serverUrl, WmsCapabilities wmsCapabilities, Layer layer, Dictionary<string, string> customParameters,
     string crs, ProjectionInfo projectionInfo, string style, NetworkCredential credentials)
 {
     Credentials = credentials;
     CustomParameters = customParameters;
     CRS = crs;
     CrsProjectionInfo = projectionInfo;
     Style = style;
     Layer = layer;
     WmsCapabilities = wmsCapabilities;
     ServerUrl = serverUrl;
 }

 /// <summary>
 /// Transforms a <see cref="SharpMap.Geometries.Point"/>.
 /// </summary>
 /// <param name="p">Point to transform</param>
 /// <param name="from">Source Projection</param>
 /// <param name="to">Target Projection</param>
 /// <returns>Transformed Point</returns>
 public static Point TransformPoint(Point p, ProjectionInfo from, ProjectionInfo to)
 {
     try
     {
         double[] coords = p.ToDoubleArray();
         Reproject.ReprojectPoints(coords, null, from, to, 0, 1);
         return new Point(coords);
     }
     catch
     {
         return null;
     }
 }

 /// <summary>
 /// Creates an instance of this class
 /// </summary>
 /// <param name="tileSource">The tile source to use</param>
 /// <param name="tileCache">The tile cache to use</param>
 public BruTileLayer(ITileSource tileSource, ITileCache<byte[]> tileCache)
 {
     TileSource = tileSource;
     TileCache = tileCache;
     int epsgCode;
     if (int.TryParse(TileSource.Schema.Srs.Substring(5), out epsgCode))
     {
         _projection = new ProjectionInfo();
         _projection = ProjectionInfo.FromEpsgCode(epsgCode);
     }
     else
         _projection = KnownCoordinateSystems.Projected.World.WebMercator;
     LegendItemVisible = true;
 }