public void Filter(ICoordinateSequence seq, int index)
            {
                /**
                 * This logic also handles skipping Point geometries
                 */
                if (index == 0)
                {
                    return;
                }

                var p0 = seq.GetCoordinate(index - 1);
                var p1 = seq.GetCoordinate(index);

                double delx = (p1.X - p0.X) / _numSubSegs;
                double dely = (p1.Y - p0.Y) / _numSubSegs;

                for (int i = 0; i < _numSubSegs; i++)
                {
                    double x  = p0.X + i * delx;
                    double y  = p0.Y + i * dely;
                    var    pt = new Coordinate(x, y);
                    _minPtDist.Initialize();
                    DistanceToPoint.ComputeDistance(_geom, pt, _minPtDist);
                    _maxPtDist.SetMaximum(_minPtDist);
                }
            }
            /// <inheritdoc cref="ICoordinateFilter.Filter"/>
            public void Filter(Coordinate pt)
            {
                var minPtDist = new PointPairDistance();

                DistanceToPoint.ComputeDistance(_geom, pt, minPtDist);
                _maxPtDist.SetMaximum(minPtDist);
            }
示例#3
0
文件: AssertGeo.cs 项目: emij/OpenLR
        /// <summary>
        /// Compares two linestrings.
        /// </summary>
        /// <param name="expected"></param>
        /// <param name="actual"></param>
        /// <param name="delta"></param>
        public static void AreEqual(ILineString expected, ILineString actual, double delta)
        {
            var distance = new PointPairDistance();

            foreach (Coordinate actualCoordinate in actual.Coordinates)
            {
                DistanceToPoint.ComputeDistance(expected, actualCoordinate, distance);
                Assert.AreEqual(0.0, distance.Distance, delta);
            }
            foreach (Coordinate expectedCoordinate in expected.Coordinates)
            {
                DistanceToPoint.ComputeDistance(actual, expectedCoordinate, distance);
                Assert.AreEqual(0.0, distance.Distance, delta);
            }
        }
            void IEntireCoordinateSequenceFilter.Filter(CoordinateSequence seq)
            {
                /*
                 * This logic also handles skipping Point geometries
                 */
                for (int index = 1; index < seq.Count; index++)
                {
                    var p0 = seq.GetCoordinate(index - 1);
                    var p1 = seq.GetCoordinate(index);

                    double delx = (p1.X - p0.X) / _numSubSegs;
                    double dely = (p1.Y - p0.Y) / _numSubSegs;

                    for (int i = 0; i < _numSubSegs; i++)
                    {
                        double x         = p0.X + i * delx;
                        double y         = p0.Y + i * dely;
                        var    pt        = new Coordinate(x, y);
                        var    minPtDist = new PointPairDistance();
                        DistanceToPoint.ComputeDistance(_geom, pt, minPtDist);
                        _maxPtDist.SetMaximum(minPtDist);
                    }
                }
            }
 public void Filter(Coordinate pt)
 {
     _minPtDist.Initialize();
     DistanceToPoint.ComputeDistance(_geom, pt, _minPtDist);
     _maxPtDist.SetMaximum(_minPtDist);
 }
 public static int CompareTo(DistanceToPoint lhs, DistanceToPoint rhs)
 {
     return(lhs.SqrDistance.CompareTo(rhs.SqrDistance));
 }