public void CreateMultiPointGraphics()
{
var graphicsLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <ArcGIS.Desktop.Mapping.GraphicsLayer>().FirstOrDefault();
if (graphicsLayer == null)
{
return;
}
QueuedTask.Run(() =>
{
#region Multi-point Graphic Element using CIMGraphic
//On the QueuedTask
//Place a multipoint graphic using the mapview extent geometry
var extent = MapView.Active.Extent;
//Contract the extent
var polygonEnv = extent.Expand(-100000, -90000, false);
//create a polygon using the envelope
var polygon = PolygonBuilder.CreatePolygon(polygonEnv);
//Create MultipPoints from the polygon
var multiPoints = MultipointBuilder.CreateMultipoint(polygon);
//specify a symbol
var point_symbol = SymbolFactory.Instance.ConstructPointSymbol(
ColorFactory.Instance.GreenRGB);
//create a CIMGraphic
var graphic = new CIMMultipointGraphic
{
Symbol = point_symbol.MakeSymbolReference(),
Multipoint = multiPoints
};
graphicsLayer.AddElement(graphic);
#endregion
});
}
public static ArcGIS.Core.Geometry.Geometry ToScreenGeometry(
MapView mapView, Polygon mapGeometry)
{
// TODO: ensure single-part, linear segments
var screenPoints = new List <Coordinate2D>();
if (mapGeometry.Extent.Width > 0 || mapGeometry.Extent.Height > 0)
{
foreach (var mapPoint in mapGeometry.Points)
{
var screenVertex = mapView.MapToScreen(mapPoint);
screenPoints.Add(new Coordinate2D(screenVertex.X, screenVertex.Y));
}
return(PolygonBuilder.CreatePolygon(screenPoints, mapView.Camera.SpatialReference));
}
// The screen is probably the entire screen
var screenPoint = mapView.MapToScreen(mapGeometry.Extent.Center);
// The client is probably the relevant map canvas, these coords seem to correspond
// with the tool's mouse coordinates in SketchOutputMode.Screen!?!
var clientPoint = mapView.ScreenToClient(screenPoint);
return(MapPointBuilder.CreateMapPoint(new Coordinate2D(clientPoint.X, clientPoint.Y)));
}
public void MoveGraphicElements()
{
var graphicsLayer = MapView.Active.Map.GetLayersAsFlattenedList()
.OfType <ArcGIS.Desktop.Mapping.GraphicsLayer>().FirstOrDefault();
QueuedTask.Run(() => {
#region Move Graphic Elements
//Each selected element will move to a set distance to the upper right.
var selElements = graphicsLayer.GetSelectedElements();
if (selElements.Count == 0)
{
return;
}
//Move the element up
foreach (var selElement in selElements)
{
//Get the element's bounds
var elementPoly = PolygonBuilder.CreatePolygon(selElement.GetBounds());
//get the coordinates of the element bounding envelope.
var pointsList = elementPoly.Copy2DCoordinatesToList();
//Move the element's Anchor point to the upper right.
selElement.SetAnchorPoint(pointsList[1]);
}
#endregion
});
}
public void setPolygon()
{
QueuedTask.Run(() =>
{
var sr = SpatialReferenceBuilder.CreateSpatialReference(4326);
polygon = PolygonBuilder.CreatePolygon(footprintVertices, sr).Clone();
});
}
public static Polygon CreatePolygon(Envelope envelope, SpatialReference sref = null)
{
if (envelope == null)
{
return(null);
}
return(PolygonBuilder.CreatePolygon(envelope, sref));
}
private Task OnBeforeSketchCompletedEvent(BeforeSketchCompletedEventArgs arg)
{
//replace curved sketch segments with straight segments
//return if sketch geometry is not polygon or polyline
if (!(arg.Sketch.GeometryType == GeometryType.Polyline || arg.Sketch.GeometryType == GeometryType.Polygon))
{
return(Task.CompletedTask);
}
var sketchMP = arg.Sketch as Multipart;
//if the sketch doesnt have curves then return
if (!sketchMP.HasCurves)
{
return(Task.CompletedTask);
}
//itterate through each sketch part
var newParts = new List <List <Segment> >();
foreach (var sketchPart in sketchMP.Parts)
{
//itterate through each sketch segment
var newSegments = new List <Segment>();
foreach (var sketchSegment in sketchPart)
{
if (sketchSegment.IsCurve)
{
newSegments.Add(LineBuilder.CreateLineSegment(sketchSegment.StartPoint, sketchSegment.EndPoint));
}
else
{
newSegments.Add(sketchSegment);
}
}
newParts.Add(newSegments);
}
//create the new sketch geometry based on sketch type and set back on the sketch
if (arg.Sketch.GeometryType == GeometryType.Polyline)
{
var polyline = PolylineBuilder.CreatePolyline(newParts);
arg.SetSketchGeometry(polyline);
}
else
{
var polygon = PolygonBuilder.CreatePolygon(newParts);
arg.SetSketchGeometry(polygon);
}
return(Task.CompletedTask);
}
public Polygon ClosePolygon()
{
Polygon polygon = PolygonBuilder.CreatePolygon(_points);
// todo daro: remove when equality is assured
// CreatePolygon() should close the polygon. Simplify it to check equality
Geometry simplifiedGeometry = GeometryEngine.Instance.SimplifyAsFeature(polygon);
Assert.True(simplifiedGeometry.IsEqual(polygon));
return(polygon);
}
protected async void CreateNewRecord()
{
#region Create a new record
await QueuedTask.Run(async() =>
{
Dictionary <string, object> RecordAttributes = new Dictionary <string, object>();
var layers = MapView.Active.Map.GetLayersAsFlattenedList();
var recordsLayer = layers.FirstOrDefault(l => l.Name == "Records" && l is FeatureLayer);
var myParcelFabricLayer = layers.FirstOrDefault(l => l is ParcelLayer) as ParcelLayer;
var spatRef = recordsLayer.Map.SpatialReference;
var editOper = new EditOperation()
{
Name = "Create Parcel Fabric Record",
ProgressMessage = "Create Parcel Fabric Record...",
ShowModalMessageAfterFailure = true,
SelectNewFeatures = false,
SelectModifiedFeatures = false
};
string sNewRecordName = "myNewRecord";
Polygon newPolygon = null;
newPolygon = PolygonBuilder.CreatePolygon(spatRef);
if (newPolygon != null)
{
RecordAttributes.Add("Name", sNewRecordName);
var editRowToken = editOper.CreateEx(recordsLayer, newPolygon, RecordAttributes);
RecordAttributes.Clear();
if (!await editOper.ExecuteAsync())
{
return;
}
//Default Guid
var defGuid = new Guid("dddddddd-dddd-dddd-dddd-dddddddddddd");
var defOID = -1;
var guid = editRowToken.GlobalID.HasValue ? editRowToken.GlobalID.Value : defGuid;
var lOid = editRowToken.ObjectID.HasValue ? editRowToken.ObjectID.Value : defOID;
if (guid == defGuid | lOid == defOID)
{
return;
}
ParcelRecord parcelRecord = new ParcelRecord(myParcelFabricLayer.Map, sNewRecordName, guid, lOid);
await myParcelFabricLayer.SetActiveRecord(parcelRecord);
}
});
#endregion
}
private async void OnUndoButtonClicked(object sender, RoutedEventArgs e)
{
MeasurementPoint measurementPoint = GetMeasurementPoint();
Measurement measurement = measurementPoint.Measurement;
if (measurement.IsPointMeasurement)
{
measurementPoint.RemoveMe();
if (measurement.ObjectId == null)
{
measurement.AddMeasurementPoint();
}
else
{
measurement.CreateMeasurementPoint(measurementPoint.LastPoint);
}
}
else
{
MapView mapView = MapView.Active;
Geometry geometry = await mapView.GetCurrentSketchAsync();
List <MapPoint> points = await measurement.ToPointCollectionAsync(geometry);
int removePoints = measurement.IsGeometryType(GeometryType.Polygon) && points.Count == 2 &&
measurement.PointNr == 1 ? 2 : 1;
for (int i = 0; i < removePoints; i++)
{
int substract = (measurement.IsGeometryType(GeometryType.Polygon) && (removePoints == 1)) ? 2 : 1;
points.RemoveAt(points.Count - substract);
}
await QueuedTask.Run(() =>
{
if (measurement.IsGeometryType(GeometryType.Polygon))
{
geometry = PolygonBuilder.CreatePolygon(points);
}
else if (measurement.IsGeometryType(GeometryType.Polyline))
{
geometry = PolylineBuilder.CreatePolyline(points);
}
});
await mapView.SetCurrentSketchAsync(geometry);
}
}
protected override void OnClick()
{
QueuedTask.Run(() => {
//Get all the graphics layers in the map
var allGraphicsLayers = MapView.Active?.Map?.GetLayersAsFlattenedList().OfType <GraphicsLayer>();
if (allGraphicsLayers.Count() == 0)
{
return;
}
//Get the geometry of the map's extent
var geometry = PolygonBuilder.CreatePolygon(MapView.Active.Extent);
//Keep adding the elements to the selection
MapView.Active.SelectElements(geometry, SelectionCombinationMethod.Add);
});
}
public static Polygon GetShipPolygon()
{
MapPoint pt1 = MapPointBuilder.CreateMapPoint(0, 2.0);
MapPoint pt2 = MapPointBuilder.CreateMapPoint(1.0, 1.0);
MapPoint pt3 = MapPointBuilder.CreateMapPoint(1.0, -2.0);
MapPoint pt4 = MapPointBuilder.CreateMapPoint(-1.0, -2.0);
MapPoint pt5 = MapPointBuilder.CreateMapPoint(-1.0, 1.0);
List <MapPoint> list = new List <MapPoint>()
{
pt1, pt2, pt3, pt4, pt5
};
Polygon polygon = PolygonBuilder.CreatePolygon(list);
return(polygon);
}
/// <summary>
/// Copy the elements to an offset location
/// </summary>
/// <param name="graphicsLayer"></param>
/// <param name="elements"></param>
internal static void CustomCopyElements(this GraphicsLayer graphicsLayer, IEnumerable <Element> elements)
{
if (elements.Count() == 0)
{
return;
}
//Copy the elements.
var copyElements = graphicsLayer.CopyElements(elements);
//Iterate through the elements to move the anchor point for the copy.
foreach (var element in copyElements)
{
var elementPoly = PolygonBuilder.CreatePolygon(element.GetBounds());
var pointsList = elementPoly.Copy2DCoordinatesToList();
element.SetAnchorPoint(pointsList[1]);
}
}
private Polygon CreatePolygon(IWorkItem item)
{
Envelope extent = item.Extent;
if (UseExtent(item))
{
return(PolygonBuilder.CreatePolygon(extent, extent.SpatialReference));
}
item.QueryPoints(out double xmin, out double ymin,
out double xmax, out double ymax,
out double zmax);
return(PolygonBuilder.CreatePolygon(EnvelopeBuilder.CreateEnvelope(
new Coordinate3D(xmin, ymin, zmax),
new Coordinate3D(xmax, ymax, zmax),
extent.SpatialReference)));
}
private static IList <ArcGIS.Core.Geometry.Geometry> GetSearchGeometries(
[NotNull] ICollection <Feature> features,
[CanBeNull] Envelope clipExtent)
{
var result = new List <ArcGIS.Core.Geometry.Geometry>(features.Count);
foreach (var geometry in GdbObjectUtils.GetGeometries(features))
{
if (clipExtent != null)
{
clipExtent =
GeometryUtils.EnsureSpatialReference(clipExtent, geometry.SpatialReference);
if (GeometryUtils.Disjoint(geometry, clipExtent))
{
continue;
}
}
var multiPatch = geometry as Multipatch;
// multipatches are not supported by ISpatialFilter (and neither are bags containing them)
var polycurve = multiPatch != null
? PolygonBuilder.CreatePolygon(
multiPatch
.Extent) // GeometryFactory.CreatePolygon(multiPatch)
: geometry as Multipart;
if (polycurve != null)
{
// clipping is an optimization to pull less features from the db
result.Add(clipExtent == null
? polycurve
: GetClippedGeometry(polycurve, clipExtent));
}
else
{
// don't clip points etc.
result.Add(geometry);
}
}
return(result);
}
private Task <ArcGIS.Core.Geometry.Geometry> createGeometryFromJson(string json)
{
return(QueuedTask.Run(() =>
{
ArcGIS.Core.Geometry.Geometry retGeom = null;
//{"xmin":1,"ymin":2,"xmax":3,"ymax":4,"spatialReference":{"wkid":4326}}
try
{
retGeom = GeometryEngine.Instance.ImportFromJSON(JSONImportFlags.jsonImportDefaults, json);
switch (retGeom.GeometryType)
{
case GeometryType.Polygon:
break;
case GeometryType.Envelope:
retGeom = PolygonBuilder.CreatePolygon(retGeom as Envelope);
break;
case GeometryType.Point:
retGeom = MapPointBuilder.CreateMapPoint(retGeom as MapPoint);
break;
case GeometryType.Multipoint:
retGeom = MultipointBuilder.CreateMultipoint(retGeom as Multipoint);
break;
case GeometryType.Polyline:
retGeom = PolylineBuilder.CreatePolyline(retGeom as Polyline);
break;
default:
retGeom = null;
break;
}
}
catch
{
this.message = "I can't create a geometry...";
}
return retGeom;
}));
}
//public int AreaCoverage { get; set; }
public async Task setAreaCoverageAsync(Geometry queryGeom)
{
var vertices = new List <Coordinate2D>();
object[][][] geom = geometry.coordinates;
object[][] coords = geom[0];
try
{
// Create a list of coordinates describing the polygon vertices.
for (int i = 0; i < coords.Length; i++)
{
object[] xy = coords[i];
object x = xy[0];
object y = xy[1];
double _x = Convert.ToDouble(x);
double _y = Convert.ToDouble(y);
vertices.Add(new Coordinate2D(_x, _y));
}
await QueuedTask.Run(() =>
{
var sr = SpatialReferenceBuilder.CreateSpatialReference(4326);
Geometry spurcepolygon = PolygonBuilder.CreatePolygon(vertices, sr).Clone();
Polygon interse = (Polygon)GeometryEngine.Instance.Intersection(queryGeom, spurcepolygon);
//if (interse.Parts.Count > 1)
//{
// IDisposable _graphic = null;
// IDisposable _graph2 = null;
// CIMPolygonSymbol _polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.BlackRGB, SimpleFillStyle.Cross, SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 1.0, SimpleLineStyle.Solid));
// _graphic = MapView.Active.AddOverlay(interse, _polygonSymbol.MakeSymbolReference());
// _graphic = MapView.Active.AddOverlay(interse, _polygonSymbol.MakeSymbolReference());
//}
Polygon source = (Polygon)queryGeom;
AreaCover = Math.Round((interse.Area / source.Area) * 100, 1, MidpointRounding.AwayFromZero);
});
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public static Polygon CreateBezierCircle(double radius = 1, MapPoint center = null)
{
// Approximate a full circle with Bezier curves. (We could use
// EllipticArc segments, of course, but in the context of markers,
// Béziers are more appropriate.) It is customary to use four cubic
// Bézier curves, one for each quadrant. The control points must be
// on tangential lines to ensure continuity, their distance from
// the axes is chosen for minimal deviation from a true circle.
// See: https://spencermortensen.com/articles/bezier-circle/
const double magic = 0.551915; // for best circle approximation
double cx = 0, cy = 0;
if (center != null)
{
cx = center.X;
cy = center.Y;
}
var p0 = new Coordinate2D(radius, 0).Shifted(cx, cy);
var p01 = new Coordinate2D(radius, magic * radius).Shifted(cx, cy);
var p10 = new Coordinate2D(magic * radius, radius).Shifted(cx, cy);
var p1 = new Coordinate2D(0, radius).Shifted(cx, cy);
var p12 = new Coordinate2D(-magic * radius, radius).Shifted(cx, cy);
var p21 = new Coordinate2D(-radius, magic * radius).Shifted(cx, cy);
var p2 = new Coordinate2D(-radius, 0).Shifted(cx, cy);
var p23 = new Coordinate2D(-radius, -magic * radius).Shifted(cx, cy);
var p32 = new Coordinate2D(-magic * radius, -radius).Shifted(cx, cy);
var p3 = new Coordinate2D(0, -radius).Shifted(cx, cy);
var p30 = new Coordinate2D(magic * radius, -radius).Shifted(cx, cy);
var p03 = new Coordinate2D(radius, -magic * radius).Shifted(cx, cy);
// segments for each quadrant
var q1 = CubicBezierBuilder.CreateCubicBezierSegment(p0, p01, p10, p1);
var q2 = CubicBezierBuilder.CreateCubicBezierSegment(p1, p12, p21, p2);
var q3 = CubicBezierBuilder.CreateCubicBezierSegment(p2, p23, p32, p3);
var q4 = CubicBezierBuilder.CreateCubicBezierSegment(p3, p30, p03, p0);
var segments = new[] { q1, q2, q3, q4 };
return(PolygonBuilder.CreatePolygon(segments));
}
private Geometry Buffer(Geometry geom, esriGeometryType shapeType, double margin,
MaskKind maskKind, bool isAnno = false)
{
var poly_outline = geom as Polygon;
if (poly_outline.HasCurves)
{
poly_outline =
GeometryEngine.Instance.DensifyByDeviation(geom, 0.1 * margin) as Polygon;
}
if (margin > 0.0)
{
if (maskKind == MaskKind.Box || maskKind == MaskKind.ConvexHull)
{
//strip out interior polygons
var ext_poly = PolygonBuilder.CreatePolygon(poly_outline.GetExteriorRings(true));
var joins = maskKind == MaskKind.Box ?
LineJoinType.Miter : LineJoinType.Bevel;
var buff_out = GeometryEngine.Instance.GraphicBuffer(ext_poly, margin, joins,
LineCapType.Butt, 4, 0.05 * margin, 64);
poly_outline = GeometryEngine.Instance.Generalize(buff_out, 0.01 * margin) as Polygon;
}
else
{
var buff_out = GeometryEngine.Instance.Buffer(poly_outline, margin);
if (maskKind == MaskKind.ExactSimplified)
{
poly_outline = GeometryEngine.Instance.Generalize(buff_out, 0.05 * margin) as Polygon;
}
else
{
poly_outline = buff_out as Polygon;
}
}
}
//simplify if needed
//return GeometryEngine.Instance.SimplifyAsFeature(poly_outline);
return(poly_outline);
}
public static ArcGIS.Core.Geometry.Geometry ToMapGeometry(MapView mapView,
Polygon screenGeometry)
{
// TODO: ensure single-part, linear segments
if (screenGeometry.Extent.Width > 0 || screenGeometry.Extent.Height > 0)
{
var mapPoints = new List <MapPoint>();
foreach (var screenPoint in screenGeometry.Points)
{
var mapPoint = mapView.ScreenToMap(new Point(screenPoint.X, screenPoint.Y));
mapPoints.Add(mapPoint);
}
return(PolygonBuilder.CreatePolygon(mapPoints, mapView.Camera.SpatialReference));
}
return(mapView.ScreenToMap(new Point(screenGeometry.Extent.XMin,
screenGeometry.Extent.YMin)));
}
public void CodeExamples()
{
#region Example1
// methods need to run on the MCT
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
List <MapPoint> list = new List <MapPoint>();
MapPoint minPt = MapPointBuilder.CreateMapPoint(1.0, 1.0);
MapPoint maxPt = MapPointBuilder.CreateMapPoint(2.0, 2.0);
// create an envelope
Envelope env = EnvelopeBuilder.CreateEnvelope(minPt, maxPt);
// create a polygon from the envelope
using (PolygonBuilder polygonBuilder = new PolygonBuilder(env))
{
Polygon poly = polygonBuilder.ToGeometry();
}
});
#endregion Example1
#region Example2
// methods need to run on the MCT
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
List <MapPoint> list3D = new List <MapPoint>();
list3D.Add(MapPointBuilder.CreateMapPoint(1.0, 1.0, 1.0, 2.0));
list3D.Add(MapPointBuilder.CreateMapPoint(1.0, 2.0, 1.0, 2.0));
list3D.Add(MapPointBuilder.CreateMapPoint(2.0, 2.0, 1.0, 2.0));
list3D.Add(MapPointBuilder.CreateMapPoint(2.0, 1.0, 1.0, 2.0));
var polygon = PolygonBuilder.CreatePolygon(list3D);
});
#endregion Example2
}
/// <summary>
/// Called when the sketch finishes. This is where we will create the sketch operation and then execute it.
/// </summary>
/// <param name="geometry">The geometry created by the sketch.</param>
/// <returns>A Task returning a Boolean indicating if the sketch complete event was successfully handled.</returns>
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
if (CurrentTemplate == null || geometry == null)
{
return(Task.FromResult(false));
}
return(QueuedTask.Run(() =>
{
//build a circular arc
var cent = new Coordinate2D(geometry as MapPoint);
var circleEAB = EllipticArcBuilder.CreateEllipticArcSegment(cent, Radius, esriArcOrientation.esriArcClockwise, MapView.Active.Map.SpatialReference);
// find the source layer and determine whether polyline/polygon. Create the appropriate shape
var lyr = CurrentTemplate.Layer as BasicFeatureLayer;
Geometry circleGeom = null;
if (lyr.ShapeType == esriGeometryType.esriGeometryPolygon)
{
circleGeom = PolygonBuilder.CreatePolygon(new[] { circleEAB });
}
else
{
circleGeom = PolylineBuilder.CreatePolyline(circleEAB);
}
// Create an edit operation
var createOperation = new EditOperation();
createOperation.Name = string.Format("Create circular {0}", CurrentTemplate.Layer.Name);
createOperation.SelectNewFeatures = true;
// Queue feature creation
createOperation.Create(CurrentTemplate, circleGeom);
// Execute the operation
return createOperation.ExecuteAsync();
}));
}
public Task <bool> Select(MapView mapView, Envelope box)
{
if (mapView == null)
{
return(Task.FromResult(false));
}
_overlay?.Dispose();
if (box == null)
{
return(Task.FromResult(false));
}
;
return(QueuedTask.Run(() =>
{
var boxColor = ColorFactory.Instance.CreateRGBColor(Color.R, Color.G, Color.B);
var polygon = PolygonBuilder.CreatePolygon(box);
var symbol = SymbolFactory.Instance.ConstructPolygonSymbol(boxColor, SimpleFillStyle.Null, SymbolFactory.Instance.ConstructStroke(boxColor, LineWidth, SimpleLineStyle.Solid));
_overlay = mapView.AddOverlay(polygon, symbol.MakeSymbolReference());
return true;
}));
}
protected override void OnClick()
{
QueuedTask.Run(() =>
{
var allGraphicLayers = MapView.Active.Map.GetLayersAsFlattenedList().OfType <GraphicsLayer>();
foreach (var gl in allGraphicLayers)
{
var selElements = gl.GetSelectedElements();
if (selElements.Count == 0)
{
continue;
}
//Move the element up
foreach (var selElement in selElements)
{
var elementPoly = PolygonBuilder.CreatePolygon(selElement.GetBounds());
var pointsList = elementPoly.Copy2DCoordinatesToList();
selElement.SetAnchorPoint(pointsList[1]);
}
}
return(true);
});
}
/// <summary>
/// This method takes an input multi part geometry and breaks the parts into individual standalone geometries.
/// This method must be called on the MCT. Use QueuedTask.Run.
/// </summary>
/// <param name="inputGeometry">The geometry to be exploded into the individual parts.</param>
/// <returns>An enumeration of individual parts as standalone geometries. The type of geometry is maintained, i.e.
/// if the input geometry is of type Polyline then each geometry in the return is of type Polyline as well.
/// If the input geometry is of type Unknown then an empty list is returned.</returns>
/// <remarks>This method must be called on the MCT. Use QueuedTask.Run.</remarks>
public IEnumerable <Geometry> MultipartToSinglePart(Geometry inputGeometry)
{
// list holding the part(s) of the input geometry
List <Geometry> singleParts = new List <Geometry>();
// check if the input is a null pointer or if the geometry is empty
if (inputGeometry == null || inputGeometry.IsEmpty)
{
return(singleParts);
}
// based on the type of geometry, take the parts/points and add them individually into a list
switch (inputGeometry.GeometryType)
{
case GeometryType.Envelope:
singleParts.Add(inputGeometry.Clone() as Envelope);
break;
case GeometryType.Multipatch:
singleParts.Add(inputGeometry.Clone() as Multipatch);
break;
case GeometryType.Multipoint:
var multiPoint = inputGeometry as Multipoint;
foreach (var point in multiPoint.Points)
{
// add each point of collection as a standalone point into the list
singleParts.Add(point);
}
break;
case GeometryType.Point:
singleParts.Add(inputGeometry.Clone() as MapPoint);
break;
case GeometryType.Polygon:
var polygon = inputGeometry as Polygon;
foreach (var polygonPart in polygon.Parts)
{
// use the PolygonBuilder turning the segments into a standalone
// polygon instance
singleParts.Add(PolygonBuilder.CreatePolygon(polygonPart));
}
break;
case GeometryType.Polyline:
var polyline = inputGeometry as Polyline;
foreach (var polylinePart in polyline.Parts)
{
// use the PolylineBuilder turning the segments into a standalone
// polyline instance
singleParts.Add(PolylineBuilder.CreatePolyline(polylinePart));
}
break;
case GeometryType.Unknown:
break;
default:
break;
}
return(singleParts);
}
private Task <bool> createFunnyGarden(Geometry geometry)
{
if (geometry == null)
{
return(Task.FromResult(false));
}
// get the point layer from the active map
var pointLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>()
.Where(lyr => lyr.ShapeType == ArcGIS.Core.CIM.esriGeometryType.esriGeometryPoint).FirstOrDefault();
if (pointLayer == null)
{
return(Task.FromResult(false));
}
// get the polygon layer from the active map
var polygonLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>()
.Where(lyr => lyr.ShapeType == ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon).FirstOrDefault();
if (polygonLayer == null)
{
return(Task.FromResult(false));
}
// Create an edit operation
var createOperation = new EditOperation();
createOperation.Name = string.Format("Create green");
// we'll use the sketch geometry to create a spatial filter
SpatialQueryFilter spatialQueryFilter = new SpatialQueryFilter();
spatialQueryFilter.FilterGeometry = geometry;
spatialQueryFilter.SpatialRelationship = SpatialRelationship.Contains;
// retrieve the point features that are inside the sketch geometry
var searchCursor = pointLayer.Search(spatialQueryFilter);
// Construct a polygon placeholder for the point buffers
var treeBuffers = PolygonBuilder.CreatePolygon(geometry.SpatialReference);
// TODO
// 1. for each point geometry
// 2. buffer the geometry (Hint : use the MapView.Active.Extent.Width/50 as the buffer distance)
// 3. union this result with the existing treeBuffers
// 4. subtract the collection of buffers from the sketch geometry
// HINT: use the GeometryEngine to buffer, union and subtract (difference) the geometries
// Polygon greenGeometry = null;
// for each found feature
while (searchCursor.MoveNext())
{
// retrieve the geometry
var treeFeature = searchCursor.Current as Feature;
var treePoint = treeFeature.GetShape() as MapPoint;
// buffer the the location
var treeBuffer = GeometryEngine.Buffer(treePoint, MapView.Active.Extent.Width / 50);
// and union the new buffer to the existing buffer polygons
treeBuffers = GeometryEngine.Union(treeBuffer, treeBuffers) as Polygon;
}
// ensure the sketch geometry is simple
if (!GeometryEngine.IsSimpleAsFeature(geometry, true))
{
geometry = GeometryEngine.SimplifyAsFeature(geometry);
}
// construct the difference geometry between the sketch geometry and the buffered point polygons
var greenGeometry = GeometryEngine.Difference(geometry, treeBuffers);
// cue the create
createOperation.Create(polygonLayer, greenGeometry);
// execute the operation
return(createOperation.ExecuteAsync());
}
public void snippets_CreateLayoutElements()
{
LayoutView layoutView = LayoutView.Active;
Layout layout = layoutView.Layout;
#region Create point graphic with symbology
//Create a simple 2D point graphic and apply an existing point style item as the symbology.
//An alternative simple symbol is also provided below. This would completely elminate the 4 lines of code that reference a style.
QueuedTask.Run(() =>
{
//Build 2D point geometry
Coordinate2D coord2D = new Coordinate2D(2.0, 10.0);
//Reference a point symbol in a style
StyleProjectItem ptStylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
SymbolStyleItem ptSymStyleItm = ptStylePrjItm.SearchSymbols(StyleItemType.PointSymbol, "City Hall")[0];
CIMPointSymbol pointSym = ptSymStyleItm.Symbol as CIMPointSymbol;
pointSym.SetSize(50);
//Set symbolology, create and add element to layout
//CIMPointSymbol pointSym = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 25.0, SimpleMarkerStyle.Star); //Alternative simple symbol
GraphicElement ptElm = LayoutElementFactory.Instance.CreatePointGraphicElement(layout, coord2D, pointSym);
ptElm.SetName("New Point");
});
#endregion
#region Create line graphic with symbology
//Create a simple 2D line graphic and apply an existing line style item as the symbology.
//An alternative simple symbol is also provided below. This would completely elminate the 4 lines of code that reference a style.
QueuedTask.Run(() =>
{
//Build 2d line geometry
List <Coordinate2D> plCoords = new List <Coordinate2D>();
plCoords.Add(new Coordinate2D(1, 8.5));
plCoords.Add(new Coordinate2D(1.66, 9));
plCoords.Add(new Coordinate2D(2.33, 8.1));
plCoords.Add(new Coordinate2D(3, 8.5));
Polyline linePl = PolylineBuilder.CreatePolyline(plCoords);
//Reference a line symbol in a style
StyleProjectItem lnStylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
SymbolStyleItem lnSymStyleItm = lnStylePrjItm.SearchSymbols(StyleItemType.LineSymbol, "Line with 2 Markers")[0];
CIMLineSymbol lineSym = lnSymStyleItm.Symbol as CIMLineSymbol;
lineSym.SetSize(20);
//Set symbolology, create and add element to layout
//CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlueRGB, 4.0, SimpleLineStyle.Solid); //Alternative simple symbol
GraphicElement lineElm = LayoutElementFactory.Instance.CreateLineGraphicElement(layout, linePl, lineSym);
lineElm.SetName("New Line");
});
#endregion
#region Create rectangle graphic with simple symbology
//Create a simple 2D rectangle graphic and apply simple fill and outline symbols.
QueuedTask.Run(() =>
{
//Build 2D envelope geometry
Coordinate2D rec_ll = new Coordinate2D(1.0, 4.75);
Coordinate2D rec_ur = new Coordinate2D(3.0, 5.75);
Envelope rec_env = EnvelopeBuilder.CreateEnvelope(rec_ll, rec_ur);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 5.0, SimpleLineStyle.Solid);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.GreenRGB, SimpleFillStyle.DiagonalCross, outline);
GraphicElement recElm = LayoutElementFactory.Instance.CreateRectangleGraphicElement(layout, rec_env, polySym);
recElm.SetName("New Rectangle");
});
#endregion
#region Create text element with basic font properties
//Create a simple point text element and assign basic symbology as well as basic text settings.
QueuedTask.Run(() =>
{
//Build 2D point geometry
Coordinate2D coord2D = new Coordinate2D(3.5, 10);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.RedRGB, 32, "Arial", "Regular");
string textString = "Point text";
GraphicElement ptTxtElm = LayoutElementFactory.Instance.CreatePointTextGraphicElement(layout, coord2D, textString, sym);
ptTxtElm.SetName("New Point Text");
//Change additional text properties
ptTxtElm.SetAnchor(Anchor.CenterPoint);
ptTxtElm.SetX(4.5);
ptTxtElm.SetY(9.5);
ptTxtElm.SetRotation(45);
});
#endregion
#region Create rectangle text with more advanced symbol settings
//Create rectangle text with background and border symbology. Also notice how formatting tags are using within the text string.
QueuedTask.Run(() =>
{
//Build 2D polygon geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(3.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.1));
plyCoords.Add(new Coordinate2D(3.5, 6.1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
string text = "Some Text String that is really long and is <BOL>forced to wrap to other lines</BOL> so that we can see the effects." as String;
GraphicElement polyTxtElm = LayoutElementFactory.Instance.CreatePolygonParagraphGraphicElement(layout, poly, text, sym);
polyTxtElm.SetName("New Polygon Text");
//(Optionally) Modify paragraph border
CIMGraphic polyTxtGra = polyTxtElm.Graphic;
CIMParagraphTextGraphic cimPolyTxtGra = polyTxtGra as CIMParagraphTextGraphic;
cimPolyTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimPolyTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
polyTxtElm.SetGraphic(polyTxtGra);
});
#endregion
#region Create a new picture element with advanced symbol settings
//Create a picture element and also set background and border symbology.
QueuedTask.Run(() =>
{
//Build 2D envelope geometry
Coordinate2D pic_ll = new Coordinate2D(6, 1);
Coordinate2D pic_ur = new Coordinate2D(8, 2);
Envelope env = EnvelopeBuilder.CreateEnvelope(pic_ll, pic_ur);
//Create and add element to layout
string picPath = @"C:\Temp\WhitePass.jpg";
GraphicElement picElm = LayoutElementFactory.Instance.CreatePictureGraphicElement(layout, env, picPath);
picElm.SetName("New Picture");
//(Optionally) Modify the border and shadow
CIMGraphic picGra = picElm.Graphic;
CIMPictureGraphic cimPicGra = picGra as CIMPictureGraphic;
cimPicGra.Frame.BorderSymbol = new CIMSymbolReference();
cimPicGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.Solid);
cimPicGra.Frame.ShadowSymbol = new CIMSymbolReference();
cimPicGra.Frame.ShadowSymbol.Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.BlackRGB, SimpleFillStyle.Solid);
picElm.SetGraphic(picGra);
});
#endregion
#region Create a map frame and zoom to a bookmark
//Create a map frame and also sets its extent by zooming the the extent of an existing bookmark.
QueuedTask.Run(() =>
{
//Build 2D envelope geometry
Coordinate2D mf_ll = new Coordinate2D(6.0, 8.5);
Coordinate2D mf_ur = new Coordinate2D(8.0, 10.5);
Envelope mf_env = EnvelopeBuilder.CreateEnvelope(mf_ll, mf_ur);
//Reference map, create MF and add to layout
MapProjectItem mapPrjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map"));
Map mfMap = mapPrjItem.GetMap();
MapFrame mfElm = LayoutElementFactory.Instance.CreateMapFrame(layout, mf_env, mfMap);
mfElm.SetName("New Map Frame");
//Zoom to bookmark
Bookmark bookmark = mfElm.Map.GetBookmarks().FirstOrDefault(b => b.Name == "Great Lakes");
mfElm.SetCamera(bookmark);
});
#endregion
#region Create a legend for a specifc map frame
//Create a legend for an associated map frame.
QueuedTask.Run(() =>
{
//Build 2D envelope geometry
Coordinate2D leg_ll = new Coordinate2D(6, 2.5);
Coordinate2D leg_ur = new Coordinate2D(8, 4.5);
Envelope leg_env = EnvelopeBuilder.CreateEnvelope(leg_ll, leg_ur);
//Reference MF, create legend and add to layout
MapFrame mapFrame = layout.FindElement("New Map Frame") as MapFrame;
if (mapFrame == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Map frame not found", "WARNING");
return;
}
Legend legendElm = LayoutElementFactory.Instance.CreateLegend(layout, leg_env, mapFrame);
legendElm.SetName("New Legend");
});
#endregion
#region Creating group elements
//Create an empty group element at the root level of the contents pane
//Note: call within QueuedTask.Run()
GroupElement grp1 = LayoutElementFactory.Instance.CreateGroupElement(layout);
grp1.SetName("Group");
//Create a group element inside another group element
//Note: call within QueuedTask.Run()
GroupElement grp2 = LayoutElementFactory.Instance.CreateGroupElement(grp1);
grp2.SetName("Group in Group");
#endregion Creating group elements
{
#region Create scale bar
Coordinate2D llScalebar = new Coordinate2D(6, 2.5);
MapFrame mapframe = layout.FindElement("New Map Frame") as MapFrame;
//Note: call within QueuedTask.Run()
LayoutElementFactory.Instance.CreateScaleBar(layout, llScalebar, mapframe);
#endregion
}
#region How to search for scale bars in a style
var arcgis_2d = Project.Current.GetItems <StyleProjectItem>().First(si => si.Name == "ArcGIS 2D");
QueuedTask.Run(() => {
var scaleBarItems = arcgis_2d.SearchScaleBars("Double Alternating Scale Bar");
});
#endregion
#region How to add a scale bar from a style to a layout
var arcgis_2dStyle = Project.Current.GetItems <StyleProjectItem>().First(si => si.Name == "ArcGIS 2D");
QueuedTask.Run(() =>
{
//Imperial Double Alternating Scale Bar
//Metric Double Alternating Scale Bar
//or just use empty string to list them all...
var scaleBarItem = arcgis_2d.SearchScaleBars("Double Alternating Scale Bar").FirstOrDefault();
Coordinate2D coord2D = new Coordinate2D(10.0, 7.0);
MapFrame myMapFrame = layout.FindElement("Map Frame") as MapFrame;
LayoutElementFactory.Instance.CreateScaleBar(layout, coord2D, myMapFrame, scaleBarItem);
});
#endregion
#region Create NorthArrow
Coordinate2D llNorthArrow = new Coordinate2D(6, 2.5);
MapFrame mf = layout.FindElement("New Map Frame") as MapFrame;
//Note: call within QueuedTask.Run()
var northArrow = LayoutElementFactory.Instance.CreateNorthArrow(layout, llNorthArrow, mf);
#endregion
#region How to search for North Arrows in a style
var arcgis_2dStyles = Project.Current.GetItems <StyleProjectItem>().First(si => si.Name == "ArcGIS 2D");
QueuedTask.Run(() => {
var scaleBarItems = arcgis_2dStyles.SearchNorthArrows("ArcGIS North 13");
});
#endregion
#region How to add a North Arrow from a style to a layout
var arcgis2dStyles = Project.Current.GetItems <StyleProjectItem>().First(si => si.Name == "ArcGIS 2D");
QueuedTask.Run(() => {
var northArrowStyleItem = arcgis2dStyles.SearchNorthArrows("ArcGIS North 13").FirstOrDefault();
Coordinate2D nArrow = new Coordinate2D(6, 2.5);
MapFrame newFrame = layout.FindElement("New Map Frame") as MapFrame;
//Note: call within QueuedTask.Run()
var newNorthArrow = LayoutElementFactory.Instance.CreateNorthArrow(layout, nArrow, newFrame, northArrowStyleItem);
});
#endregion
#region Create dynamic text
var title = @"<dyn type = ""page"" property = ""name"" />";
Coordinate2D llTitle = new Coordinate2D(6, 2.5);
//Note: call within QueuedTask.Run()
var titleGraphics = LayoutElementFactory.Instance.CreatePointTextGraphicElement(layout, llTitle, null) as TextElement;
titleGraphics.SetTextProperties(new TextProperties(title, "Arial", 24, "Bold"));
#endregion
#region Create dynamic table
QueuedTask.Run(() =>
{
//Build 2D envelope geometry
Coordinate2D tab_ll = new Coordinate2D(6, 2.5);
Coordinate2D tab_ur = new Coordinate2D(12, 6.5);
Envelope tab_env = EnvelopeBuilder.CreateEnvelope(tab_ll, tab_ur);
MapFrame mapFrame = layout.FindElement("New Map Frame") as MapFrame;
// get the layer
MapProjectItem mapPrjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map"));
Map theMap = mapPrjItem?.GetMap();
var lyrs = theMap?.FindLayers("Inspection Point Layer", true);
if (lyrs?.Count > 0)
{
Layer lyr = lyrs[0];
var table1 = LayoutElementFactory.Instance.CreateTableFrame(layout, tab_env, mapFrame, lyr, new string[] { "No", "Type", "Description" });
}
});
#endregion
}
private async static void Visualize(BasicFeatureLayer dam3dLayer, BasicFeatureLayer reservoirVisLayer, BasicFeatureLayer reservoirSurfacesLayer, BasicFeatureLayer damLayer)
{
SharedFunctions.DeleteAllFeatures(reservoirVisLayer);
SharedFunctions.DeleteAllFeatures(dam3dLayer);
List <long> damIDs = new List <long>();
var reservoirPairsLayer = MapView.Active.Map.FindLayers("ReservoirPairs").FirstOrDefault();
if (reservoirPairsLayer != null && ((BasicFeatureLayer)reservoirPairsLayer).SelectionCount > 0)
{
var reservoirPairsCursor = ((BasicFeatureLayer)reservoirPairsLayer).GetSelection().Search();
while (reservoirPairsCursor.MoveNext())
{
using (Row row = reservoirPairsCursor.Current)
{
int damId = (int)row["LowerDamId"];
if (!damIDs.Contains(damId))
{
damIDs.Add(damId);
}
damId = (int)row["UpperDamId"];
if (!damIDs.Contains(damId))
{
damIDs.Add(damId);
}
}
}
}
if (damLayer.SelectionCount > 0)
{
var damCursor = damLayer.GetSelection().Search();
while (damCursor.MoveNext())
{
using (Row row = damCursor.Current)
{
int damId = (int)row["ObjectID"];
if (!damIDs.Contains(damId))
{
damIDs.Add(damId);
}
}
}
}
List <CandidateDam> candidates = new List <CandidateDam>();
SharedFunctions.LoadDamCandidatesFromLayer(candidates, damLayer);
foreach (var dam in candidates.Where(c => damIDs.Contains(c.ObjectID)).ToList())
{
double contourHeight = dam.ContourHeight;
try
{
MapPoint startPoint = dam.StartPoint;
MapPoint endPoint = dam.EndPoint;
double damHeight = (double)dam.DamHeight;
double damLength = (double)dam.Length;
Coordinate3D coord1 = startPoint.Coordinate3D;
int factor = ((startPoint.Y <endPoint.Y && startPoint.X> endPoint.X) ||
(startPoint.Y > endPoint.Y && startPoint.X < endPoint.X)
) ? 1 : -1;
Coordinate3D coord2 = new Coordinate3D(coord1.X + factor * damHeight / damLength * Math.Abs(startPoint.Y - endPoint.Y) //X
, coord1.Y + damHeight / damLength * Math.Abs(startPoint.X - endPoint.X) //Y
, coord1.Z - damHeight); //Z
Coordinate3D coord3 = new Coordinate3D(coord1.X - factor * damHeight / damLength * Math.Abs(startPoint.Y - endPoint.Y) //X
, coord1.Y - damHeight / damLength * Math.Abs(startPoint.X - endPoint.X) //Y
, coord1.Z - damHeight); //Z
//Workaround for Bug in ArcGIS Pro 2.4.1: if values are equal, extrusion will fail
coord2.X += 0.1;
coord2.Y += 0.1;
coord3.X += 0.1;
coord3.Y += 0.1;
List <Coordinate3D> coords = new List <Coordinate3D>();
coords.Add(coord1);
coords.Add(coord2);
coords.Add(coord3);
var newPolygon3D = PolygonBuilder.CreatePolygon(coords, SpatialReference);
Coordinate3D coord = new Coordinate3D(endPoint.X - startPoint.X, endPoint.Y - startPoint.Y, 0.1);
var multipatch = GeometryEngine.Instance.ConstructMultipatchExtrudeAlongVector3D(newPolygon3D, coord);
var attributes2 = new Dictionary <string, object>
{
{ "Shape", multipatch },
{ "DamID", (long)dam.ObjectID }
};
var createOperation2 = new EditOperation()
{
Name = "Create multipatch", SelectNewFeatures = false
};
createOperation2.Create(dam3dLayer, attributes2);
await createOperation2.ExecuteAsync();
//add SurfacePolygon to Visualization:
var queryFilter = new QueryFilter {
WhereClause = string.Format("DamID = {0}", dam.ObjectID)
};
var surfaceCursor = reservoirSurfacesLayer.Select(queryFilter).Search();
if (surfaceCursor.MoveNext())
{
using (Row row = surfaceCursor.Current)
{
var polygon = (row as Feature).GetShape() as Polygon;
attributes2 = new Dictionary <string, object>
{
{ "Shape", polygon },
{ "DamID", (long)dam.ObjectID }
};
var createOperationSurface = new EditOperation()
{
Name = "Create surface", SelectNewFeatures = false
};
createOperationSurface.Create(reservoirVisLayer, attributes2);
await createOperationSurface.ExecuteAsync();
}
}
}
catch (Exception ex)
{
SharedFunctions.Log("Error for 3D Dam with DamID " + dam.ObjectID + ": " + ex.Message);
}
SharedFunctions.Log("3D Dam created for Dam " + dam.ObjectID);
}
await Project.Current.SaveEditsAsync();
}
async public static void CreateElementSnippets()
{
//There are already many Create element snippets in the PRO snippets section. This section will only contain examples that are NOT in the Pro snippets section
//Pro snippets region names includes:
// Create point graphic with symbology
// Create line graphic with symbology
// Create rectangle graphic with simple symbology
// Create text element with basic font properties
// Create rectangle text with more advanced symbol settings
// Create a new picture element with advanced symbol settings
// Create a map frame and zoom to a bookmark
// Create a legend for a specifc map frame
// Creating group elements
LayoutView lytView = LayoutView.Active;
Layout layout = lytView.Layout;
#region Create_BeizierCurve
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D pt1 = new Coordinate2D(1, 7.5);
Coordinate2D pt2 = new Coordinate2D(1.66, 8);
Coordinate2D pt3 = new Coordinate2D(2.33, 7.1);
Coordinate2D pt4 = new Coordinate2D(3, 7.5);
CubicBezierBuilder bez = new CubicBezierBuilder(pt1, pt2, pt3, pt4);
CubicBezierSegment bezSeg = bez.ToSegment();
Polyline bezPl = PolylineBuilder.CreatePolyline(bezSeg);
//Set symbology, create and add element to layout
CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.RedRGB, 4.0, SimpleLineStyle.DashDot);
GraphicElement bezElm = LayoutElementFactory.Instance.CreateLineGraphicElement(layout, bezPl, lineSym);
bezElm.SetName("New Bezier Curve");
});
#endregion Create_BeizierCurve
#region Create_freehand
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plCoords = new List <Coordinate2D>();
plCoords.Add(new Coordinate2D(1.5, 10.5));
plCoords.Add(new Coordinate2D(1.25, 9.5));
plCoords.Add(new Coordinate2D(1, 10.5));
plCoords.Add(new Coordinate2D(0.75, 9.5));
plCoords.Add(new Coordinate2D(0.5, 10.5));
plCoords.Add(new Coordinate2D(0.5, 1));
plCoords.Add(new Coordinate2D(0.75, 2));
plCoords.Add(new Coordinate2D(1, 1));
Polyline linePl = PolylineBuilder.CreatePolyline(plCoords);
//Set symbolology, create and add element to layout
CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
GraphicElement lineElm = LayoutElementFactory.Instance.CreateLineGraphicElement(layout, linePl, lineSym);
lineElm.SetName("New Freehand");
});
#endregion Create_freehand
#region Create_polygon
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(1, 7));
plyCoords.Add(new Coordinate2D(2, 7));
plyCoords.Add(new Coordinate2D(2, 6.7));
plyCoords.Add(new Coordinate2D(3, 6.7));
plyCoords.Add(new Coordinate2D(3, 6.1));
plyCoords.Add(new Coordinate2D(1, 6.1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.DashDotDot);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
GraphicElement polyElm = LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, poly, polySym);
polyElm.SetName("New Polygon");
});
#endregion Create_polygon
#region Create_circle
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(2, 4);
EllipticArcBuilder eabCir = new EllipticArcBuilder(center, 0.5, esriArcOrientation.esriArcClockwise);
EllipticArcSegment cir = eabCir.ToSegment();
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Dash);
CIMPolygonSymbol circleSym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, outline);
GraphicElement cirElm = LayoutElementFactory.Instance.CreateCircleGraphicElement(layout, cir, circleSym);
cirElm.SetName("New Circle");
});
#endregion Create_circle
#region Create_ellipse
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(2, 2.75);
EllipticArcBuilder eabElp = new EllipticArcBuilder(center, 0, 1, 0.45, esriArcOrientation.esriArcClockwise);
EllipticArcSegment ellipse = eabElp.ToSegment();
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.GreenRGB, 2.0, SimpleLineStyle.Dot);
CIMPolygonSymbol ellipseSym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.GreyRGB, SimpleFillStyle.Vertical, outline);
GraphicElement elpElm = LayoutElementFactory.Instance.CreateEllipseGraphicElement(layout, ellipse, ellipseSym);
elpElm.SetName("New Ellipse");
});
#endregion Create_ellipse
#region Create_lasso
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(1, 1));
plyCoords.Add(new Coordinate2D(1.25, 2));
plyCoords.Add(new Coordinate2D(1.5, 1.1));
plyCoords.Add(new Coordinate2D(1.75, 2));
plyCoords.Add(new Coordinate2D(2, 1.1));
plyCoords.Add(new Coordinate2D(2.25, 2));
plyCoords.Add(new Coordinate2D(2.5, 1.1));
plyCoords.Add(new Coordinate2D(2.75, 2));
plyCoords.Add(new Coordinate2D(3, 1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
GraphicElement polyElm = LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, poly, polySym);
polyElm.SetName("New Lasso");
});
#endregion Create_lasso
#region Create_CurveText
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D pt1 = new Coordinate2D(3.6, 7.5);
Coordinate2D pt2 = new Coordinate2D(4.26, 8);
Coordinate2D pt3 = new Coordinate2D(4.93, 7.1);
Coordinate2D pt4 = new Coordinate2D(5.6, 7.5);
CubicBezierBuilder bez = new CubicBezierBuilder(pt1, pt2, pt3, pt4);
CubicBezierSegment bezSeg = bez.ToSegment();
Polyline bezPl = PolylineBuilder.CreatePolyline(bezSeg);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 24, "Comic Sans MS", "Regular");
GraphicElement bezTxtElm = LayoutElementFactory.Instance.CreateCurvedTextGraphicElement(layout, bezPl, "Curved Text", sym);
bezTxtElm.SetName("New Splinned Text");
});
#endregion Create_CurveText
#region Create_PolygonText
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(3.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.1));
plyCoords.Add(new Coordinate2D(3.5, 6.1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
string text = "Some Text String that is really long and is <BOL>forced to wrap to other lines</BOL> so that we can see the effects." as String;
GraphicElement polyTxtElm = LayoutElementFactory.Instance.CreatePolygonParagraphGraphicElement(layout, poly, text, sym);
polyTxtElm.SetName("New Polygon Text");
//(Optionally) Modify paragraph border
CIMGraphic polyTxtGra = polyTxtElm.Graphic;
CIMParagraphTextGraphic cimPolyTxtGra = polyTxtGra as CIMParagraphTextGraphic;
cimPolyTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimPolyTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
polyTxtElm.SetGraphic(polyTxtGra);
});
#endregion Create_PolygonText
#region Create_CircleText
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(4.5, 4);
EllipticArcBuilder eabCir = new EllipticArcBuilder(center, 0.5, esriArcOrientation.esriArcClockwise);
EllipticArcSegment cir = eabCir.ToSegment();
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreenRGB, 10, "Arial", "Regular");
string text = "Circle, circle, circle, circle, circle, circle, circle, circle, circle, circle, circle";
GraphicElement cirTxtElm = LayoutElementFactory.Instance.CreateCircleParagraphGraphicElement(layout, cir, text, sym);
cirTxtElm.SetName("New Circle Text");
//(Optionally) Modify paragraph border
CIMGraphic cirTxtGra = cirTxtElm.Graphic;
CIMParagraphTextGraphic cimCirTxtGra = cirTxtGra as CIMParagraphTextGraphic;
cimCirTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimCirTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
cirTxtElm.SetGraphic(cirTxtGra);
});
#endregion Create_CircleText
#region Create_EllipseText
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(4.5, 2.75);
EllipticArcBuilder eabElp = new EllipticArcBuilder(center, 0, 1, 0.45, esriArcOrientation.esriArcClockwise);
EllipticArcSegment ellipse = eabElp.ToSegment();
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlueRGB, 10, "Arial", "Regular");
string text = "Ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse";
GraphicElement elpTxtElm = LayoutElementFactory.Instance.CreateEllipseParagraphGraphicElement(layout, ellipse, text, sym);
elpTxtElm.SetName("New Ellipse Text");
//(Optionally) Modify paragraph border
CIMGraphic elpTxtGra = elpTxtElm.Graphic;
CIMParagraphTextGraphic cimElpTxtGra = elpTxtGra as CIMParagraphTextGraphic;
cimElpTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimElpTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
elpTxtElm.SetGraphic(elpTxtGra);
});
#endregion Create_EllipseText
MapFrame mfElm = null;
#region Create_MapFrame
//This example creates a new map frame and changes the camera scale.
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D ll = new Coordinate2D(6.0, 8.5);
Coordinate2D ur = new Coordinate2D(8.0, 10.5);
Envelope env = EnvelopeBuilder.CreateEnvelope(ll, ur);
//Reference map, create MF and add to layout
MapProjectItem mapPrjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map"));
Map mfMap = mapPrjItem.GetMap();
mfElm = LayoutElementFactory.Instance.CreateMapFrame(layout, env, mfMap);
mfElm.SetName("New Map Frame");
//Set the camera
Camera camera = mfElm.Camera;
camera.Scale = 24000;
mfElm.SetCamera(camera);
});
#endregion Create_MapFrame
#region Create_ScaleBar
await QueuedTask.Run(() =>
{
//Reference a North Arrow in a style
StyleProjectItem stylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars("Double Alternating Scale Bar 1")[0];
//Build geometry
Coordinate2D center = new Coordinate2D(7, 8);
//Reference MF, create north arrow and add to layout
MapFrame mf = layout.FindElement("New Map Frame") as MapFrame;
if (mf == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Map frame not found", "WARNING");
return;
}
ScaleBar sbElm = LayoutElementFactory.Instance.CreateScaleBar(layout, center, mf, sbStyleItm);
sbElm.SetName("New Scale Bar");
sbElm.SetWidth(2);
sbElm.SetX(6);
sbElm.SetY(7.5);
});
#endregion Create_ScaleBar
#region Create_NorthArrow
await QueuedTask.Run(() =>
{
//Reference a North Arrow in a style
StyleProjectItem stylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
NorthArrowStyleItem naStyleItm = stylePrjItm.SearchNorthArrows("ArcGIS North 10")[0];
//Build geometry
Coordinate2D center = new Coordinate2D(7, 5.5);
//Reference MF, create north arrow and add to layout
MapFrame mf = layout.FindElement("New Map Frame") as MapFrame;
if (mf == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Map frame not found", "WARNING");
return;
}
NorthArrow arrowElm = LayoutElementFactory.Instance.CreateNorthArrow(layout, center, mf, naStyleItm);
arrowElm.SetName("New North Arrow");
arrowElm.SetHeight(1.75);
arrowElm.SetX(7);
arrowElm.SetY(6);
});
#endregion Create_NorthArrow
}
internal async Task PerformAnalysis(MapPoint ptStartLoc, MapView mapView, ProgressorSource ps)
{
ps.Progressor.Message = "Running the analysis...";
ps.Progressor.Status = "Gathering and verifying parameter data";
string sReqUrl = Properties.Settings.Default.QryPointToState;
string sReq = String.Format("{0}?returnGeometry=false&returnDistinctValues=false&geometry={1}&geometryType=esriGeometryPoint&f=json&outFields=*&spatialRel=esriSpatialRelIntersects",
sReqUrl, ptStartLoc.ToJson());
// Find out what state the user clicked; or report an error if outside the U.S.
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sReq);
string sResp;
try {
using (StreamReader sread = new StreamReader(req.GetResponse().GetResponseStream()))
sResp = sread.ReadToEnd();
} catch (Exception e) {
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Error mapping the chosen spot to a petroleum area district in the U.S.A.: " + e.Message);
return;
}
dynamic respPADDState = JsonConvert.DeserializeObject(sResp);
try {
string sState = respPADDState.features[0].attributes.STATE.ToString();
// Find out what PADD zone the state is in
SelectedPADDZone = PaddStateToZone[sState];
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine("Exception getting PADD for chosen spot: " + e.Message);
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Please choose a spot within the U.S.A.");
return /*null*/;
}
// Find out the gallons/$1.00 in that PADD zone
double nFuelCost = PADDZoneToFuelCost[SelectedPADDZone];
// Find out the miles per dollar each vehicle: (mi / gal) / (dollars / gal)
// Map is in meters, so convert miles to meters
Vehicle[] orderedVehicles = SelectedVehicles.OrderBy(vehicle => vehicle.Mpg).ToArray <Vehicle>();
IEnumerable <double> vehicleMetersPerDollar =
orderedVehicles.Select(vehicle => (vehicle.MetersPerGallon) / nFuelCost);
string sDistsParam = String.Join(" ", vehicleMetersPerDollar.ToArray());
MapPoint ptStartLocNoZ = await QueuedTask.Run(() => {
MapPoint ptNoZ = MapPointBuilder.CreateMapPoint(ptStartLoc.X, ptStartLoc.Y, ptStartLoc.SpatialReference);
return(ptNoZ);
});
// No corresponding type for the needed GPFeatureRecordSetLayer parameter
string sStartGeom = ptStartLocNoZ.ToJson();
string sStartLocParam = "{\"geometryType\":\"esriGeometryPoint\",\"features\":[{\"geometry\":" + sStartGeom + "}]}";
// Run the query
ps.Progressor.Status = "Executing the analysis";
string sGPUrl = Properties.Settings.Default.GPFindSA;
sGPUrl += String.Format("?Distances={0}&Start_Location={1}&f=json", sDistsParam, sStartLocParam);
HttpWebRequest reqSA = (HttpWebRequest)WebRequest.Create(sGPUrl);
HttpWebResponse wr;
try {
wr = (HttpWebResponse)reqSA.GetResponse();
if (wr.StatusCode != HttpStatusCode.OK)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Error running analysis: " + wr.StatusDescription);
return;
}
} catch (WebException e) {
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Error running analysis: " + e.Message);
return;
}
// Show the results
ps.Progressor.Status = "Processing the results";
using (StreamReader sread = new StreamReader(wr.GetResponseStream()))
sResp = sread.ReadToEnd();
JObject respAnalysis = JObject.Parse(sResp);
JArray feats = respAnalysis["results"][0]["value"]["features"] as JArray;
// Rectify results and order so that largest polygon can be added to the map first
List <JToken> aryResFeats = RectifyResults(feats, orderedVehicles);
int iSR = respAnalysis["results"][0]["value"]["spatialReference"]["wkid"].ToObject <Int32>();
SpatialReference sr = await QueuedTask.Run <SpatialReference>(() => {
SpatialReference srTemp = SpatialReferenceBuilder.CreateSpatialReference(iSR);
return(srTemp);
});
/*lock (_lockResults)*/
Results.ClearResults();
// Iterate backwards to add larger polygons behind smaller ones
for (int iVeh = orderedVehicles.Count() - 1; iVeh >= 0; iVeh--)
{
Result result = new Result(orderedVehicles[iVeh]);
Polygon poly = null;
IDisposable graphic = null;
// Compute color for this result
float multiplier = aryResFeats.Count > 1 ? ((float)iVeh) / ((float)(aryResFeats.Count - 1)) : 0;
byte red = (byte)(255 - (255 * multiplier));
byte green = (byte)(255 * multiplier);
Color color = Color.FromRgb(red, green, 0);
result.Color = color.ToString();
result.PaddZone = SelectedPADDZone;
result.DollarsPerGallon = nFuelCost;
string sGeom = aryResFeats[iVeh]["geometry"].ToString();
poly = await QueuedTask.Run(() => {
Polygon polyNoSR = PolygonBuilder.FromJson(sGeom);
return(PolygonBuilder.CreatePolygon(polyNoSR, sr));
});
CIMStroke outline = SymbolFactory.ConstructStroke(ColorFactory.BlackRGB, 1.0, SimpleLineStyle.Solid);
CIMPolygonSymbol symPoly = SymbolFactory.ConstructPolygonSymbol(
ColorFactory.CreateRGBColor(color.R, color.G, color.B, RESULT_OPACITY_PCT),
SimpleFillStyle.Solid, outline);
CIMSymbolReference sym = symPoly.MakeSymbolReference();
CIMSymbolReference symDef = SymbolFactory.DefaultPolygonSymbol.MakeSymbolReference();
graphic = await QueuedTask.Run(() => {
return(mapView.AddOverlay(poly, sym));
});
result.DriveServiceArea = poly;
result.DriveServiceAreaGraphic = graphic;
result.DriveDistM = aryResFeats[iVeh]["attributes"]["ToBreak"].Value <double>();
/*lock (_lockResults)*/
Results.Add(result);
}
}
public async Task <string> GenerateGmlAsync()
{
MapView mapView = MapView.Active;
Map map = mapView?.Map;
SpatialReference mapSpatRef = map?.SpatialReference;
MySpatialReference myCyclSpatRef = _settings.CycloramaViewerCoordinateSystem;
SpatialReference cyclSpatRef = (myCyclSpatRef == null)
? mapSpatRef
: (myCyclSpatRef.ArcGisSpatialReference ?? (await myCyclSpatRef.CreateArcGisSpatialReferenceAsync()));
Unit unit = cyclSpatRef?.Unit;
double factor = unit?.ConversionFactor ?? 1;
Color color = Color.White;
string result =
"<wfs:FeatureCollection xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:wfs=\"http://www.opengis.net/wfs\" xmlns:gml=\"http://www.opengis.net/gml\">";
await QueuedTask.Run(async() =>
{
SpatialReference layerSpatRef = Layer.GetSpatialReference();
IList <IList <Segment> > geometries = new List <IList <Segment> >();
ICollection <Viewer> viewers = _viewerList.Viewers;
foreach (var viewer in viewers)
{
double distance = viewer.OverlayDrawDistance;
RecordingLocation recordingLocation = viewer.Location;
if (recordingLocation != null)
{
if (cyclSpatRef?.IsGeographic ?? true)
{
distance = distance * factor;
}
else
{
distance = distance / factor;
}
double x = recordingLocation.X;
double y = recordingLocation.Y;
double xMin = x - distance;
double xMax = x + distance;
double yMin = y - distance;
double yMax = y + distance;
Envelope envelope = EnvelopeBuilder.CreateEnvelope(xMin, yMin, xMax, yMax, cyclSpatRef);
Envelope copyEnvelope = envelope;
if (layerSpatRef.Wkid != 0)
{
ProjectionTransformation projection = ProjectionTransformation.Create(cyclSpatRef, layerSpatRef);
copyEnvelope = GeometryEngine.Instance.ProjectEx(envelope, projection) as Envelope;
}
Polygon copyPolygon = PolygonBuilder.CreatePolygon(copyEnvelope, layerSpatRef);
ReadOnlyPartCollection polygonParts = copyPolygon.Parts;
IEnumerator <ReadOnlySegmentCollection> polygonSegments = polygonParts.GetEnumerator();
IList <Segment> segments = new List <Segment>();
while (polygonSegments.MoveNext())
{
ReadOnlySegmentCollection polygonSegment = polygonSegments.Current;
foreach (Segment segment in polygonSegment)
{
segments.Add(segment);
}
}
geometries.Add(segments);
}
}
GC.Collect();
Polygon polygon = PolygonBuilder.CreatePolygon(geometries, layerSpatRef);
using (FeatureClass featureClass = Layer?.GetFeatureClass())
{
string uri = Layer?.URI;
SpatialQueryFilter spatialFilter = new SpatialQueryFilter
{
FilterGeometry = polygon,
SpatialRelationship = SpatialRelationship.Intersects,
SubFields = "*"
};
using (RowCursor existsResult = featureClass?.Search(spatialFilter, false))
{
while (existsResult?.MoveNext() ?? false)
{
Row row = existsResult.Current;
long objectId = row.GetObjectID();
if ((_selection == null) || (!_selection.Contains(objectId)))
{
Feature feature = row as Feature;
var fieldvalues = new Dictionary <string, string> {
{ FieldUri, uri }, { FieldObjectId, objectId.ToString() }
};
Geometry geometry = feature?.GetShape();
GeometryType geometryType = geometry?.GeometryType ?? GeometryType.Unknown;
Geometry copyGeometry = geometry;
if ((geometry != null) && (layerSpatRef.Wkid != 0))
{
ProjectionTransformation projection = ProjectionTransformation.Create(layerSpatRef, cyclSpatRef);
copyGeometry = GeometryEngine.Instance.ProjectEx(geometry, projection);
}
if (copyGeometry != null)
{
string gml = string.Empty;
switch (geometryType)
{
case GeometryType.Envelope:
break;
case GeometryType.Multipatch:
break;
case GeometryType.Multipoint:
break;
case GeometryType.Point:
MapPoint point = copyGeometry as MapPoint;
if (point != null)
{
gml =
$"<gml:Point {GmlDimension(copyGeometry)}><gml:coordinates>{await GmlPointAsync(point)}</gml:coordinates></gml:Point>";
}
break;
case GeometryType.Polygon:
Polygon polygonGml = copyGeometry as Polygon;
if (polygonGml != null)
{
ReadOnlyPartCollection polygonParts = polygonGml.Parts;
IEnumerator <ReadOnlySegmentCollection> polygonSegments = polygonParts.GetEnumerator();
while (polygonSegments.MoveNext())
{
ReadOnlySegmentCollection segments = polygonSegments.Current;
gml =
$"{gml}<gml:MultiPolygon><gml:PolygonMember><gml:Polygon {GmlDimension(copyGeometry)}><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
for (int i = 0; i < segments.Count; i++)
{
if (segments[i].SegmentType == SegmentType.Line)
{
MapPoint polygonPoint = segments[i].StartPoint;
gml = $"{gml}{((i == 0) ? string.Empty : " ")}{await GmlPointAsync(polygonPoint)}";
if (i == (segments.Count - 1))
{
polygonPoint = segments[i].EndPoint;
gml = $"{gml} {await GmlPointAsync(polygonPoint)}";
}
}
}
gml =
$"{gml}</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs></gml:Polygon></gml:PolygonMember></gml:MultiPolygon>";
}
}
break;
case GeometryType.Polyline:
Polyline polylineGml = copyGeometry as Polyline;
if (polylineGml != null)
{
ReadOnlyPartCollection polylineParts = polylineGml.Parts;
IEnumerator <ReadOnlySegmentCollection> polylineSegments = polylineParts.GetEnumerator();
while (polylineSegments.MoveNext())
{
ReadOnlySegmentCollection segments = polylineSegments.Current;
gml =
$"{gml}<gml:MultiLineString><gml:LineStringMember><gml:LineString {GmlDimension(copyGeometry)}><gml:coordinates>";
for (int i = 0; i < segments.Count; i++)
{
if (segments[i].SegmentType == SegmentType.Line)
{
MapPoint linePoint = segments[i].StartPoint;
gml = $"{gml}{((i == 0) ? string.Empty : " ")}{await GmlPointAsync(linePoint)}";
if (i == (segments.Count - 1))
{
linePoint = segments[i].EndPoint;
gml = $"{gml} {await GmlPointAsync(linePoint)}";
}
}
}
gml = $"{gml}</gml:coordinates></gml:LineString></gml:LineStringMember></gml:MultiLineString>";
}
}
break;
case GeometryType.Unknown:
break;
}
string fieldValueStr = fieldvalues.Aggregate(string.Empty,
(current, fieldvalue) =>
string.Format("{0}<{1}>{2}</{1}>", current, fieldvalue.Key, fieldvalue.Value));
result =
$"{result}<gml:featureMember><xs:Geometry>{fieldValueStr}{gml}</xs:Geometry></gml:featureMember>";
}
}
}
}
}
CIMRenderer renderer = Layer.GetRenderer();
CIMSimpleRenderer simpleRenderer = renderer as CIMSimpleRenderer;
CIMUniqueValueRenderer uniqueValueRendererRenderer = renderer as CIMUniqueValueRenderer;
CIMSymbolReference symbolRef = simpleRenderer?.Symbol ?? uniqueValueRendererRenderer?.DefaultSymbol;
CIMSymbol symbol = symbolRef?.Symbol;
CIMColor cimColor = symbol?.GetColor();
double[] colorValues = cimColor?.Values;
int red = ((colorValues != null) && (colorValues.Length >= 1)) ? ((int)colorValues[0]) : 255;
int green = ((colorValues != null) && (colorValues.Length >= 2)) ? ((int)colorValues[1]) : 255;
int blue = ((colorValues != null) && (colorValues.Length >= 3)) ? ((int)colorValues[2]) : 255;
int alpha = ((colorValues != null) && (colorValues.Length >= 4)) ? ((int)colorValues[3]) : 255;
color = Color.FromArgb(alpha, red, green, blue);
});
GmlChanged = (Color != color);
Color = color;
string newGml = $"{result}</wfs:FeatureCollection>";
GmlChanged = ((newGml != Gml) || GmlChanged);
return(Gml = newGml);
}