ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / PolylineBuilderEx Class / CreatePolyline Method / CreatePolyline(IEnumerable<Coordinate3D>,SpatialReference) Method
Coordinates to create the polyline. Line segments are created from the coordinates.
(Optional) The SpatialReference. The default value is null.
Example

In This Topic
    CreatePolyline(IEnumerable<Coordinate3D>,SpatialReference) Method
    In This Topic
    Convenience method to create a new instance of the Polyline class.
    Syntax
    Public Overloads Shared Function CreatePolyline( _
       ByVal coordinates As IEnumerable(Of Coordinate3D), _
       Optional ByVal spatialReference As SpatialReference _
    ) As Polyline

    Parameters

    coordinates
    Coordinates to create the polyline. Line segments are created from the coordinates.
    spatialReference
    (Optional) The SpatialReference. The default value is null.

    Return Value

    Exceptions
    ExceptionDescription
    coordinates is null.
    Remarks
    The HasZ property is set to true.
    Example
    Construct a Polyline - from a Cubic Bezier
    {
      polyline = PolylineBuilderEx.CreatePolyline(bezierSegment);
    }
    Interpolate Z values on a polyline
    {
      List<Coordinate3D> coords2 =
    [
      new Coordinate3D(0, 0, 0),
      new Coordinate3D(0, 1000, double.NaN),
      new Coordinate3D(1000, 1000, 50),
      new Coordinate3D(1000, 1000, 76),
      new Coordinate3D(0, 1000, double.NaN),
      new Coordinate3D(0, 0, 0)
    ];
    
      SpatialReference sr = SpatialReferences.WebMercator;
    
      polyline = PolylineBuilderEx.CreatePolyline(coords2, sr);
    
      // polyline.HasZ = true
      // polyline.Points[1].HasZ = true
      // polyline.Points[1].Z  = NaN
      // polyline.Points[4].HasZ = true
      // polyline.Points[4].Z  = NaN
    
      Polyline polylineNoNaNZs = GeometryEngine.Instance.CalculateNonSimpleZs(polyline, 0) as Polyline;
    
      // polylineNoNaNZs.Points[1].HasZ = true
      // polylineNoNaNZs.Points[1].Z = 25  (halfway between 0 and 50)
      // polylineNoNaNZs.Points[4].HasZ = true
      // polylineNoNaNZs.Points[4].Z = 38  (halfway between 76 and 0)
    }
    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
    }
    Set all Zs in a polyline
    {
      List<Coordinate3D> coordsZ =
      [
        new Coordinate3D(1, 2, 3),
      new Coordinate3D(4, 5, 6),
      new Coordinate3D(7, 8, double.NaN)
      ];
    
      polyline = PolylineBuilderEx.CreatePolyline(coordsZ);
      // polyline.HasZ = true
    
      Polyline polylineSetZ = GeometryEngine.Instance.SetConstantZ(polyline, -1) as Polyline;
      // polylineSetZ.Points[0].Z = -1
      // polylineSetZ.Points[1].Z = -1
      // polylineSetZ.Points[2].Z = -1
    
      polylineSetZ = GeometryEngine.Instance.SetConstantZ(polyline, double.NaN) as Polyline;
      // polyline.HasZ = true
      // polylineSetZ.Points[0].HasZ = true
      // polylineSetZ.Points[0].Z = NaN
      // polylineSetZ.Points[1].HasZ = true
      // polylineSetZ.Points[1].Z = NaN
      // polylineSetZ.Points[2].HasZ = true
      // polylineSetZ.Points[2].Z = NaN
    
      polylineSetZ = GeometryEngine.Instance.SetConstantZ(polyline, double.PositiveInfinity) as Polyline;
      // polyline.HasZ = true
      // polylineSetZ.Points[0].HasZ = true
      // polylineSetZ.Points[0].Z = double.PositiveInfinity
      // polylineSetZ.Points[1].HasZ = true
      // polylineSetZ.Points[1].Z = double.PositiveInfinity
      // polylineSetZ.Points[2].HasZ = true
      // polylineSetZ.Points[2].Z = double.PositiveInfinity
    }
    SimplifyOGC
    {
      SpatialReference sr = SpatialReferences.WGS84;
    
      Coordinate2D[] coords = [new Coordinate2D(5, 10), new Coordinate2D(15, 20), new Coordinate2D(25, 10), new Coordinate2D(5, 20)];
      polyline = PolylineBuilderEx.CreatePolyline(coords, sr);
      // polyline.IsKnownSimpleOgc = false
      // polyline.IsKnownSimple = false
    
      bool isSimple = GeometryEngine.Instance.IsSimpleOgc(polyline, out NonSimpleReason nonSimpleReason, true);
      // isSimple = false
      // nonSimpleReason = NonSimpleReason.SelfIntersections
    
      Polyline simplePolyline = GeometryEngine.Instance.SimplifyOgc(polyline) as Polyline;
      // simplePolyline.IsKnownSimpleOgc = true
      // simplePolyline.IsKnownSimple = true
    
      double resolution = sr.XYResolution;
      Coordinate3D[] coords3D = [ new Coordinate3D(0, 0, 0), new Coordinate3D(0, 1.8 * resolution, 0.8 * sr.ZTolerance), new Coordinate3D(10, 10, 1),
    new Coordinate3D(0, 5, 1) ];
      polyline = PolylineBuilderEx.CreatePolyline(coords3D, sr);
    
      isSimple = GeometryEngine.Instance.IsSimpleOgc(polyline, out nonSimpleReason);
      // isSimple = false
      // nonSimpleReason = NonSimpleReason.ShortSegments
    
      simplePolyline = GeometryEngine.Instance.SimplifyOgc(polyline, true) as Polyline;
      // simplePolyline.IsKnownSimpleOgc = true
      // simplePolyline.IsKnownSimple = true
    
      coords = [new Coordinate2D(0, 0), new Coordinate2D(0, 0)];
      Multipoint multipoint = MultipointBuilderEx.CreateMultipoint(coords, sr);
    
      isSimple = GeometryEngine.Instance.IsSimpleOgc(multipoint, out nonSimpleReason);
      // isSimple = false
      // nonSimpleReason = NonSimpleReason.DuplicateVertex
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also