C# IGeometry.Contains方法代码示例

            private static bool CheckContains(IGeometry target, IGeometry test)
            {
                bool expectedResult = target.Contains(test);

                PreparedGeometryFactory pgFact = new PreparedGeometryFactory();
                IPreparedGeometry prepGeom = pgFact.Create(target);

                bool prepResult = prepGeom.Contains(test);

                if (prepResult != expectedResult)
                {
                    return false;
                }
                return true;
            }

 public void DoPredicates(IGeometry a, IGeometry b)
 {
     Assert.IsTrue(a.Contains(b) == a.Relate(b).IsContains());
     Assert.IsTrue(a.Crosses(b) == a.Relate(b).IsCrosses(a.Dimension, b.Dimension));
     Assert.IsTrue(a.Disjoint(b) == a.Relate(b).IsDisjoint());
     Assert.IsTrue(a.Equals(b) == a.Relate(b).IsEquals(a.Dimension, b.Dimension));
     Assert.IsTrue(a.Intersects(b) == a.Relate(b).IsIntersects());
     Assert.IsTrue(a.Overlaps(b) == a.Relate(b).IsOverlaps(a.Dimension, b.Dimension));
     Assert.IsTrue(a.Touches(b) == a.Relate(b).IsTouches(a.Dimension, b.Dimension));
     Assert.IsTrue(a.Within(b) == a.Relate(b).IsWithin());
 }

        private void RunRectanglePred(IGeometry rect, IGeometry testGeom)
        {
            bool intersectsValue = rect.Intersects(testGeom);
            bool relateIntersectsValue = rect.Relate(testGeom).IsIntersects();
            bool intersectsOK = intersectsValue == relateIntersectsValue;

            bool containsValue = rect.Contains(testGeom);
            bool relateContainsValue = rect.Relate(testGeom).IsContains();
            bool containsOK = containsValue == relateContainsValue;

            //System.out.println(testGeom);
            if (!intersectsOK || !containsOK)
            {
                Console.WriteLine(testGeom);
            }
            Assert.IsTrue(intersectsOK);
            Assert.IsTrue(containsOK);
        }

        internal static IGeometry SplitPolygon(IGeometry polygon, IGeometry line)
        {
            var nodedLinework = polygon.Boundary.Union(line);
            var polygons = Polygonize(nodedLinework);

            // only keep polygons which are inside the input
            var output = new List<IGeometry>();
            for (var i = 0; i < polygons.NumGeometries; i++)
            {
                var candpoly = (IPolygon) polygons.GetGeometryN(i);
                if (polygon.Contains(candpoly.InteriorPoint))
                    output.Add(candpoly);
            }
            /*
            return polygon.Factory.CreateGeometryCollection(
                GeometryFactory.ToGeometryArray(output));
             */
            return polygon.Factory.BuildGeometry(output);
        }

 private static void CheckInteriorPoint(IGeometry g)
 {
     var ip = g.InteriorPoint;
     Assert.IsTrue(g.Contains(ip));
 }

 /// <summary>
 /// Returns <c>true</c> if the DE-9IM intersection matrix for the two
 /// <c>Geometry</c>s is T*F**F***.
 /// </summary>
 /// <param name="g">The <c>Geometry</c> with which to compare this <c>Geometry</c>.</param>
 /// <returns><c>true</c> if this <c>Geometry</c> is within <c>other</c>.</returns>
 public virtual bool Within(IGeometry g)
 {
     return g.Contains(this);
 }

 /// <summary>
 /// Returns <c>true</c> if the DE-9IM intersection matrix for the two
 /// <c>Geometry</c>s is T*F**F***.
 /// </summary>
 /// <param name="g">The <c>Geometry</c> with which to compare this <c>Geometry</c>.</param>
 /// <returns><c>true</c> if this <c>Geometry</c> is within <c>other</c>.</returns>
 public bool Within(IGeometry g)
 {
     return g.Contains(this); ;
 }

        public static double GetSampledIntersectionArea(IGeometry geometry, IGeometry other)
        {
            const int steps = 10;
            var area = 0.0;
            var envelopeInternal = geometry.EnvelopeInternal;
            var width = envelopeInternal.Width;
            var height = envelopeInternal.Height;
            var widthStep = width/steps;
            var heightStep = height/steps;
            var minX = envelopeInternal.MinX + widthStep/2.0;
            var minY = envelopeInternal.MinY + heightStep/2.0;
            var boxArea = width*height;
            var cellArea = boxArea/(steps*steps);

            for (var i = 0; i < steps; i++)
            {
                var x = minX + i*widthStep;
                for(var j = 0; j < steps; j++)
                {
                    var y = minY + j*heightStep;
                    if (geometry.Contains(new Point(x, y)) && other.Contains(new Point(x,y)))
                    {
                        area += cellArea;
                    }
                }
            }
            return area;
        }

internal static IGeometry ClipPolygon(IGeometry polygon, IPolygonal clipPolygonal)
{
    var clipPolygon = (IGeometry) clipPolygonal;
    var nodedLinework = polygon.Boundary.Union(clipPolygon.Boundary);
    var polygons = Polygonize(nodedLinework);
            
    /*
    // Build a prepared clipPolygon
    var prepClipPolygon = NetTopologySuite.Geometries.Prepared.PreparedGeometryFactory.Prepare(clipPolygon);
        */
            
    // only keep polygons which are inside the input
    var output = new List<IGeometry>();
    for (var i = 0; i < polygons.NumGeometries; i++)
    {
        var candpoly = (IPolygon) polygons.GetGeometryN(i);
        var interiorPoint = candpoly.InteriorPoint;
        if (polygon.Contains(interiorPoint) &&
            /*prepClipPolygon.Contains(candpoly)*/
            clipPolygon.Contains(interiorPoint))
            output.Add(candpoly);
    }
    /*
    return polygon.Factory.CreateGeometryCollection(
        GeometryFactory.ToGeometryArray(output));
        */
    return polygon.Factory.BuildGeometry(output);
}

        // get features within geometry
        public List<Feature> getWithin(IGeometry rect)
        {
            // if node is completely inside geometry, return all features
            if (rect.Contains(gboundary))
                return getAll();
            // if node is completely outside geometry, return no features
            if (!rect.Intersects(gboundary))
                return new List<Feature>();

            // create list for returning features
            List<Feature> retfeatures = new List<Feature>();

            // recursively add features from children
            if (hasChildren)
                foreach (QuadTree qt in children)
                    retfeatures.AddRange(qt.getWithin(rect));

            // check each feature in current node
            foreach (Feature f in features)
                if (rect.Intersects(f.Geometry))
                    retfeatures.Add(f);
            return retfeatures;
        }