private static async Task <MapPoint> CreatePointAlongArc(MapPoint startPt, MapPoint endPt, MapPoint centerPt, double angle, double radius, SpatialReference spatRef, bool arcIsMinor, bool arcIsCounterClockwise)
{
System.Windows.Media.Media3D.Vector3D start = new System.Windows.Media.Media3D.Vector3D(startPt.X - centerPt.X, startPt.Y - centerPt.Y, startPt.Z - centerPt.Z);
System.Windows.Media.Media3D.Vector3D end = new System.Windows.Media.Media3D.Vector3D(endPt.X - centerPt.X, endPt.Y - centerPt.Y, endPt.Z - centerPt.Z);
System.Windows.Media.Media3D.Vector3D normalOfPlane = new System.Windows.Media.Media3D.Vector3D();
normalOfPlane = System.Windows.Media.Media3D.Vector3D.CrossProduct(start, end);
//Two ortho vectors: orthoVec and start
System.Windows.Media.Media3D.Vector3D orthoVec = new System.Windows.Media.Media3D.Vector3D();
orthoVec = System.Windows.Media.Media3D.Vector3D.CrossProduct(normalOfPlane, start);
//If this is not done then half of the keyframes for S-shaped curve are not on the curve
if (arcIsMinor && !arcIsCounterClockwise)
{
orthoVec.Negate();
}
//Normalize
start.Normalize();
orthoVec.Normalize();
System.Windows.Media.Media3D.Vector3D ptAlong = new System.Windows.Media.Media3D.Vector3D();
ptAlong = radius * Math.Cos(angle) * start + radius * Math.Sin(angle) * orthoVec;
MapPoint intermediateKeyframePoint = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(ptAlong.X + centerPt.X, ptAlong.Y + centerPt.Y, ptAlong.Z + centerPt.Z, spatRef));
return(intermediateKeyframePoint);
}
public async Task <bool> ApplyResults(MapView mapView, SearchResults results, IPointSymbology symbology, CancellationToken ctsToken)
{
Clear();
if (ctsToken.IsCancellationRequested)
{
return(false);
}
await QueuedTask.Run(() =>
{
InitSymbology(symbology);
var spatialRef = SpatialReferences.WGS84; // TODO: this should be coming from response
foreach (var point in results.GetValuePoints(ValueName))
{
if (ctsToken.IsCancellationRequested)
{
return;
}
var location = MapPointBuilder.CreateMapPoint(point.Longitude, point.Latitude, spatialRef);
var overlay = mapView.AddOverlay(location, _symbolRef);
_elements.Add(new Element()
{
Value = point, Location = location, Overlay = overlay, Hitbox = CreateHitBox(mapView, location, symbology.Size / 2, spatialRef)
});
}
});
return(_elements.Count > 0);
}
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 CanMapPointBuilderStatic()
{
MapPoint pt1 = MapPointBuilder.CreateMapPoint(1.0, 2.0);
Assert.False(pt1.HasZ);
Assert.False(pt1.HasM);
Assert.False(pt1.HasID);
Assert.False(pt1.IsEmpty);
MapPoint pt2 = MapPointBuilder.CreateMapPoint(1.0, 2.0, 3.0);
Assert.True(pt2.HasZ);
Assert.False(pt2.HasM);
Assert.False(pt2.HasID);
Assert.False(pt2.IsEmpty);
MapPoint pt3 = MapPointBuilder.CreateMapPoint(1.0, 2.0, 3.0, 4.0);
Assert.True(pt3.HasZ);
Assert.True(pt3.HasM);
Assert.False(pt3.HasID);
Assert.False(pt3.IsEmpty);
MapPoint pt3Copy = MapPointBuilder.CreateMapPoint(pt3);
Assert.True(pt3Copy.IsEqual(pt3));
Assert.False(ReferenceEquals(pt3, pt3Copy)); // Note: since geoms are immutable, returning *same* would be ok, but here test for behavior
}
public async Task <bool> ApplyResults(MapView mapView, SearchResults results, IPointSymbology symbology, CancellationToken ctsToken)
{
Clear();
if (ctsToken.IsCancellationRequested)
{
return(false);
}
await QueuedTask.Run(() =>
{
InitSymbology(symbology);
var spatialRef = SpatialReferences.WGS84; // TODO: this should be coming from response
foreach (var pointCluster in results.GetValuePointClusters(ValueName))
{
if (ctsToken.IsCancellationRequested)
{
return;
}
var location = MapPointBuilder.CreateMapPoint(pointCluster.Longitude, pointCluster.Latitude, spatialRef);
var addItems = AddOverlay(mapView, location, pointCluster, spatialRef);
_elements.Add(new Element()
{
Location = location, Value = pointCluster, PointOverlay = addItems.Item1, TextOverlay = addItems.Item2, Hitbox = addItems.Item3
});
}
});
return(_elements.Count > 0);
}
private void UpdateFlash(System.Windows.Point?point)
{
var flashVM = OverlayEmbeddableControl as FlashEmbeddedControlViewModel;
if (flashVM != null)
{
flashVM.ClientPoint = point.Value;
}
var temp = QueuedTask.Run(() =>
{
if (flashVM != null && MapView.Active != null)
{
flashVM.ScreenPoint = MapView.Active.ClientToScreen(point.Value);
var p1 = MapView.Active.MapToScreen(MapPointBuilder.CreateMapPoint(MapView.Active.Extent.XMin, MapView.Active.Extent.YMin));
var p3 = MapView.Active.MapToScreen(MapPointBuilder.CreateMapPoint(MapView.Active.Extent.XMax, MapView.Active.Extent.YMax));
var width = (p3.X - p1.X) + 1;
var height = (p1.Y - p3.Y) + 1;
flashVM.MapWidth = width;
flashVM.MapHeight = height;
flashVM.RunFlashAnimation();
}
return(true);
}).Result;
}
private void SetThumbnail(Mosaic item)
{
TilePointConvert tilePointConvert = new TilePointConvert();
var extent = MapView.Active.Extent;
int z = 7;
MapPoint sw = MapPointBuilder.CreateMapPoint(extent.XMin, extent.YMin, extent.SpatialReference);
sw = GeometryEngine.Instance.Project(sw, SpatialReferences.WGS84) as MapPoint;
MapPoint ne = MapPointBuilder.CreateMapPoint(extent.XMax, extent.YMax, SpatialReferences.WGS84);
ne = GeometryEngine.Instance.Project(ne, SpatialReferences.WGS84) as MapPoint;
IList <MapPoint> mapPoints = new List <MapPoint>();
mapPoints.Add(sw);
mapPoints.Add(ne);
double zz = TilePointConvert.BestMapView(mapPoints, 100, 56, 2);
z = (int)Math.Floor(zz);
if (z < 0)
{
z = z * -1;
}
var centerProjected = GeometryEngine.Instance.Project(extent.Center, SpatialReferences.WGS84) as MapPoint;
double centerlong = centerProjected.X;
double centerlat = centerProjected.Y;
PointF point = tilePointConvert.WorldToTilePos(centerlong, centerlat, z);
item.Thumbnail = item._links.tiles.Replace("{x}", Math.Floor(point.X).ToString()).Replace("{y}", Math.Floor(point.Y).ToString()).Replace("{z}", z.ToString());
}
protected async Task InitializeAsync(RecordingLocation location, double angle, double hFov, Color color)
{
_angle = angle;
_hFov = hFov;
Color = color;
_isInitialized = true;
double x = location.X;
double y = location.Y;
Settings settings = Settings.Instance;
MySpatialReference spatRel = settings.CycloramaViewerCoordinateSystem;
await QueuedTask.Run(() =>
{
Map map = MapView.Active?.Map;
SpatialReference mapSpatialReference = map?.SpatialReference;
SpatialReference spatialReference = spatRel?.ArcGisSpatialReference ?? mapSpatialReference;
MapPoint point = MapPointBuilder.CreateMapPoint(x, y, spatialReference);
if ((mapSpatialReference != null) && (spatialReference.Wkid != mapSpatialReference.Wkid))
{
ProjectionTransformation projection = ProjectionTransformation.Create(spatialReference, mapSpatialReference);
_mapPoint = GeometryEngine.Instance.ProjectEx(point, projection) as MapPoint;
}
else
{
_mapPoint = (MapPoint)point.Clone();
}
});
MapViewCameraChangedEvent.Subscribe(OnMapViewCameraChanged);
await RedrawConeAsync();
}
public static async Task <MapPoint> CycloramaToMapPointAsync(double x, double y, double z)
{
MapView mapView = MapView.Active;
Map map = mapView?.Map;
SpatialReference mapSpatialReference = map?.SpatialReference;
SpatialReference gsSpatialReference = await CycloramaSpatialReferenceAsync();
MapPoint point = null;
await QueuedTask.Run(() =>
{
MapPoint mapPoint = MapPointBuilder.CreateMapPoint(x, y, z, gsSpatialReference);
if ((mapSpatialReference != null) && (gsSpatialReference != null) &&
(gsSpatialReference.Wkid != mapSpatialReference.Wkid))
{
ProjectionTransformation projection = ProjectionTransformation.Create(gsSpatialReference, mapSpatialReference);
point = GeometryEngine.Instance.ProjectEx(mapPoint, projection) as MapPoint;
}
else
{
point = (MapPoint)mapPoint.Clone();
}
});
return(point);
}
/// <summary>
/// Called when the OnToolMouseDown event is handled. Allows the opportunity to perform asynchronous operations corresponding to the event.
/// </summary>
protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
{
//Get the instance of the ViewModel
var symbolDockPaneViewModel = FrameworkApplication.DockPaneManager.Find("ProSymbolEditor_MilitarySymbolDockpane") as MilitarySymbolDockpaneViewModel;
if (symbolDockPaneViewModel == null)
{
return(Task.FromResult(0));
}
//Get the map coordinates from the click point and set the property on the ViewModel.
return(QueuedTask.Run(() =>
{
var tempMapPoint = MapView.Active.ClientToMap(e.ClientPoint);
try
{
// for now we will always project to WGS84
MapPoint projectedMapPoint = GeometryEngine.Project(tempMapPoint, SpatialReferences.WGS84) as MapPoint;
//Create a point with a z value, since the mil spec feature classes have z enabled (TODO: other way to do this?)
symbolDockPaneViewModel.MapGeometry = MapPointBuilder.CreateMapPoint(projectedMapPoint.X, projectedMapPoint.Y, 0, projectedMapPoint.SpatialReference);
symbolDockPaneViewModel.MapPointCoordinatesString = string.Format("{0:0.0####} {1:0.0####}", tempMapPoint.Y, tempMapPoint.X);
}
catch (Exception exception)
{
System.Console.WriteLine(exception.Message);
}
}));
}
private void Watcher_PositionChanged(object sender, GeoPositionChangedEventArgs <GeoCoordinate> e)
{
GeoCoordinate coord = e.Position.Location;
var mapView = MapView.Active;
if (mapView == null)
{
return;
}
if (coord.IsUnknown != true)
{
System.Diagnostics.Debug.WriteLine("Lat: {0}, Long: {1}",
coord.Latitude,
coord.Longitude);
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
MapPoint zoomToPnt = MapPointBuilder.CreateMapPoint(coord.Longitude, coord.Latitude, SpatialReferences.WGS84);
var geoProject = GeometryEngine.Instance.Project(zoomToPnt, SpatialReferences.WebMercator) as MapPoint;
var expandSize = 200.0;
var minPoint = MapPointBuilder.CreateMapPoint(geoProject.X - expandSize, geoProject.Y - expandSize, SpatialReferences.WebMercator);
var maxPoint = MapPointBuilder.CreateMapPoint(geoProject.X + expandSize, geoProject.Y + expandSize, SpatialReferences.WebMercator);
Envelope env = EnvelopeBuilder.CreateEnvelope(minPoint, maxPoint);
mapView.ZoomTo(env, new TimeSpan(0, 0, 3));
_graphic = MapView.Active.AddOverlay(zoomToPnt, _pointSymbol.MakeSymbolReference());
});
}
else
{
MessageBox.Show("Unknown latitude and longitude. Check your control panel for Location Privacy settings.");
}
}
/// <summary>
/// Update the CIMPointGraphic location
/// </summary>
/// <param name="point"></param>
public void UpdateLocation(PointN point)
{
ArcGIS.Core.Geometry.SpatialReference sptlRef = SpatialReferenceBuilder.CreateSpatialReference(point.SpatialReference.WKID);
MapPoint mapPoint = MapPointBuilder.CreateMapPoint(point.X, point.Y, sptlRef);
_graphic.Location = mapPoint;
}
/// <summary>
/// Create a CIMPointGaphic which can be added to the MapView overlay.
/// </summary>
/// <param name="point">The location for the point (as a CIM point)</param>
/// <returns></returns>
public CIMPointGraphic MakeCIMPointGraphic(PointN point)
{
CIMMarker marker = SymbolFactory.Instance.ConstructMarker(Red, 10, SimpleMarkerStyle.Star);
CIMSymbolLayer[] layers = new CIMSymbolLayer[1];
layers[0] = marker;
CIMPointSymbol pointSymbol = new CIMPointSymbol()
{
SymbolLayers = layers,
ScaleX = 1
};
CIMSymbolReference symbolRef = new CIMSymbolReference()
{
Symbol = pointSymbol
};
CIMPointGraphic pointGraphic = new CIMPointGraphic();
ArcGIS.Core.Geometry.SpatialReference spatialRef = SpatialReferenceBuilder.CreateSpatialReference(point.SpatialReference.WKID);
MapPoint mapPoint = MapPointBuilder.CreateMapPoint(point.X, point.Y, spatialRef);
pointGraphic.Location = mapPoint;
pointGraphic.Symbol = symbolRef;
return(pointGraphic);
}
public async Task <MapPoint> AddHeightToMapPointAsync(MapPoint srcPoint)
{
return(await QueuedTask.Run(async() =>
{
MapView mapView = MapView.Active;
Map map = mapView.Map;
SpatialReference srcSpatialReference = map.SpatialReference;
SpatialReference dstSpatialReference = await CoordSystemUtils.CycloramaSpatialReferenceAsync();
ProjectionTransformation dstProjection = ProjectionTransformation.Create(srcSpatialReference,
dstSpatialReference);
MapPoint dstPoint = GeometryEngine.Instance.ProjectEx(srcPoint, dstProjection) as MapPoint;
if (dstPoint != null)
{
double?height = await _cycloMediaGroupLayer.GetHeightAsync(dstPoint.X, dstPoint.Y);
if (height != null)
{
dstPoint = MapPointBuilder.CreateMapPoint(dstPoint.X, dstPoint.Y, ((double)height), dstSpatialReference);
ProjectionTransformation srcProjection = ProjectionTransformation.Create(dstSpatialReference,
srcSpatialReference);
srcPoint = GeometryEngine.Instance.ProjectEx(dstPoint, srcProjection) as MapPoint;
}
}
return srcPoint;
}));
}
private Task <bool> CreateLocations(FeatureLayer pointFeatureLayer, IReadOnlyList <Location> locations)
{
return(QueuedTask.Run(() =>
{
var createOperation = new EditOperation()
{
Name = "Generate points",
SelectNewFeatures = false
};
foreach (var location in locations)
{
var firstfeature = location.Feature;
var jfeature = firstfeature as JObject;
var token = jfeature.GetValue("type").ToString();
if (token == "Point")
{
var p = jfeature.ToObject <GeoJSON.Net.Geometry.Point>();
var mapView = MapView.Active;
var newMapPoint = MapPointBuilder.CreateMapPoint(p.Coordinates.Longitude, p.Coordinates.Latitude, SpatialReferences.WGS84);
var atts = new Dictionary <string, object>();
atts.Add("id", location.Id);
atts.Add("Shape", newMapPoint);
atts.Add("description", location.Description);
createOperation.Create(pointFeatureLayer, atts);
}
}
return createOperation.ExecuteAsync();
}));
}
private async Task <MapPoint> AddZOffsetAsync(MapPoint mapPoint)
{
return(await QueuedTask.Run(async() => mapPoint.HasZ
?MapPointBuilder.CreateMapPoint(mapPoint.X, mapPoint.Y,
mapPoint.Z + ((VectorLayer != null) ? await VectorLayer.GetOffsetZAsync() : 0),
mapPoint.SpatialReference)
: MapPointBuilder.CreateMapPoint(mapPoint.X, mapPoint.Y, mapPoint.SpatialReference)));
}
private static Dictionary <MapMember, List <long> > GetSelectedItems(MapViewMouseButtonEventArgs e)
{
var point = MapPointBuilder.CreateMapPoint(e.ClientPoint.X, e.ClientPoint.Y);
var selectedLayerFeatures = MapView.Active.GetFeatures(point, true);
var selectedItems = selectedLayerFeatures.ToDictionary(x => x.Key as MapMember, x => x.Value);
return(selectedItems);
}
public void CanUseCoreDirectly()
{
SpatialReference ch1903 = SpatialReferenceBuilder.CreateSpatialReference(21781);
MapPoint point = MapPointBuilder.CreateMapPoint(600000, 200000, ch1903);
Assert.AreEqual(600000.0, point.X);
Assert.AreEqual(200000.0, point.Y);
}
public static Polygon SetShipRotate(double angle)
{
Polygon init_p = GetShipPolygon();
MapPoint center = MapPointBuilder.CreateMapPoint(0, 0);
double radians = AngularUnit.Degrees.ConvertToRadians(angle);
Polygon p = GeometryEngine.Instance.Rotate(init_p, center, -radians) as Polygon;
return(p);
}
private MapPoint GetAveragePoint(MapPoint leftPoint, MapPoint rightPoint)
{
var avgX = (leftPoint.X + rightPoint.X) / 2;
var avgY = (leftPoint.Y + rightPoint.Y) / 2;
var avgZ = (leftPoint.Z + rightPoint.Z) / 2;
var spatialRef = leftPoint.SpatialReference;
return(MapPointBuilder.CreateMapPoint(avgX, avgY, avgZ, spatialRef));
}
private MapPoint CreateTargetShipPoint(MapPoint own_ship, double movedX, double movedY)
{
double lon = own_ship.X;
double lat = own_ship.Y;
double m_movedX = movedX * 1852;
double m_movedY = movedY * 1852;
MapPoint newTarget = MapPointBuilder.CreateMapPoint(lon + m_movedX, lat + m_movedY, own_ship.SpatialReference);
return(newTarget);
}
private static MapPoint CreatePointFromSketchPolygon(Geometry sketchGeometry)
{
var clickCoord =
new Coordinate2D(sketchGeometry.Extent.XMin, sketchGeometry.Extent.YMin);
MapPoint sketchPoint =
MapPointBuilder.CreateMapPoint(clickCoord, sketchGeometry.SpatialReference);
return(sketchPoint);
}
private static void CreateField(Report report)
{
#region Create a new field in the report
//This is the gap between two fields.
double fieldIncrement = 0.9388875113593206276389;
//On the QueuedTask
//New field to add.
var newReportField = new CIMReportField
{
Name = "POP1990",
FieldOrder = 2,
};
//Get the "ReportSection element"
var mainReportSection = report.Elements.OfType <ReportSection>().FirstOrDefault();
if (mainReportSection == null)
{
return;
}
//Get the "ReportDetails" within the ReportSectionElement. ReportDetails is where "fields" are.
var reportDetailsSection = mainReportSection?.Elements.OfType <ReportDetails>().FirstOrDefault();
if (reportDetailsSection == null)
{
return;
}
//Within ReportDetails find the envelope that encloses a field.
//We get the first CIMParagraphTextGraphic in the collection so that we can add the new field next to it.
var lastFieldGraphic = reportDetailsSection.Elements.FirstOrDefault((r) =>
{
var gr = r as GraphicElement;
if (gr == null)
{
return(false);
}
return(gr.GetGraphic() is CIMParagraphTextGraphic ? true : false);
});
//Get the Envelope of the last field
var graphicBounds = lastFieldGraphic.GetBounds();
//Min and Max values of the envelope
var xMinOfFieldEnvelope = graphicBounds.XMin;
var yMinOfFieldEnvelope = graphicBounds.YMin;
var xMaxOfFieldEnvelope = graphicBounds.XMax;
var YMaxOfFieldEnvelope = graphicBounds.YMax;
//create the new Envelope to be offset from the existing field
MapPoint newMinPoint = MapPointBuilder.CreateMapPoint(xMinOfFieldEnvelope + fieldIncrement, yMinOfFieldEnvelope);
MapPoint newMaxPoint = MapPointBuilder.CreateMapPoint(xMaxOfFieldEnvelope + fieldIncrement, YMaxOfFieldEnvelope);
Envelope newFieldEnvelope = EnvelopeBuilder.CreateEnvelope(newMinPoint, newMaxPoint);
//Create field
GraphicElement fieldGraphic = ReportElementFactory.Instance.CreateFieldValueTextElement(reportDetailsSection, newFieldEnvelope, newReportField);
#endregion
}
private async Task OpenImageAsync(bool replace)
{
if (_api != null)
{
string location = ((dynamic)DataContext).Location;
bool nearest = ((dynamic)DataContext).Nearest;
_api.SetActiveViewerReplaceMode(replace);
if (nearest)
{
MySpatialReference spatialReference = _settings.CycloramaViewerCoordinateSystem;
SpatialReference thisSpatialReference = spatialReference.ArcGisSpatialReference ??
await spatialReference.CreateArcGisSpatialReferenceAsync();
if ((_lastSpatialReference != null) && (thisSpatialReference.Wkid != _lastSpatialReference.Wkid))
{
string[] splitLoc = location.Split(',');
CultureInfo ci = CultureInfo.InvariantCulture;
double x = double.Parse(splitLoc.Length >= 1 ? splitLoc[0] : "0.0", ci);
double y = double.Parse(splitLoc.Length >= 2 ? splitLoc[1] : "0.0", ci);
MapPoint point = null;
await QueuedTask.Run(() =>
{
point = MapPointBuilder.CreateMapPoint(x, y, _lastSpatialReference);
ProjectionTransformation projection = ProjectionTransformation.Create(_lastSpatialReference,
thisSpatialReference);
point = GeometryEngine.Instance.ProjectEx(point, projection) as MapPoint;
});
if (point != null)
{
location = string.Format(ci, "{0},{1}", point.X, point.Y);
DockPaneGlobeSpotter globeSpotter = ((dynamic)DataContext);
globeSpotter.PropertyChanged -= OnGlobeSpotterPropertyChanged;
((dynamic)DataContext).Location = location;
globeSpotter.PropertyChanged += OnGlobeSpotterPropertyChanged;
}
}
_startOpenNearest = true;
_api.OpenNearestImage(location, _settings.CtrlClickHashTag * _settings.CtrlClickDelta);
}
else
{
_api.OpenImage(location);
}
MySpatialReference cycloSpatialReference = _settings.CycloramaViewerCoordinateSystem;
_lastSpatialReference = cycloSpatialReference.ArcGisSpatialReference ??
await cycloSpatialReference.CreateArcGisSpatialReferenceAsync();
}
}
//Use this method if you want keyframes ONLY at line vertices. This is good if the line is highly densified.
//However, you will get sharp turns at corners because there is no attempt to smooth the animation
public static async Task CreateKeyframes_AtVertices(MapView mapView, SpatialReference layerSpatRef, ProjectionTransformation transformation,
CameraTrack cameraTrack, Polyline lineGeom, IEnumerator <ReadOnlySegmentCollection> segments,
int segmentCount, double pathLength)
{
double segmentLength = 0;
int num_iterations = 0;
segments.Reset();
//process each segment depending upon its type - straight line or arc
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
double accumulatedDuration = mapView.Map.Animation.Duration.TotalSeconds + ((mapView.Map.Animation.Duration.TotalSeconds > 0) ? ANIMATION_APPEND_TIME : 0); // 0;
foreach (Segment s in seg)
{
segmentLength = 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));
double segmentDuration = (TotalDuration / pathLength) * segmentLength;
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z, layerSpatRef));
//create keyframe at start vertex of path in map space
double timeSpanValue = accumulatedDuration;
TimeSpan keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(startPt, endPt);
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at end point of segment only for the end point of last segment
//Otherwise we will get duplicate keyframes at end of one segment and start of the next one
if (num_iterations == segmentCount - 1)
{
timeSpanValue = accumulatedDuration + segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (SelectedCameraView == "Face target")
{
SetPitchAndHeadingForLine(endPt, TargetPoint);
}
await CreateCameraKeyframe(mapView, endPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
accumulatedDuration += segmentDuration;
num_iterations++;
}
}
}
/// <summary>
/// Create random sample points in the extent of the spatial reference
/// </summary>
/// <param name="pointFeatureLayer">Point geometry feature layer used to the generate the points.</param>
/// <returns>Task of bool</returns>
private Task <bool> constructSamplePoints(FeatureLayer pointFeatureLayer)
{
// create a random number generator
var randomGenerator = new Random();
// the database and geometry interactions are considered fine-grained and must be executed on
// the main CIM thread
return(QueuedTask.Run(() =>
{
// get the feature class associated with the layer
var featureClass = pointFeatureLayer.GetTable() as FeatureClass;
// define an area of interest. Random points are generated in the allowed
// confines of the allow extent range
var areaOfInterest = MapView.Active.Extent;
// retrieve the class definition of the point feature class
var classDefinition = featureClass.GetDefinition() as FeatureClassDefinition;
// store the spatial reference as its own variable
var spatialReference = classDefinition.GetSpatialReference();
// start an edit operation to create new (random) point features
var createOperation = new EditOperation();
createOperation.Name = "Generate points";
createOperation.SelectNewFeatures = false;
// create 20 new point geometries and queue them for creation
for (int i = 0; i < 20; i++)
{
MapPoint newMapPoint = null;
// generate either 2D or 3D geometries
if (classDefinition.HasZ())
{
newMapPoint = MapPointBuilder.CreateMapPoint(randomGenerator.NextCoordinate(areaOfInterest, true), spatialReference);
}
else
{
newMapPoint = MapPointBuilder.CreateMapPoint(randomGenerator.NextCoordinate(areaOfInterest, false), spatialReference);
}
// queue feature creation
createOperation.Create(pointFeatureLayer, newMapPoint);
}
// execute the edit (feature creation) operation
return createOperation.ExecuteAsync();
}));
}
internal Task <Polyline> CreatePolylineFromPointAsync(MapPoint pt, double tolerance)
{
return(QueuedTask.Run(() =>
{
// create a polyline from a starting point
//use a tolerance to construct the second point
MapPoint pt2 = MapPointBuilder.CreateMapPoint(pt.X + tolerance, pt.Y, pt.SpatialReference);
return PolylineBuilder.CreatePolyline(new List <MapPoint>()
{
pt, pt2
});
}));
}
public async Task <MapPoint> ToMapPoint()
{
if (_mapPoint == null)
{
await QueuedTask.Run(() =>
{
ArcGIS.Core.Geometry.SpatialReference sr = SpatialReferenceBuilder.CreateSpatialReference(WKID);
_mapPoint = MapPointBuilder.CreateMapPoint(Feature.Location.X, Feature.Location.Y, sr);
});
}
return(_mapPoint);
}
public async Task RedrawObservationAsync()
{
await QueuedTask.Run(() =>
{
_disposeInnerLine?.Dispose();
_disposeOuterLine?.Dispose();
if (_measurementPoint?.IsObservationVisible() ?? false)
{
MapView thisView = MapView.Active;
MapPoint measPoint = _measurementPoint?.Point;
MapPoint mapPointObsLine;
if ((measPoint != null) && (!double.IsNaN(measPoint.X)) && (!double.IsNaN(measPoint.Y)))
{
Point winMeasPoint = thisView.MapToScreen(measPoint);
Point winObsPoint = thisView.MapToScreen(Point);
double xdir = ((winMeasPoint.X - winObsPoint.X) * 3) / 2;
double ydir = ((winMeasPoint.Y - winObsPoint.Y) * 3) / 2;
Point winPointObsLine = new Point(winObsPoint.X + xdir, winObsPoint.Y + ydir);
mapPointObsLine = thisView.ScreenToMap(winPointObsLine);
}
else
{
mapPointObsLine = MapPointBuilder.CreateMapPoint((Point.X + (XDir * DistLine)), (Point.Y + (YDir * DistLine)));
}
IList <MapPoint> linePointList = new List <MapPoint>();
linePointList.Add(mapPointObsLine);
linePointList.Add(Point);
Polyline polyline = PolylineBuilder.CreatePolyline(linePointList);
Color outerColorLine = Viewer?.Color ?? Color.DarkGray;
CIMColor cimOuterColorLine = ColorFactory.Instance.CreateColor(Color.FromArgb(255, outerColorLine));
CIMLineSymbol cimOuterLineSymbol = SymbolFactory.Instance.DefaultLineSymbol;
cimOuterLineSymbol.SetColor(cimOuterColorLine);
cimOuterLineSymbol.SetSize(OuterLineSize);
CIMSymbolReference cimOuterLineSymbolRef = cimOuterLineSymbol.MakeSymbolReference();
_disposeOuterLine = thisView.AddOverlay(polyline, cimOuterLineSymbolRef);
Color innerColorLine = Color.LightGray;
CIMColor cimInnerColorLine = ColorFactory.Instance.CreateColor(innerColorLine);
CIMLineSymbol cimInnerLineSymbol = SymbolFactory.Instance.DefaultLineSymbol;
cimInnerLineSymbol.SetColor(cimInnerColorLine);
cimInnerLineSymbol.SetSize(InnerLineSize);
CIMSymbolReference cimInnerLineSymbolRef = cimInnerLineSymbol.MakeSymbolReference();
_disposeInnerLine = thisView.AddOverlay(polyline, cimInnerLineSymbolRef);
}
});
}
public void ProCreateAddInPointTest()
{
MapPoint point = MapPointBuilder.CreateMapPoint(1300757, 554219);
Assert.IsNotNull(point);
AddInPoint addinPoint = new AddInPoint();
addinPoint.Point = point;
string output = addinPoint.Text;
Assert.IsFalse(output.Equals("NA"));
}