ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / MapPointBuilderEx Class / CreateMapPoint Method / CreateMapPoint(Double,Double,SpatialReference) Method
X coordinate.
Y coordinate.
(Optional) The SpatialReference. The default value is null.
Example

In This Topic
    CreateMapPoint(Double,Double,SpatialReference) Method
    In This Topic
    Convenience method to create a MapPoint instance with the given X and Y coordinates.
    Syntax
    public static MapPoint CreateMapPoint( 
       double x,
       double y,
       SpatialReference spatialReference
    )
    Public Overloads Shared Function CreateMapPoint( _
       ByVal x As Double, _
       ByVal y As Double, _
       Optional ByVal spatialReference As SpatialReference _
    ) As MapPoint

    Parameters

    x
    X coordinate.
    y
    Y coordinate.
    spatialReference
    (Optional) The SpatialReference. The default value is null.

    Return Value

    Example
    Determine grid convergence for a SpatialReference at a given point
    {
      Coordinate2D coordinate = new Coordinate2D(10, 30);
      double angle = SpatialReferences.WGS84.GetConvergenceAngle(coordinate);
      // angle = 0
    
      SpatialReference srUTM30N = SpatialReferenceBuilder.CreateSpatialReference(32630);
      coordinate.X = 500000;
      coordinate.Y = 550000;
      angle = srUTM30N.GetConvergenceAngle(coordinate);
      // angle = 0
    
      MapPoint pointWGS84 = MapPointBuilderEx.CreateMapPoint(10, 50, SpatialReferences.WGS84);
      MapPoint pointUTM30N = GeometryEngine.Instance.Project(
        pointWGS84, srUTM30N) as MapPoint;
    
      coordinate = (Coordinate2D)pointUTM30N;
      // get convergence angle and convert to degrees
      angle = srUTM30N.GetConvergenceAngle(coordinate) * 180 / Math.PI;
      // angle = 10.03
    }
    Builder Properties
    {
      // list of points
      List<MapPoint> pointsForBuilder = new List<MapPoint>
    {
      MapPointBuilderEx.CreateMapPoint(0, 0, 2, 3, 1),
      MapPointBuilderEx.CreateMapPoint(1, 1, 5, 6),
      MapPointBuilderEx.CreateMapPoint(2, 1, 6),
      MapPointBuilderEx.CreateMapPoint(0, 0)
    };
    
      // will have attributes because it is created with convenience method
      Polyline polylineWithAttrs = PolylineBuilderEx.CreatePolyline(pointsForBuilder);
      bool hasZ = polylineWithAttrs.HasZ;          // hasZ = true
      bool hasM = polylineWithAttrs.HasM;          // hasM = true
      bool hasID = polylineWithAttrs.HasID;        // hasID = true
    
      // will not have attributes because it is specified as a parameter
      Polyline polylineWithoutAttrs =
        PolylineBuilderEx.CreatePolyline(pointsForBuilder, AttributeFlags.None);
      hasZ = polylineWithoutAttrs.HasZ;          // hasZ = false
      hasM = polylineWithoutAttrs.HasM;          // hasM = false
      hasID = polylineWithoutAttrs.HasID;        // hasID = false
    
      // will have attributes because it is created with convenience method
      Polygon polygonWithAttrs = PolygonBuilderEx.CreatePolygon(pointsForBuilder);
      hasZ = polygonWithAttrs.HasZ;               // hasZ = true
      hasM = polygonWithAttrs.HasM;               // hasM = true
      hasID = polygonWithAttrs.HasID;             // hasID = true
    
      // will not have attributes because it is specified as a parameter
      Polygon polygonWithoutAttrs =
            PolygonBuilderEx.CreatePolygon(pointsForBuilder, AttributeFlags.None);
      hasZ = polygonWithoutAttrs.HasZ;               // hasZ = false
      hasM = polygonWithoutAttrs.HasM;               // hasM = false
      hasID = polygonWithoutAttrs.HasID;             // hasID = false
    
      // will not have attributes because it is specified as a parameter
      PolylineBuilderEx polylineB =
                 new PolylineBuilderEx(pointsForBuilder, AttributeFlags.None);
      hasZ = polylineB.HasZ;                      // hasZ = false
      hasM = polylineB.HasM;                      // hasM = false
      hasID = polylineB.HasID;                    // hasID = false
    
      // will have attributes because it is passed an attributed polyline
      polylineB = new PolylineBuilderEx(polylineWithAttrs);
      hasZ = polylineB.HasZ;                      // hasZ = true
      hasM = polylineB.HasM;                      // hasM = true
      hasID = polylineB.HasID;                    // hasID = true
    
      // will not have attributes because it is passed a non-attributed polyline
      polylineB = new PolylineBuilderEx(polylineWithoutAttrs);
      hasZ = polylineB.HasZ;                      // hasZ = false
      hasM = polylineB.HasM;                      // hasM = false
      hasID = polylineB.HasID;                    // hasID = false
    
      // will not have attributes because it is specified as a parameter
      PolygonBuilderEx polygonB = new PolygonBuilderEx(pointsForBuilder, AttributeFlags.None);
      hasZ = polygonB.HasZ;                       // hasZ = false
      hasM = polygonB.HasM;                       // hasM = false
      hasID = polygonB.HasID;                     // hasID = false
    
      // will have attributes because it is passed an attributed polygon
      polygonB = new PolygonBuilderEx(polygonWithAttrs);
      hasZ = polygonB.HasZ;                       // hasZ = true
      hasM = polygonB.HasM;                       // hasM = true
      hasID = polygonB.HasID;                     // hasID = true
    
      // will not have attributes because it is passed a non-attributed polygon
      polygonB = new PolygonBuilderEx(polygonWithoutAttrs);
      hasZ = polygonB.HasZ;                       // hasZ = true
      hasM = polygonB.HasM;                       // hasM = true
      hasID = polygonB.HasID;                     // hasID = true
    }
    Construct a MapPoint
    {
      // Use a builder convenience method or use a builder constructor.
    
      // Create a 2D point without a spatial reference
      MapPoint point2D = MapPointBuilderEx.CreateMapPoint(1, 2);
      SpatialReference sr = point2D.SpatialReference; // sr = null
      bool hasZ = point2D.HasZ;   // hasZ = false
      bool hasM = point2D.HasM;   // hasM = false
      bool hasID = point2D.HasID; // hasID = false
      double x = point2D.X;   // x = 1
      double y = point2D.Y;   // y = 2
      double z = point2D.Z;   // z = 0 default value
      double m = point2D.M;   // m is NaN default value
      double id = point2D.ID; // id = 0 default value
    
      // Or use a builderEx which doesn't need to run on the MCT.
      MapPointBuilderEx builderEx = new MapPointBuilderEx(1, 2);
    
      // do something with the builder
      builderEx.Y = 3;
      point2D = builderEx.ToGeometry();
      sr = point2D.SpatialReference; // sr = null
      hasZ = point2D.HasZ;   // hasZ = false
      hasM = point2D.HasM;   // hasM = false
      hasID = point2D.HasID; // hasID = false
      x = point2D.X;   // x = 1
      y = point2D.Y;   // y = 3
      z = point2D.Z;   // z = 0 default value
      m = point2D.M;   // m is NaN default value
      id = point2D.ID; // id = 0 default value
    
      // Create a 2D point with a spatial reference
      SpatialReference spatialReference = SpatialReferenceBuilder.CreateSpatialReference(4269);
      point2D = MapPointBuilderEx.CreateMapPoint(1, 2, spatialReference);
      sr = point2D.SpatialReference; // sr != null
      int wkid = sr.Wkid; // wkid = 4269
    
      // Or use a builder
      builderEx = new MapPointBuilderEx(1, 2, spatialReference);
    
      // Do something with the builder
      builderEx.SetValues(3, 5);
      point2D = builderEx.ToGeometry();
      sr = point2D.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4269
      x = point2D.X; // x = 3
      y = point2D.Y; // y = 5
    
      // Change the spatial reference of the builder
      builderEx.SpatialReference = SpatialReferences.WGS84;
      point2D = builderEx.ToGeometry();
      sr = point2D.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4326
      x = point2D.X; // x = 3
      y = point2D.Y; // y = 5
    
      // Create a 3D point with M
      MapPoint pointZM = MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4);
      sr = pointZM.SpatialReference; // sr = null
      hasZ = pointZM.HasZ;   // hasZ = true
      hasM = pointZM.HasM;   // hasM = true
      hasID = pointZM.HasID; // hasID = false
      x = pointZM.X;   // x = 1
      y = pointZM.Y;   // y = 2
      z = pointZM.Z;   // z = 3
      m = pointZM.M;   // m = 4
      id = pointZM.ID; // id = 0 default value
    
      // Create a 3D point with M and a spatial reference
      pointZM = MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4, spatialReference);
      sr = pointZM.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4269
    
      // Create a point from another point in three ways
      MapPoint clone = pointZM.Clone() as MapPoint; // Has the same values including the spatial reference as pointZM
      MapPoint anotherZM = MapPointBuilderEx.CreateMapPoint(pointZM);  // Has the same values including the spatial reference as pointZM
    
      builderEx = new MapPointBuilderEx(pointZM); // Has the same values including the spatial reference as pointZM
      // Do something with the builder
      builderEx.HasM = false;
      builderEx.ID = 7; // Setting the id also sets HasID = true
      MapPoint pointZId = builderEx.ToGeometry();
      sr = pointZId.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4269
      hasZ = pointZId.HasZ;   // hasZ = true
      hasM = pointZId.HasM;   // hasM = false
      hasID = pointZId.HasID; // hasID = true
      x = pointZId.X;   // x = 1
      y = pointZId.Y;   // y = 2
      z = pointZId.Z;   // z = 3
      m = pointZId.M;   // m is NaN, default value
      id = pointZId.ID; // id = 7
    
      // Create a point with Z, M, and ID-values
      MapPoint pointZMId = MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4, 5, spatialReference);
      sr = pointZMId.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4269
      hasZ = pointZMId.HasZ;   // hasZ = true
      hasM = pointZMId.HasM;   // hasM = true
      hasID = pointZMId.HasID; // hasID = true
      x = pointZMId.X;   // x = 1
      y = pointZMId.Y;   // y = 2
      z = pointZMId.Z;   // z = 3
      m = pointZMId.M;   // m = 4
      id = pointZMId.ID; // id = 5
    
      // Pick and choose which attributes to include
      MapPoint point = MapPointBuilderEx.CreateMapPoint(1, 2, false, 3, true, 4, true, 5);
      sr = point.SpatialReference; // sr = null
      hasZ = point.HasZ;   // hasZ = false
      hasM = point.HasM;   // hasM = true
      hasID = point.HasID; // hasID = true
      x = point.X;   // x = 1
      y = point.Y;   // y = 2
      z = point.Z;   // z = 0, default value
      m = point.M;   // m = 4
      id = point.ID; // id = 5
    
      // Or use a builder
      builderEx = new(1, 2, true, 3, false, 4, true, 5);
      // Do something with the builder
      builderEx.ID = 7;
      builderEx.SpatialReference = SpatialReferences.WGS84;
      point = builderEx.ToGeometry();
      sr = point.SpatialReference; // sr != null
      wkid = sr.Wkid; // wkid = 4326
      hasZ = point.HasZ;   // hasZ = true
      hasM = point.HasM;   // hasM = false
      hasID = point.HasID; // hasID = true
      x = point.X;   // x = 1
      y = point.Y;   // y = 2
      z = point.Z;   // z = 0, default value
      m = point.M;   // m is NaN, default value
      id = point.ID; // id = 7
    }
    Zoom to a specified point
    {
      double x = -122.45;
      double y = 37.75;
      double buffer_size = 0.1;
      //Create a point
      var pt = MapPointBuilderEx.CreateMapPoint(x, y,
                     SpatialReferenceBuilder.CreateSpatialReference(4326));
      //Buffer it - for purpose of zoom
      var poly = GeometryEngine.Instance.Buffer(pt, buffer_size);
    
      //do we need to project the buffer polygon?
      if (!MapView.Active.Map.SpatialReference.IsEqual(poly.SpatialReference))
      {
        //project the polygon
        poly = GeometryEngine.Instance.Project(poly, MapView.Active.Map.SpatialReference);
      }
    
      // Must run on MCT.
      var zoomMapView = MapView.Active;
      if (zoomMapView == null)
        return;
    
      await QueuedTask.Run(() =>
      {
        //Zoom - add in a delay for animation effect
        zoomMapView.ZoomTo(poly, new TimeSpan(0, 0, 0, 3));
      });
    }
    Construct a Polyline - from an enumeration of MapPoints
    {
      // Use a builderEx convenience method or a builderEx constructor.
      // neither need to run on the MCT
    
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
    
      List<MapPoint> list = new List<MapPoint>() { startPt, endPt };
    
      Polyline polylineFromPointList = PolylineBuilderEx.CreatePolyline(list, SpatialReferences.WGS84);
    
      // use AttributeFlags.None since we only have 2D points in the list
      PolylineBuilderEx pb = new PolylineBuilderEx(list, AttributeFlags.None);
      pb.SpatialReference = SpatialReferences.WGS84;
      Polyline polyline2 = pb.ToGeometry();
    
      // Use AttributeFlags.NoAttributes because we only have 2d points in the list
      Polyline polyline4 = PolylineBuilderEx.CreatePolyline(list, AttributeFlags.None);
    }
    Build a multi-part Polyline
    {
      List<MapPoint> firstPoints = new List<MapPoint>();
      firstPoints.Add(MapPointBuilderEx.CreateMapPoint(1.0, 1.0));
      firstPoints.Add(MapPointBuilderEx.CreateMapPoint(1.0, 2.0));
      firstPoints.Add(MapPointBuilderEx.CreateMapPoint(2.0, 2.0));
      firstPoints.Add(MapPointBuilderEx.CreateMapPoint(2.0, 1.0));
    
      List<MapPoint> nextPoints = new List<MapPoint>();
      nextPoints.Add(MapPointBuilderEx.CreateMapPoint(11.0, 1.0));
      nextPoints.Add(MapPointBuilderEx.CreateMapPoint(11.0, 2.0));
      nextPoints.Add(MapPointBuilderEx.CreateMapPoint(12.0, 2.0));
      nextPoints.Add(MapPointBuilderEx.CreateMapPoint(12.0, 1.0));
    
      // use AttributeFlags.None since we have 2D points in the list
      PolylineBuilderEx pBuilder = new PolylineBuilderEx(firstPoints, AttributeFlags.None);
      pBuilder.AddPart(nextPoints);
    
      Polyline polylineFromBuilder = pBuilder.ToGeometry();
      // polyline has 2 parts
    
      pBuilder.RemovePart(0);
      polylineFromBuilder = pBuilder.ToGeometry();
      // polyline has 1 part
    }
    Construct a Clothoid by Angle
    {
      MapPoint startPoint = MapPointBuilderEx.CreateMapPoint(0, 0);
      double tangentDirection = Math.PI / 6;
      ArcOrientation orientation = ArcOrientation.ArcCounterClockwise;
      double startRadius = double.PositiveInfinity;
      double endRadius = 0.2;
      ClothoidCreateMethod createMethod = ClothoidCreateMethod.ByAngle;
      double angle = Math.PI / 2;
      CurveDensifyMethod densifyMethod = CurveDensifyMethod.ByLength;
      double densifyParameter = 0.1;
    
      Polyline polylineCl = PolylineBuilderEx.CreatePolyline(startPoint, tangentDirection, startRadius, endRadius, orientation, createMethod, angle, densifyMethod, densifyParameter, SpatialReferences.WGS84);
    
      int numPoints = polylineCl.PointCount;
      MapPoint queryPoint = polylineCl.Points[numPoints - 2];
    
      MapPoint pointOnPath;
      double radiusCalculated, tangentDirectionCalculated, lengthCalculated, angleCalculated;
    
      PolylineBuilderEx.QueryClothoidParameters(queryPoint, startPoint, tangentDirection, startRadius, endRadius, orientation, createMethod, angle, out pointOnPath, out radiusCalculated, out tangentDirectionCalculated, out lengthCalculated, out angleCalculated, SpatialReferences.WGS84);
    }
    Construct a Clothoid by Length
    {
      MapPoint startPoint = MapPointBuilderEx.CreateMapPoint(0, 0);
      MapPoint queryPoint = MapPointBuilderEx.CreateMapPoint(3.8, 1);
      double tangentDirection = 0;
      ArcOrientation orientation = ArcOrientation.ArcCounterClockwise;
      double startRadius = double.PositiveInfinity;
      double endRadius = 1;
      ClothoidCreateMethod createMethod = ClothoidCreateMethod.ByLength;
      double curveLength = 10;
      MapPoint pointOnPath;
      double radiusCalculated, tangentDirectionCalculated, lengthCalculated, angleCalculated;
    
    
      PolylineBuilderEx.QueryClothoidParameters(queryPoint, startPoint, tangentDirection, startRadius, endRadius, orientation, createMethod, curveLength, out pointOnPath, out radiusCalculated, out tangentDirectionCalculated, out lengthCalculated, out angleCalculated, SpatialReferences.WGS84);
    
      pointOnPath = MapPointBuilderEx.CreateMapPoint(3.7652656620171379, 1.0332006103128575);
      radiusCalculated = 2.4876382887687227;
      tangentDirectionCalculated = 0.80797056423543978;
      lengthCalculated = 4.0198770235802987;
      angleCalculated = 0.80797056423544011;
    
      queryPoint = MapPointBuilderEx.CreateMapPoint(1.85, 2.6);
    
      PolylineBuilderEx.QueryClothoidParameters(queryPoint, startPoint, tangentDirection, startRadius, endRadius, orientation, createMethod, curveLength, out pointOnPath, out radiusCalculated, out tangentDirectionCalculated, out lengthCalculated, out angleCalculated, SpatialReferences.WGS84);
    
      pointOnPath = MapPointBuilderEx.CreateMapPoint(1.8409964973501549, 2.6115979967308132);
      radiusCalculated = 1;
      tangentDirectionCalculated = -1.2831853071795867;
      lengthCalculated = 10;
      angleCalculated = 5;
    
      tangentDirection = Math.PI / 4;
      orientation = ArcOrientation.ArcClockwise;
      startRadius = double.PositiveInfinity;
      endRadius = 0.8;
      createMethod = ClothoidCreateMethod.ByLength;
      curveLength = 10;
    
      Polyline polylineByLength = PolylineBuilderEx.CreatePolyline(startPoint, tangentDirection, startRadius, endRadius, orientation, createMethod, curveLength, CurveDensifyMethod.ByLength, 0.5, SpatialReferences.WGS84);
    }
    Split Polyline at distance
    {
      // create list of points
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
    
      List<MapPoint> list = new List<MapPoint>() { startPt, endPt };
    
      // BuilderEx constructors don't need to run on the MCT.
    
      // use the PolylineBuilder as we wish to manipulate the geometry
      // use AttributeFlags.None as we have 2D points
      PolylineBuilderEx polylineBuilder = new PolylineBuilderEx(list, AttributeFlags.None);
      // split at a distance 0.75
      polylineBuilder.SplitAtDistance(0.75, false);
      // get the polyline
      Polyline polylineFromBuilder = polylineBuilder.ToGeometry();
      // polyline should have 3 points  (1,1), (1.75, 1), (2,1)
    
      // add another path
      MapPoint p1 = MapPointBuilderEx.CreateMapPoint(4.0, 1.0);
      MapPoint p2 = MapPointBuilderEx.CreateMapPoint(6.0, 1.0);
      MapPoint p3 = MapPointBuilderEx.CreateMapPoint(7.0, 1.0);
      List<MapPoint> pts = new List<MapPoint>() { p1, p2, p3 };
    
      polylineBuilder.AddPart(pts);
      polylineFromBuilder = polylineBuilder.ToGeometry();
    
      // polyline has 2 parts. Each part has 3 points
    
      // split the 2nd path half way - don't create a new path
      polylineBuilder.SplitPartAtDistance(1, 0.5, true, false);
    
      polylineFromBuilder = polylineBuilder.ToGeometry();
    
      // polyline still has 2 parts; but now has 7 points
    }
    Construct a Polygon - from an enumeration of MapPoints
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(1.0, 2.0);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
      MapPoint pt4 = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
    
      List<MapPoint> list = new List<MapPoint>() { pt1, pt2, pt3, pt4 };
    
      Polygon polygonFromPoints = PolygonBuilderEx.CreatePolygon(list, SpatialReferences.WGS84);
      // polygon.HasZ will be false - it is determined by the HasZ flag of the points in the list
    
      // or specifically use AttributeFlags.NoAttributes
      polygonFromPoints = PolygonBuilderEx.CreatePolygon(list, AttributeFlags.None);
    
      // use AttributeFlags.None as we have 2D points
      PolygonBuilderEx polygonBuilder = new PolygonBuilderEx(list, AttributeFlags.None);
      polygonBuilder.SpatialReference = SpatialReferences.WGS84;
      polygonFromPoints = polygonBuilder.ToGeometry();
    }
    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;
    }
    Construct 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);
    
      Envelope envelope = EnvelopeBuilderEx.CreateEnvelope(minPt, maxPt);
    
      EnvelopeBuilderEx builderEx = new EnvelopeBuilderEx(minPt, maxPt);
      envelope = builderEx.ToGeometry() as Envelope;
    }
    Construct a Multipoint - from an enumeration of MapPoints
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      List<MapPoint> list = new List<MapPoint>();
      list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 1.0));
      list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 2.0));
      list.Add(MapPointBuilderEx.CreateMapPoint(2.0, 2.0));
      list.Add(MapPointBuilderEx.CreateMapPoint(2.0, 1.0));
    
      // use the builderEx constructors which don't need to run on the MCT.
      // use AttributeFlags.NoAttributes since we have 2d points in the list
      MultipointBuilderEx builderEx = new MultipointBuilderEx(list, AttributeFlags.None);
      Multipoint multiPoint = builderEx.ToGeometry() as Multipoint;
      int ptCount = builderEx.PointCount;
    
      // builderEx convenience methods don't need to run on the MCT
      multiPoint = MultipointBuilderEx.CreateMultipoint(list);
      // multiPoint.HasZ, HasM, HasID will be false - the attributes are determined
      //    based on the attribute state of the points in the list
    
      // or specifically set the state
      multiPoint = MultipointBuilderEx.CreateMultipoint(list, AttributeFlags.None);
      // multiPoint.HasM = false
    
      multiPoint = MultipointBuilderEx.CreateMultipoint(list, AttributeFlags.HasM);
      // multiPoint.HasM = true
    
      ptCount = multiPoint.PointCount;
    }
    Modify the points of a Multipoint
    {
      // assume a multiPoint has been built from 4 points
      // the modified multiPoint will have the first point removed and the last point moved
    
      // use the builderEx constructors which don't need to run on the MCT.
      MultipointBuilderEx builderEx = new MultipointBuilderEx(multipoint);
      // remove the first point
      builderEx.RemovePoint(0);
      // modify the coordinates of the last point
      var ptEx = builderEx.GetPoint(builderEx.PointCount - 1);
      builderEx.RemovePoint(builderEx.PointCount - 1);
    
      var newPtEx = MapPointBuilderEx.CreateMapPoint(ptEx.X + 1.0, ptEx.Y + 2.0);
      builderEx.AddPoint(newPtEx);
      Multipoint modifiedMultiPointEx = builderEx.ToGeometry() as Multipoint;
    }
    Construct a LineSegment using two MapPoints
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
    
      // BuilderEx convenience methods don't need to run on the MCT.
      LineSegment lineFromMapPoint = LineBuilderEx.CreateLineSegment(startPt, endPt);
    
      // coordinate2D
      Coordinate2D start2d = (Coordinate2D)startPt;
      Coordinate2D end2d = (Coordinate2D)endPt;
    
      LineSegment lineFromCoordinate2D = LineBuilderEx.CreateLineSegment(start2d, end2d);
    
      // coordinate3D
      Coordinate3D start3d = (Coordinate3D)startPt;
      Coordinate3D end3d = (Coordinate3D)endPt;
    
      LineSegment lineFromCoordinate3D = LineBuilderEx.CreateLineSegment(start3d, end3d);
    
      // lineSegment
      LineSegment anotherLineFromLineSegment = LineBuilderEx.CreateLineSegment(lineFromCoordinate3D);
    
    
      // builderEx constructors don't need to run on the MCT
      LineBuilderEx lbEx = new LineBuilderEx(startPt, endPt);
      lineFromMapPoint = lbEx.ToSegment() as LineSegment;
    
      lbEx = new LineBuilderEx(start2d, end2d);
      lineFromCoordinate2D = lbEx.ToSegment() as LineSegment;
    
      lbEx = new LineBuilderEx(start3d, end3d);
      lineFromCoordinate3D = lbEx.ToSegment() as LineSegment;
    
      lbEx = new LineBuilderEx(startPt, endPt);
      lineFromMapPoint = lbEx.ToSegment() as LineSegment;
    
      lbEx = new LineBuilderEx(lineFromCoordinate3D);
      anotherLineFromLineSegment = lbEx.ToSegment() as LineSegment;
    }
    Alter LineSegment Coordinates
    {
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
      // builderEx constructors don't need to run on the MCT
      LineBuilderEx lbuilderEx = new LineBuilderEx(lineSegment);
      // find the existing coordinates
      lbuilderEx.QueryCoords(out startPt, out endPt);
    
      // or use
      //startPt = lbuilderEx.StartPoint;
      //endPt = lbuilderEx.EndPoint;
    
      // update the coordinates
      lbuilderEx.SetCoords(GeometryEngine.Instance.Move(startPt, 10, 10) as MapPoint, GeometryEngine.Instance.Move(endPt, -10, -10) as MapPoint);
    
      // or use
      //lbuilderEx.StartPoint = GeometryEngine.Instance.Move(startPt, 10, 10) as MapPoint;
      //lbuilderEx.EndPoint = GeometryEngine.Instance.Move(endPt, -10, -10) as MapPoint;
    
      LineSegment segment2 = lbuilderEx.ToSegment() as LineSegment;
    }
    Construct a Cubic Bezier - from MapPoints
    {
      // Use a builderEx convenience method or a builderEx constructor.
    
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0, SpatialReferences.WGS84);
    
      MapPoint ctrl1Pt = MapPointBuilderEx.CreateMapPoint(1.0, 2.0, SpatialReferences.WGS84);
      MapPoint ctrl2Pt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0, SpatialReferences.WGS84);
    
      // BuilderEx convenience methods don't need to run on the MCT
      CubicBezierSegment bezier = CubicBezierBuilderEx.CreateCubicBezierSegment(startPt, ctrl1Pt, ctrl2Pt, endPt);
    
      // builderEx constructors don't need to run on the MCT
      CubicBezierBuilderEx cbbEx = new CubicBezierBuilderEx(startPt, ctrl1Pt, ctrl2Pt, endPt);
      bezier = cbbEx.ToSegment() as CubicBezierSegment;
    }
    Construct a Cubic Bezier - from an enumeration of MapPoints
    {
      // Use a buildeExr convenience method or use a builderEx constructor.
    
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0, SpatialReferences.WGS84);
    
      MapPoint ctrl1Pt = MapPointBuilderEx.CreateMapPoint(1.0, 2.0, SpatialReferences.WGS84);
      MapPoint ctrl2Pt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0, SpatialReferences.WGS84);
    
      List<MapPoint> listMapPoints = new List<MapPoint>();
      listMapPoints.Add(startPt);
      listMapPoints.Add(ctrl1Pt);
      listMapPoints.Add(ctrl2Pt);
      listMapPoints.Add(endPt);
    
      // BuilderEx convenience methods don't need to run on the MCT
      CubicBezierSegment bezier = CubicBezierBuilderEx.CreateCubicBezierSegment(listMapPoints);
    
      // builderEx constructors don't need to run on the MCT
      CubicBezierBuilderEx cbbEx = new CubicBezierBuilderEx(listMapPoints);
      bezier = cbbEx.ToSegment() as CubicBezierSegment;
    }
    Construct a Circular Arc - using an interior point
    {
      // Construct a circular arc from (2, 1) to (1, 2) with interior pt (1 + sqrt(2)/2, 1 + sqrt(2)/2).
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint fromPtCircArc = MapPointBuilderEx.CreateMapPoint(2, 1);
      MapPoint toPtCircArc = MapPointBuilderEx.CreateMapPoint(1, 2);
      Coordinate2D interiorPtNew = new Coordinate2D(1 + Math.Sqrt(2) / 2, 1 + Math.Sqrt(2) / 2);
    
      // BuilderEx convenience methods don't need to run on the MCT.
      EllipticArcSegment circularArcBuilder = EllipticArcBuilderEx.CreateCircularArc(fromPtCircArc, toPtCircArc, interiorPtNew);
    
      // BuilderEx constructors don't need to run on the MCT.
      EllipticArcBuilderEx eab = new EllipticArcBuilderEx(fromPtCircArc, toPtCircArc, interiorPtNew);
      // do something with the builder
    
      EllipticArcSegment anotherCircularArc = eab.ToSegment();
    }
    Construct a Circular Arc - using a chord length and bearing
    {
      // Construct a circular arc counterclockwise from (2, 1) to (1, 2) such that the embedded
      // circle has center point at (1, 1) and radius = 1.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint fromPtArc = MapPointBuilderEx.CreateMapPoint(2, 1, SpatialReferences.WGS84);
      double chordLength = Math.Sqrt(2);
      double chordBearing = 3 * Math.PI / 4;
      double radius = 1;
      ArcOrientation orientation = ArcOrientation.ArcCounterClockwise;
      MinorOrMajor minorOrMajor = MinorOrMajor.Minor;
    
      // BuildeEx convenience methods don't need to run on the MCT.
      EllipticArcSegment circularArcBuilder = EllipticArcBuilderEx.CreateCircularArc(fromPtArc, chordLength, chordBearing, radius, orientation, minorOrMajor);
    
      // BuilderEx constructors don't need to run on the MCT either.
      EllipticArcBuilderEx ellipticArcBuilderEx = new EllipticArcBuilderEx(fromPtArc, chordLength, chordBearing, radius, orientation, minorOrMajor);
      // do something with the builder
    
      EllipticArcSegment anotherCircularArc = ellipticArcBuilderEx.ToSegment();
    }
    Construct a Circular Arc - using a center point and orientation
    {
      // Construct a circular arc from (2, 1) to (1, 2)
      // with center point at (1, 1) and orientation counterclockwise.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint toPt = MapPointBuilderEx.CreateMapPoint(1, 2);
      MapPoint fromPt = MapPointBuilderEx.CreateMapPoint(2, 1);
      Coordinate2D centerPtCoord = new Coordinate2D(1, 1);
    
      // BuilderEx convenience methods don't need to run on the MCT.
      ellipticArcSegment = EllipticArcBuilderEx.CreateCircularArc(fromPt, toPt, centerPtCoord, ArcOrientation.ArcCounterClockwise);
    
      // BuilderEx constructors need to run on the MCT.
      EllipticArcBuilderEx ellipticArcBuilder = new EllipticArcBuilderEx(fromPt, toPt, centerPtCoord, ArcOrientation.ArcCounterClockwise);
      EllipticArcSegment arcSegment = ellipticArcBuilder.ToSegment();
    }
    Construct GeometryBag
    {
      MapPoint point = MapPointBuilderEx.CreateMapPoint(1, 2, SpatialReferences.WebMercator);
    
      List<Coordinate2D> coords2DToUse = new List<Coordinate2D>()
      {
        new Coordinate2D(0, 0),
        new Coordinate2D(0, 1),
        new Coordinate2D(1, 1),
        new Coordinate2D(1, 0)
      };
    
      Multipoint multipointNew = MultipointBuilderEx.CreateMultipoint(coords2DToUse, SpatialReferences.WGS84);
      Polyline polylineNew = PolylineBuilderEx.CreatePolyline(coords2DToUse, SpatialReferences.WebMercator);
    
      GeometryBagBuilderEx builder = new GeometryBagBuilderEx(SpatialReferences.WGS84);
    
      GeometryBag emptyBag = builder.ToGeometry();
      // emptyBag.IsEmpty = true
    
      builder.AddGeometry(point);
      // builder.GeometryCount = 1
    
      GeometryBag geometryBag = builder.ToGeometry();
      // geometryBag.PartCount = 1
      // geometryBag.PointCount = 1
      // geometryBag.IsEmpty = false
    
      IReadOnlyList<ArcGIS.Core.Geometry.Geometry> geometries = geometryBag.Geometries;
      // geometries.Count = 1
      // geometries[0] is MapPoint with a sr of WGS84
    
      bool isEqual = geometryBag.IsEqual(emptyBag);   // isEqual = false
    
      builder.InsertGeometry(0, multipoint);
      geometryBag = builder.ToGeometry();
      // geometryBag.PartCount = 2
    
      geometries = geometryBag.Geometries;
      // geometries.Count = 2
      // geometries[0] is Multipoint
      // geometries[1] is MapPoint
    
      builder.AddGeometry(polyline);
      builder.RemoveGeometry(1);
      geometryBag = builder.ToGeometry();
      // geometryBag.PartCount = 2
    
      geometries = geometryBag.Geometries;
      // geometries.Count = 2
      // geometries[0] is Multipoint
      // geometries[1] is Polyline
    }
    Construct GeometryBag - from an enumeration of geometries
    {
      // Use a builder convenience method or use a builder constructor.
    
      MapPoint point = MapPointBuilderEx.CreateMapPoint(10, 20);
      List<Coordinate2D> coords = new List<Coordinate2D>() { new Coordinate2D(50, 60), new Coordinate2D(-120, -70), new Coordinate2D(40, 60) };
      Multipoint multipointNew = MultipointBuilderEx.CreateMultipoint(coords, SpatialReferences.WebMercator);
      Polyline polylineNew = PolylineBuilderEx.CreatePolyline(coords);
    
      string json = "{\"rings\":[[[0,0],[0,1],[1,1],[1,0],[0,0]],[[3,0],[3,1],[4,1],[4,0],[3,0]]]}";
      Polygon polygonNew = PolygonBuilderEx.FromJson(json);
    
      var geometries = new List<Geometry>() { point, multipoint, polyline, polygon };
    
      // Builder convenience methods don't need to run on the MCT.
      var bag = GeometryBagBuilderEx.CreateGeometryBag(geometries, SpatialReferences.WGS84);
    
      var builder = new GeometryBagBuilderEx(geometries, SpatialReferences.WGS84);
      // do something with the builder
      bag = builder.ToGeometry();
    }
    Construct GeometryBag - adding or inserting an enumeration of geometries
    {
      MapPoint point = MapPointBuilderEx.CreateMapPoint(10, 20);
      List<Coordinate2D> coords = new List<Coordinate2D>() { new Coordinate2D(50, 60), new Coordinate2D(-120, -70), new Coordinate2D(40, 60) };
      Multipoint multipointNew = MultipointBuilderEx.CreateMultipoint(coords, SpatialReferences.WebMercator);
      Polyline polylineNew = PolylineBuilderEx.CreatePolyline(coords);
    
      string json = "{\"rings\":[[[0,0],[0,1],[1,1],[1,0],[0,0]],[[3,0],[3,1],[4,1],[4,0],[3,0]]]}";
      Polygon polygonNew = PolygonBuilderEx.FromJson(json);
    
      var geometries = new List<Geometry>() { point, multipoint, polyline, polygon };
    
      var builder = new GeometryBagBuilderEx(SpatialReferences.WGS84);
      builder.AddGeometries(geometries);
    
      GeometryBag geomBag = builder.ToGeometry();
      // geomBag.PartCount == 4    (point, multipoint, polyline, polygon)
    
      geometries = new List<Geometry>() { point, polyline };
      builder.InsertGeometries(1, geometries);
      // builder.GeometryCount == 6
      geomBag = builder.ToGeometry();
      // geomBag.PartCount == 6    (point, point, polyline, multipoint, polyline, polygon)
    }
    MapPoint - GeoCoordinateString Conversion
    {
      SpatialReference sr = SpatialReferences.WGS84;
      SpatialReference sr2 = SpatialReferences.WebMercator;
    
      // create some points
      MapPoint point0 = MapPointBuilderEx.CreateMapPoint(0, 0, sr);
      MapPoint point1 = MapPointBuilderEx.CreateMapPoint(10, 20, sr);
      MapPoint point2 = GeometryEngine.Instance.Project(point1, sr2) as MapPoint;
      MapPoint pointEmpty = MapPointBuilderEx.CreateMapPoint(sr);
      MapPoint pointwithNoSR = MapPointBuilderEx.CreateMapPoint(1, 1);
      MapPoint pointZM = MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4, sr);
    
      // convert to MGRS
      ToGeoCoordinateParameter mgrsParam =
               new ToGeoCoordinateParameter(GeoCoordinateType.MGRS);
      // 31NAA6602100000
      string geoCoordString = point0.ToGeoCoordinateString(mgrsParam);
    
      // use the builder to create a new point from the string.
      // Coordinates are the same
      // outPoint.x = 0; outPoint.Y = 0
      MapPoint outPoint =
            MapPointBuilderEx.FromGeoCoordinateString(
                      geoCoordString, sr, GeoCoordinateType.MGRS);
    
      // 32QPH0460911794
      // outPoint.X = 10; outPoint.Y = 20
      geoCoordString = point1.ToGeoCoordinateString(mgrsParam);
      outPoint = MapPointBuilderEx.FromGeoCoordinateString(
                 geoCoordString, sr, GeoCoordinateType.MGRS);
    
      // z, m are not transformed
      // outPoint.X = 1; outPoint.Y = 2; outPoint.Z = Nan; outPoint.M = Nan;
      geoCoordString = pointZM.ToGeoCoordinateString(mgrsParam);
      outPoint = MapPointBuilderEx.FromGeoCoordinateString(
        geoCoordString, sr, GeoCoordinateType.MGRS);
    
      // set the number of digits to 2 and convert
      // 32QPH0512
      // outPoint.X = 10; outPoint.Y = 20
      mgrsParam.NumDigits = 2;
      geoCoordString = point1.ToGeoCoordinateString(mgrsParam);
      outPoint = MapPointBuilderEx.FromGeoCoordinateString(
        geoCoordString, sr, GeoCoordinateType.MGRS);
    
    
      // convert to UTM
      ToGeoCoordinateParameter utmParam =
           new ToGeoCoordinateParameter(GeoCoordinateType.UTM);
      // 31N 166021 0000000
      geoCoordString = point0.ToGeoCoordinateString(utmParam);
      // 32Q 604609 2211793
      geoCoordString = point1.ToGeoCoordinateString(utmParam);
    
      // convert to DMS
      ToGeoCoordinateParameter dmsParam =
        new ToGeoCoordinateParameter(GeoCoordinateType.DMS);
      // 00 00 00.00N 000 00 00.00E
      geoCoordString = point0.ToGeoCoordinateString(dmsParam);
      // 20 00 00.00N 010 00 00.00E
      geoCoordString = point1.ToGeoCoordinateString(dmsParam);
    
      // convert to DDM
      ToGeoCoordinateParameter ddmParam =
        new ToGeoCoordinateParameter(GeoCoordinateType.DDM);
      // 00 00.0000N 000 00.0000E
      geoCoordString = point0.ToGeoCoordinateString(ddmParam);
      // 20 00.0000N 010 00.0000E
      geoCoordString = point1.ToGeoCoordinateString(ddmParam);
    
      // convert to DD
      ToGeoCoordinateParameter ddParam =
        new ToGeoCoordinateParameter(GeoCoordinateType.DD);
      // 00.000000N 000.000000E
      geoCoordString = point0.ToGeoCoordinateString(ddParam);
      // 20.000000N 010.000000E
      geoCoordString = point1.ToGeoCoordinateString(ddParam);
    }
    Buffer a MapPoint
    {
      // buffer a point
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84);
      Geometry ptBuffer = GeometryEngine.Instance.Buffer(pt, 5.0);
      Polygon buffer = ptBuffer as Polygon;
    }
    Buffer a Circular Arc
    {
      // create the circular arc
      MapPoint fromPt = MapPointBuilderEx.CreateMapPoint(2, 1);
      MapPoint toPt = MapPointBuilderEx.CreateMapPoint(1, 2);
      Coordinate2D interiorPt = new(1 + Math.Sqrt(2) / 2, 1 + Math.Sqrt(2) / 2);
    
      EllipticArcSegment circularArc = EllipticArcBuilderEx.CreateCircularArc(fromPt, toPt, interiorPt);
    
      // buffer the arc
      polyline = PolylineBuilderEx.CreatePolyline(circularArc);
      Geometry lineBuffer = GeometryEngine.Instance.Buffer(polyline, 10);
    }
    Buffer multiple MapPoints
    {
      // creates a buffer around each MapPoint
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
        MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
        MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
        MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
      ];
    
      Geometry ptsBuffer = GeometryEngine.Instance.Buffer(pts, 0.25);
      Polygon bufferResult = ptsBuffer as Polygon;      // bufferResult will have 4 parts
    }
    Interpolate M values on a polygon
    {
      List<MapPoint> coords =
      [
        MapPointBuilderEx.CreateMapPoint(0, 0, 0, 0),
        MapPointBuilderEx.CreateMapPoint(0, 1000),
        MapPointBuilderEx.CreateMapPoint(1000, 1000, 10, 50)
      ];
    
      SpatialReference sr = SpatialReferences.WebMercator;
    
      polygon = PolygonBuilderEx.CreatePolygon(coords, sr);
    
      // polygon.HasM = true
      // polygon.Points[1].HasM = true
      // polygon.Points[1].M = NaN
    
      Polygon polygonNoNaNMs = GeometryEngine.Instance.CalculateNonSimpleMs(polygon, 0) as Polygon;
    
      // polygonNoNaNMs.Points[1].HasM = true
      // polygonNoNaNMs.Points[1].M = 25  (halfway between 0 and 50)
    }
    Clip a Polyline by a Polygon
    {
      // clip a polyline by a polygon
    
      List<Coordinate2D> list =
      [
        new Coordinate2D(1.0, 1.0),
        new Coordinate2D(1.0, 4.0),
        new Coordinate2D(4.0, 4.0),
        new Coordinate2D(4.0, 1.0),
      ];
    
      polygon = PolygonBuilderEx.CreatePolygon(list, SpatialReferences.WGS84);
    
      LineSegment crossingLine = LineBuilderEx.CreateLineSegment(MapPointBuilderEx.CreateMapPoint(0, 3), MapPointBuilderEx.CreateMapPoint(5.0, 3.0));
      Polyline p = PolylineBuilderEx.CreatePolyline(crossingLine);
      Geometry geometry = GeometryEngine.Instance.Clip(p, polygon.Extent);
    }
    Construct a geodetic line with specified distance and azimuth
    {
      var sr = SpatialReferenceBuilder.CreateSpatialReference(4326);
      var mapPoint = MapPointBuilderEx.CreateMapPoint(15, 60, sr);
    
      // calculate
      var polylineGeodetic = GeometryEngine.Instance.ConstructGeodeticLineFromDistance(GeodeticCurveType.Loxodrome, mapPoint, 5000000, 45, null, CurveDensifyMethod.ByLength, 300000);
    }
    Construct a geodetic line connecting points
    {
      var sr = SpatialReferenceBuilder.CreateSpatialReference(4326);
    
      var pt1 = MapPointBuilderEx.CreateMapPoint(60, 180, sr);
      var pt2 = MapPointBuilderEx.CreateMapPoint(60, 0, sr);
    
      // densify by length
      var gl = GeometryEngine.Instance.ConstructGeodeticLineFromPoints(GeodeticCurveType.Geodesic, pt1, pt2, null, CurveDensifyMethod.ByLength, -3.356);
    
      // densify by deviation
      gl = GeometryEngine.Instance.ConstructGeodeticLineFromPoints(GeodeticCurveType.Geodesic, pt1, pt2, null, CurveDensifyMethod.ByDeviation, -0.0026);
    }
    Construct a Point at a distance and angle from an existing Point
    {
      MapPoint inPoint = MapPointBuilderEx.CreateMapPoint(3, 4);
      double angle = 0;
      double distance = 10;
    
      MapPoint outPoint = GeometryEngine.Instance.ConstructPointFromAngleDistance(inPoint, angle, distance);
      // outPoint.X = 13
      // outPoint.Y = 4
    
      SpatialReference sr = SpatialReferences.WGS84;
      inPoint = MapPointBuilderEx.CreateMapPoint(0, 0, sr);
      angle = Math.PI;
      distance = 1;
    
      outPoint = GeometryEngine.Instance.ConstructPointFromAngleDistance(inPoint, angle, distance, sr);
      // outPoint.X = -1
      // outPoint.Y = 0
    }
    Polygon contains MapPoints, Polylines, Polygons
    {
        // build a polygon
        List<MapPoint> pts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        Polygon poly = PolygonBuilderEx.CreatePolygon(pts);
    
        // test if an inner point is contained
        MapPoint innerPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
        bool contains = GeometryEngine.Instance.Contains(poly, innerPt);   // contains = true
    
        // test a point on a boundary
        contains = GeometryEngine.Instance.Contains(poly, poly.Points[0]);     // contains = false
    
        // test an interior line
        MapPoint innerPt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
        List<MapPoint> innerLinePts = [innerPt, innerPt2];
    
        // test an inner polyline
        polyline = PolylineBuilderEx.CreatePolyline(innerLinePts);
        contains = GeometryEngine.Instance.Contains(poly, polyline);   // contains = true
    
        // test a line that crosses the boundary
        MapPoint outerPt = MapPointBuilderEx.CreateMapPoint(3, 1.5);
        List<MapPoint> crossingLinePts = [innerPt, outerPt];
    
        polyline = PolylineBuilderEx.CreatePolyline(crossingLinePts);
        contains = GeometryEngine.Instance.Contains(poly, polyline);     // contains = false
    
        // test a polygon in polygon
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(innerPt, innerPt2);
        contains = GeometryEngine.Instance.Contains(poly, env);      // contains = true
      }
    Determine convex hull
    {
        //
        // convex hull around a point - returns a point
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
        Geometry hull = GeometryEngine.Instance.ConvexHull(pt);
        MapPoint hullPt = hull as MapPoint;
        // nullPt.X = 2
        // hullPt.Y = 2
    
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        //
        // convex hull around a multipoint - returns a polygon
        //
    
        // build a multiPoint
        Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(list);
    
        hull = GeometryEngine.Instance.ConvexHull(multiPoint);
        Polygon hullPoly = hull as Polygon;
        // hullPoly.Area = 1
        // hullPoly.PointCount = 5
    
        //
        // convex hull around a line - returns a polyline or polygon
        //
    
        List<MapPoint> polylineList = [MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(2.0, 2.0)];
    
        // 2 point straight line
        polyline = PolylineBuilderEx.CreatePolyline(polylineList);
        hull = GeometryEngine.Instance.ConvexHull(polyline);
        Polyline hullPolyline = hull as Polyline;
        // hullPolyline.Length = Math.Sqrt(2)
        // hullPolyline.PointCount = 2
    
        // 3 point angular line
        polylineList.Add(MapPointBuilderEx.CreateMapPoint(2.0, 1.0));
        polyline = PolylineBuilderEx.CreatePolyline(polylineList);
        hull = GeometryEngine.Instance.ConvexHull(polyline);
        hullPoly = hull as Polygon;
        // hullPoly.Length = 2 + Math.Sqrt(2)
        // hullPoly.Area = 0.5
        // hullPoly.PointCount = 4
    
        //
        // convex hull around a polygon - returns a polygon
        //
    
        // simple polygon
        Polygon poly = PolygonBuilderEx.CreatePolygon(list);
        hull = GeometryEngine.Instance.ConvexHull(poly);
        hullPoly = hull as Polygon;
    
        // hullPoly.Length = 4.0
        // hullPoly.Area = 1.0
        // hullPoly.PointCount = 5
    
        // polygon with concave angles
        List<MapPoint> funkyList =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.5, 1.5),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(1.5, 1.5),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
    ];
    
        Polygon funkyPoly = PolygonBuilderEx.CreatePolygon(funkyList);
        hull = GeometryEngine.Instance.ConvexHull(funkyPoly);
        hullPoly = hull as Polygon;
        // hullPoly.Length = 4.0
        // hullPoly.Area = 1.0
        // hullPoly.PointCount = 5
        // hullPoly.Points[0] = 1.0, 1.0
        // hullPoly.Points[1] = 1.0, 2.0
        // hullPoly.Points[2] = 2.0, 2.0
        // hullPoly.Points[3] = 2.0, 1.0
        // hullPoly.Points[4] = 1.0, 1.0
      }
    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
      }
    Cut a geometry with a polyline
    {
        SpatialReference sr = SpatialReferences.WGS84;
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, sr),
      MapPointBuilderEx.CreateMapPoint(1.0, 4.0, sr),
      MapPointBuilderEx.CreateMapPoint(4.0, 4.0, sr),
      MapPointBuilderEx.CreateMapPoint(4.0, 1.0, sr),
    ];
    
        List<Geometry> cutGeometries;
    
        LineSegment line = LineBuilderEx.CreateLineSegment(MapPointBuilderEx.CreateMapPoint(0, 0, sr), MapPointBuilderEx.CreateMapPoint(3, 6, sr));
        Polyline cutter = PolylineBuilderEx.CreatePolyline(line);
    
        // polyline
        polyline = PolylineBuilderEx.CreatePolyline(list);
        bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
        cutGeometries = GeometryEngine.Instance.Cut(polyline, cutter) as List<Geometry>;
    
        Polyline leftPolyline = cutGeometries[0] as Polyline;
        Polyline rightPolyline = cutGeometries[1] as Polyline;
    
        // leftPolyline.Points[0] = 1, 2
        // leftPolyline.Points[1] = 1, 4
        // leftPolyline.Points[2] = 2, 4
    
        // rightPolyline.Points.Count = 5
        // rightPolyline.Parts.Count = 2
    
        ReadOnlySegmentCollection segments0 = rightPolyline.Parts[0];
        // segments0[0].StartCoordinate = 1, 1
        // segments0[0].EndCoordinate = 1, 2
    
        ReadOnlySegmentCollection segments1 = rightPolyline.Parts[1];
        // segments1.Count = 2
        // segments1[0].StartCoordinate = 2, 4
        // segments1[0].EndCoordinate = 4, 4
        // segments1[1].StartCoordinate = 4, 4
        // segments1[1].EndCoordinate = 4, 1
    
        // polygon
        polygon = PolygonBuilderEx.CreatePolygon(list);
        isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polygon);
        cutGeometries = GeometryEngine.Instance.Cut(polygon, cutter) as List<Geometry>;
      }
    Densify by Length
    {
      // densify a line segment
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(1, 21);
      LineSegment line = LineBuilderEx.CreateLineSegment(startPt, endPt);
      polyline = PolylineBuilderEx.CreatePolyline(line);
    
      Geometry geom = GeometryEngine.Instance.DensifyByLength(polyline, 2);
      Polyline result = geom as Polyline;
    
      // densify a circular arc
      MapPoint fromPt = MapPointBuilderEx.CreateMapPoint(2, 1);
      MapPoint toPt = MapPointBuilderEx.CreateMapPoint(1, 2);
      Coordinate2D interiorPt = new(1 + Math.Sqrt(2) / 2, 1 + Math.Sqrt(2) / 2);
    
      EllipticArcBuilderEx cab = new(fromPt, toPt, interiorPt);
      EllipticArcSegment circularArc = cab.ToSegment();
      polyline = PolylineBuilderEx.CreatePolyline(circularArc);
      geom = GeometryEngine.Instance.DensifyByLength(polyline, 2);
      result = geom as Polyline;
    }
    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)
    }
    Extend a polyline
    {
      // build a polyline
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 1, 10, 20),
        MapPointBuilderEx.CreateMapPoint(0, 0, 10, 20),
        MapPointBuilderEx.CreateMapPoint(1, -1, 10, 20)
      ]);
    
      // build the extender line
      var extender = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(2, 2),
        MapPointBuilderEx.CreateMapPoint(2, -2),
      ]);
    
      // extend
      var result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes);
      Polyline extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 10, 20
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
      // result.Parts[0].Points[4] = 2, -2, 10, 20
    
      // change the flags
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.NoEndAttributes);
      extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 0
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
      // result.Parts[0].Points[4] = 2, -2, 0
    
      // extend
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes | ExtendFlags.NoExtendAtTo);
      extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 10, 20
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
    
      // extend with no intersection
    
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 1),
        MapPointBuilderEx.CreateMapPoint(3, 1)
      ]);
    
      extender = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 4),
        MapPointBuilderEx.CreateMapPoint(3, 4)
      ]);
    
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.Default);
      // result = null
    
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes | ExtendFlags.NoExtendAtTo);
    
      // Use the result ...
    }
    Calculate the Geodesic Area of a polygon
    {
      polygon = PolygonBuilderEx.CreatePolygon(
      [
        MapPointBuilderEx.CreateMapPoint(-10018754.1713946, 10018754.1713946),
        MapPointBuilderEx.CreateMapPoint(10018754.1713946, 10018754.1713946),
        MapPointBuilderEx.CreateMapPoint(10018754.1713946, -10018754.1713946),
        MapPointBuilderEx.CreateMapPoint(-10018754.1713946, -10018754.1713946)
      ], SpatialReferences.WebMercator);
      var area = GeometryEngine.Instance.GeodesicArea(polygon);
    
      // area is close to 255032810857732.31
    
      area = GeometryEngine.Instance.GeodesicArea(polygon, AreaUnit.SquareKilometers);
      // area is close to 255032810.85953,
    }
    Create a buffer polygon at the specified geodesic distance
    {
        // buffer a point
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84);
        Polygon outPolygon = GeometryEngine.Instance.GeodesicBuffer(pt, 5) as Polygon;
    
        double delta = SpatialReferences.WGS84.XYTolerance * 2 * Math.Sqrt(2);
        ReadOnlyPointCollection points = outPolygon.Points;
        foreach (MapPoint p in points)
        {
          double d = GeometryEngine.Instance.GeodesicDistance(pt, p);
          // d = 5 (+- delta)
        }
    
        // specify a unit for the distance
        outPolygon = GeometryEngine.Instance.GeodesicBuffer(pt, 5000, LinearUnit.Millimeters) as Polygon;
    
        // buffer of 0 distance produces an empty geometry
        Geometry g = GeometryEngine.Instance.GeodesicBuffer(pt, 0);
        // g.IsEmpty = true
    
        // buffer many points
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(10.0, 20.0),
      MapPointBuilderEx.CreateMapPoint(40.0, 40.0),
      MapPointBuilderEx.CreateMapPoint(60.0, 60.0),
    ];
    
        outPolygon = GeometryEngine.Instance.GeodesicBuffer(list, 10000) as Polygon;
        // outPolygon.PartCount = 4
    
        // buffer different geometry types
        List<Coordinate2D> coords =
        [
          new Coordinate2D(1, 2), new Coordinate2D(10, 20), new Coordinate2D(20, 30),
      new Coordinate2D(50, 60), new Coordinate2D(70, 80), new Coordinate2D(80, 40),
      new Coordinate2D(90, 10), new Coordinate2D(110, 15), new Coordinate2D(120, 30),
      new Coordinate2D(10, 40), new Coordinate2D(-10, 40), new Coordinate2D(-10, 50)
        ];
    
        List<Geometry> manyGeometries =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      PolylineBuilderEx.CreatePolyline([coords[0], coords[1], coords[2]], SpatialReferences.WGS84),
      PolylineBuilderEx.CreatePolyline([coords[3], coords[4], coords[5]]),
      PolygonBuilderEx.CreatePolygon([coords[9], coords[10], coords[11]])
        ];
    
        outPolygon = GeometryEngine.Instance.GeodesicBuffer(manyGeometries, 20000) as Polygon;
    
        // specify unit types
        outPolygon = GeometryEngine.Instance.GeodesicBuffer(manyGeometries, 20, LinearUnit.Miles) as Polygon;
      }
    Determine geodesic distance between two Geometries
    {
      var point1 = MapPointBuilderEx.CreateMapPoint(-170, 45, SpatialReferences.WGS84);
      var point2 = MapPointBuilderEx.CreateMapPoint(170, 45, SpatialReferences.WGS84);
    
      var distances_meters = GeometryEngine.Instance.GeodesicDistance(point1, point2);
      // distance is approximately 1572912.2066940258 in meters
    
      var distance_feet = GeometryEngine.Instance.GeodesicDistance(point1, point2, LinearUnit.Feet);
      // distance is approximately  5160473.11904786 in feet
    }
    Determine geodesic length of a line
    {
      polyline = PolylineBuilderEx.CreatePolyline(
      [
          MapPointBuilderEx.CreateMapPoint(-10018754.1713946, 10018754.1713946),
      MapPointBuilderEx.CreateMapPoint(10018754.1713946, 10018754.1713946)
      ], SpatialReferences.WebMercator);
    
      var length = GeometryEngine.Instance.GeodesicLength(polyline);
      // length is approx 5243784.5551844323 in meters
    
      length = GeometryEngine.Instance.GeodesicLength(polyline, LinearUnit.Miles);
      // length is approx 3258.33666089067 in miles
    
      var polyline2 = GeometryEngine.Instance.Project(polyline, SpatialReferences.WGS84);
      length = GeometryEngine.Instance.GeodesicLength(polyline2);
      // length is approx 5243784.55518443 in meters after projecting
    }
    Calculate geodetic distance, azimuth between two points
    {
      SpatialReference sr = SpatialReferences.WGS84;
    
      MapPoint p1 = MapPointBuilderEx.CreateMapPoint(111, 55, sr);
      MapPoint p2 = MapPointBuilderEx.CreateMapPoint(95.5845, 64.2285, sr);
    
      double distance;
    
      distance = GeometryEngine.Instance.GeodeticDistanceAndAzimuth(p1, p2, GeodeticCurveType.Geodesic, out double az12, out double az21);
      // distance - 1339728.0303777338
      // az12 - 326.235780421405
      // az21 - 132.87425637913955
    
      distance = GeometryEngine.Instance.GeodeticDistanceAndAzimuth(p1, p2, GeodeticCurveType.Loxodrome, out az12, out az21);
      // distance - 1342745.9687172563
      // az12 - 319.966400332104
      // az21- 139.96640033210397
    
      distance = GeometryEngine.Instance.GeodeticDistanceAndAzimuth(p1, p2, GeodeticCurveType.GreatElliptic, out az12, out az21);
      // distance - 1339728.038837946
      // az12 - 326.22479262335418
      // az21 - 132.88558894347742
    
      MapPoint p3 = MapPointBuilderEx.CreateMapPoint(0, 0, sr);
      MapPoint p4 = MapPointBuilderEx.CreateMapPoint(1, 0, sr);
    
      distance = GeometryEngine.Instance.GeodeticDistanceAndAzimuth(p3, p4, GeodeticCurveType.Geodesic, out az12, out az21);
      // distance - 111319.49079327342
      // az12 - 90
      // az21 - 270
    
      distance = GeometryEngine.Instance.GeodeticDistanceAndAzimuth(p3, p4, GeodeticCurveType.Geodesic, LinearUnit.Miles, out az12, out az21);
      // distance - 69.1707247134693
      // az12 - 90
      // az21 - 270
    }
    Perform Geodetic Move on a set of MapPoints
    {
      SpatialReference sr = SpatialReferences.WebMercator;
      var points = new[] { MapPointBuilderEx.CreateMapPoint(0, 0, sr) };
      double distance = 10;
      double azimuth = Math.PI / 2;
      var resultPoints = GeometryEngine.Instance.GeodeticMove(points, sr, distance, LinearUnit.Meters, azimuth, GeodeticCurveType.Geodesic);
    
      // resultPoints.First().X = 10
      // resultPoints.First().Y = 0
      // resultPoints.First().SpatialReference.Wkid = sr.Wkid
    
      // Change LinearUnit to Miles
      resultPoints = GeometryEngine.Instance.GeodeticMove(points, sr, distance, LinearUnit.Miles, azimuth, GeodeticCurveType.Geodesic);
      // resultPoints.First().X = 16093.44
      // resultPoints.First().Y = 0
    
      // Change curve type
      resultPoints = GeometryEngine.Instance.GeodeticMove(points, sr, distance, LinearUnit.Miles, azimuth, GeodeticCurveType.Loxodrome);
      // resultPoints.First().X = 16093.44
      // resultPoints.First().Y = 0
    }
    GraphicBuffer Many
    {
      // round join and round caps
      MapPoint point1 = MapPointBuilderEx.CreateMapPoint(0, 0);
      MapPoint point2 = MapPointBuilderEx.CreateMapPoint(1, 1, SpatialReferences.WGS84);
      MapPoint point3 = MapPointBuilderEx.CreateMapPoint(1000000, 1200000, SpatialReferences.WebMercator);
      List<MapPoint> points = [point1, point2, point3];
    
      IReadOnlyList<Geometry> geometries = GeometryEngine.Instance.GraphicBuffer(points, 5, LineJoinType.Round, LineCapType.Round, 0, 0, 3000);
    }
    Intersection between two Polylines
    {
      // determine intersection between two polylines
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
      Polyline line1 = PolylineBuilderEx.CreatePolyline(pts);
    
      List<MapPoint> pts2 =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
      Polyline line2 = PolylineBuilderEx.CreatePolyline(pts2);
    
      bool intersects = GeometryEngine.Instance.Intersects(line1, line2);    // intersects = true
      Geometry g = GeometryEngine.Instance.Intersection(line1, line2, GeometryDimensionType.EsriGeometry0Dimension);
      Multipoint resultMultipoint = g as Multipoint;
    
      // result is a multiPoint that intersects at (2,2) and (4,2)
    }
    Move a MapPoint
    {
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0);
      MapPoint ptResult = GeometryEngine.Instance.Move(pt, -3.5, 2.5) as MapPoint;
      // ptResult is (-2.5, 5.5)
    }
    MovePointAlongLine
    {
      LineSegment line = LineBuilderEx.CreateLineSegment(MapPointBuilderEx.CreateMapPoint(0, 3), MapPointBuilderEx.CreateMapPoint(5.0, 3.0));
      polyline = PolylineBuilderEx.CreatePolyline(line);
      bool simple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
    
      // ratio = false
      MapPoint pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, 0.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 3.0
    
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, -1.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 4.0
    
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, 2.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 1.0
    
      // ratio = true
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt = 2.5, 3.0
    
      // move past the line
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 7, false, 0, SegmentExtensionType.NoExtension);
      // pt = 5.0, 3.0
    
      // move past the line with extension at "to" point
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 7, false, 0, SegmentExtensionType.ExtendEmbeddedAtTo);
      // pt = 7.0, 3.0
    
      // negative distance with extension at "from" point
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, -2, false, 0, SegmentExtensionType.ExtendEmbeddedAtFrom);
      // pt = -2.0, 3.0
    
      // ratio = true
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt = 2.5, 3.0
    
      // line with Z
      List<Coordinate3D> coords3D = [new Coordinate3D(0, 0, 0), new Coordinate3D(1113195, 1118890, 5000)];
      Polyline polylineZ = PolylineBuilderEx.CreatePolyline(coords3D, SpatialReferences.WebMercator);
      // polylineZ.HasZ = true
    
      // ratio = true, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt.X = 556597.5
      // pt.Y = 559445
      // pt.Z = 2500
    
      // ratio = true, past the line with "to" extension, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, 1.5, true, 0, SegmentExtensionType.ExtendEmbeddedAtTo);
      // pt.X = 1669792.5
      // pt.Y = 1678335
      // pt.Z = 7500
    
      // ratio = true, negative distance past the line with no extension, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, -1.5, true, 0, SegmentExtensionType.NoExtension);
      // pt.X = 0
      // pt.Y = 0
      // pt.Z = -7500
    
      // polyline with Z but 2d distance = 0
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(5, 5, 0);
      MapPoint pt4 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      List<MapPoint> pts = [pt3, pt4];
    
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.HasZ = true
      // polyline.Length3D = 10
      // polyline.Length = 0
    
      MapPoint result = GeometryEngine.Instance.MovePointAlongLine(polyline, 2, false, 0, SegmentExtensionType.NoExtension);
      // result = 5, 5, 2
    
      // polyline with length2d = 0 and length3d = 0
      MapPoint pt5 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      MapPoint pt6 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      pts.Clear();
      pts.Add(pt5);
      pts.Add(pt6);
    
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.HasZ = true
      // polyline.Length3D = 0
      // polyline.Length = 0
    
      result = GeometryEngine.Instance.MovePointAlongLine(polyline, 3, true, 0, SegmentExtensionType.NoExtension);
      // result = 5, 5, 10
    
      result = GeometryEngine.Instance.MovePointAlongLine(polyline, 3, true, 0, SegmentExtensionType.ExtendEmbeddedAtFrom);
      // result = 5, 5, 10
    
      // polyline with Z and M
      List<MapPoint> inputPoints =
      [
          MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4),
        MapPointBuilderEx.CreateMapPoint(1, 2, 33, 44),
    ];
    
      Polyline polylineZM = PolylineBuilderEx.CreatePolyline(inputPoints, SpatialReferences.WGS84);
      // polylineZM.HasZ = true
      // polylineZM.HasM = true
    
      // ratio = true, no offset
      MapPoint pointAlong = GeometryEngine.Instance.MovePointAlongLine(polylineZM, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pointAlong = 1, 2, 18, 24
    
      // ratio = true with offset
      pointAlong = GeometryEngine.Instance.MovePointAlongLine(polylineZM, 0.2, true, 2.23606797749979, SegmentExtensionType.NoExtension);
      // pointAlong = 1, 2, 9, 12
    }
    Nearest Point versus Nearest Vertex
    {
      SpatialReference sr = SpatialReferences.WGS84;
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(5, 5, sr);
    
      List<Coordinate2D> coords =
      [
        new Coordinate2D(10, 1),
      new Coordinate2D(10, -4),
      new Coordinate2D(0, -4),
      new Coordinate2D(0, 1),
      new Coordinate2D(10, 1)
      ];
    
      polygon = PolygonBuilderEx.CreatePolygon(coords);
    
      // find the nearest point in the polygon geometry to the pt
      ProximityResult result = GeometryEngine.Instance.NearestPoint(polygon, pt);
      // result.Point = 5, 1
      // result.SegmentIndex = 3
      // result.PartIndex = 0
      // result.PointIndex = null
      //result.Distance = 4
      //result.RightSide = false
    
      // find the nearest vertex in the polgyon geometry to the pt
      result = GeometryEngine.Instance.NearestVertex(polygon, pt);
      // result.Point = 10, 1
      // result.PointIndex = 0
      // result.SegmentIndex = null
      // result.PartIndex = 0
      // result.Distance = Math.Sqrt(41)
      // result.RightSide = false
    }
    Calculate a geometry offset from the source
    {
        List<MapPoint> linePts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(10.0, 1.0, SpatialReferences.WGS84),
    ];
    
        polyline = PolylineBuilderEx.CreatePolyline(linePts);
    
        Geometry g = GeometryEngine.Instance.Offset(polyline, 10, OffsetType.Square, 0);
        Polyline gResult = g as Polyline;
        // gResult.PointCount = 2
        // gResult.Points[0] = (1, -9)
        // gResult.Points[1] = (10, -9)
    
        g = GeometryEngine.Instance.Offset(polyline, -10, OffsetType.Round, 0.5);
        gResult = g as Polyline;
        // gResult.PointCount = 2
        // gResult.Points[0] = (1, -11
        // gResult.Points[1] = (10, 11)
    
        //
        // elliptic arc curve
        //
        Coordinate2D fromPt = new(2, 1);
        Coordinate2D toPt = new(1, 2);
        Coordinate2D interiorPt = new(1 + Math.Sqrt(2) / 2, 1 + Math.Sqrt(2) / 2);
    
        EllipticArcSegment circularArc = EllipticArcBuilderEx.CreateCircularArc(fromPt.ToMapPoint(), toPt.ToMapPoint(), interiorPt);
    
        polyline = PolylineBuilderEx.CreatePolyline(circularArc);
        g = GeometryEngine.Instance.Offset(polyline, -0.25, OffsetType.Miter, 0.5);
        gResult = g as Polyline;
    
        g = GeometryEngine.Instance.Offset(polyline, 0.25, OffsetType.Bevel, 0.5);
        gResult = g as Polyline;
    
        //
        //  offset for a polygon
        //
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(10.0, 10.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(10.0, 20.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(20.0, 20.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(20.0, 10.0, SpatialReferences.WGS84),
      ];
    
        polygon = PolygonBuilderEx.CreatePolygon(list);
    
        g = GeometryEngine.Instance.Offset(polygon, 2, OffsetType.Square, 0);
        Polygon gPolygon = g as Polygon;
    
        g = GeometryEngine.Instance.Offset(polygon, -2, OffsetType.Round, 0.3);
        gPolygon = g as Polygon;
    
        g = GeometryEngine.Instance.Offset(polygon, -0.5, OffsetType.Miter, 0.6);
        gPolygon = g as Polygon;
      }
    Determine if geometries overlap
    {
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(3, 1.5);
      MapPoint pt4 = MapPointBuilderEx.CreateMapPoint(1.5, 2);
    
      //
      // point and point overlap
      //
      bool overlaps = GeometryEngine.Instance.Overlaps(pt1, pt2);        // overlaps = false
      overlaps = GeometryEngine.Instance.Overlaps(pt1, pt1);             // overlaps = false
                                                                         // Two geometries overlap if the region of their intersection is of the same dimension as the geometries involved and
                                                                         // is not equivalent to either of the geometries.
    
      List<MapPoint> pts = [pt1, pt2, pt3];
    
      List<MapPoint> pts2 = [pt2, pt3, pt4];
    
      //
      // pt and line overlap
      //
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);         // isSimple = true
      overlaps = GeometryEngine.Instance.Overlaps(polyline, pt1);                  // overlaps = false
    
      //
      // line and line
      //
      Polyline polyline2 = PolylineBuilderEx.CreatePolyline(pts2);
      isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline2);             // isSimple = true
      overlaps = GeometryEngine.Instance.Overlaps(polyline, polyline2);            // overlaps = true
    }
    Project from WGS84 to WebMercator
    {
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0, SpatialReferences.WGS84);
      Geometry result = GeometryEngine.Instance.Project(pt, SpatialReferences.WebMercator);
      MapPoint projectedPt = result as MapPoint;
    }
    Project from WGS84
    {
      // create the polygon
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0, SpatialReferences.WGS84),
    ];
    
      polygon = PolygonBuilderEx.CreatePolygon(pts);
      // ensure it is simple
      bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polygon);
    
      // create the spatial reference to project to
      SpatialReference northPole = SpatialReferenceBuilder.CreateSpatialReference(102018);   // north pole stereographic
    
      // project
      Geometry geometry = GeometryEngine.Instance.Project(polygon, northPole);
    }
    QueryPointAndDistance
    {
        // Horizontal line segment
        List<MapPoint> linePts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(11.0, 1.0, SpatialReferences.WGS84),
    ];
        polyline = PolylineBuilderEx.CreatePolyline(linePts);
        bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
    
        // Don't extend the segment
        SegmentExtensionType extension = SegmentExtensionType.NoExtension;
    
        // A point on the line segment
        MapPoint inPoint = MapPointBuilderEx.CreateMapPoint(2, 1, SpatialReferences.WGS84);
    
        AsRatioOrLength asRatioOrLength = AsRatioOrLength.AsLength;
    
        MapPoint outPoint = GeometryEngine.Instance.QueryPointAndDistance(polyline, extension, inPoint, asRatioOrLength, out double distanceAlongCurve, out double distanceFromCurve, out LeftOrRightSide whichSide);
        // outPoint = 2, 1
        // distanceAlongCurve = 1
        // distanceFromCurve = 0
        // whichSide = GeometryEngine.Instance.LeftOrRightSide.LeftSide
    
        // Extend infinitely in both directions
        extension = SegmentExtensionType.ExtendTangents;
    
        // A point on the left side
        inPoint = MapPointBuilderEx.CreateMapPoint(16, 6, SpatialReferences.WGS84);
        asRatioOrLength = AsRatioOrLength.AsRatio;
    
        outPoint = GeometryEngine.Instance.QueryPointAndDistance(polyline, extension, inPoint, asRatioOrLength, out distanceAlongCurve, out distanceFromCurve, out whichSide);
        // outPoint = 16, 1
        // distanceAlongCurve = 1.5
        // distanceFromCurve = 5
        // whichSide = GeometryEngine.Instance.LeftOrRightSide.LeftSide
      }
    Determine relationship between two geometries
    {
      // set up some geometries
    
      // points
      MapPoint point0 = MapPointBuilderEx.CreateMapPoint(0, 0, SpatialReferences.WGS84);
      MapPoint point1 = MapPointBuilderEx.CreateMapPoint(1, 1, SpatialReferences.WGS84);
      MapPoint point2 = MapPointBuilderEx.CreateMapPoint(-5, 5, SpatialReferences.WGS84);
    
      // multipoint
      List<MapPoint> points = [point0, point1, point2];
      Multipoint multipoint = MultipointBuilderEx.CreateMultipoint(points, SpatialReferences.WGS84);
    
      // polygon
      List<Coordinate2D> polygonCoords =
      [
          new Coordinate2D(-10, 0),
      new Coordinate2D(0, 10),
      new Coordinate2D(10, 0),
      new Coordinate2D(-10, 0)
      ];
      polygon = PolygonBuilderEx.CreatePolygon(polygonCoords, SpatialReferences.WGS84);
    
      // polylines
      Polyline polyline1 = PolylineBuilderEx.CreatePolyline(LineBuilderEx.CreateLineSegment(new Coordinate2D(-9.1, 0.1), new Coordinate2D(0, 9)), SpatialReferences.WGS84);
      Polyline polyline2 = PolylineBuilderEx.CreatePolyline(LineBuilderEx.CreateLineSegment(new Coordinate2D(-5, 5), new Coordinate2D(0, 5)), SpatialReferences.WGS84);
      Polyline polyline3 = PolylineBuilderEx.CreatePolyline(LineBuilderEx.CreateLineSegment(new Coordinate2D(2.09, -2.04), new Coordinate2D(5, 10)), SpatialReferences.WGS84);
      Polyline polyline4 = PolylineBuilderEx.CreatePolyline(LineBuilderEx.CreateLineSegment(new Coordinate2D(10, -5), new Coordinate2D(10, 5)), SpatialReferences.WGS84);
    
      List<Segment> segments =
      [
          LineBuilderEx.CreateLineSegment(new Coordinate2D(5.05, -2.87), new Coordinate2D(6.35, 1.57)),
      LineBuilderEx.CreateLineSegment(new Coordinate2D(6.35, 1.57), new Coordinate2D(4.13, 2.59)),
      LineBuilderEx.CreateLineSegment(new Coordinate2D(4.13, 2.59), new Coordinate2D(5, 5))
      ];
      Polyline polyline5 = PolylineBuilderEx.CreatePolyline(segments, SpatialReferences.WGS84);
    
      segments.Add(LineBuilderEx.CreateLineSegment(new Coordinate2D(5, 5), new Coordinate2D(10, 10)));
    
      Polyline polyline6 = PolylineBuilderEx.CreatePolyline(segments, SpatialReferences.WGS84);
      Polyline polyline7 = PolylineBuilderEx.CreatePolyline(polyline5);
      Polyline polyline8 = PolylineBuilderEx.CreatePolyline(LineBuilderEx.CreateLineSegment(new Coordinate2D(5, 5), new Coordinate2D(10, 10)), SpatialReferences.WGS84);
    
      segments.Clear();
      segments.Add(LineBuilderEx.CreateLineSegment(new Coordinate2D(0.6, 3.5), new Coordinate2D(0.7, 7)));
      segments.Add(LineBuilderEx.CreateLineSegment(new Coordinate2D(0.7, 7), new Coordinate2D(3, 9)));
    
      Polyline polyline9 = PolylineBuilderEx.CreatePolyline(segments, SpatialReferences.WGS84);
    
      // now do the Related tests
    
      // Interior/Interior Intersects
      string scl = "T********";
      bool related = GeometryEngine.Instance.Relate(polygon, polyline1, scl);     // related = true
      related = GeometryEngine.Instance.Relate(point0, point1, scl);              // related = false
      related = GeometryEngine.Instance.Relate(point0, multipoint, scl);          // related = true
      related = GeometryEngine.Instance.Relate(multipoint, polygon, scl);         // related = true
      related = GeometryEngine.Instance.Relate(multipoint, polyline1, scl);       // related = false
      related = GeometryEngine.Instance.Relate(polyline2, point2, scl);           // related = false
      related = GeometryEngine.Instance.Relate(point1, polygon, scl);             // related = true
    
      // Interior/Boundary Intersects
      scl = "*T*******";
      related = GeometryEngine.Instance.Relate(polygon, polyline2, scl);          // related = true
      related = GeometryEngine.Instance.Relate(polygon, polyline3, scl);          // related = false
      related = GeometryEngine.Instance.Relate(point1, polygon, scl);             // related = false
    
      // Boundary/Boundary Interior intersects
      scl = "***T*****";
      related = GeometryEngine.Instance.Relate(polygon, polyline4, scl);          // related = true
    
      // Overlaps Dim1
      scl = "1*T***T**";
      related = GeometryEngine.Instance.Relate(polygon, polyline5, scl);          // related = true
    
      // Crosses Area/Line (LineB crosses PolygonA)
      scl = "1020F1102";
      related = GeometryEngine.Instance.Relate(polygon, polyline6, scl);          // related = false
      related = GeometryEngine.Instance.Relate(polygon, polyline9, scl);          // related = true
    
      // Boundary/Boundary Touches
      scl = "F***T****";
      related = GeometryEngine.Instance.Relate(polygon, polyline7, scl);          // related = false
      related = GeometryEngine.Instance.Relate(polygon, polyline8, scl);          // related = true
    }
    Rotate a MapPoint
    {
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0);
      MapPoint rotatePt = MapPointBuilderEx.CreateMapPoint(3.0, 3.0);
    
      Geometry result = GeometryEngine.Instance.Rotate(pt, rotatePt, Math.PI / 2);
    }
    // result point is (3, 1)
    Rotate a Polyline
    {
      // rotate a polyline
    
      MapPoint fixedPt = MapPointBuilderEx.CreateMapPoint(3.0, 3.0);
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 5.0),
      MapPointBuilderEx.CreateMapPoint(5, 5),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
      polyline = PolylineBuilderEx.CreatePolyline(pts);
    
      Polyline rotated = GeometryEngine.Instance.Rotate(polyline, fixedPt, Math.PI / 4) as Polyline;  // rotate 45 deg
    }
    Scale a geometry
    {
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      MapPoint midPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.Length = 6
      // polyline.Length3D = 0
      Geometry g = GeometryEngine.Instance.Scale(polyline, midPt, 0.5, 0.5);
      Polyline resultPolyline = g as Polyline;
      // resultPolyline.length  = 3
      // resultPolyline.Points[0] = 1.25, 1.25, 3
      // resultPolyline.Points[1] = 1.25, 2.25, 3
      // resultPolyline.Points[2] = 2.25, 2.25, 3
      // resultPolyline.Points[3] = 2.25, 1.25, 3
    
      // 3D point - scale in 3d
      MapPoint midPtZ = MapPointBuilderEx.CreateMapPoint(1.5, 1.5, 1);
      g = GeometryEngine.Instance.Scale(polyline, midPtZ, 0.5, 0.5, 0.25);
      resultPolyline = g as Polyline;
      // resultPolyline.Points[0] = 1.25, 1.25, 1.5
      // resultPolyline.Points[1] = 1.25, 2.25, 1.5
      // resultPolyline.Points[2] = 2.25, 2.25, 1.5
      // resultPolyline.Points[3] = 2.25, 1.25, 1.5
    }
    Calculate area of geometry on surface of Earth's ellipsoid - ShapePreservingArea
    {
      // pt
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0, SpatialReferences.WebMercator);
      double area = GeometryEngine.Instance.ShapePreservingArea(pt);         // area = 0
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      // multipoint
      Multipoint mPt = MultipointBuilderEx.CreateMultipoint(pts);
      area = GeometryEngine.Instance.ShapePreservingArea(mPt);               // area = 0
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      area = GeometryEngine.Instance.ShapePreservingArea(polyline);          // area = 0
    
      // polygon
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WGS84);
      area = GeometryEngine.Instance.ShapePreservingArea(polygon);
    
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WebMercator);
      area = GeometryEngine.Instance.ShapePreservingArea(polygon);
    
      polygon = PolygonBuilderEx.CreatePolygon(
      [
        MapPointBuilderEx.CreateMapPoint( -170, 45),
      MapPointBuilderEx.CreateMapPoint( 170, 45),
      MapPointBuilderEx.CreateMapPoint( 170, -45),
      MapPointBuilderEx.CreateMapPoint( -170, -54)
      ], SpatialReferences.WGS84);
    
      var area_meters = GeometryEngine.Instance.ShapePreservingArea(polygon);// , AreaUnits.SquareMeters);
      var area_miles = GeometryEngine.Instance.ShapePreservingArea(polygon, AreaUnit.SquareMiles);
    
      // area_meters - 352556425383104.37
      // area_miles - 136122796.848425
    }
    Calculate length of geometry on surface of Earth's ellipsoid - ShapePreservingLength
    {
      // pt
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0, SpatialReferences.WebMercator);
      double len = GeometryEngine.Instance.ShapePreservingLength(pt);          // len = 0
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      // multipoint
      Multipoint mPt = MultipointBuilderEx.CreateMultipoint(pts);
      len = GeometryEngine.Instance.ShapePreservingLength(mPt);                // len = 0
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts, SpatialReferences.WGS84);
      len = GeometryEngine.Instance.ShapePreservingLength(polyline);
    
      // polygon
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WGS84);
      len = GeometryEngine.Instance.ShapePreservingLength(polygon);
    
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint( -170, 0),
      MapPointBuilderEx.CreateMapPoint( 170, 0)
      ], SpatialReferences.WGS84);
    
    
      var length_meters = GeometryEngine.Instance.ShapePreservingLength(polyline); // , LinearUnits.Meters);
      var length_miles = GeometryEngine.Instance.ShapePreservingLength(polyline, LinearUnit.Miles);
    
      // length_meters - 37848626.869713023
      // length_miles - 23518.046402579574
    }
    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 MapPoints - creates a Multipoint
    {
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.5);
    
      Geometry geometry = GeometryEngine.Instance.Union(pt1, pt2);
      Multipoint multipoint = geometry as Multipoint;   // multipoint has point count of 2
    }
    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;
    }
    MapPoints, Polylines, Polygons within Polygon
    {
        // build a polygon
        List<MapPoint> pts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        Polygon poly = PolygonBuilderEx.CreatePolygon(pts);
    
        // an inner point
        MapPoint innerPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
        bool within = GeometryEngine.Instance.Within(innerPt, poly);   // within = true
    
        // point on a boundary
        within = GeometryEngine.Instance.Within(pts[0], poly);     // within = false
    
        // an interior line
        MapPoint innerPt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
        List<MapPoint> innerLinePts = [innerPt, innerPt2];
    
        polyline = PolylineBuilderEx.CreatePolyline(innerLinePts);
        within = GeometryEngine.Instance.Within(polyline, poly);   // within = true
    
        // a line that crosses the boundary
        MapPoint outerPt = MapPointBuilderEx.CreateMapPoint(3, 1.5);
        List<MapPoint> crossingLinePts = [innerPt, outerPt];
    
        polyline = PolylineBuilderEx.CreatePolyline(crossingLinePts);
        within = GeometryEngine.Instance.Within(polyline, poly);     // within = false
    
        // polygon in polygon
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(innerPt, innerPt2);
        within = GeometryEngine.Instance.Within(env, poly);      // within = true
      }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also