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;
}
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();
}));
}
protected void UpdateAttrib()
{
QueuedTask.Run(() =>
{
//get the geometry of the selected feature.
var selectedFeatures = MapView.Active.Map.GetSelection();
var insp = new Inspector();
insp.Load(selectedFeatures.Keys.First(), selectedFeatures.Values.First());
var selGeom = insp.Shape;
//var extPolyline = some geometry operation.
var extPolyline = new MapPointBuilder(1.0, 1.0).ToGeometry();
//set the new geometry back on the feature
insp.Shape = extPolyline;
//update an attribute value
insp["RouteNumber"] = 42;
//create and execute the edit operation
var op = new EditOperation()
{
Name = "Extend"
};
op.Modify(insp);
op.Execute();
});
}
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);
}
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>
/// 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);
}
private static Geometry GetGeometryFromBuffer(byte[] geomBuffer, SpatialReference sr)
{
var geomType = GetGeometryType(geomBuffer);
switch (geomType)
{
case GeometryType.Point:
{
int offset = 4;
double x = DoubleWithNaN(BitConverter.ToDouble(geomBuffer, offset));
offset += 8;
double y = DoubleWithNaN(BitConverter.ToDouble(geomBuffer, offset));
var mp = MapPointBuilder.FromEsriShape(geomBuffer, sr);
//System.Diagnostics.Debug.WriteLine($@"x: {x} = {mp.X} y: {y} = {mp.Y}");
return(mp);
}
case GeometryType.Polyline:
{
var line = PolylineBuilder.FromEsriShape(geomBuffer, sr);
return(line);
}
case GeometryType.Polygon:
{
var poly = PolygonBuilder.FromEsriShape(geomBuffer, sr);
return(poly);
}
}
return(null);
}
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)));
}
/// <summary>
/// Get the current row, convert the data to a plugin row
/// Project the data in the right projection.
/// </summary>
/// <returns></returns>
public override PluginRow GetCurrentRow()
{
if (StationMeasurements != null && StationMeasurements.Current != null)
{
// Create a point
MapPointBuilder location = new MapPointBuilder(StationMeasurements.Current.Lon, StationMeasurements.Current.Lat, new SpatialReferenceBuilder(4326).ToSpatialReference());
// Convert point to rd point.
Geometry locationRD = GeometryEngine.Instance.Project(location.ToGeometry(), SpatialReferenceBuilder.CreateSpatialReference(28992));
// Convert attribute data
var listOfRowValues = new List <object>();
listOfRowValues.Add(StationMeasurements.Current.Stationid);
listOfRowValues.Add(StationMeasurements.Current.Stationname);
listOfRowValues.Add(StationMeasurements.Current.Temperature);
listOfRowValues.Add(StationMeasurements.Current.Timestamp);
listOfRowValues.Add(StationMeasurements.Current.Weatherdescription);
listOfRowValues.Add(StationMeasurements.Current.Iconurl);
listOfRowValues.Add(StationMeasurements.Current.Humidity);
listOfRowValues.Add(StationMeasurements.Current.Sunpower);
listOfRowValues.Add(StationMeasurements.Current.Airpressure);
listOfRowValues.Add(StationMeasurements.Current.Visibility);
// Add the geometry
listOfRowValues.Add(locationRD);
return(new PluginRow(listOfRowValues));
}
return(new PluginRow());
}
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 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
}
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);
}
}));
}
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);
}
/// <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;
}
private async void UpdateManualFeedback()
{
if (LineFromType == LineFromTypes.BearingAndDistance && Azimuth.HasValue && HasPoint1 && Point1 != null)
{
GeodeticCurveType curveType = DeriveCurveType(LineType);
LinearUnit lu = DeriveUnit(LineDistanceType);
// update feedback
var segment = QueuedTask.Run(() =>
{
var mpList = new List <MapPoint>()
{
Point1
};
// get point 2
// SDK Bug, GeometryEngine.GeodesicMove seems to not honor the LinearUnit passed in, always does Meters
var tempDistance = ConvertFromTo(LineDistanceType, DistanceTypes.Meters, Distance);
var results = GeometryEngine.Instance.GeodeticMove(mpList, MapView.Active.Map.SpatialReference, tempDistance, LinearUnit.Meters /*GetLinearUnit(LineDistanceType)*/, GetAzimuthAsRadians().Value, GetCurveType());
foreach (var mp in results)
{
// WORKAROUND: For some odd reason GeodeticMove is removing the Z attribute of the point
// so need to put it back so all points will have a consistent Z.
// This is important when storing to feature class with Z
if (mp == null)
{
continue;
}
if (Double.IsNaN(mp.Z))
{
MapPointBuilder mb = new MapPointBuilder(mp.X, mp.Y, 0.0, mp.SpatialReference);
Point2 = mb.ToGeometry();
}
else
{
Point2 = mp;
}
}
if (Point2 != null)
{
var point2Proj = GeometryEngine.Instance.Project(Point2, Point1.SpatialReference);
return(LineBuilder.CreateLineSegment(Point1, (MapPoint)point2Proj));
}
else
{
return(null);
}
}).Result;
if (segment != null)
{
await UpdateFeedbackWithGeoLine(segment, curveType, lu);
}
}
else
{
ClearTempGraphics(); // if not, or no longer, valid clear
}
}
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)));
}
public static MapPoint MidPoint(MapPoint p1, MapPoint p2)
{
MapPointBuilder p = new MapPointBuilder(p1.SpatialReference);
p.X = (p1.X + p2.X) / 2.0;
p.Y = (p1.Y + p2.Y) / 2.0;
return(p.ToGeometry());
}
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);
}
private static async Task CreateFeatures(List <MapPoint> mapPointList)
{
RowBuffer rowBuffer = null;
try
{
await QueuedTask.Run(() =>
{
var layer = MapView.Active.GetSelectedLayers()[0];
if (layer is FeatureLayer)
{
var featureLayer = layer as FeatureLayer;
using (var table = featureLayer.GetTable())
{
TableDefinition definition = table.GetDefinition();
int shapeIndex = definition.FindField("Shape");
foreach (var point in mapPointList)
{
rowBuffer = table.CreateRowBuffer();
rowBuffer[shapeIndex] = new MapPointBuilder(point).ToGeometry();
Row row = table.CreateRow(rowBuffer);
}
}
//Get simple renderer from feature layer
CIMSimpleRenderer currentRenderer = featureLayer.GetRenderer() as CIMSimpleRenderer;
CIMSymbolReference sybmol = currentRenderer.Symbol;
//var outline = SymbolFactory.ConstructStroke(ColorFactory.RedRGB, 1.0, SimpleLineStyle.Solid);
//var s = SymbolFactory.ConstructPolygonSymbol(ColorFactory.RedRGB, SimpleFillStyle.Null, outline);
var s = SymbolFactory.ConstructPointSymbol(ColorFactory.RedRGB, 3.0);
CIMSymbolReference symbolRef = new CIMSymbolReference()
{
Symbol = s
};
currentRenderer.Symbol = symbolRef;
featureLayer.SetRenderer(currentRenderer);
}
});
}
catch (GeodatabaseException exObj)
{
Console.WriteLine(exObj);
throw;
}
finally
{
if (rowBuffer != null)
{
rowBuffer.Dispose();
}
}
}
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);
}
public static MapPoint InterpolatePointOnLine(MapPoint p1, MapPoint p2, double scale)
{
MapPointBuilder p = new MapPointBuilder(p1.SpatialReference);
double x = 0.0, y = 0.0;
GeometryAlgorithms.InterpolatePointOnLine(p1.X, p1.Y, p2.X, p2.Y, scale, ref x, ref y);
p.X = x;
p.Y = y;
return(p.ToGeometry());
}
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
}
// Helper method
private static PointCollection FromArray(params double[] parameters)
{
PointCollection coll = new PointCollection(SpatialReferences.Wgs84);
var mapPointBuilder = new MapPointBuilder(SpatialReferences.Wgs84);
for (int i = 0; i < parameters.Length - 1; i+=2)
{
mapPointBuilder.SetValues(parameters[i], parameters[i + 1]);
coll.Add(mapPointBuilder.ToGeometry());
}
return coll;
}
public static MapPoint MidPoint(MapPoint p1, MapPoint p2)
{
MapPointBuilder p = new MapPointBuilder(p1.SpatialReference);
p.X = (p1.X + p2.X) / 2.0;
p.Y = (p1.Y + p2.Y) / 2.0;
return p.ToGeometry();
}
public static MapPoint InterpolatePointOnLine(MapPoint p1, MapPoint p2, double scale)
{
MapPointBuilder p = new MapPointBuilder(p1.SpatialReference);
double x = 0.0, y = 0.0;
GeometryAlgorithms.InterpolatePointOnLine(p1.X, p1.Y, p2.X, p2.Y, scale, ref x, ref y);
p.X = x;
p.Y = y;
return p.ToGeometry();
}
VectorArrowPoints(double beginPntX, double beginPntY, MapPoint endPnt)
{
double x = beginPntX - endPnt.X;
double y = beginPntY - endPnt.Y;
double angle = Math.Atan2(y, x);
double alpha = Math.PI / 6; // arrow is 30 degree by each side of original line
double length = Math.Sqrt(x * x + y * y) * 0.25; // arrow is a quarter of original length
MapPointBuilder p1 = new MapPointBuilder(endPnt);
MapPointBuilder p2 = new MapPointBuilder(endPnt);
p1.X += length * Math.Cos(angle + alpha);
p1.Y += length * Math.Sin(angle + alpha);
p2.X += length * Math.Cos(angle - alpha);
p2.Y += length * Math.Sin(angle - alpha);
Esri.ArcGISRuntime.Geometry.PointCollection pc = new Esri.ArcGISRuntime.Geometry.PointCollection();
pc.Add(p1.ToGeometry());
pc.Add(endPnt);
pc.Add(p2.ToGeometry());
return pc;
}
