Exemple #1
0
        public void TestPointPoint1()
        {
            // test two points that are the same location
            Coordinate coord1 = new Coordinate(5.0, 7.0);
            Coordinate coord2 = new Coordinate(5.0, 7.0);
            Point      pt1    = _factory.CreatePoint(coord1);
            Point      pt2    = _factory.CreatePoint(coord2);

            Assertion.AssertEquals("intersects", true, pt1.Intersects(pt2));
            Assertion.AssertEquals("disjoint", false, pt1.Disjoint(pt2));
            Assertion.AssertEquals("contains", true, pt1.Contains(pt2));
            Assertion.AssertEquals("within", true, pt1.Within(pt2));


            //Cross returns 1 (TRUE) if the intersection results in a geometry whose dimension
            //is one less than the maximum dimension of the two source geometries and the
            //intersection set is interior to both source geometries. Cross returns t (TRUE)
            //for only a multipoint/polygon, multipoint/linestring, linestring/linestring,
            //linestring/polygon, and linestring/multipolygon comparisons.
            Assertion.AssertEquals("crosses", false, pt1.Crosses(pt2));

            // Touch returns 1 (TRUE) if none of the points common to both geometries
            // intersect the interiors of both geometries. At least one geometry must
            // be a linestring, polygon, multilinestring or multipolygon.
            Assertion.AssertEquals("touches", false, pt1.Touches(pt2));


            //This pattern matrix applies to linestring/linestring and multilinestring/
            //multilinestring overlays. In this case the intersection of the geometries
            //must result in a geometry that has a dimension of 1 (another linestring).
            //If the dimension of the intersection of the interiors had been 1 the overlay
            //predicate would return FALSE, however the cross predicate would have returned TRUE.
            Assertion.AssertEquals("overlaps", false, pt1.Overlaps(pt2));
        }
Exemple #2
0
        /// <summary>
        /// Returns the display index to set the column to
        /// </summary>
        /// <param name="mousePosition"></param>
        /// <param name="ignoreVertical"></param>
        /// <param name="clipToVisible"></param>
        /// <returns></returns>
        private int?GetReorderingTargetDisplayIndex(Point mousePosition, bool ignoreVertical, bool clipToVisible)
        {
            if (!clipToVisible || (mousePosition.Within(this, this.OwningGrid, ignoreVertical) && mousePosition.Within(this, this.OwningGrid.ColumnHeaders, ignoreVertical)))
            {
                DataGridColumnHeader result = this.OwningGrid.ColumnHeaders.Children
                                              .OfType <DataGridColumnHeader>()
                                              .Where(header => header.OwningGrid != null && header.OwningColumn != this.OwningGrid.ColumnsInternal.FillerColumn)
                                              .OrderBy(header => header.OwningColumn.DisplayIndex)
                                              .FirstOrDefault(header => IsReorderTargeted(mousePosition, header, ignoreVertical));

                if (result != null)
                {
                    if (result.OwningColumn.DisplayIndex > this.OwningColumn.DisplayIndex)
                    {
                        // later column, but we need to adjust for the index shift that would happen
                        return(result.OwningColumn.DisplayIndex - 1);
                    }
                    else
                    {
                        // earlier column
                        return(result.OwningColumn.DisplayIndex);
                    }
                }
                else
                {
                    // last column
                    return(this.OwningGrid.Columns.Count - 1);
                }
            }

            return(null);
        }
Exemple #3
0
        public static void Run()
        {
            //ExStart: DetermineIfOneGeometryContainsAnother
            var geometry1 = new Polygon();

            geometry1.ExteriorRing = new LinearRing(new[]
            {
                new Point(0, 0),
                new Point(0, 4),
                new Point(4, 4),
                new Point(4, 0),
                new Point(0, 0),
            });
            geometry1.AddInteriorRing(new LinearRing(new[]
            {
                new Point(1, 1),
                new Point(1, 3),
                new Point(3, 3),
                new Point(3, 1),
                new Point(1, 1),
            }));

            var geometry2 = new Point(2, 2);

            Console.WriteLine(geometry1.SpatiallyContains(geometry2)); // False

            var geometry3 = new Point(0.5, 0.5);

            Console.WriteLine(geometry1.SpatiallyContains(geometry3)); // True

            // 'a.SpatiallyContains(b)' equals to 'b.Within(a)'
            Console.WriteLine(geometry3.Within(geometry1)); // True
            //ExEnd: DetermineIfOneGeometryContainsAnother
        }
