ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / PolygonBuilderEx Class / CreatePolygon Method / CreatePolygon(Envelope,SpatialReference) Method
The envelope to create the polygon. Note that if the envelope has Z-values, they will be interpolated for the upper right and lower left vertices.
(Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from envelope.
Example

In This Topic
    CreatePolygon(Envelope,SpatialReference) Method
    In This Topic
    Convenience method to create a new instance of the Polygon class.
    Syntax
    public static Polygon CreatePolygon( 
       Envelope envelope,
       SpatialReference spatialReference
    )
    Public Overloads Shared Function CreatePolygon( _
       ByVal envelope As Envelope, _
       Optional ByVal spatialReference As SpatialReference _
    ) As Polygon

    Parameters

    envelope
    The envelope to create the polygon. Note that if the envelope has Z-values, they will be interpolated for the upper right and lower left vertices.
    spatialReference
    (Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from envelope.

    Return Value

    Exceptions
    ExceptionDescription
    envelope is null.
    Remarks
    HasZ, HasM and HasID attributes are inherited from the input envelope.
    Example
    Construct a Polygon - from an Envelope
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint minPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint maxPt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
    
      // Create an envelope
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(minPt, maxPt);
    
      Polygon polygonFromEnv = PolygonBuilderEx.CreatePolygon(env);
    
      PolygonBuilderEx polygonBuilderEx = new PolygonBuilderEx(env);
      polygonBuilderEx.SpatialReference = SpatialReferences.WGS84;
      polygonFromEnv = polygonBuilderEx.ToGeometry() as Polygon;
    }
    Determine if two geometries cross
    {
        //
        // pt on pt
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
        MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
    
        bool crosses = GeometryEngine.Instance.Crosses(pt, pt2);         // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt, pt);               // crosses = false
    
        //
        // pt and line
        //
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
        Polyline line1 = PolylineBuilderEx.CreatePolyline(list);
        crosses = GeometryEngine.Instance.Crosses(line1, pt2);           // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt2, line1);           // crosses = false
                                                                         // end pt of line
        crosses = GeometryEngine.Instance.Crosses(line1, pt);            // crosses = false
    
        //
        // pt and polygon
        //
        List<MapPoint> polyPts =
        [
          MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
        Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
        crosses = GeometryEngine.Instance.Crosses(poly1, pt);              // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt, poly1);              // crosses = false
    
        //
        // line and line
        //
        List<MapPoint> list2 =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
        Polyline line2 = PolylineBuilderEx.CreatePolyline(list2);
        crosses = GeometryEngine.Instance.Crosses(line1, line2);           // crosses = true
    
        //
        // line and polygon
        //
        crosses = GeometryEngine.Instance.Crosses(poly1, line1);           // crosses = true
    
        //
        // polygon and polygon
        //
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
        crosses = GeometryEngine.Instance.Crosses(poly1, poly2);           // crosses = false
      }
    Difference between two Polygons
    {
        List<MapPoint> polyPts =
        [
          MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
        Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
    
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
    
        Geometry result = GeometryEngine.Instance.Difference(poly1, poly2);
        Polygon polyResult = result as Polygon;
        // polyResult.Area = 10.0
    
        result = GeometryEngine.Instance.Difference(poly2, poly1);
        polyResult = result as Polygon;
        // polyResult.Area = 7.0
      }
    Determine if two Geometries are disjoint
    {
        //
        // pt on pt
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
        MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.5);
    
        bool disjoint = GeometryEngine.Instance.Disjoint(pt, pt2);       // result is true
    
        MultipointBuilderEx mpb = new();
        mpb.AddPoint(pt);
        mpb.AddPoint(pt2);
        Multipoint multiPoint = mpb.ToGeometry();
    
        disjoint = GeometryEngine.Instance.Disjoint(multiPoint, pt);     // result is false
    
        //
        // pt and line
        //
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
        Polyline line1 = PolylineBuilderEx.CreatePolyline(list);
        disjoint = GeometryEngine.Instance.Disjoint(line1, pt2);       // result is true
    
        disjoint = GeometryEngine.Instance.Disjoint(pt2, line1);       // result is true
    
        // end pt of line
        disjoint = GeometryEngine.Instance.Disjoint(line1, pt);        // result is false
    
        //
        // pt and polygon
        //
        List<MapPoint> polyPts =
        [
          MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
        Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
        disjoint = GeometryEngine.Instance.Disjoint(poly1, pt);          // result is true
        disjoint = GeometryEngine.Instance.Disjoint(pt, poly1);          // result is true
    
        //
        // line and line
        //
    
        List<MapPoint> list2 =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
        Polyline line2 = PolylineBuilderEx.CreatePolyline(list2);
        disjoint = GeometryEngine.Instance.Disjoint(line1, line2);         // result is false
    
        //
        // line and polygon
        //
        disjoint = GeometryEngine.Instance.Disjoint(poly1, line1);         // result is false
        disjoint = GeometryEngine.Instance.Disjoint(line1, poly1);         // result is false
    
        //
        // polygon and polygon
        //
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
    
        disjoint = GeometryEngine.Instance.Disjoint(poly1, poly2);         // result is false
    
    
        // disjoint3D
    
        SpatialReference sr = SpatialReferences.WGS84;
    
        MapPoint pt3D_1 = MapPointBuilderEx.CreateMapPoint(1, 1, 1, sr);
        MapPoint pt3D_2 = MapPointBuilderEx.CreateMapPoint(2, 2, 2, sr);
        MapPoint pt3D_3 = MapPointBuilderEx.CreateMapPoint(1, 1, 2, sr);
    
        MultipointBuilderEx mpbEx = new();
        mpbEx.AddPoint(pt3D_1);
        mpbEx.AddPoint(pt3D_2);
        mpbEx.HasZ = true;
    
        multiPoint = mpbEx.ToGeometry();
        disjoint = GeometryEngine.Instance.Disjoint3D(multiPoint, pt3D_2);     // disjoint = false
        disjoint = GeometryEngine.Instance.Disjoint3D(multiPoint, pt3D_3);     // disjoint = true
      }
    Determine distance between two Geometries
    {
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(4.0, 2.0);
    
      //
      // pt and pt
      //
      double d = GeometryEngine.Instance.Distance(pt1, pt2);         // d = Math.Sqrt(2)
    
      //
      // pt and multipoint
      //
      List<MapPoint> multiPts = [pt2, pt3];
      Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(multiPts);
      d = GeometryEngine.Instance.Distance(pt1, multiPoint);         // d = Math.Sqrt(2)
    
      //
      // pt and envelope
      //
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(pt1, pt2);
      d = GeometryEngine.Instance.Distance(pt1, env);                // d = 0
    
      //
      // pt and polyline
      //
      List<MapPoint> polylinePts = [MapPointBuilderEx.CreateMapPoint(2.0, 1.0), pt2];
      polyline = PolylineBuilderEx.CreatePolyline(polylinePts);
    
      d = GeometryEngine.Instance.Distance(pt1, polyline);             // d = 1.0
    
      //
      // pt and polygon
      //
      Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(3.0, 3.0), MapPointBuilderEx.CreateMapPoint(5.0, 5.0));
      Polygon poly = PolygonBuilderEx.CreatePolygon(env2);
      d = GeometryEngine.Instance.Distance(pt1, poly);                 // d = Math.Sqrt(8)
    
      //
      // envelope and polyline
      //
      d = GeometryEngine.Instance.Distance(env, polyline);             // d = 0
    
      //
      // polyline and polyline
      //
      List<MapPoint> polylineList = [MapPointBuilderEx.CreateMapPoint(4, 3), MapPointBuilderEx.CreateMapPoint(4, 4)];
      Polyline polyline2 = PolylineBuilderEx.CreatePolyline(polylineList);
    
      d = GeometryEngine.Instance.Distance(polyline, polyline2);           // d = Math.Sqrt(5)
    
    
      //
      // polygon and polygon
      //
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
      d = GeometryEngine.Instance.Distance(poly, poly2);                 // d = Math.Sqrt(2)
    }
    Intersection between two Polygons
    {
      // determine intersection between two polygons
    
      Envelope env1 = EnvelopeBuilderEx.CreateEnvelope(new Coordinate2D(3.0, 2.0), new Coordinate2D(6.0, 6.0));
      Polygon poly1 = PolygonBuilderEx.CreatePolygon(env1);
    
      Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(new Coordinate2D(1.0, 1.0), new Coordinate2D(4.0, 4.0));
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env2);
    
      Polygon polyResult = GeometryEngine.Instance.Intersection(poly1, poly2) as Polygon;
    }
    Polygon touches another Polygon
    {
      // two disjoint polygons
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(4.0, 4.0), MapPointBuilderEx.CreateMapPoint(8, 8));
      Polygon poly1 = PolygonBuilderEx.CreatePolygon(env);
    
      Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(5, 5));
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env2);
    
      bool touches = GeometryEngine.Instance.Touches(poly1, poly2);    // touches = false
    
      // another polygon that touches the first
      Envelope env3 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
      Polygon poly3 = PolygonBuilderEx.CreatePolygon(env3);
    
      touches = GeometryEngine.Instance.Touches(poly1, poly3);         // touches = true
    }
    Union two Polygons
    {
      // union two polygons
    
      List<MapPoint> polyPts =
      [
        MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
      Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
      bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(poly1);
    
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(4.0, 4.0), MapPointBuilderEx.CreateMapPoint(8, 8));
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
      isSimple = GeometryEngine.Instance.IsSimpleAsFeature(poly2);
    
      Geometry g = GeometryEngine.Instance.Union(poly1, poly2);
      Polygon polyResult = g as Polygon;
    }
    Get the individual parts of a multipart feature
    IEnumerable<Geometry> MultipartToSinglePart(Geometry inputGeometry)
    {
      // list holding the part(s) of the input geometry
      List<Geometry> singleParts = new List<Geometry>();
    
      // check if the input is a null pointer or if the geometry is empty
      if (inputGeometry == null || inputGeometry.IsEmpty)
      {
        return singleParts;
      }
    
      // based on the type of geometry, take the parts/points and add them individually into a list
      switch (inputGeometry.GeometryType)
      {
        case GeometryType.Envelope:
          singleParts.Add(inputGeometry.Clone() as Envelope);
          break;
        case GeometryType.Multipatch:
          singleParts.Add(inputGeometry.Clone() as Multipatch);
          break;
        case GeometryType.Multipoint:
          var multiPoint = inputGeometry as Multipoint;
    
          foreach (var point in multiPoint.Points)
          {
            // add each point of collection as a standalone point into the list
            singleParts.Add(point);
          }
          break;
        case GeometryType.Point:
          singleParts.Add(inputGeometry.Clone() as MapPoint);
          break;
        case GeometryType.Polygon:
          var polygonNew = inputGeometry as Polygon;
    
          foreach (var polygonPart in polygonNew.Parts)
          {
            // use the PolygonBuilderEx turning the segments into a standalone
            // polygon instance
            singleParts.Add(PolygonBuilderEx.CreatePolygon(polygonPart));
          }
          break;
        case GeometryType.Polyline:
          var polylineNew = inputGeometry as Polyline;
    
          foreach (var polylinePart in polyline.Parts)
          {
            // use the PolylineBuilderEx turning the segments into a standalone
            // polyline instance
            singleParts.Add(PolylineBuilderEx.CreatePolyline(polylinePart));
          }
          break;
        case GeometryType.Unknown:
          break;
        default:
          break;
      }
      return singleParts;
    }
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also