ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / EllipticArcBuilderEx Class / ToSegment Method
Example

In This Topic
    ToSegment Method (EllipticArcBuilderEx)
    In This Topic
    Returns an EllipticArcSegment instance representing the current state of the builder.
    Syntax
    public new EllipticArcSegment ToSegment()
    Public Shadows Function ToSegment() As EllipticArcSegment

    Return Value

    An EllipticArc segment.
    Example
    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, angle and radius
    {
      // Construct a circular arc with center point at (0, 0), from angle = 0,
      // central angle = pi/2, radius = 1.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      SpatialReference sr4326 = SpatialReferences.WGS84;
      Coordinate2D centerPt = new Coordinate2D(0, 0);
      double fromAngle = 0;
      double centralAngle = Math.PI / 2;
      double radius = 1;
    
      // BuilderEx convenience methods don't need to run on the MCT.
      EllipticArcSegment circularArcBuilder = EllipticArcBuilderEx.CreateCircularArc(fromAngle, centralAngle, centerPt, radius, sr4326);
    
      // BuilderEx constructors don't need to run on the MCT.
      EllipticArcBuilderEx ellipticArcBuilderEx = new EllipticArcBuilderEx(fromAngle, centralAngle, centerPt, radius, sr4326);
      ellipticArcSegment = ellipticArcBuilderEx.ToSegment();
    }
    Construct an Elliptic Arc - using a center point and rotation angle
    {
      // Construct an elliptic arc centered at (1,1), startAngle = 0, centralAngle = PI/2,
      // rotationAngle = 0, semiMajorAxis = 1, minorMajorRatio = 0.5.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      Coordinate2D centerPt = new Coordinate2D(1, 1);
    
      // BuilderEx convenience methods don't need to run on the MCT.
      ellipticArcSegment = EllipticArcBuilderEx.CreateEllipticArcSegment(centerPt, 0, Math.PI / 2, 0, 1, 0.5);
    
      double semiMajor;
      double semiMinor;
      ellipticArcSegment.GetAxes(out semiMajor, out semiMinor);
      // semiMajor = 1, semiMinor = 0.5
    
      // BuilderEx constructors don't need to run on the MCT.
      EllipticArcBuilderEx ellipticArcBuilderEx = new EllipticArcBuilderEx(centerPt, 0, Math.PI / 2, 0, 1, 0.5);
      ellipticArcBuilderEx.GetAxes(out semiMajor, out semiMinor);
      EllipticArcSegment arcSegment = 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 a Circular Arc - using two segments and radius
    {
      // Construct a segment from (100, 100) to (50, 50) and another segment from (100, 100) to (150, 50).
      // Use a builderEx convenience method or use a builderEx constructor.
    
      LineSegment segment1 = LineBuilderEx.CreateLineSegment(new Coordinate2D(100, 100), new Coordinate2D(50, 50));
      LineSegment segment2 = LineBuilderEx.CreateLineSegment(new Coordinate2D(100, 100), new Coordinate2D(150, 50));
    
      // Construct the hint point to determine where the arc will be constructed.
      Coordinate2D hintPoint = new Coordinate2D(100, 75);
    
      // Call QueryFilletRadius to get the minimum and maximum radii that can be used with these segments.
      var minMaxRadii = EllipticArcBuilderEx.QueryFilletRadiusRange(segment1, segment2, hintPoint);
    
      // Use the maximum radius to create the arc.
      double maxRadius = minMaxRadii.Item2;
    
      // BuilderEx convenience methods don't need to run on the MCT.
      //At 2.x - EllipticArcSegment circularArc = EllipticArcBuilderEx.CreateEllipticArcSegment(segment1, segment2, maxRadius, hintPoint);
      EllipticArcSegment circularArc = EllipticArcBuilderEx.CreateCircularArc(
                          segment1, segment2, maxRadius, hintPoint);
    
      // This EllipticArcBuilderEx constructor needs to run on the MCT either.
      EllipticArcBuilderEx cab = new EllipticArcBuilderEx(segment1, segment2, maxRadius, hintPoint);
      EllipticArcSegment otherCircularArc = cab.ToSegment();
    }
    Construct a Circle
    {
      // Construct a circle with center at (-1,-1), radius = 2, and oriented clockwise.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      Coordinate2D centerPtCoord = new Coordinate2D(-1, -1);
    
      // Builder convenience methods don't need to run on the MCT.
      EllipticArcSegment circle = EllipticArcBuilderEx.CreateCircle(centerPtCoord, 2, ArcOrientation.ArcClockwise);
      // circle.IsCircular = true
      // circle.IsCounterClockwise = false
      // circle.IsMinor = false
    
      double startAngle, rotationAngle, centralAngle, semiMajor, semiMinor;
      Coordinate2D actualCenterPt;
      circle.QueryCoords(out actualCenterPt, out startAngle, out centralAngle, out rotationAngle, out semiMajor, out semiMinor);
    
      // semiMajor = 2.0
      // semiMinor = 2.0
      // startAngle = PI/2
      // centralAngle = -2*PI
      // rotationAngle = 0
      // endAngle = PI/2
    
      // This EllipticArcBuilderEx constructor doesn't need to run on the MCT.
      EllipticArcBuilderEx builder = new EllipticArcBuilderEx(centerPtCoord, 2, ArcOrientation.ArcClockwise);
      EllipticArcSegment otherCircle = builder.ToSegment();
    }
    Construct an Ellipse
    {
      // Construct an ellipse centered at (1, 2) with rotationAngle = -pi/6,
      // semiMajorAxis = 5, minorMajorRatio = 0.2, oriented clockwise.
      // Use a builderEx convenience method or use a builderEx constructor.
    
      Coordinate2D centerPt = new Coordinate2D(1, 2);
    
      // BuilderEx convenience methods don't need to run on the MCT.
      EllipticArcSegment ellipse = EllipticArcBuilderEx.CreateEllipse(centerPt, -1 * Math.PI / 6, 5, 0.2, ArcOrientation.ArcClockwise);
    
      // This EllipticArcBuilderEx constructor doesn't need to run on the MCT.
      EllipticArcBuilderEx builder = new EllipticArcBuilderEx(centerPt, -1 * Math.PI / 6, 5, 0.2, ArcOrientation.ArcClockwise);
      EllipticArcSegment anotherEllipse = builder.ToSegment();
    }
    Create Circle Text Element
    {
      await QueuedTask.Run(() =>
      {
      //Build geometry
      Coordinate2D center = new Coordinate2D(4.5, 4);
      var eabCir = new EllipticArcBuilderEx(center, 0.5, ArcOrientation.ArcClockwise);
      var cir = eabCir.ToSegment();
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(cir, AttributeFlags.AllAttributes));
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                      ColorFactory.Instance.GreenRGB, 10, "Arial", "Regular");
      string text = "Circle, circle, circle";
    
      GraphicElement cirTxtElm = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.CircleParagraph, poly, sym, text, "New Circle Text", false);
      });
    }
    Create Ellipse Text Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D center = new Coordinate2D(4.5, 2.75);
      var eabElp = new EllipticArcBuilderEx(center, 0, 1, 0.45, ArcOrientation.ArcClockwise);
      var ellipse = eabElp.ToSegment();
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(ellipse, AttributeFlags.AllAttributes));
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                            ColorFactory.Instance.BlueRGB, 10, "Arial", "Regular");
      string text = "Ellipse, ellipse, ellipse";
    
      GraphicElement ge = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PolygonParagraph, poly, sym, text, "New Ellipse Text", false);
      });
    }
    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;
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also