Exemple #4
0
        public void TestPointLine2()
        {
            // test when the point being tested in a node on the line
            Coordinate coordLine1  = new Coordinate(5.0, 5.0);
            Coordinate coordLine2  = new Coordinate(10.0, 10.0);
            Coordinate coordPoint1 = new Coordinate(6.0, 6.0);

            Coordinates coordinates = new Coordinates();

            coordinates.Add(coordLine1);
            coordinates.Add(coordLine2);

            Point point1 = _factory.CreatePoint(coordPoint1);

            LineString linestring = _factory.CreateLineString(coordinates);

            Assertion.AssertEquals("intersects", true, point1.Intersects(linestring));
            Assertion.AssertEquals("intersects", true, linestring.Intersects(point1));
            Assertion.AssertEquals("disjoint", false, point1.Disjoint(linestring));
            Assertion.AssertEquals("contains", false, point1.Contains(linestring));
            Assertion.AssertEquals("OppositeContains", true, linestring.Contains(point1));
            Assertion.AssertEquals("within", true, point1.Within(linestring));                          // point1 is within linestring and linestring contains point.

            // always returns false when a point is involves
            Assertion.AssertEquals("crosses", false, point1.Crosses(linestring));

            Assertion.AssertEquals("touches", false, point1.Touches(linestring));                       // false because point is in the interior of linestring and not the boundary. The boundary is the endpoints.

            // always returns false when a point is involved
            Assertion.AssertEquals("overlaps", false, point1.Overlaps(linestring));
        }
Exemple #5
0
        public void TestPointLine1()
        {
            // test when the point being tested in a node on the line
            Coordinate coordLine1  = new Coordinate(5.0, 5.0);
            Coordinate coordLine2  = new Coordinate(10.0, 10.0);
            Coordinate coordPoint1 = new Coordinate(5.0, 5.0);

            Coordinates coordinates = new Coordinates();

            coordinates.Add(coordLine1);
            coordinates.Add(coordLine2);

            Point point1 = _factory.CreatePoint(coordPoint1);

            LineString linestring = _factory.CreateLineString(coordinates);

            Assertion.AssertEquals("intersects", true, point1.Intersects(linestring));
            Assertion.AssertEquals("disjoint", false, point1.Disjoint(linestring));
            Assertion.AssertEquals("contains", false, point1.Contains(linestring));
            Assertion.AssertEquals("within", false, point1.Within(linestring));

            // always returns false when a point is involves
            Assertion.AssertEquals("crosses", false, point1.Crosses(linestring));

            Assertion.AssertEquals("touches", true, point1.Touches(linestring));

            // always returns false when a point is involved
            Assertion.AssertEquals("overlaps", false, point1.Overlaps(linestring));
        }
Exemple #6
0
      static void Main(string[] args)
      {
         Point p1 = new Point(3, 3);
         Point p2 = new Point(3, 1);
         Point p3 = new Point(2, 1);
         Point p4 = new Point(1, 1);

         //Console.WriteLine(p1.Distance(p2));
         //Console.WriteLine(p1.Distance(p3));
         //Console.WriteLine(p1.Distance(p4));

         p1.Within(2).ForEach(p =>
            Console.WriteLine(p));

         //RandomUntity ran = new RandomUntity();
         //ran.GetRandom(1, 100, 100).ToList().ForEach(i=>
         //   Console.Write(i + "\t"));

         //Console.WriteLine(BitOperator.GetBinaryCount(0x00042400));
      }
Exemple #7
0
        public void TestPointPoint3()
        {
            // test two points that are the same location
            Coordinate coord1 = new Coordinate(5.0, 7.0);
            Coordinate coord2 = new Coordinate();
            Point      pt1    = _factory.CreatePoint(coord1);
            Point      pt2    = _factory.CreatePoint(coord2);

            Assertion.AssertEquals("intersects", false, pt1.Intersects(pt2));
            Assertion.AssertEquals("disjoint", true, pt1.Disjoint(pt2));
            Assertion.AssertEquals("contains", false, pt1.Contains(pt2));
            Assertion.AssertEquals("within", false, pt1.Within(pt2));


            // will always return false because point vs point is not a valid op
            // see comments above.
            Assertion.AssertEquals("crosses", false, pt1.Crosses(pt2));
            Assertion.AssertEquals("touches", false, pt1.Touches(pt2));
            Assertion.AssertEquals("overlaps", false, pt1.Overlaps(pt2));
        }
