C# Shape.Relate方法代码示例

 public SpatialRelation Relate(Shape other, SpatialContext ctx)
 {
     // ** NOTE ** the overall order of logic is kept consistent here with simple.PointImpl.
     if (other is Point)
         return this.Equals(other) ? SpatialRelation.INTERSECTS : SpatialRelation.DISJOINT;
     return other.Relate(this, ctx).Transpose();
 }

 public SpatialRelation Relate(Shape other)
 {
     if (other is Point)
         return Relate((Point)other);
     else if (other is Rectangle)
         return Relate((Rectangle)other);
     else if (other is Circle)
         return Relate((Circle)other, ctx);
     else if (other is NtsGeometry)
         return Relate((NtsGeometry)other);
     return other.Relate(this).Transpose();
 }

 public SpatialRelation Relate(Shape other, SpatialContext ctx)
 {
     var point = other as Point;
     if (point != null)
     {
         return Relate(point, ctx);
     }
     var rectangle = other as Rectangle;
     if (rectangle != null)
     {
         return Relate(rectangle, ctx);
     }
     return other.Relate(this, ctx).Transpose();
 }

 // possibly consider hilbert curve
 // http://en.wikipedia.org/wiki/Hilbert_curve
 // http://blog.notdot.net/2009/11/Damn-Cool-Algorithms-Spatial-indexing-with-Quadtrees-and-Hilbert-Curves
 // if we actually use the range property in the query, this could be useful
 private void CheckBattenberg(char c, double cx, double cy, int level, IList<Cell>
                                                                           matches, StringBuilder str,
                              Shape shape, int maxLevel)
 {
     Debug.Assert(str.Length == level);
     double w = levelW[level] / 2;
     double h = levelH[level] / 2;
     int strlen = str.Length;
     Rectangle rectangle = ctx.MakeRectangle(cx - w, cx + w, cy - h, cy + h);
     SpatialRelation v = shape.Relate(rectangle);
     if (SpatialRelation.CONTAINS == v)
     {
         str.Append(c);
         //str.append(SpatialPrefixGrid.COVER);
         matches.Add(new QuadCell(this, str.ToString(), v.Transpose()));
     }
     else
     {
         if (SpatialRelation.DISJOINT == v)
         {
         }
         else
         {
             // nothing
             // SpatialRelation.WITHIN, SpatialRelation.INTERSECTS
             str.Append(c);
             int nextLevel = level + 1;
             if (nextLevel >= maxLevel)
             {
                 //str.append(SpatialPrefixGrid.INTERSECTS);
                 matches.Add(new QuadCell(this, str.ToString(), v.Transpose()));
             }
             else
             {
                 Build(cx, cy, nextLevel, matches, str, shape, maxLevel);
             }
         }
     }
     str.Length = strlen;
 }

 public SpatialRelation Relate(Shape other)
 {
     if (other is Point)
         return this.Equals(other) ? SpatialRelation.INTERSECTS : SpatialRelation.DISJOINT;
     return other.Relate(this).Transpose();
 }

 public SpatialRelation Relate(Shape other)
 {
     var point = other as Point;
     if (point != null)
     {
         return Relate(point);
     }
     var rectangle = other as Rectangle;
     if (rectangle != null)
     {
         return Relate(rectangle);
     }
     return other.Relate(this).Transpose();
 }

        public SpatialRelation Relate(Shape other, SpatialContext ctx)
        {
            Debug.Assert(this.ctx == ctx);

            //This shortcut was problematic in testing due to distinctions of CONTAINS/WITHIN for no-area shapes (lines, points).
            //    if (distance == 0) {
            //      return point.relate(other,ctx).intersects() ? SpatialRelation.WITHIN : SpatialRelation.DISJOINT;
            //    }

            var other1 = other as Point;
            if (other1 != null)
            {
                return Relate(other1, ctx);
            }
            var rectangle = other as Rectangle;
            if (rectangle != null)
            {
                return Relate(rectangle, ctx);
            }
            var circle = other as Circle;
            if (circle != null)
            {
                return Relate(circle, ctx);
            }
            return other.Relate(this, ctx).Transpose();
        }

        private void AssertIntersect(String msg, SpatialRelation expected, Shape a, Shape b)
        {
            SpatialRelation sect = a.Relate(b, ctx);
            if (sect == expected)
                return;
            if (expected == SpatialRelation.WITHIN || expected == SpatialRelation.CONTAINS)
            {
                if (a.GetType() == b.GetType()) // they are the same shape type
                    Assert.Equal(/*msg,*/ a, b);
                else
                {
                    //they are effectively points or lines that are the same location
                    Assert.True(!a.HasArea(), msg);
                    Assert.True(!b.HasArea(), msg);

                    Rectangle aBBox = a.GetBoundingBox();
                    Rectangle bBBox = b.GetBoundingBox();
                    if (aBBox.GetHeight() == 0 && bBBox.GetHeight() == 0
                        && (aBBox.GetMaxY() == 90 && bBBox.GetMaxY() == 90
                            || aBBox.GetMinY() == -90 && bBBox.GetMinY() == -90))
                    {
                        ; //== a point at the pole
                    }
                    else
                    {
                        Assert.Equal( /*msg,*/ aBBox, bBBox);
                    }
                }
            }
            else
            {
                Assert.Equal(/*msg,*/ expected, sect);
            }
        }