Return Value
A Polyline.
{
// 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);
}
{
var polylineBuilder = new PolylineBuilderEx(polyline);
polylineBuilder.ReverseOrientation();
Polyline reversedPolyline = polylineBuilder.ToGeometry();
}
{
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
}
{
// 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
}
{
PolylineBuilderEx polylineBuilder = new PolylineBuilderEx(polyline);
polylineBuilder.HasZ = true;
// The HasZ property is set to true for all the points in
// polyline3D when you call ToGeometry().
Polyline polyline3D = polylineBuilder.ToGeometry();
// For this example, create Z-values.
// You may want to pass them in as a parameter.
int numPoints = polyline3D.PointCount;
double[] zValues = new double[numPoints];
for (int i = 0; i < numPoints; i++)
{
zValues[i] = i % 2 == 0 ? 2 : 1;
}
// We need to know at which point index each part starts
int partPointIndex = 0;
int numParts = polyline3D.PartCount;
for (int i = 0; i < numParts; i++)
{
var part = polyline3D.Parts[i];
int numSegmentsInPolyline3D = part.Count;
for (int j = 0; j < numSegmentsInPolyline3D; j++)
{
Segment segment = part[j];
MapPointBuilderEx pointBuilder = new MapPointBuilderEx(segment.StartPoint);
pointBuilder.Z = zValues[partPointIndex++];
MapPoint startPoint = pointBuilder.ToGeometry();
// Make sure that the end point of this segment is the same as the start point of the next segment
pointBuilder = new MapPointBuilderEx(segment.EndPoint);
pointBuilder.Z = zValues[partPointIndex];
MapPoint endPoint = pointBuilder.ToGeometry();
SegmentType segmentType = segment.SegmentType;
SegmentBuilderEx segmentBuilder = null;
switch (segmentType)
{
case SegmentType.Line:
segmentBuilder = new LineBuilderEx((LineSegment)segment);
break;
case SegmentType.Bezier:
segmentBuilder = new CubicBezierBuilderEx((CubicBezierSegment)segment);
break;
case SegmentType.EllipticArc:
segmentBuilder = new EllipticArcBuilderEx((EllipticArcSegment)segment);
break;
}
// Only change the start and end point which now have Z-values set.
// This will preserve the curve if the segment is an EllipticArcSegment or CubicBezierSegment.
segmentBuilder.StartPoint = startPoint;
segmentBuilder.EndPoint = endPoint;
segment = segmentBuilder.ToSegment();
polylineBuilder.ReplaceSegment(i, j, segment);
}
// Move point index for the next part
partPointIndex++;
}
polyline3D = polylineBuilder.ToGeometry();
}
{
Coordinate2D[] coords = [new Coordinate2D(-2, 2), new Coordinate2D(3, 5), new Coordinate2D(7, 2)];
polyline = PolylineBuilderEx.CreatePolyline(coords); // polyline.HasM = false
bool isMSimple = GeometryEngine.Instance.IsMSimple(polyline); // isMSimple = false
PolylineBuilderEx polylineBuilder = new(polyline)
{
HasM = true
};
polyline = polylineBuilder.ToGeometry();
isMSimple = GeometryEngine.Instance.IsMSimple(polyline); // isMSimple = false
MapPoint point1 = MapPointBuilderEx.CreateMapPoint(-2, 2, -1, 1);
MapPoint point2 = MapPointBuilderEx.CreateMapPoint(3, 5, -2, 2);
MapPoint[] points = [point1, point2];
polyline = PolylineBuilderEx.CreatePolyline(points, AttributeFlags.HasM);
isMSimple = GeometryEngine.Instance.IsMSimple(polyline); // isMSimple = true
}
Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)