Exemple #8
0
        static void Main(string[] args)
        {
            Point p1 = new Point(3, 3);
            Point p2 = new Point(3, 1);
            Point p3 = new Point(2, 1);
            Point p4 = new Point(1, 1);

            //Console.WriteLine(p1.Distance(p2));
            //Console.WriteLine(p1.Distance(p3));
            //Console.WriteLine(p1.Distance(p4));

            p1.Within(2).ForEach(p =>
                                 Console.WriteLine(p));

            //RandomUntity ran = new RandomUntity();
            //ran.GetRandom(1, 100, 100).ToList().ForEach(i=>
            //   Console.Write(i + "\t"));

            //Console.WriteLine(BitOperator.GetBinaryCount(0x00042400));
        }
Exemple #9
0
        /// <summary>
        /// Returns the column against whose top-left the reordering caret should be positioned
        /// </summary>
        /// <param name="mousePosition"></param>
        /// <param name="ignoreVertical"></param>
        /// <param name="clipToVisible"></param>
        /// <returns></returns>
        private DataGridColumn GetReorderingTargetColumn(Point mousePosition, bool ignoreVertical, bool clipToVisible)
        {
            if (!clipToVisible || (mousePosition.Within(this, this.OwningGrid, ignoreVertical) && mousePosition.Within(this, this.OwningGrid.ColumnHeaders, ignoreVertical)))
            {
                DataGridColumnHeader result = this.OwningGrid.ColumnHeaders.Children
                                              .OfType <DataGridColumnHeader>()
                                              .Where(header => header.OwningGrid != null && header.OwningColumn != this.OwningGrid.ColumnsInternal.FillerColumn)
                                              .OrderBy(header => header.OwningColumn.DisplayIndex)
                                              .FirstOrDefault(header => IsReorderTargeted(mousePosition, header, ignoreVertical));

                if (result == null)
                {
                    return(this.OwningGrid.ColumnsInternal.FillerColumn);
                }
                else
                {
                    return(result.OwningColumn);
                }
            }


            return(null);
        }
        /// <summary>
        /// Returns the display index to set the column to
        /// </summary>
        /// <param name="mousePosition"></param>
        /// <param name="ignoreVertical"></param>
        /// <param name="clipToVisible"></param>
        /// <returns></returns>
        private int? GetReorderingTargetDisplayIndex(Point mousePosition, bool ignoreVertical, bool clipToVisible)
        {
            if (!clipToVisible || (mousePosition.Within(this, this.OwningGrid, ignoreVertical) && mousePosition.Within(this, this.OwningGrid.ColumnHeaders, ignoreVertical)))
            {
                DataGridColumnHeader result = this.OwningGrid.ColumnHeaders.Children
                    .OfType<DataGridColumnHeader>()
                    .Where(header => header.OwningGrid != null && header.OwningColumn != this.OwningGrid.ColumnsInternal.FillerColumn)
                    .OrderBy(header => header.OwningColumn.DisplayIndex)
                    .FirstOrDefault(header => IsReorderTargeted(mousePosition, header, ignoreVertical));

                if (result != null)
                {
                    if (result.OwningColumn.DisplayIndex > this.OwningColumn.DisplayIndex)
                    {
                        // later column, but we need to adjust for the index shift that would happen
                        return result.OwningColumn.DisplayIndex - 1;
                    }
                    else
                    {
                        // earlier column
                        return result.OwningColumn.DisplayIndex;
                    }
                }
                else
                {
                    // last column
                    return this.OwningGrid.Columns.Count - 1;
                }
            }

            return null;
        }
        /// <summary>
        /// Returns the column against whose top-left the reordering caret should be positioned
        /// </summary>
        /// <param name="mousePosition"></param>
        /// <param name="ignoreVertical"></param>
        /// <param name="clipToVisible"></param>
        /// <returns></returns>
        private DataGridColumn GetReorderingTargetColumn(Point mousePosition, bool ignoreVertical, bool clipToVisible)
        {
            if (!clipToVisible || (mousePosition.Within(this, this.OwningGrid, ignoreVertical) && mousePosition.Within(this, this.OwningGrid.ColumnHeaders, ignoreVertical)))
            {
                DataGridColumnHeader result = this.OwningGrid.ColumnHeaders.Children
                    .OfType<DataGridColumnHeader>()
                    .Where(header => header.OwningGrid != null && header.OwningColumn != this.OwningGrid.ColumnsInternal.FillerColumn)
                    .OrderBy(header => header.OwningColumn.DisplayIndex)
                    .FirstOrDefault(header => IsReorderTargeted(mousePosition, header, ignoreVertical));

                if (result == null)
                {
                    return this.OwningGrid.ColumnsInternal.FillerColumn;
                }
                else
                {
                    return result.OwningColumn;
                }
            }

            return null;
        }
