ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / PolylineBuilderEx Class / CreatePolyline Method / CreatePolyline(Segment,SpatialReference) Method
A segment to create the polyline.
(Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from segment.
Example

In This Topic
    CreatePolyline(Segment,SpatialReference) Method
    In This Topic
    Convenience method to create a new instance of the Polyline class.
    Syntax
    public static Polyline CreatePolyline( 
       Segment segment,
       SpatialReference spatialReference
    )
    Public Overloads Shared Function CreatePolyline( _
       ByVal segment As Segment, _
       Optional ByVal spatialReference As SpatialReference _
    ) As Polyline

    Parameters

    segment
    A segment to create the polyline.
    spatialReference
    (Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from segment.

    Return Value

    Exceptions
    ExceptionDescription
    segment is null.
    Remarks
    The newly created polyline inherits the HasZ, HasM, HasID attributes and the corresponding Z, M, ID values from the start and end points of the input segment.
    Example
    Construct a Polyline - from a Cubic Bezier
    {
      polyline = PolylineBuilderEx.CreatePolyline(bezierSegment);
    }
    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);
    }
    Clip a Polyline
    {
      // clip a polyline by an envelope
    
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(2.0, 2.0, 4.0, 4.0);
      LineSegment line = LineBuilderEx.CreateLineSegment(new Coordinate2D(0, 3), new Coordinate2D(5.0, 3.0));
      polyline = PolylineBuilderEx.CreatePolyline(line);
    
      Geometry clipGeom = GeometryEngine.Instance.Clip(polyline, env);
    }
    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);
    }
    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;
    }
    GeodeticDensifyByLength - polygon
    {
      List<Coordinate2D> coords =
      [
        new Coordinate2D(-80, 0),
    new Coordinate2D(-20, 60),
    new Coordinate2D(40, 20),
    new Coordinate2D(0, -20),
    new Coordinate2D(-80, 0)
      ];
    
      SpatialReference sr = SpatialReferences.WGS84;
    
      // create a polygon
      polygon = PolygonBuilderEx.CreatePolygon(coords, sr);
    
      // get the geodesic lengths of the polygon segments
      ReadOnlySegmentCollection segments = polygon.Parts[0];
      List<double> geoLengths = new(segments.Count);
      foreach (Segment s in segments)
      {
        Polyline line = PolylineBuilderEx.CreatePolyline(s, sr);
        double geoLen = GeometryEngine.Instance.GeodesicLength(line);
        geoLengths.Add(geoLen);
      }
    
      // find the max length
      geoLengths.Sort();
      double maxLen = geoLengths[^1];
    
      // densify the polygon (in meters)
      Polygon densifiedPoly = GeometryEngine.Instance.GeodeticDensifyByLength(polygon, maxLen, LinearUnit.Meters, GeodeticCurveType.Geodesic) as Polygon;
    
      // densify the polygon (in km)
      double maxSegmentLength = maxLen / 10000;
      densifiedPoly = GeometryEngine.Instance.GeodeticDensifyByLength(polygon, maxSegmentLength, LinearUnit.Kilometers, GeodeticCurveType.Geodesic) as Polygon;
    }
    Determine Length, Length3D of line
    {
      MapPoint c1 = MapPointBuilderEx.CreateMapPoint(1, 2, 3);
      MapPoint c2 = MapPointBuilderEx.CreateMapPoint(4, 2, 4);
    
      // line segment
      LineSegment line = LineBuilderEx.CreateLineSegment(c1, c2);
      double len = line.Length;     // = 3
      double len3D = line.Length3D;   // = Math.Sqrt(10)
    
      // polyline
      Polyline p = PolylineBuilderEx.CreatePolyline(line);
      double p_len = p.Length;        // = len = 3
      double p_len3D = p.Length3D;    // = len3D = Math.Sqrt(10)
    
      double ge_len = GeometryEngine.Instance.Length(p);      // = p_len = len = 3
      double ge_len3d = GeometryEngine.Instance.Length3D(p);    // = p_len3D = len3D = Math.Sqrt(10)
    }
    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
    }
    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;
      }
    QueryPoint
    {
      SpatialReference sr = SpatialReferences.WGS84;
    
      // Horizontal line segment
      Coordinate2D start = new(1, 1);
      Coordinate2D end = new(11, 1);
      LineSegment line = LineBuilderEx.CreateLineSegment(start, end, sr);
    
      polyline = PolylineBuilderEx.CreatePolyline(line);
    
      // Don't extend the segment
    
      MapPoint outPoint = GeometryEngine.Instance.QueryPoint(polyline, SegmentExtensionType.NoExtension, 1.0, AsRatioOrLength.AsLength);
      // outPoint = (2, 1)
    
      // or the segment
      MapPoint outPoint_seg = GeometryEngine.Instance.QueryPoint(line, SegmentExtensionType.NoExtension, 1.0, AsRatioOrLength.AsLength);
      // outPoint_seg = (2, 1)
    
      // Extend infinitely in both directions
      outPoint = GeometryEngine.Instance.QueryPoint(polyline, SegmentExtensionType.ExtendTangents, 1.5, AsRatioOrLength.AsRatio);
      // outPoint = (16, 1)
      outPoint_seg = GeometryEngine.Instance.QueryPoint(line, SegmentExtensionType.ExtendTangents, 1.5, AsRatioOrLength.AsRatio);
      // outPoint_seg = (16, 1)
    }
    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
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also