public static PartCollection ChangeSpatialReference(
ReadOnlyPartCollection parts,
SpatialReference sr)
{
PartCollection newParts = new PartCollection(sr);
foreach (IEnumerable <MapPoint> part in parts.GetPartsAsPoints())
{
IEnumerable <MapPoint> points = ChangeSpatialReference(part, sr);
newParts.AddPart(points);
}
return(newParts);
}
protected override async void OnClick()
{
FeatureLayer ftrLayer = (MapView.Active.Map.Layers.First(layer => layer.Name.Equals("MyRide")) as FeatureLayer);
ProjectionTransformation transformation = await QueuedTask.Run(() => ProjectionTransformation.Create(ftrLayer.GetSpatialReference(), MapView.Active.Map.SpatialReference));
SpatialReference layerSpatRef = await QueuedTask.Run(() => ftrLayer.GetSpatialReference());
Polyline lineGeom = await GetPolyFineFromLayer(ftrLayer);
//couldn't get the selected feature
if (lineGeom == null)
{
return;
}
var animation = MapView.Active.Map.Animation;
var cameraTrack = animation.Tracks.OfType <CameraTrack>().First();
var keyframes = cameraTrack.Keyframes;
//Get segment list for line
ReadOnlyPartCollection polylineParts = lineGeom.Parts;
//get total segment count and determine path length
double pathLength = 0;
int segmentCount = 0;
IEnumerator <ReadOnlySegmentCollection> segments = polylineParts.GetEnumerator();
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
foreach (Segment s in seg)
{
double length3D = Math.Sqrt((s.EndPoint.X - s.StartPoint.X) * (s.EndPoint.X - s.StartPoint.X) +
(s.EndPoint.Y - s.StartPoint.Y) * (s.EndPoint.Y - s.StartPoint.Y) +
(s.EndPoint.Z - s.StartPoint.Z) * (s.EndPoint.Z - s.StartPoint.Z));
pathLength += length3D;
segmentCount += 1;
}
}
await CreateKeyframes_AtVertices(MapView.Active, layerSpatRef, transformation, cameraTrack, segments, segmentCount, pathLength);
}
public static async Task CreateKeyframes()
{
FeatureLayer ftrLayer = null;
MapView mapView = MapView.Active;
if (mapView == null)
{
return;
}
var mapSelection = await QueuedTask.Run(() => MapView.Active.Map.GetSelection());
if (mapSelection.Count == 1)
{
var layer = mapSelection.First().Key;
if (layer is FeatureLayer)
{
ftrLayer = (FeatureLayer)layer;
if (ftrLayer.ShapeType != ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolyline)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
int numFtrsSelected = await QueuedTask.Run(() => ftrLayer.GetSelection().GetCount());
if (numFtrsSelected != 1)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select only one polyline feature.");
return;
}
}
else
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
}
else
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
if (SelectedCameraView == "Face target" && TargetPoint == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Selected view type is - Face target - but a target point is not set.");
return;
}
string oid_fieldName = await QueuedTask.Run(() => ftrLayer.GetTable().GetDefinition().GetObjectIDField());
//get selected polyline
Polyline lineGeom = await QueuedTask.Run <Polyline>(() =>
{
var selectedFtrOID = MapView.Active.Map.GetSelection()[ftrLayer][0];
QueryFilter qf = new QueryFilter();
qf.WhereClause = oid_fieldName + " = " + selectedFtrOID.ToString();
RowCursor result = ftrLayer.GetFeatureClass().Search(qf);
if (result != null)
{
result.MoveNext();
Feature selectedFtr = result.Current as Feature;
return(selectedFtr.GetShape() as Polyline);
}
return(null);
});
//couldn't get the selected feature
if (lineGeom == null)
{
return;
}
ProjectionTransformation transformation = await QueuedTask.Run(() => ProjectionTransformation.Create(ftrLayer.GetSpatialReference(), mapView.Map.SpatialReference));
SpatialReference layerSpatRef = await QueuedTask.Run(() => ftrLayer.GetSpatialReference());
if (layerSpatRef.Unit.Name != "Degree")
{
Z_CONVERSION_FACTOR = layerSpatRef.Unit.ConversionFactor;
}
//Project target point if method is Face target
if (SelectedCameraView == "Face target")
{
if (TargetPoint != null && TargetPoint.SpatialReference != layerSpatRef)
{
ProjectionTransformation transf_forTarget = await QueuedTask.Run(() => ProjectionTransformation.Create(TargetPoint.SpatialReference, layerSpatRef));
MapPoint projected_targetPoint = (MapPoint)GeometryEngine.Instance.ProjectEx(TargetPoint, transf_forTarget);
TargetPoint = null;
TargetPoint = projected_targetPoint;
}
}
var animation = mapView.Map.Animation;
var cameraTrack = animation.Tracks.OfType <CameraTrack>().First();
var keyframes = cameraTrack.Keyframes;
//Get segment list for line
ReadOnlyPartCollection polylineParts = lineGeom.Parts;
//get total segment count and determine path length
double pathLength = 0;
int segmentCount = 0;
IEnumerator <ReadOnlySegmentCollection> segments = polylineParts.GetEnumerator();
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
foreach (Segment s in seg)
{
//pathLength += s.Length;//s.Length returns 2D length
double length3D = Math.Sqrt((s.EndPoint.X - s.StartPoint.X) * (s.EndPoint.X - s.StartPoint.X) +
(s.EndPoint.Y - s.StartPoint.Y) * (s.EndPoint.Y - s.StartPoint.Y) +
(s.EndPoint.Z - s.StartPoint.Z) * (s.EndPoint.Z - s.StartPoint.Z));
pathLength += length3D;
segmentCount += 1;
}
}
//reset heading and pitch
_keyframeHeading = 0;
_keyframePitch = 0;
// Create keyframes based on chosen method
if (SelectedMethod == "Keyframes along path")
{
await CreateKeyframes_AlongPath(mapView, layerSpatRef, transformation, cameraTrack, segments, segmentCount, pathLength);
}
else if (SelectedMethod == "Keyframes every N seconds")
{
await CreateKeyframes_EveryNSeconds(mapView, layerSpatRef, transformation, cameraTrack, segments, segmentCount, pathLength, KeyEveryNSecond);
}
else if (SelectedMethod == "Keyframes only at vertices")
{
await CreateKeyframes_AtVertices(mapView, layerSpatRef, transformation, cameraTrack, lineGeom, segments, segmentCount, pathLength);
}
}
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);
}
public static PartCollection ChangeSpatialReference(
ReadOnlyPartCollection parts,
SpatialReference sr)
{
PartCollection newParts = new PartCollection(sr);
foreach (IEnumerable<MapPoint> part in parts.GetPartsAsPoints())
{
IEnumerable<MapPoint> points = ChangeSpatialReference(part, sr);
newParts.AddPart(points);
}
return newParts;
}