Exemple #12
0
 public static bool Within(this Point pt, Size s)
 {
     return(pt.Within(new Rect(s)));
 }
Exemple #13
0
        private bool Within(Odwiert drilling, Geometry geometry)
        {
            Point point = new Point(drilling.EurefY.Value, drilling.EurefX.Value);

            return(point.Within(geometry));
        }
Exemple #14
0
        /// <summary>
        ///
        /// </summary>
        public void Start()
        {
            var pInterior = Factory.CreatePoint(new Coordinate(100, 100));
            var pExterior = Factory.CreatePoint(new Coordinate(100, 101));

            try
            {
                Write(point.Area);
                Write(point.Boundary);
                Write(point.BoundaryDimension);
                Write(point.Centroid);
                Write(point.Coordinate);
                Write(point.Coordinates);
                Write(point.CoordinateSequence);
                Write(point.Dimension);
                Write(point.Envelope);
                Write(point.EnvelopeInternal);
                Write(point.Factory);
                Write(point.InteriorPoint);
                Write(point.IsEmpty);
                Write(point.IsSimple);
                Write(point.IsValid);
                Write(point.Length);
                Write(point.NumPoints);
                Write(point.PrecisionModel);
                Write(point.X);
                Write(point.Y);

                Write(point.Contains(pInterior));
                Write(point.Contains(pExterior));

                Write(point.Buffer(10));
                Write(point.Buffer(10, new BufferParameters {
                    EndCapStyle = EndCapStyle.Square
                }));
                Write(point.Buffer(10, new BufferParameters {
                    EndCapStyle = EndCapStyle.Flat
                }));
                Write(point.Buffer(10, 20));
                Write(point.Buffer(10, new BufferParameters(20)
                {
                    EndCapStyle = EndCapStyle.Square
                }));
                Write(point.Buffer(10, new BufferParameters(20)
                {
                    EndCapStyle = EndCapStyle.Flat
                }));

                Write(point.Crosses(pInterior));
                Write(point.Crosses(pExterior));
                Write(point.Difference(pInterior));
                Write(point.Difference(pExterior));
                Write(point.Disjoint(pInterior));
                Write(point.Disjoint(pExterior));
                Write(point.EqualsTopologically(pInterior));
                Write(point.EqualsTopologically(pExterior));
                Write(point.EqualsExact(pInterior));
                Write(point.EqualsExact(pExterior));
                Write(point.ConvexHull());
                Write(point.Intersection(pInterior));
                Write(point.Intersection(pExterior));
                Write(point.Intersects(pInterior));
                Write(point.Intersects(pExterior));
                Write(point.IsWithinDistance(pInterior, 0.001));
                Write(point.IsWithinDistance(pExterior, 0.001));
                Write(point.Overlaps(pInterior));
                Write(point.Overlaps(pExterior));
                Write(point.SymmetricDifference(pInterior));
                Write(point.SymmetricDifference(pExterior));
                Write(point.ToString());
                Write(point.AsText());
                Write(point.Touches(pInterior));
                Write(point.Touches(pExterior));
                Write(point.Union(pInterior));
                Write(point.Union(pExterior));
                Write(point.Within(pInterior));
                Write(point.Within(pExterior));

                string pointstring        = "POINT (100.22 100.33)";
                string anotherpointstring = "POINT (12345 3654321)";
                var    geom1 = Reader.Read(pointstring);
                Write(geom1.AsText());
                var geom2 = Reader.Read(anotherpointstring);
                Write(geom2.AsText());

                byte[] bytes = point.AsBinary();
                var    test1 = new WKBReader().Read(bytes);
                Write(test1.ToString());

                bytes = Factory.CreatePoint(new Coordinate(double.MinValue, double.MinValue)).AsBinary();
                var testempty = new WKBReader().Read(bytes);
                Write(testempty);

                bytes = new GDBWriter().Write(geom1);
                test1 = new GDBReader().Read(bytes);
                Write(test1.ToString());

                // Test Empty Geometries
                Write(Point.Empty);
                Write(LineString.Empty);
                Write(Polygon.Empty);
                Write(MultiPoint.Empty);
                Write(MultiLineString.Empty);
                Write(MultiPolygon.Empty);
                Write(GeometryCollection.Empty);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }