Esempio n. 1
0
        public void Bulk_Transform_Enum(System.Windows.Point[][] xy, bool test, bool bProj, TestAttribute ta, object setup, ref double x, ref double y)
        {
            Console.WriteLine("--- WARNING --- Bulk_Transform_Enum has been rewritten, name is misleading ---");

            int j = random.Next(xy[0].Length);

            List <Test> _test = new List <Test>();

            for (int i = 0; i < xy[0].Length; i++)
            {
                _test.Add(new Test {
                    p = xy[0][i]
                });
            }

            ICoordinateTransformation t = GetTransformation(!bProj);

            t.Transform <Test>(_test, u => u.p, (u, v) => u.p = v);

            for (int i = 0; i < ta.PerPoint / xy[0].Length; ++i)
            {
                t.Transform(xy[0], xy[1]);

                x = xy[1][j].X;
                y = xy[1][j].Y;
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Creates the transformation function that determines the position of a
        /// source pixel, given the position of a target pixel.
        /// </summary>
        /// <param name="targetMapRectangle">The requested target rectangle.</param>
        /// <param name="targetSize">The requested target size.</param>
        /// <param name="sourceBoundingBox">The source bounding box corresponding to the target map rectangle..</param>
        /// <param name="sourceSize">The source size corresponding to the target size.</param>
        /// <returns>Position of source pixel</returns>
        protected virtual Func <PointD, PointD> GetTransformFunction(MapRectangle targetMapRectangle, Size targetSize, IBoundingBox sourceBoundingBox, Size sourceSize)
        {
            return(target =>
            {
                // knowing the map rectangle, we can compute the logical coordinate corresponding to the position of the target pixel
                var pLogicalTarget = new Location(
                    targetMapRectangle.Left + (targetMapRectangle.Right - targetMapRectangle.Left) * (target.X / (targetSize.Width - 1)),
                    targetMapRectangle.Top - (targetMapRectangle.Top - targetMapRectangle.Bottom) * (target.Y / (targetSize.Height - 1))
                    );

                // transform this logical coordinate into the source CRS
                var pLogicalSource = TargetToSourceTransformation.Transform(pLogicalTarget);

                // knowing the source bounding box and its configured orientation, we can now
                // turn the logical source coordinate into the logical offsets (left and top)
                var sourceOffset = new SizeD(

                    new[] { ContentAlignment.TopLeft, ContentAlignment.BottomLeft }.Contains(SourceMapService.MinAlignment)
                        ? pLogicalSource.X - sourceBoundingBox.MinX
                        : sourceBoundingBox.MaxX - pLogicalSource.X,

                    new[] { ContentAlignment.BottomLeft, ContentAlignment.BottomRight }.Contains(SourceMapService.MinAlignment)
                        ? sourceBoundingBox.MaxY - pLogicalSource.Y
                        : pLogicalSource.Y - sourceBoundingBox.MinY
                    );

                // and finally, we an turn the logical offsets into the pixel position
                return new PointD(
                    sourceSize.Width * sourceOffset.Width / sourceBoundingBox.Size().Width,
                    sourceSize.Height * sourceOffset.Height / sourceBoundingBox.Size().Height
                    );
            });
        }
Esempio n. 3
0
        public void Single_Transform_Proj_XY(TestAttribute ta, object setup, ref double x, ref double y)
        {
            ICoordinateTransformation t = GetTransformation(false);

            for (int i = 0; i < ta.PerPoint; ++i)
            {
                t.Transform(p.X, p.Y, out x, out y);
            }
        }
        public void TestLineInterception()
        {
            var wktReader = new WKTReader();
            var ab_4326   = wktReader.Read("LINESTRING(11.4047661 48.1403687,11.4053519 48.141055)") as ILineString;
            var a_4326    = ab_4326.GetPointN(0);
            var b_4326    = ab_4326.GetPointN(1);
            var a         = _transformation4326To3395.Transform(a_4326.ToCoordinate2D());
            var b         = _transformation4326To3395.Transform(b_4326.ToCoordinate2D());

            var points = new String[] {
                "POINT(11.406501117689324 48.14051652560591)",  // East
                "POINT(11.406713245538327 48.14182906667162)",  // Northeast
                "POINT(11.404923416812364 48.14258477213369)",  // North
                "POINT(11.403300759321036 48.14105540093837)",  // Northwest
                "POINT(11.403193249043934 48.140881120346386)", // West
                "POINT(11.40327279698731 48.13987351306362)",   // Southwest
                "POINT(11.405221721600025 48.1392039845402)",   // South
                "POINT(11.406255844863914 48.13963486923349)"   // Southeast
            };

            foreach (var pointWkt in points)
            {
                var c_4326 = wktReader.Read(pointWkt) as IPoint;
                var c      = _transformation4326To3395.Transform(c_4326.ToCoordinate2D());

                var f = Spatial.Intercept(a, b, c);
                var p = Spatial.Interpolate(a, b, f);

                var res = Intercept(a, b, c);

                var s = Spatial.Distance(p, c);

                var p_4326 = _transformation3395To4326.Transform(p);
                var s_esri = this.DistanceEpsg4326(p_4326, c_4326.ToCoordinate2D());

                Assert.InRange(f > 1 ? 1 : f < 0 ? 0 : f, res.Item3 - 0.2, res.Item3 + 0.2);
                Assert.InRange(p.X, res.Item1.X - 50, res.Item1.X + 50);
                Assert.InRange(p.Y, res.Item1.Y - 50, res.Item1.Y + 50);

                AssertEquals(s, s_esri, 10E-6);
            }
        }
Esempio n. 5
0
 public static RectangleD Transform(this RectangleD @this, ICoordinateTransformation transformation)
 {
     double[] pts = new double[8];
     pts[0] = @this.Left; pts[1] = @this.Bottom;
     pts[2] = @this.Right; pts[3] = @this.Bottom;
     pts[4] = @this.Right; pts[5] = @this.Top;
     pts[6] = @this.Left; pts[7] = @this.Top;
     transformation.Transform(pts, 4);
     return(RectangleD.FromLTRB(Math.Min(pts[0], pts[6]),
                                Math.Min(pts[5], pts[7]), Math.Max(pts[2], pts[4]),
                                Math.Max(pts[1], pts[3])));
 }
Esempio n. 6
0
        public void Bulk_Transform_XY(double[][] xy, bool bProj, TestAttribute ta, object setup, ref double x, ref double y)
        {
            int j = random.Next(xy[0].Length);

            ICoordinateTransformation t = GetTransformation(!bProj);

            for (int i = 0; i < ta.PerPoint / xy[0].Length; ++i)
            {
                t.Transform(xy[0], xy[1], xy[2], xy[3]);

                x = xy[2][j];
                y = xy[3][j];
            }
        }
Esempio n. 7
0
        public void Bulk_Transform_Point(System.Windows.Point[][] xy, bool bProj, TestAttribute ta, object setup, ref double x, ref double y)
        {
            int j = random.Next(xy[0].Length);

            ICoordinateTransformation t = GetTransformation(!bProj);

            for (int i = 0; i < ta.PerPoint / xy[0].Length; ++i)
            {
                xy[1] = t.Transform(xy[0]);

                x = xy[1][j].X;
                y = xy[1][j].Y;
            }
        }
        public static ILineString Transform(this ICoordinateTransformation self, ILineString line)
        {
            var newCoords = new Coordinate[line.NumPoints];

            for (var i = 0; i < line.NumPoints; i++)
            {
                var pt               = line.GetPointN(i);
                var coord            = newCoords[i];
                var oldCoord         = new Coordinate2D(pt.X, pt.Y);
                var transformedCoord = self.Transform(oldCoord);
                newCoords[i] = new Coordinate(transformedCoord.X, transformedCoord.Y);
            }
            return(new LineString(newCoords));
        }
Esempio n. 9
0
        public void Single_Transform_Proj_Point(TestAttribute ta, object setup, ref double x, ref double y)
        {
            ICoordinateTransformation t = GetTransformation(false);

            System.Windows.Point pOut =
                new System.Windows.Point();

            for (int i = 0; i < ta.PerPoint; ++i)
            {
                pOut = t.Transform(p);
            }

            x = pOut.X;
            y = pOut.Y;
        }
Esempio n. 10
0
        public bool Single_Direct(TestAttribute ta, object setup, ref double x, ref double y)
        {
            ICoordinateTransformation t = GetTransformation(true);

            for (int i = 0; i < ta.PerPoint; ++i)
            {
                x = p.X;
                y = p.Y;

                double?z;
                t.Transform(x, y, null, out x, out y, out z);
            }

            return(true);
        }
Esempio n. 11
0
        public void Bulk_100000_Direct_XY(TestAttribute ta, object setup, ref double x, ref double y)
        {
            double[][] xy = bulk_XY_100000;

            int j = random.Next(xy[0].Length);

            ICoordinateTransformation t = GetTransformation(true);

            for (int i = 0; i < ta.PerPoint / xy[0].Length; ++i)
            {
                t.Transform(xy[0], xy[1], null, xy[2], xy[3], null);

                x = xy[2][j];
                y = xy[3][j];
            }
        }
        private IExtents TransformExtents(IExtents ext)
        {
            if (!Provider.SpatialReference.EqualParams(ext.SpatialReference))
            {
                if (Provider.CoordinateTransformationFactory == null)
                {
                    throw new MissingCoordinateTransformationFactoryException(
                              "Data requires transformation however no CoordinateTransformationFactory is set");
                }

                ICoordinateTransformation ct =
                    Provider.CoordinateTransformationFactory.CreateFromCoordinateSystems(ext.SpatialReference,
                                                                                         Provider.
                                                                                         OriginalSpatialReference);
                return(ct.Transform(ext, Provider.GeometryFactory));
            }
            return(ext);
        }
Esempio n. 13
0
        /// <summary>
        /// Helper for generating transformed points on a line (x0,y0) - (x1,y1),
        /// given the number of points to generate and a coordinate transformation.
        /// </summary>
        /// <param name="t">Coordinate transformation to use.</param>
        /// <param name="x0">x-coordinate of start point</param>
        /// <param name="y0">y-coordinate of start point</param>
        /// <param name="x1">x-coordinate of end point</param>
        /// <param name="y1">y-coordinate of end point</param>
        /// <param name="n">Number of points to generate.</param>
        /// <returns>Generated points</returns>
        private static Location[] MakeLineString(ICoordinateTransformation t, double x0, double y0, double x1, double y1, int n)
        {
            // setup interpolator
            var pointInterpolator = new
            {
                x = x0, xi = (x1 - x0) / (n - 1),
                y = y0, yi = (y1 - y0) / (n - 1)
            };

            // local function for interpolating points given an index
            Func <int, Location> interpolatedLocation = index => new Location(
                pointInterpolator.x + index * pointInterpolator.xi,
                pointInterpolator.y + index * pointInterpolator.yi
                );

            // create and return locations using interpolator and coordinate transformation
            return(t.Transform(Enumerable.Range(0, n).Select(interpolatedLocation).ToArray()));
        }
Esempio n. 14
0
        public static RectangleD Transform(this RectangleD @this, ICRS source, ICRS target)
        {
            if (source == null || target == null || source.IsEquivalent(target))
            {
                return(@this);
            }
            using (ICoordinateTransformation transformation = CoordinateReferenceSystemFactory.Default.CreateCoordinateTrasformation(source, target))
            {
                double[] pts = new double[8];
                pts[0] = @this.Left; pts[1] = @this.Bottom;
                pts[2] = @this.Right; pts[3] = @this.Bottom;
                pts[4] = @this.Right; pts[5] = @this.Top;
                pts[6] = @this.Left; pts[7] = @this.Top;
                transformation.Transform(pts, 4);

                return(RectangleD.FromLTRB(Math.Min(pts[0], pts[6]),
                                           Math.Min(pts[5], pts[7]), Math.Max(pts[2], pts[4]),
                                           Math.Max(pts[1], pts[3])));
            }
        }
Esempio n. 15
0
        private void Run(System.Reflection.MethodInfo mi, TestAttribute ta)
        {
            proj4Transformation.Transform(new Location());

            try
            {
                double   x = 0, y = 0;
                object[] args = new object[] { ta, null, x, y };

                HiResTimer timer = new HiResTimer();

                bool bSucceeded = ta.Enabled;

                if (bSucceeded)
                {
                    try
                    {
                        mi.Invoke(this, args);
                    }
                    catch
                    {
                        bSucceeded = false;
                    }
                }

                double d = timer.Elapsed;

                if (ta.Enabled)
                {
                    Console.WriteLine("{0}: {1} after {2:0}ms ({3:0}ns per point), x={4:0}, y={5:0}",
                                      ta.TestName, bSucceeded ? "succeeded" : "FAILED", d, 1000000.0 * d / ta.PerPoint, args[2], args[3]);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Test \"" + mi.Name + "\" failed with " + ex.GetType().FullName + ": " + ex.Message);
                Console.WriteLine(ex.StackTrace.ToString());
            }
        }
Esempio n. 16
0
        static void SimpleTest()
        {
            // create some places
            var places = new Place[] {
                new Place {
                    Location = new Location(841090, 5006420), Name = "Frankfurt"
                },
                new Place {
                    Location = new Location(1323560, 5230020), Name = "Berlin"
                }
            };

            // get a transformation for transforming from PTV GeoMinSek to PTV Mercator
            ICoordinateTransformation t = CoordinateTransformation.Get(
                CoordinateReferenceSystem.Mapserver.cfGEOMINSEK,
                CoordinateReferenceSystem.XServer.PTV_MERCATOR
                );

            // transform the places
            t.Transform <Place>(
                places,
                place => place.Location,
                (place, loc) => place.Location = loc
                );

            double d_Frankfurt_Berlin = CoordinateReferenceSystem.XServer.PTV_MERCATOR.GetHaversineDistance(965820, 6458402, 1489888, 6883432);

            Console.WriteLine("-- simple test --\n");

            // Location l = new Location(1528170, 6623338);
            // Location m = new Location(33411907, 5656638);

            // Console.WriteLine("" + m + " == " + l.Transform("cfMERCATOR", "cfUTM"));

            TestBase.Run();

            Console.WriteLine("\n<press return to continue>");
            Console.ReadLine();
        }
Esempio n. 17
0
        /// <summary>
        /// Transforms a point into a way point description for xRoute
        /// </summary>
        /// <param name="p">Point to create the way point from</param>
        /// <param name="viaType">Via type to be set, if any</param>
        /// <returns>Newly created way point</returns>
        public static WaypointDesc ToWayPoint(this System.Windows.Point p, ViaTypeEnum?viaType = null)
        {
            p = Wgs84ToPtvSmartUnitsTransform.Transform(p);

            var wayPointDesc = new WaypointDesc
            {
                linkType      = LinkType.AUTO_LINKING,
                wrappedCoords = new[] { new Point {
                                            point = new PlainPoint {
                                                x = p.X, y = p.Y
                                            }
                                        } }
            };

            if (viaType.HasValue)
            {
                wayPointDesc.viaType = new ViaType {
                    viaType = viaType.Value
                }
            }
            ;

            return(wayPointDesc);
        }
        /// <summary>
        /// Transforms a point into a way point description for xRoute
        /// </summary>
        /// <param name="p">Point to create the way point from</param>
        /// <param name="viaType">Via type to be set, if any</param>
        /// <returns>Newly created way point</returns>
        public static Demo.XrouteService.WaypointDesc ToWaypoint(this Point p, Demo.XrouteService.ViaTypeEnum?viaType = null)
        {
            p = Wgs84ToPtvSmartUnitsTransform.Transform(p);

            var waypointDesc = new Demo.XrouteService.WaypointDesc
            {
                linkType      = Demo.XrouteService.LinkType.AUTO_LINKING,
                wrappedCoords = new[] { new Demo.XrouteService.Point {
                                            point = new Demo.XrouteService.PlainPoint {
                                                x = p.X, y = p.Y
                                            }
                                        } }
            };

            if (viaType.HasValue)
            {
                waypointDesc.viaType = new Demo.XrouteService.ViaType {
                    viaType = viaType.Value
                }
            }
            ;

            return(waypointDesc);
        }
        protected IGeometry TransformGeometry(IGeometry geom)
        {
            if (geom.SpatialReference == null && Provider.SpatialReference == null)
            {
                return(geom);
            }

            if (!Provider.SpatialReference.EqualParams(geom.SpatialReference))
            {
                if (Provider.CoordinateTransformationFactory == null)
                {
                    throw new MissingCoordinateTransformationFactoryException(
                              "Data requires transformation however no CoordinateTransformationFactory is set");
                }

                ICoordinateTransformation ct =
                    Provider.CoordinateTransformationFactory.CreateFromCoordinateSystems(geom.SpatialReference,
                                                                                         Provider.
                                                                                         OriginalSpatialReference);

                return(ct.Transform(geom, Provider.GeometryFactory));
            }
            return(geom);
        }
Esempio n. 20
0
        static void Main(string[] args)
        {
            SimpleTest();

            Console.SetWindowSize(120, 60);

            Thread.CurrentThread.CurrentCulture   = CultureInfo.InvariantCulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

            string r1 = Registry.GetContent();
            string r2 = Registry.GetContent(true);

            Direct.CoordinateTransformation.Enabled = true;

            double x = 8, y = 49;

            CoordinateTransformation.Get("EPSG:4326", "PTV_MERCATOR").Transform(x, y, out x, out y);

            string wkt = Registry.Get("cfGeoMinSek").WKT;

            MessageBox.Show(wkt);

            CoordinateReferenceSystem.Parse("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +custom=Ptv.Components.Projections.Custom.GeoMinSekTransformation");

            Registry.SetContent(r1, true, true);

            ICoordinateTransformation t = Proj4.CoordinateTransformation.Get("cfGEOMINSEK", "EPSG:76131");

            System.Windows.Point p =
                new System.Windows.Point(959361, 5332563);

            t.Transform(p);

            SimpleTest();
            ExtendedTest();
        }
 /// <summary>
 /// Transforms coordinates from PTV Mercator to WSG84;
 /// </summary>
 /// <param name="p">Point to transform</param>
 /// <returns>Transformed point</returns>
 public static Point PtvMercatorToWgs84(this Point p)
 {
     return(PtvMercatorToWgs84Transform.Transform(p));
 }
 /// <summary>
 /// Transforms xRoute WKB coordinates from PTV SmartUnits to WSG84.
 /// </summary>
 /// <param name="c">Extension object</param>
 /// <returns>Transformed point</returns>
 public static Point PtvSmartUnitsToWgs84(this ICoordinate c)
 {
     return(PtvSmartUnitsToWgs84Transform.Transform(new Point(c.X, c.Y)));
 }
 public CartesianSpatialOperationTest()
 {
     _reyk_3395 = _transformation4326To3395.Transform(_reyk_4326);
     _berl_3395 = _transformation4326To3395.Transform(_berl_4326);
     _mosk_3395 = _transformation4326To3395.Transform(_mosk_4326);
 }
 public static RectangleD Transform(this RectangleD @this, ICoordinateTransformation transformation)
 {
     return(transformation.Transform(@this));
 }
Esempio n. 25
0
 /// <summary>
 /// Transforms coordinates from WSG84 to PTV Mercator.
 /// </summary>
 /// <param name="p">Point to transform</param>
 /// <returns>Transformed point</returns>
 public static System.Windows.Point Wgs84ToPtvMercator(this System.Windows.Point p)
 {
     return(Wgs84ToPtvMercatorTransform.Transform(p));
 }
Esempio n. 26
0
 /// <summary>
 /// Transforms coordinates from PTV Mercator to WSG84;
 /// </summary>
 /// <param name="p">Point to transform</param>
 /// <returns>Transformed point</returns>
 public static System.Windows.Point PtvMercatorToWgs84(this System.Windows.Point p)
 {
     return(PtvMercatorToWgs84Transform.Transform(p));
 }
Esempio n. 27
0
        // FIX_PERF
        private static void setFeatureRowFromIFeatureDataRecord(IFeatureDataRecord srcFeature,
                                                                FeatureDataRow targetFeature,
                                                                ColumnMapper columnMapper,
                                                                ICoordinateTransformation transform,
                                                                IGeometryFactory geoFactory)
        {
            //for (Int32 i = 0; i < srcFeature.FieldCount; i++)
            //{
            //    String colName = srcFeature.GetName(i);
            //    targetFeature[colName] = srcFeature.GetValue(i);
            //}
            if (transform != null)//jd: to prevent case when transform is null -  probably because a test was done earlier. need to check
            {
                if (srcFeature.Geometry.SpatialReference.EqualParams(transform.Target))
                {
                    transform = null;
                }
            }

            srcFeature.GetValues(columnMapper.SourceValues);
            targetFeature.ItemArray = columnMapper.Map();
            targetFeature.Geometry = transform == null
                                         ? srcFeature.Geometry
                                         : transform.Transform(srcFeature.Geometry, geoFactory);
            targetFeature.IsFullyLoaded = targetFeature.IsFullyLoaded || srcFeature.IsFullyLoaded;
        }
 /// <summary>
 /// Transforms coordinates from WSG84 to PTV Mercator.
 /// </summary>
 /// <param name="p">Point to transform</param>
 /// <returns>Transformed point</returns>
 public static Point Wgs84ToPtvMercator(this Point p)
 {
     return(Wgs84ToPtvMercatorTransform.Transform(p));
 }
Esempio n. 29
0
 /// <summary>
 /// Transforms xRoute WKB coordinates from PTV SmartUnits to WSG84.
 /// </summary>
 /// <param name="c">Extension object</param>
 /// <returns>Transformed point</returns>
 public static System.Windows.Point PtvSmartUnitsToWgs84(this ICoordinate c)
 {
     return(PtvSmartUnitsToWgs84Transform.Transform(new System.Windows.Point(c.X, c.Y)));
 }