internal ActualCoordinateSystem(ICoordinateSystem coordinateSystem) { if (coordinateSystem == null) throw new ArgumentNullException("coordinateSystem"); //NOXLATE CoordinateTransformationFactory f = new CoordinateTransformationFactory(); CoordinateSystemFactory cf = new CoordinateSystemFactory(); m_transform = f.CreateFromCoordinateSystems(coordinateSystem, cf.CreateFromWkt(XY_M)); }
public void TestNAD27toWGS84() { CoordinateSystemFactory csFact = new CoordinateSystemFactory(); CoordinateTransformationFactory ctFact = new CoordinateTransformationFactory(); ICoordinateSystem ESPG32054 = csFact.CreateFromWkt( "PROJCS[\"NAD27 / Wisconsin South\",GEOGCS[\"NAD27\",DATUM[\"North_American_Datum_1927\",SPHEROID[\"Clarke 1866\",6378206.4,294.9786982138982,AUTHORITY[\"EPSG\",\"7008\"]],AUTHORITY[\"EPSG\",\"6267\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4267\"]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"standard_parallel_1\",42.73333333333333],PARAMETER[\"standard_parallel_2\",44.06666666666667],PARAMETER[\"latitude_of_origin\",42],PARAMETER[\"central_meridian\",-90],PARAMETER[\"false_easting\",2000000],PARAMETER[\"false_northing\",0],UNIT[\"US survey foot\",0.3048006096012192,AUTHORITY[\"EPSG\",\"9003\"]],AUTHORITY[\"EPSG\",\"32054\"]]"); GeographicCoordinateSystem WGS84 = (ProjNet.CoordinateSystems.GeographicCoordinateSystem)GeographicCoordinateSystem.WGS84; ICoordinateTransformation trans = ctFact.CreateFromCoordinateSystems(ESPG32054, WGS84); List<double[]> points = new List<double[]> { new[] { 2555658.00, 388644.00}, new[] { 2557740.000, 387024.000} }; for (int i = 0; i < points.Count; i++) { double[] rst = trans.MathTransform.Transform(points[i]); Console.WriteLine(rst[0].ToString()+" \t"+ rst[1].ToString()); } }
private void TestMercator_2SP() { CoordinateSystemFactory cFac = new CoordinateSystemFactory(); IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("Krassowski 1940", 6378245.0, 298.3, LinearUnit.Metre); IHorizontalDatum datum = cFac.CreateHorizontalDatum("Krassowski 1940", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("Krassowski 1940", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); List<ProjectionParameter> parameters = new List<ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 42)); parameters.Add(new ProjectionParameter("central_meridian", 51)); parameters.Add(new ProjectionParameter("false_easting", 0)); parameters.Add(new ProjectionParameter("false_northing", 0)); IProjection projection = cFac.CreateProjection("Mercator_2SP", "Mercator_2SP", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem( "Pulkovo 1942 / Mercator Caspian Sea", gcs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North)); ICoordinateTransformation trans = new CoordinateTransformationFactory().CreateFromCoordinateSystems(gcs, coordsys); Point pGeo = new Point(53, 53); Point pUtm = new Point(trans.MathTransform.Transform(pGeo.ToDoubleArray())); Point pGeo2 = new Point(trans.MathTransform.Inverse().Transform(pUtm.ToDoubleArray())); result.Text += PrintResultTable(gcs, coordsys, pGeo, pUtm, new Point(165704.29, 5171848.07), pGeo2, "Mercator_2SP test"); }
public static Extent ConvertToMercatore(Extent extent) { NetTopologySuite.Geometries.PrecisionModel precisionModel = new NetTopologySuite.Geometries.PrecisionModel(GeoAPI.Geometries.PrecisionModels.Floating); CoordinateSystem wgs84 = GeographicCoordinateSystem.WGS84 as CoordinateSystem; CoordinateSystem mercatore = ProjectedCoordinateSystem.WebMercator as CoordinateSystem; ICoordinateSystemFactory cFac = new CoordinateSystemFactory(); int SRID_wgs84 = Convert.ToInt32(wgs84.AuthorityCode); //WGS84 SRID int SRID_mercatore = Convert.ToInt32(mercatore.AuthorityCode); //Mercatore SRID ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory ctFact = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); GeoAPI.CoordinateSystems.Transformations.ICoordinateTransformation transformation = ctFact.CreateFromCoordinateSystems(wgs84, mercatore); NetTopologySuite.Geometries.GeometryFactory factory_wgs84 = new NetTopologySuite.Geometries.GeometryFactory(precisionModel, SRID_wgs84); var bottomLeft = factory_wgs84.CreatePoint(new GeoAPI.Geometries.Coordinate(extent.Left, extent.Bottom, 0)); var topRight = factory_wgs84.CreatePoint(new GeoAPI.Geometries.Coordinate(extent.Right, extent.Top, 0)); double[] coords_bl = transformation.MathTransform.Transform(new double[] { bottomLeft.X, bottomLeft.Y }); double[] coords_tr = transformation.MathTransform.Transform(new double[] { topRight.X, topRight.Y }); NetTopologySuite.Geometries.GeometryFactory factory_mercatore = new NetTopologySuite.Geometries.GeometryFactory(precisionModel, SRID_mercatore); var p1_bl = factory_mercatore.CreatePoint(new GeoAPI.Geometries.Coordinate(coords_bl[0], coords_bl[1])); var p2_tr = factory_mercatore.CreatePoint(new GeoAPI.Geometries.Coordinate(coords_tr[0], coords_tr[1])); return new Extent(p1_bl.X, p1_bl.Y, p2_tr.X, p2_tr.Y); }
public void TestTransform() { CoordinateSystemFactory csFactory = new CoordinateSystemFactory(); const string sourceCsWkt = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]"; ICoordinateSystem sourceCs = csFactory.CreateFromWkt(sourceCsWkt); Assert.That(sourceCs, Is.Not.Null); const string targetCsWkt = "PROJCS[\"WGS 84 / Australian Antarctic Lambert\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"standard_parallel_1\",-68.5],PARAMETER[\"standard_parallel_2\",-74.5],PARAMETER[\"latitude_of_origin\",-50],PARAMETER[\"central_meridian\",70],PARAMETER[\"false_easting\",6000000],PARAMETER[\"false_northing\",6000000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AUTHORITY[\"EPSG\",\"3033\"]]"; ICoordinateSystem targetCs = csFactory.CreateFromWkt(targetCsWkt); Assert.That(targetCs, Is.Not.Null); CoordinateTransformationFactory ctFactory = new CoordinateTransformationFactory(); ICoordinateTransformation coordTransformation = ctFactory.CreateFromCoordinateSystems(sourceCs, targetCs); IGeometryFactory gf = GeometryFactory.Default; const string geomWkt = "MULTIPOINT (152.83949210500001 -42.14413555,152.83910355899999 -42.129844618)"; WKTReader reader = new WKTReader(gf); IGeometry geom = reader.Read(geomWkt); Assert.That(geom, Is.Not.Null); Assert.That(geom.IsValid, Is.True); Assert.That(geom, Is.InstanceOf<IMultiPoint>()); IMultiPoint mp = (IMultiPoint)geom; foreach (IPoint pt in mp.Geometries) { IGeometry tp = GeometryTransform.TransformGeometry(gf, pt, coordTransformation.MathTransform); Assert.That(tp, Is.Not.Null); Assert.That(tp.IsValid, Is.True); } IGeometry transformed = GeometryTransform.TransformGeometry(gf, mp, coordTransformation.MathTransform); Assert.That(transformed, Is.Not.Null); Assert.That(transformed.IsValid, Is.True); }
public void TestTransformListOfDoubleArray() { CoordinateSystemFactory csFact = new CoordinateSystemFactory(); CoordinateTransformationFactory ctFact = new CoordinateTransformationFactory(); ICoordinateSystem utm35ETRS = csFact.CreateFromWkt( "PROJCS[\"ETRS89 / ETRS-TM35\",GEOGCS[\"ETRS89\",DATUM[\"D_ETRS_1989\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",27],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]"); IProjectedCoordinateSystem utm33 = ProjectedCoordinateSystem.WGS84_UTM(33, true); ICoordinateTransformation trans = ctFact.CreateFromCoordinateSystems(utm35ETRS, utm33); List<double[]> points = new List<double[]> { new[] {290586.087, 6714000 }, new[] {90586.392, 6713996.224}, new[] {290590.133, 6713973.772}, new[] {290594.111, 6713957.416}, new[] {290596.615, 6713943.567}, new[] {290596.701, 6713939.485} }; double[][] tpoints = trans.MathTransform.TransformList(points).ToArray(); for (int i = 0; i < points.Count; i++) { Console.WriteLine(tpoints[i]); NUnit.Framework.Assert.IsTrue(Equal(tpoints[i], trans.MathTransform.Transform(points[i]))); } }
//Este para que hace falta?? public SpatialReference createSRSfromWKT(string wkt, IMathTransform transf) { ProjNet.CoordinateSystems.CoordinateSystemFactory csf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory ctf = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); throw new NotImplementedException(); }
public void TestAlbersProjectionFeet() { CoordinateSystemFactory cFac = new CoordinateSystemFactory(); IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("Clarke 1866", 6378206.4, 294.9786982138982, LinearUnit.USSurveyFoot); IHorizontalDatum datum = cFac.CreateHorizontalDatum("Clarke 1866", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("Clarke 1866", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); List<ProjectionParameter> parameters = new List<ProjectionParameter>(5); parameters.Add(new ProjectionParameter("central_meridian", -96)); parameters.Add(new ProjectionParameter("latitude_of_center", 23)); parameters.Add(new ProjectionParameter("standard_parallel_1", 29.5)); parameters.Add(new ProjectionParameter("standard_parallel_2", 45.5)); parameters.Add(new ProjectionParameter("false_easting", 0)); parameters.Add(new ProjectionParameter("false_northing", 0)); IProjection projection = cFac.CreateProjection("Albers Conical Equal Area", "albers", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Albers Conical Equal Area", gcs, projection, LinearUnit.Foot, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North)); ICoordinateTransformation trans = new CoordinateTransformationFactory().CreateFromCoordinateSystems(gcs, coordsys); double[] pGeo = new double[] { -75, 35 }; double[] pUtm = trans.MathTransform.Transform(pGeo); double[] pGeo2 = trans.MathTransform.Inverse().Transform(pUtm); double[] expected = new double[] { 1885472.7 / LinearUnit.Foot.MetersPerUnit, 1535925 / LinearUnit.Foot.MetersPerUnit }; Assert.IsTrue(ToleranceLessThan(pUtm, expected, 0.1), String.Format("Albers forward transformation outside tolerance, Expected [{0},{1}], got [{2},{3}]", expected[0], expected[1], pUtm[0], pUtm[1])); Assert.IsTrue(ToleranceLessThan(pGeo, pGeo2, 0.0000001), String.Format("Albers reverse transformation outside tolerance, Expected [{0},{1}], got [{2},{3}]", pGeo[0], pGeo[1], pGeo2[0], pGeo2[1])); }
public static GisPoint ConvertToWgs84(GisPoint point) { NetTopologySuite.Geometries.PrecisionModel precisionModel = new NetTopologySuite.Geometries.PrecisionModel(GeoAPI.Geometries.PrecisionModels.Floating); CoordinateSystem wgs84 = GeographicCoordinateSystem.WGS84 as CoordinateSystem; CoordinateSystem mercatore = ProjectedCoordinateSystem.WebMercator as CoordinateSystem; ICoordinateSystemFactory cFac = new CoordinateSystemFactory(); int SRID_wgs84 = Convert.ToInt32(wgs84.AuthorityCode); //WGS84 SRID int SRID_mercatore = Convert.ToInt32(mercatore.AuthorityCode); //Mercatore SRID ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory ctFact = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); GeoAPI.CoordinateSystems.Transformations.ICoordinateTransformation transformation = ctFact.CreateFromCoordinateSystems(mercatore, wgs84); NetTopologySuite.Geometries.GeometryFactory factory_mercatore = new NetTopologySuite.Geometries.GeometryFactory(precisionModel, SRID_mercatore); var convertedPoint = factory_mercatore.CreatePoint(new GeoAPI.Geometries.Coordinate(point.X, point.Y, 0)); double[] coords = transformation.MathTransform.Transform(new double[] { convertedPoint.X, convertedPoint.Y }); NetTopologySuite.Geometries.GeometryFactory factory_wgs84 = new NetTopologySuite.Geometries.GeometryFactory(precisionModel, SRID_wgs84); var p1 = factory_wgs84.CreatePoint(new GeoAPI.Geometries.Coordinate(coords[0], coords[1])); return new GisPoint(p1.X, p1.Y); }
public static ICoordinateTransformation LatLonToGoogle() { CoordinateSystemFactory csFac = new CoordinateSystemFactory(); CoordinateTransformationFactory ctFac = new CoordinateTransformationFactory(); IGeographicCoordinateSystem sourceCs = csFac.CreateGeographicCoordinateSystem( "WGS 84", AngularUnit.Degrees, HorizontalDatum.WGS84, PrimeMeridian.Greenwich, new AxisInfo("north", AxisOrientationEnum.North), new AxisInfo("east", AxisOrientationEnum.East)); List<ProjectionParameter> parameters = new List<ProjectionParameter> { new ProjectionParameter("semi_major", 6378137.0), new ProjectionParameter("semi_minor", 6378137.0), new ProjectionParameter("latitude_of_origin", 0.0), new ProjectionParameter("central_meridian", 0.0), new ProjectionParameter("scale_factor", 1.0), new ProjectionParameter("false_easting", 0.0), new ProjectionParameter("false_northing", 0.0) }; IProjection projection = csFac.CreateProjection("Google Mercator", "mercator_1sp", parameters); IProjectedCoordinateSystem targetCs = csFac.CreateProjectedCoordinateSystem( "Google Mercator", sourceCs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North)); return ctFac.CreateFromCoordinateSystems(sourceCs, targetCs); }
/// <summary> /// Creates a UTM projection for the northern/// hemisphere based on the WGS84 datum /// </summary> /// <param name="utmZone">Utm Zone</param> /// <returns>Projection</returns> private IProjectedCoordinateSystem CreateUtmProjection(int utmZone) { CoordinateSystemFactory cFac = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); //CoordinateSystemFactory cFac = new SharpMap.CoordinateSystems.CoordinateSystemFactory(); //Create geographic coordinate system based on the WGS84 datum IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("WGS 84", 6378137, 298.257223563, LinearUnit.Metre); IHorizontalDatum datum = cFac.CreateHorizontalDatum("WGS_1984", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("WGS 84", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); //Create UTM projection List <ProjectionParameter> parameters = new List <ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 0)); parameters.Add(new ProjectionParameter("central_meridian", -183 + 6 * utmZone)); parameters.Add(new ProjectionParameter("scale_factor", 0.9996)); parameters.Add(new ProjectionParameter("false_easting", 500000)); parameters.Add(new ProjectionParameter("false_northing", 0.0)); IProjection projection = cFac.CreateProjection("Transverse Mercator", "Transverse Mercator", parameters); return(cFac.CreateProjectedCoordinateSystem("WGS 84 / UTM zone " + utmZone.ToString() + "N", gcs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North))); }
/// <summary> /// Gets a coordinate system from the SRID.csv file /// </summary> /// <param name="id">EPSG ID</param> /// <returns>Coordinate system, or null if SRID was not found.</returns> public static ICoordinateSystem GetCSbyID(int id) { ICoordinateSystemFactory factory = new CoordinateSystemFactory(); foreach (var wkt in GetSrids(null)) if (wkt.WktId == id) return factory.CreateFromWkt(wkt.Wkt); return null; }
public void TestCentralMeridianParse() { const string strSouthPole = "PROJCS[\"South_Pole_Lambert_Azimuthal_Equal_Area\",GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Lambert_Azimuthal_Equal_Area\"],PARAMETER[\"False_Easting\",0],PARAMETER[\"False_Northing\",0],PARAMETER[\"Central_Meridian\",-127],PARAMETER[\"Latitude_Of_Origin\",-90],UNIT[\"Meter\",1]]"; CoordinateSystemFactory pCoordSysFactory = new CoordinateSystemFactory(); ICoordinateSystem pSouthPole = pCoordSysFactory.CreateFromWkt(strSouthPole); NUnit.Framework.Assert.IsNotNull(pSouthPole); }
/** * Creates a new SRS from an ESRI-style WKT/PRJ string. * * @param wkt * ESRI-style WKT (well-known text) SRS definition * @return * A spatial reference. Caller is responsible for deleting * the return object. */ public SpatialReference createSRSfromESRI(string wkt) { SpatialReference result = null; //SetUp coordinate transformation ProjNet.CoordinateSystems.CoordinateSystemFactory csf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); cs = csf.CreateFromWkt(wkt); throw new NotImplementedException(); }
public void ParseCoordSys() { CoordinateSystemFactory fac = new CoordinateSystemFactory(); string wkt = "PROJCS[\"NAD83(HARN) / Texas Central (ftUS)\", GEOGCS[\"NAD83(HARN)\", DATUM[\"NAD83_High_Accuracy_Regional_Network\", SPHEROID[\"GRS 1980\", 6378137, 298.257222101, AUTHORITY[\"EPSG\", \"7019\"]], TOWGS84[725, 685, 536, 0, 0, 0, 0], AUTHORITY[\"EPSG\", \"6152\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9122\"]], AUTHORITY[\"EPSG\", \"4152\"]], UNIT[\"US survey foot\", 0.304800609601219, AUTHORITY[\"EPSG\", \"9003\"]], PROJECTION[\"Lambert_Conformal_Conic_2SP\"], PARAMETER[\"standard_parallel_1\", 31.883333333333], PARAMETER[\"standard_parallel_2\", 30.1166666667], PARAMETER[\"latitude_of_origin\", 29.6666666667], PARAMETER[\"central_meridian\", -100.333333333333], PARAMETER[\"false_easting\", 2296583.333], PARAMETER[\"false_northing\", 9842500], AUTHORITY[\"EPSG\", \"2918\"]]"; ProjectedCoordinateSystem pcs = CoordinateSystemWktReader.Parse(wkt) as ProjectedCoordinateSystem; Assert.IsNotNull(pcs, "Could not parse WKT: " + wkt); Assert.AreEqual("NAD83(HARN) / Texas Central (ftUS)", pcs.Name); Assert.AreEqual("NAD83(HARN)", pcs.GeographicCoordinateSystem.Name); Assert.AreEqual("NAD83_High_Accuracy_Regional_Network", pcs.GeographicCoordinateSystem.HorizontalDatum.Name); Assert.AreEqual("GRS 1980", pcs.GeographicCoordinateSystem.HorizontalDatum.Ellipsoid.Name); Assert.AreEqual(6378137, pcs.GeographicCoordinateSystem.HorizontalDatum.Ellipsoid.SemiMajorAxis); Assert.AreEqual(298.257222101, pcs.GeographicCoordinateSystem.HorizontalDatum.Ellipsoid.InverseFlattening); Assert.AreEqual("EPSG", pcs.GeographicCoordinateSystem.HorizontalDatum.Ellipsoid.Authority); Assert.AreEqual(7019, pcs.GeographicCoordinateSystem.HorizontalDatum.Ellipsoid.AuthorityCode); Assert.AreEqual("EPSG", pcs.GeographicCoordinateSystem.HorizontalDatum.Authority); Assert.AreEqual(6152, pcs.GeographicCoordinateSystem.HorizontalDatum.AuthorityCode); Assert.AreEqual(new Wgs84ConversionInfo(725, 685, 536, 0, 0, 0, 0), pcs.GeographicCoordinateSystem.HorizontalDatum.Wgs84Parameters); Assert.AreEqual("Greenwich", pcs.GeographicCoordinateSystem.PrimeMeridian.Name); Assert.AreEqual(0, pcs.GeographicCoordinateSystem.PrimeMeridian.Longitude); Assert.AreEqual("EPSG", pcs.GeographicCoordinateSystem.PrimeMeridian.Authority); Assert.AreEqual(8901, pcs.GeographicCoordinateSystem.PrimeMeridian.AuthorityCode, 8901); Assert.AreEqual("degree", pcs.GeographicCoordinateSystem.AngularUnit.Name); Assert.AreEqual(0.0174532925199433, pcs.GeographicCoordinateSystem.AngularUnit.RadiansPerUnit); Assert.AreEqual("EPSG", pcs.GeographicCoordinateSystem.AngularUnit.Authority); Assert.AreEqual(9122, pcs.GeographicCoordinateSystem.AngularUnit.AuthorityCode); Assert.AreEqual("EPSG", pcs.GeographicCoordinateSystem.Authority); Assert.AreEqual(4152, pcs.GeographicCoordinateSystem.AuthorityCode, 4152); Assert.AreEqual("Lambert_Conformal_Conic_2SP", pcs.Projection.ClassName, "Projection Classname"); ProjectionParameter latitude_of_origin = pcs.Projection.GetParameter("latitude_of_origin"); Assert.IsNotNull(latitude_of_origin); Assert.AreEqual(29.6666666667, latitude_of_origin.Value); ProjectionParameter central_meridian = pcs.Projection.GetParameter("central_meridian"); Assert.IsNotNull(central_meridian); Assert.AreEqual(-100.333333333333, central_meridian.Value); ProjectionParameter standard_parallel_1 = pcs.Projection.GetParameter("standard_parallel_1"); Assert.IsNotNull(standard_parallel_1); Assert.AreEqual(31.883333333333, standard_parallel_1.Value); ProjectionParameter standard_parallel_2 = pcs.Projection.GetParameter("standard_parallel_2"); Assert.IsNotNull(standard_parallel_2); Assert.AreEqual(30.1166666667, standard_parallel_2.Value); ProjectionParameter false_easting = pcs.Projection.GetParameter("false_easting"); Assert.IsNotNull(false_easting); Assert.AreEqual(2296583.333, false_easting.Value); ProjectionParameter false_northing = pcs.Projection.GetParameter("false_northing"); Assert.IsNotNull(false_northing); Assert.AreEqual(9842500, false_northing.Value); Assert.AreEqual("US survey foot", pcs.LinearUnit.Name); Assert.AreEqual(0.304800609601219, pcs.LinearUnit.MetersPerUnit); Assert.AreEqual("EPSG", pcs.LinearUnit.Authority); Assert.AreEqual(9003, pcs.LinearUnit.AuthorityCode); Assert.AreEqual("EPSG", pcs.Authority); Assert.AreEqual(2918, pcs.AuthorityCode); Assert.AreEqual(wkt, pcs.WKT); }
public Projections() { CoordinateSystemFactory c = new CoordinateSystemFactory(); ICoordinateSystem osgb = c.CreateFromWkt("PROJCS[\"OSGB 1936 / British National Grid\",GEOGCS[\"OSGB 1936\",DATUM[\"OSGB_1936\",SPHEROID[\"Airy 1830\",6377563.396,299.3249646,AUTHORITY[\"EPSG\",\"7001\"]],AUTHORITY[\"EPSG\",\"6277\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4277\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",49],PARAMETER[\"central_meridian\",-2],PARAMETER[\"scale_factor\",0.9996012717],PARAMETER[\"false_easting\",400000],PARAMETER[\"false_northing\",-100000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AUTHORITY[\"EPSG\",\"27700\"]]"); ICoordinateSystem wgs = c.CreateFromWkt("GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]"); CoordinateTransformationFactory trf = new CoordinateTransformationFactory(); this.OsgbToWgs = trf.CreateFromCoordinateSystems(osgb, wgs); this.WgsToOsgb = trf.CreateFromCoordinateSystems(wgs, osgb); }
public void WebMercatorCanBeTranformed(int srid) { var wkt = SharpMap.Converters.WellKnownText.SpatialReference.SridToWkt(srid); var csf = new CoordinateSystemFactory(); var cs = csf.CreateFromWkt(wkt); var ctf = new CoordinateTransformationFactory(); Assert.DoesNotThrow(() => ctf.CreateFromCoordinateSystems(cs, GeographicCoordinateSystem.WGS84), "Could not reproject SRID:" + srid); }
public void ParseAllWKTs() { CoordinateSystemFactory fac = new CoordinateSystemFactory(); int parsecount = 0; foreach (SRIDReader.WKTstring wkt in SRIDReader.GetSRIDs()) { ICoordinateSystem cs = CoordinateSystemWktReader.Parse(wkt.WKT) as ICoordinateSystem; Assert.IsNotNull(cs, "Could not parse WKT: " + wkt); parsecount++; } Assert.AreEqual(parsecount, 2671, "Not all WKT was parsed"); }
public static void ConvertSVY21_to_EPSG3857(double x, double y, out double[] lnglat) { var gcs_WGS84 = GeographicCoordinateSystem.WGS84; var coordFactory = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); var coordTransform = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); var svy21 = coordFactory.CreateFromWkt(wkt_SVY21); var transformTo3857 = coordTransform.CreateFromCoordinateSystems(svy21, gcs_WGS84); double[] fromPoint = { x, y }; lnglat = transformTo3857.MathTransform.Transform(fromPoint); }
public static void ConvertEPSG3857_to_SVY21(double lat, double lng, out double[] xy) { var gcs_WGS84 = GeographicCoordinateSystem.WGS84; var coordFactory = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); var coordTransform = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); var svy21 = coordFactory.CreateFromWkt(wkt_SVY21); var transformTo3857 = coordTransform.CreateFromCoordinateSystems(gcs_WGS84, svy21); double[] fromPoint = { lat, lng }; xy = transformTo3857.MathTransform.Transform(fromPoint); }
public SpatialReference createSRSfromWKT(string wkttarget, string wktsource) { ProjNet.CoordinateSystems.CoordinateSystemFactory csf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); ProjNet.CoordinateSystems.ICoordinateSystem csSource = csf.CreateFromWkt(wktsource); ProjNet.CoordinateSystems.ICoordinateSystem csTarget = csf.CreateFromWkt(wkttarget); ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory ctf = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); ProjNet.CoordinateSystems.Transformations.ICoordinateTransformation ct = ctf.CreateFromCoordinateSystems(csSource, csTarget); SharpMapSpatialReference sr = new SharpMapSpatialReference(); sr.CoordinateSystem = csSource; sr.MathTransform = ct.MathTransform; return(sr); }
public SpatialReference createSRSfromWKT(string wkt, ICoordinateSystem source) { SpatialReference result = null; //SetUp coordinate transformation ProjNet.CoordinateSystems.CoordinateSystemFactory csf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); cs = csf.CreateFromWkt(wkt); ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory ctf = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory(); ctf.CreateFromCoordinateSystems(source, cs); ProjNet.CoordinateSystems.Transformations.ICoordinateTransformation ct = ctf.CreateFromCoordinateSystems(cs, source); //crear SharpMapSpatialReference usando el coordinateTranformation. throw new NotImplementedException(); }
public static ProjNetCS.ICoordinateSystem Convert(ICoordinateSystem system) { if (system==null) return null; var cs=system as CoordinateSystem; if (cs==null) { var factory=new ProjNetCS.CoordinateSystemFactory(); return factory.CreateFromWkt(system.ToString()); } return cs.System; }
//获取shp投影方式 public ICoordinateTransformation getmapTransform(config.ProjPara proj) { CoordinateTransformationFactory ctFac = new CoordinateTransformationFactory(); CoordinateSystemFactory cFac = new CoordinateSystemFactory(); ICoordinateTransformation transform = null; //等经纬,shp数据原始投影 var epsg4326 = cFac.CreateFromWkt("GEOGCS[\"GCS_WGS_1984\",DATUM[\"WGS_1984\",SPHEROID[\"WGS_84\",6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]]"); //目标坐标系 var epsg3857 = cFac.CreateFromWkt(getSrcCoordinate(proj)); transform = ctFac.CreateFromCoordinateSystems(epsg4326, epsg3857); return transform; }
/** * Creates a new SRS from an OSG WKT string. * * @param wkt * OGC WKT (well-known text) SRS definition * @param reference_frame * Reference frame to apply to points in this SRS * @return * A spatial reference. Caller is responsible for deleting * the return object. */ public SpatialReference createSRSfromWKT(string wkt, Mogre.Matrix4 reference_frame) { //Implementar el MatrixTransform //rellenar el MatrixTransform usando el reference_frame //SetUp coordinate transformation ProjNet.CoordinateSystems.CoordinateSystemFactory csf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); ProjNet.CoordinateSystems.ICoordinateSystem csSource = csf.CreateFromWkt(wkt); SharpMapSpatialReference sr = new SharpMapSpatialReference(); sr.CoordinateSystem = csSource; sr.MathTransform = new MatrixTransform(csSource.Dimension, reference_frame); return(sr); }
private static bool TestParse(int srid, string srtext) { try { CoordinateSystemFactory factory = new CoordinateSystemFactory(); factory.CreateFromWkt(srtext); //CoordinateSystemWktReader.Parse(srtext); return true; } catch (Exception ex) { Console.WriteLine("Test {0} failed:\n {1}\n {2}", srid, srtext, ex.Message); return false; } }
private static ICoordinateSystem CreateCoordinateSystem(ISpatialReference spatialReference) { var pisr = spatialReference as ProjNetSpatialReference; if (pisr != null && pisr.CoordinateSystem != null) return pisr.CoordinateSystem; switch (spatialReference.DefinitionType) { case SpatialReferenceDefinitionType.WellKnownText: var csFactory = new CoordinateSystemFactory(); return csFactory.CreateFromWkt(spatialReference.Definition); default: throw new NotSupportedException(); } }
public static ProjNetCS.ICoordinateSystem Convert(ICoordinateSystem system) { if (system == null) { return(null); } var cs = system as CoordinateSystem; if (cs == null) { var factory = new ProjNetCS.CoordinateSystemFactory(); return(factory.CreateFromWkt(system.ToString())); } return(cs.System); }
private static void Initialize() { if (_fromCS == null) { string utmWkt = @"PROJCS[""ETRS89 / UTM zone 32N"", GEOGCS[""ETRS89"", DATUM[""European_Terrestrial_Reference_System_1989"", SPHEROID[""GRS 1980"",6378137,298.257222101, AUTHORITY[""EPSG"",""7019""]], AUTHORITY[""EPSG"",""6258""]], PRIMEM[""Greenwich"",0, AUTHORITY[""EPSG"",""8901""]], UNIT[""degree"",0.01745329251994328, AUTHORITY[""EPSG"",""9122""]], AUTHORITY[""EPSG"",""4258""]], UNIT[""metre"",1, AUTHORITY[""EPSG"",""9001""]], PROJECTION[""Transverse_Mercator""], PARAMETER[""latitude_of_origin"",0], PARAMETER[""central_meridian"",9], PARAMETER[""scale_factor"",0.9996], PARAMETER[""false_easting"",500000], PARAMETER[""false_northing"",0], AUTHORITY[""EPSG"",""25832""], AXIS[""Easting"",EAST], AXIS[""Northing"",NORTH]]"; // WGS 84 string wgsWkt = @" GEOGCS[""GCS_WGS_1984"", DATUM[""D_WGS_1984"",SPHEROID[""WGS_1984"",6378137,298.257223563]], PRIMEM[""Greenwich"",0], UNIT[""Degree"",0.0174532925199433] ]"; var cf = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); _fromCS = cf.CreateFromWkt(utmWkt); _toCS = cf.CreateFromWkt(wgsWkt); _ctfac = new CoordinateTransformationFactory(); _trans = _ctfac.CreateFromCoordinateSystems(_fromCS, _toCS); } }
ICoordinateTransformation _ctFrom; //WGS84 to Custom public void LoadSourceWKT(string filepath) { //@"C:\DRC_Data\Arcview\USA\Townships\NYTOWNS_POLY.prj"; ICoordinateSystemFactory csFac = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); string file = @"NYTOWNS_POLY.prj"; string wkt = System.IO.File.ReadAllText(file); ICoordinateSystem csFrom = csFac.CreateFromWkt(wkt); _ctFac = new CoordinateTransformationFactory(); _ctTo = _ctFac.CreateFromCoordinateSystems( csFrom, GeographicCoordinateSystem.WGS84); _ctFrom = _ctFac.CreateFromCoordinateSystems( GeographicCoordinateSystem.WGS84, csFrom); }
private void TestMercator_1SP() { CoordinateSystemFactory cFac = new CoordinateSystemFactory(); IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("Bessel 1840", 6377397.155, 299.15281, LinearUnit.Metre); IHorizontalDatum datum = cFac.CreateHorizontalDatum("Bessel 1840", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("Bessel 1840", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); List<ProjectionParameter> parameters = new List<ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 0)); parameters.Add(new ProjectionParameter("central_meridian", 110)); parameters.Add(new ProjectionParameter("scale_factor", 0.997)); parameters.Add(new ProjectionParameter("false_easting", 3900000)); parameters.Add(new ProjectionParameter("false_northing", 900000)); IProjection projection = cFac.CreateProjection("Mercator_1SP", "Mercator_1SP", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Makassar / NEIEZ", gcs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum. North)); ICoordinateTransformation trans = new CoordinateTransformationFactory().CreateFromCoordinateSystems(gcs, coordsys); var pGeo = new Coordinate(120, -3); var pUtm = Transform(trans.MathTransform, pGeo); trans.MathTransform.Invert(); var pGeo2 = Transform(trans.MathTransform, pUtm); trans.MathTransform.Invert(); result.Text += PrintResultTable(gcs, coordsys, pGeo, pUtm, new Coordinate(5009726.58, 569150.82), pGeo2, "Mercator_1SP test"); }
public void TestTransformListOfCoordinates() { CoordinateSystemFactory csFact = new CoordinateSystemFactory(); CoordinateTransformationFactory ctFact = new CoordinateTransformationFactory(); ICoordinateSystem utm35ETRS = csFact.CreateFromWkt( "PROJCS[\"ETRS89 / ETRS-TM35\",GEOGCS[\"ETRS89\",DATUM[\"D_ETRS_1989\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",27],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"Meter\",1]]"); IProjectedCoordinateSystem utm33 = ProjectedCoordinateSystem.WGS84_UTM(33, true); ICoordinateTransformation trans = ctFact.CreateFromCoordinateSystems(utm35ETRS, utm33); Coordinate[] points = new Coordinate[] { new Coordinate(290586.087, 6714000), new Coordinate(290586.392, 6713996.224), new Coordinate(290590.133, 6713973.772), new Coordinate(290594.111, 6713957.416), new Coordinate(290596.615, 6713943.567), new Coordinate(290596.701, 6713939.485) }; Coordinate[] tpoints = trans.MathTransform.TransformList(points).ToArray(); for (int i = 0; i < points.Length; i++) Assert.That(tpoints[i].Equals(trans.MathTransform.Transform(points[i]))); }
// public method to set envelope and transform to new projection /// <summary> /// Method to set <see cref="Envelope"/> and <see cref="Layer.CoordinateTransformation"/> to the projection of the map /// </summary> /// <param name="map">The map</param> public void ReprojectToMap(Map map) { ICoordinateSystem cs = null; if (map.SRID > 0) { using (var p = new OSGeo.OSR.SpatialReference(null)) { string wkt; p.ImportFromEPSG(map.SRID); p.ExportToWkt(out wkt); #if !DotSpatialProjections cs = new CoordinateSystemFactory().CreateFromWkt(wkt); #else cs = ProjectionInfo.FromEsriString(wkt); #endif } } ReprojectToCoordinateSystem(cs); }
/// <summary>Creates a new instance of the <see cref="CoordinateSystemProvider" /> class.</summary> public CoordinateSystemProvider() { _CoordinateSystemFactory = new ProjNetCS.CoordinateSystemFactory(); _WktDictionary = new Dictionary <Srid, string>(); }
// get raster projection public ICoordinateSystem GetProjection() { var cFac = new CoordinateSystemFactory(); try { if (Projection != "") return cFac.CreateFromWkt(Projection); } catch (Exception) { } return null; }
// gets transform between raster's native projection and the map projection private void GetTransform(ICoordinateSystem mapProjection) { if (mapProjection == null || Projection == "") { Transform = null; return; } CoordinateSystemFactory cFac = new CoordinateSystemFactory(); // get our two projections ICoordinateSystem srcCoord = cFac.CreateFromWkt(Projection); ICoordinateSystem tgtCoord = mapProjection; // raster and map are in same projection, no need to transform if (srcCoord.WKT == tgtCoord.WKT) { Transform = null; return; } // create transform Transform = new CoordinateTransformationFactory().CreateFromCoordinateSystems(srcCoord, tgtCoord); }
public static ICoordinateTransformation Transform2Mercator(ICoordinateSystem source) { CoordinateSystemFactory cFac = new CoordinateSystemFactory(); List<ProjectionParameter> parameters = new List<ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 0)); parameters.Add(new ProjectionParameter("central_meridian", 0)); parameters.Add(new ProjectionParameter("false_easting", 0)); parameters.Add(new ProjectionParameter("false_northing", 0)); IProjection projection = cFac.CreateProjection("Mercator", "Mercator_2SP", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Mercator", source as IGeographicCoordinateSystem, projection, ProjNet.CoordinateSystems.LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum. North)); return new CoordinateTransformationFactory().CreateFromCoordinateSystems(source, coordsys); }
public static ICoordinateTransformation Transform2Lambert(ICoordinateSystem source) { if (source == null) throw new ArgumentException("Source coordinate system is null"); if (!(source is IGeographicCoordinateSystem)) throw new ArgumentException("Source coordinate system must be geographic"); CoordinateSystemFactory cFac = new CoordinateSystemFactory(); List<ProjectionParameter> parameters = new List<ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 50)); parameters.Add(new ProjectionParameter("central_meridian", -95)); parameters.Add(new ProjectionParameter("standard_parallel_1", 33)); parameters.Add(new ProjectionParameter("standard_parallel_2", 45)); parameters.Add(new ProjectionParameter("false_easting", 0)); parameters.Add(new ProjectionParameter("false_northing", 0)); IProjection projection = cFac.CreateProjection("Lambert Conformal Conic 2SP", "lambert_conformal_conic_2sp", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Lambert Conformal Conic 2SP", source as IGeographicCoordinateSystem, projection, ProjNet.CoordinateSystems.LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum. North)); return new CoordinateTransformationFactory().CreateFromCoordinateSystems(source, coordsys); }
private IProjectedCoordinateSystem createExpectedCoordinateSystem() { ICoordinateSystemFactory factory = new CoordinateSystemFactory<BufferedCoordinate2D>( _geoFactory.CoordinateFactory, _geoFactory); IEllipsoid grs80 = Ellipsoid.Grs80; IHorizontalDatum harn = factory.CreateHorizontalDatum( DatumType.HorizontalGeocentric, grs80, null, "D_North_American_1983_HARN"); IPrimeMeridian greenwich = PrimeMeridian.Greenwich; IAxisInfo axis0 = new AxisInfo(AxisOrientation.East, "Lon"); IAxisInfo axis1 = new AxisInfo(AxisOrientation.North, "Lat"); // Made the first parameter - the IExtents - null, which should be improved IGeographicCoordinateSystem gcs = factory.CreateGeographicCoordinateSystem(null, AngularUnit.Degrees, harn, greenwich, axis0, axis1, "GCS_North_American_1983_HARN"); IProjection prj = factory.CreateProjection( "Lambert_Conformal_Conic", new ProjectionParameter[] { new ProjectionParameter("False_Easting", 8202099.737532808), new ProjectionParameter("False_Northing", 0), new ProjectionParameter("Central_Meridian", -120.5), new ProjectionParameter("Standard_Parallel_1", 44.33333333333334), new ProjectionParameter("Standard_Parallel_2", 46.0), new ProjectionParameter("Latitude_Of_Origin", 43.66666666666666) }, "Lambert_Conformal_Conic"); IProjectedCoordinateSystem expected = factory.CreateProjectedCoordinateSystem( gcs, prj, LinearUnit.Foot, axis0, axis1, "NAD_1983_HARN_StatePlane_Oregon_North_FIPS_3601"); // TODO: Check if this is correct, since on line 184 of CoorindateSystemFactory.cs, // HorizontalDatum is passed in as null return expected; }
public override FeatureList process(FeatureList input, FilterEnv env) { FeatureList output = new FeatureList(); // HACER ALGO DEL ESTILO: if (transform == null) { //Create zone UTM 32N projection IProjectedCoordinateSystem utmProj = CreateUtmProjection(32); //Create geographic coordinate system (lets just reuse the CS from the projection) IGeographicCoordinateSystem geoCS = utmProj.GeographicCoordinateSystem; //Create transformation CoordinateTransformationFactory ctFac = new CoordinateTransformationFactory(); // TODO DANI Mirar de donde viene este source y target ICoordinateTransformation Coordinatetransform = null;// TODO = ctFac.CreateFromCoordinateSystems(source, target); //cs string wkt = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]"; //ICoordinateSystem cs = SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.Parse(wkt) as ICoordinateSystem; ICoordinateSystem cs = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(wkt) as ICoordinateSystem; //wgs84 GeographicCoordinateSystem wgs84 = GeographicCoordinateSystem.WGS84; //gcs CoordinateSystemFactory cFac = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); //CoordinateSystemFactory cFac = new SharpMap.CoordinateSystems.CoordinateSystemFactory(); //Create Bessel 1840 geographic coordinate system IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("Bessel 1840", 6377397.155, 299.15281, LinearUnit.Metre); IHorizontalDatum datum = cFac.CreateHorizontalDatum("Bessel 1840", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("Bessel 1840", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); //coordsys //Collection<ProjectionParameter> parameters = new Collection<ProjectionParameter>(5); List <ProjectionParameter> parameters = new List <ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 0)); parameters.Add(new ProjectionParameter("central_meridian", 110)); parameters.Add(new ProjectionParameter("scale_factor", 0.997)); parameters.Add(new ProjectionParameter("false_easting", 3900000)); parameters.Add(new ProjectionParameter("false_northing", 900000)); IProjection projection = cFac.CreateProjection("Mercator_1SP", "Mercator_1SP", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Makassar / NEIEZ", gcs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North)); Coordinatetransform = ctFac.CreateFromCoordinateSystems(gcs, coordsys);//gcsWGS84 -> gcenCsWGS84 //Apply transformation transform = Coordinatetransform.MathTransform; } SharpMap.Geometries.Point p = new SharpMap.Geometries.Point(30.0, 20.0); p = GeometryTransform.TransformPoint(p, transform); /*IMPORTANTE * foreach (Feature feature in input) * { * feature.row.Geometry = GeometryTransform.TransformGeometry(feature.row.Geometry, transform); * //feature.row.Geometry = GeometryTransform.TransformMultiPolygon(feature.row.Geometry, transform); * } * IMPORTANTE*/ foreach (Feature f in input) { output.Add(f);//output = input } // Cosas a cambiar: // Primero, la construccion del transform está siguiendo el ejemplo, pero hay que tener en cuenta los datos del xml y construirlo en consecuencia // Segundo, el filtro debe retornar una NUEVA lista, y no modificar la inicial. Ahora modifica los valores de la lista inicial // IMPORTANTE RETORNAR NUEVA LISTA OUTPUT <----------- FALTA POR HACER #if TODO // first time through, establish a working SRS for output data. if (working_srs == null) { // first try to use the terrain SRS if so directed: SpatialReference new_out_srs = getUseTerrainSRS() ? env.getTerrainSRS() : null; if (new_out_srs == null) { // failing that, see if we have an SRS in a resource: if (getSRS() == null && getSRSScript() != null) { ScriptResult r = env.getScriptEngine().run(getSRSScript(), env); if (r.isValid()) { setSRS(env.getSession().getResources().getSRS(r.ToString())); } else { env.getReport().error(r.ToString()); } } new_out_srs = srs; } // set the "working" SRS that will be used for all features passing though this filter: working_srs = new_out_srs != null ? new_out_srs : env.getInputSRS(); // LOCALIZE points around a local origin (the working extent's centroid) if (working_srs != null && getLocalize()) //&& env.getExtent().getArea() > 0.0 ) { if (env.getCellExtent().getSRS().isGeographic() && env.getCellExtent().getWidth() > 179.0) { //NOP - no localization for big geog extent ... needs more thought perhaps } else { GeoPoint centroid0 = new_out_srs != null? new_out_srs.transform(env.getCellExtent().getCentroid()) : env.getCellExtent().getCentroid(); // we do want the localizer point on the surface if possible: GeoPoint centroid = clampToTerrain(centroid0, env); if (centroid == null) { centroid = centroid0; } Matrixd localizer; // For geocentric datasets, we need a special localizer matrix: if (working_srs.isGeocentric()) { localizer = working_srs.getEllipsoid().createGeocentricInvRefFrame(centroid); localizer.invert(localizer); } // For projected datasets, just a simple translation: else { localizer = osg.Matrixd.translate(-centroid); } working_srs = working_srs.cloneWithNewReferenceFrame(localizer); } } } // we have to assign the output SRS on each pass if (working_srs != null) { env.setOutputSRS(working_srs); } return(base.process(input, env)); #endif //throw new NotImplementedException(); if (successor != null) { if (successor is FeatureFilter) { FeatureFilter filter = (FeatureFilter)successor; FeatureList l = filter.process(output, env); } else if (successor is FragmentFilter) { FragmentFilter filter = (FragmentFilter)successor; FragmentList l = filter.process(output, env); } } return(output); }
private static Map InitializeMapOsmWithXls(float angle) { Map map = new Map(); TileAsyncLayer tileLayer = new TileAsyncLayer(new OsmTileSource(), "TileLayer - OSM with XLS"); map.BackgroundLayer.Add(tileLayer); //Get data from excel string xlsPath = string.Format(XlsConnectionString, Directory.GetCurrentDirectory(), "GeoData\\Cities.xls"); DataSet ds = new DataSet("XLS"); using (OleDbConnection cn = new OleDbConnection(xlsPath)) { cn.Open(); using (OleDbDataAdapter da = new OleDbDataAdapter(new OleDbCommand("SELECT * FROM [Cities$]", cn))) da.Fill(ds); } #if !DotSpatialProjections //The SRS for this datasource is EPSG:4326, therefore we need to transfrom it to OSM projection CoordinateTransformationFactory ctf = new CoordinateTransformationFactory(); CoordinateSystemFactory cf = new CoordinateSystemFactory(); ICoordinateSystem epsg4326 = cf.CreateFromWkt("GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]"); ICoordinateSystem epsg3857 = cf.CreateFromWkt("PROJCS[\"Popular Visualisation CRS / Mercator\", GEOGCS[\"Popular Visualisation CRS\", DATUM[\"Popular Visualisation Datum\", SPHEROID[\"Popular Visualisation Sphere\", 6378137, 0, AUTHORITY[\"EPSG\",\"7059\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6055\"]],PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9102\"]], AXIS[\"E\", EAST], AXIS[\"N\", NORTH], AUTHORITY[\"EPSG\",\"4055\"]], PROJECTION[\"Mercator\"], PARAMETER[\"False_Easting\", 0], PARAMETER[\"False_Northing\", 0], PARAMETER[\"Central_Meridian\", 0], PARAMETER[\"Latitude_of_origin\", 0], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]], AXIS[\"East\", EAST], AXIS[\"North\", NORTH], AUTHORITY[\"EPSG\",\"3857\"]]"); ICoordinateTransformation ct = ctf.CreateFromCoordinateSystems(epsg4326, epsg3857); foreach (DataRow row in ds.Tables[0].Rows) { if (row["X"] == DBNull.Value || row["Y"] == DBNull.Value) continue; double[] coords = new[] { Convert.ToDouble(row["X"]), Convert.ToDouble(row["Y"])}; coords = ct.MathTransform.Transform(coords); row["X"] = coords[0]; row["Y"] = coords[1]; } #else var epsg4326 = DotSpatial.Projections.KnownCoordinateSystems.Geographic.World.WGS1984; var epsg3857 = DotSpatial.Projections.ProjectionInfo.FromEsriString("PROJCS[\"Popular Visualisation CRS / Mercator\", GEOGCS[\"Popular Visualisation CRS\", DATUM[\"Popular Visualisation Datum\", SPHEROID[\"Popular Visualisation Sphere\", 6378137, 0, AUTHORITY[\"EPSG\",\"7059\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6055\"]],PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9102\"]], AXIS[\"E\", EAST], AXIS[\"N\", NORTH], AUTHORITY[\"EPSG\",\"4055\"]], PROJECTION[\"Mercator\"], PARAMETER[\"False_Easting\", 0], PARAMETER[\"False_Northing\", 0], PARAMETER[\"Central_Meridian\", 0], PARAMETER[\"Latitude_of_origin\", 0], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]], AXIS[\"East\", EAST], AXIS[\"North\", NORTH], AUTHORITY[\"EPSG\",\"3857\"]]"); foreach (System.Data.DataRow row in ds.Tables[0].Rows) { if (row["X"] == DBNull.Value || row["Y"] == DBNull.Value) continue; var coords = new[] { Convert.ToDouble(row["X"]), Convert.ToDouble(row["Y"])}; DotSpatial.Projections.Reproject.ReprojectPoints(coords, null, epsg4326, epsg3857, 0, 1); row["X"] = coords[0]; row["Y"] = coords[1]; } #endif //Add Rotation Column ds.Tables[0].Columns.Add("Rotation", typeof (float)); foreach (DataRow row in ds.Tables[0].Rows) row["Rotation"] = -angle; //Set up provider DataTablePoint xlsProvider = new DataTablePoint(ds.Tables[0], "OID", "X", "Y"); VectorLayer xlsLayer = new VectorLayer("XLS", xlsProvider) {Style = {Symbol = VectorStyle.DefaultSymbol}}; //Add layer to map map.Layers.Add(xlsLayer); LabelLayer xlsLabelLayer = new LabelLayer("XLSLabel") { DataSource = xlsProvider, LabelColumn = "Name", PriorityColumn = "Population", Style = { CollisionBuffer = new SizeF(2f, 2f), CollisionDetection = true }, LabelFilter = LabelCollisionDetection.ThoroughCollisionDetection }; map.Layers.Add(xlsLabelLayer); map.ZoomToBox(tileLayer.Envelope); return map; }
private static ICoordinateTransformation GetCoordinateTransformation() { //The SRS for this datasource is EPSG:4326, therefore we need to transfrom it to OSM projection CoordinateTransformationFactory ctf = new CoordinateTransformationFactory(); CoordinateSystemFactory cf = new CoordinateSystemFactory(); ICoordinateSystem epsg4326 = cf.CreateFromWkt("GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]"); ICoordinateSystem epsg3857 = cf.CreateFromWkt("PROJCS[\"Popular Visualisation CRS / Mercator\", GEOGCS[\"Popular Visualisation CRS\", DATUM[\"Popular Visualisation Datum\", SPHEROID[\"Popular Visualisation Sphere\", 6378137, 0, AUTHORITY[\"EPSG\",\"7059\"]], TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6055\"]],PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]], UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9102\"]], AXIS[\"E\", EAST], AXIS[\"N\", NORTH], AUTHORITY[\"EPSG\",\"4055\"]], PROJECTION[\"Mercator\"], PARAMETER[\"False_Easting\", 0], PARAMETER[\"False_Northing\", 0], PARAMETER[\"Central_Meridian\", 0], PARAMETER[\"Latitude_of_origin\", 0], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]], AXIS[\"East\", EAST], AXIS[\"North\", NORTH], AUTHORITY[\"EPSG\",\"3857\"]]"); return ctf.CreateFromCoordinateSystems(epsg4326, epsg3857);
/// <summary> /// Gets a coordinate system from the SRID.csv file /// </summary> /// <param name="id">EPSG ID</param> /// <returns>Coordinate system, or null if SRID was not found.</returns> public static ICoordinateSystem GetCSbyID(int id) { CoordinateSystemFactory fac = new CoordinateSystemFactory(); foreach (WKTstring wkt in GetSRIDs()) { if (wkt.WKID == id) { return CoordinateSystemWktReader.Parse(wkt.WKT) as ICoordinateSystem; } } return null; }