/// <summary>
/// Called when a sketch is completed.
/// </summary>
protected override async Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
var popupContent = await QueuedTask.Run(() =>
{
var mapView = MapView.Active;
if (mapView == null)
{
return(null);
}
//Get the features that intersect the sketch geometry.
var result = mapView.GetFeatures(geometry);
//For each feature in the result create a new instance of our custom popup content class.
List <PopupContent> popups = new List <PopupContent>();
foreach (var kvp in result.ToDictionary())
{
kvp.Value.ForEach(id => popups.Add(new DynamicPopupContent(kvp.Key, id)));
}
//Flash the features that intersected the sketch geometry.
mapView.FlashFeature(result);
//return the collection of popup content object.
return(popups);
});
//Create the list of custom popup commands to show at the bottom of the pop-up window.
var commands = CreateCommands();
//Show the custom pop-up with the custom commands and the default pop-up commands.
MapView.Active.ShowCustomPopup(popupContent, CreateCommands(), true);
return(true);
}
protected override async Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
//Add an overlay graphic to the map view
_graphic = await this.AddOverlayAsync(geometry, _lineSymbol.MakeSymbolReference());
//define the text symbol
var textSymbol = new CIMTextSymbol();
//define the text graphic
var textGraphic = new CIMTextGraphic();
await QueuedTask.Run(() =>
{
//Create a simple text symbol
textSymbol = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 8.5, "Corbel", "Regular");
//Sets the geometry of the text graphic
textGraphic.Shape = geometry;
//Sets the text string to use in the text graphic
textGraphic.Text = "This is my line";
//Sets symbol to use to draw the text graphic
textGraphic.Symbol = textSymbol.MakeSymbolReference();
//Draw the overlay text graphic
_graphic = this.ActiveMapView.AddOverlay(textGraphic);
});
return(true);
}
/// <summary>
/// Called when a sketch is completed.
/// </summary>
protected override async Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
var popupContent = await QueuedTask.Run(() =>
{
//Get the features that intersect the sketch geometry.
var result = ActiveMapView.GetFeatures(geometry);
//For each feature in the result create a new instance of our custom pop-up content class.
List <PopupContent> popups = new List <PopupContent>();
foreach (var kvp in result)
{
kvp.Value.ForEach(id => popups.Add(new DynamicPopupContent(kvp.Key, id)));
}
//Flash the features that intersected the sketch geometry.
ActiveMapView.FlashFeature(result);
//return the collection of pop-up content object.
return(popups);
});
//Show the custom pop-up with the custom commands and the default pop-up commands.
ActiveMapView.ShowCustomPopup(popupContent, null, true);
return(true);
}
protected override Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
//Check we only have one feature to extend to
if (MapView.Active.Map.SelectionCount != 1)
{
MessageBox.Show("Please select one polyline or polygon feature to extend to", "Extend");
return(Task.FromResult(true));
}
//Run on MCT
return(QueuedTask.Run(() =>
{
//get selected feature geometry
var selectedFeatures = MapView.Active.Map.GetSelection();
var insp = new Inspector();
insp.Load(selectedFeatures.ToDictionary().Keys.First(), selectedFeatures.ToDictionary().Values.First());
var selGeom = GeometryEngine.Instance.Project(insp.Shape, MapView.Active.Map.SpatialReference);
if (!(selGeom.GeometryType == GeometryType.Polygon ||
selGeom.GeometryType == GeometryType.Polyline))
{
MessageBox.Show("Please choose as the selected feature either a polyline or polygon feature to extend to");
return false;
}
//find feature at the click
var clickFeatures = MapView.Active.GetFeatures(geometry);
var featuresOids = clickFeatures[clickFeatures.ToDictionary().Keys.First()];
insp.Load(clickFeatures.ToDictionary().First().Key, featuresOids.First());
var clickGeom = insp.Shape as Polyline;
if (clickGeom == null)
{
MessageBox.Show("Please select a polyline feature to extend");
return false;
}
//extend the line to the poly?
ArcGIS.Core.Geometry.Polyline extPolyline;
extPolyline = GeometryEngine.Instance.Extend(clickGeom, (selGeom.GeometryType == GeometryType.Polygon ? GeometryEngine.Instance.Boundary(selGeom) as Polyline : selGeom as Polyline), ExtendFlags.Default);
if (extPolyline == null)
{
MessageBox.Show(string.Format("Unable to extend the clicked {0} to the selected {1}",
clickGeom.GeometryType, selGeom.GeometryType));
return false;
}
//set the new geometry back on the feature
insp.Shape = extPolyline;
//create and execute the edit operation
var op = new EditOperation()
{
Name = "Extend",
SelectModifiedFeatures = false,
SelectNewFeatures = false
};
op.Modify(insp);
return op.Execute();
}));
}
/// <summary>
/// Finds the features in the map by the specified criteria, grouped by feature class
/// </summary>
/// <param name="mapView">The map view containing the layers to search</param>
/// <param name="searchGeometry">The search geometry</param>
/// <param name="spatialRelationship">The spatial relationship between the found features
/// and the search geometry.</param>
/// <param name="targetSelectionType">The target selection type that determines which layers
/// are searched.</param>
/// <param name="layerPredicate">An extra layer predicate that allows for a more
/// fine-granular determination of the layers to be searched.</param>
/// <param name="featurePredicate">An extra feature predicate that allows to determine
/// criteria on the feature level.</param>
/// <param name="selectedFeatures">The selected features, relevant only for
/// <see cref="targetSelectionType"/> with value <see cref="TargetFeatureSelection.SameClass"/>. </param>
/// <param name="cancelableProgressor"></param>
/// <returns></returns>
public static IEnumerable <KeyValuePair <FeatureClass, List <Feature> > > FindFeatures(
[NotNull] MapView mapView,
[NotNull] ArcGIS.Core.Geometry.Geometry searchGeometry,
SpatialRelationship spatialRelationship,
TargetFeatureSelection targetSelectionType,
[CanBeNull] Predicate <FeatureLayer> layerPredicate,
[CanBeNull] Predicate <Feature> featurePredicate,
List <Feature> selectedFeatures,
CancelableProgressor cancelableProgressor = null)
{
// NOTE: FeatureLayer.Search is quite useless, as we cannot control recyclability and as soon as the cursor
// is disposed, the feature's geometry is wrong!
// -> Get the distinct feature classes (TODO: include layer definition queries)
IEnumerable <FeatureLayer> featureLayers =
GetLayers <FeatureLayer>(
mapView, fl => IsLayerApplicable(fl, targetSelectionType, layerPredicate,
selectedFeatures));
IEnumerable <IGrouping <IntPtr, FeatureLayer> > layersGroupedByClass =
featureLayers.GroupBy(fl => fl.GetFeatureClass().Handle);
foreach (var layersInClass in layersGroupedByClass)
{
// One query per distinct definition query, then make OIDs distinct
FeatureClass featureClass = null;
List <Feature> features = new List <Feature>();
foreach (IGrouping <string, FeatureLayer> layers in layersInClass.GroupBy(
fl => fl.DefinitionQuery))
{
if (cancelableProgressor != null &&
cancelableProgressor.CancellationToken.IsCancellationRequested)
{
yield break;
}
featureClass = layers.First().GetFeatureClass();
QueryFilter filter =
GdbQueryUtils.CreateSpatialFilter(searchGeometry, spatialRelationship);
filter.WhereClause = layers.Key;
IEnumerable <Feature> foundFeatures = GdbQueryUtils
.GetFeatures(featureClass, filter, false)
.Where(f => featurePredicate == null ||
featurePredicate(f));
features.AddRange(foundFeatures);
}
if (featureClass != null && features.Count > 0)
{
yield return(new KeyValuePair <FeatureClass, List <Feature> >(
featureClass, features.DistinctBy(f => f.GetObjectID()).ToList()));
}
}
}
private static ArcGIS.Core.Geometry.Geometry SRTransform(ArcGIS.Core.Geometry.Geometry inGeometry, int inSRID, int outSRID)
{
ArcGIS.Core.Geometry.Geometry outGeometry;
SpatialReference inSR = SpatialReferenceBuilder.CreateSpatialReference(inSRID);
SpatialReference outSR = SpatialReferenceBuilder.CreateSpatialReference(outSRID);
ProjectionTransformation transformer = ProjectionTransformation.Create(inSR, outSR);
outGeometry = GeometryEngine.Instance.ProjectEx(inGeometry, transformer);
return(outGeometry);
}
private async void OnOpenCloseButtonClicked(object sender, RoutedEventArgs e)
{
DockMeasurementDetail measurementDetail = (DockMeasurementDetail)DataContext;
MeasurementPoint measurementPoint = measurementDetail?.MeasurementPoint;
Measurement measurement = measurementPoint?.Measurement;
if (measurementPoint != null)
{
if (measurementPoint.Open)
{
measurementPoint.ClosePoint();
if (!measurement.IsPointMeasurement)
{
measurement.EnableMeasurementSeries();
}
await measurement.MeasurementPointUpdatedAsync(measurementPoint.PointId);
if (measurement.IsPointMeasurement)
{
MapView mapView = MapView.Active;
Geometry geometry = await mapView.GetCurrentSketchAsync();
VectorLayer layer = measurement.VectorLayer;
long? uid = measurement.ObjectId;
if (geometry != null && uid == null && layer != null)
{
await layer.AddFeatureAsync(geometry);
}
else if (uid != null && layer != null)
{
MapPoint mapPoint = measurementPoint.Point;
await layer.UpdateFeatureAsync((long)uid, mapPoint);
}
}
measurementDetail.SelectedObservation = null;
}
else
{
if (measurement.IsPointMeasurement)
{
measurement.OpenMeasurement();
}
else
{
measurement.DisableMeasurementSeries();
}
measurementPoint.OpenPoint();
}
}
}
public async Task <Boolean> ShowGraphics()
{
return(await QueuedTask.Run(() =>
{
bool retval = false;
myGeometries = GetJsonGeometries();
bool failure = false;
this.message = "JSON successfully converted and drawn";
if (myGeometries.Count == 0)
{
this.message = "Nothing to do...";
return failure;
}
foreach (JObject myGeom in myGeometries)
{
ArcGIS.Core.Geometry.Geometry myGeometry =
this.createGeometryFromJson(myGeom.ToString()).Result;
if (myGeometry != null)
{
//this.showpro.addGraphic(myGeometry, this.OverlaySymbol.Result);
this.showpro.addGraphic(myGeometry, this.OverlaySymbolX(myGeometry.GeometryType).Result);
}
else
{
//failure
failure = true;
break;
}
}
if (failure)
{
this.message = "I can't create a geometry! Check your input.";
}
else
{
retval = true;
if (myGeometries != null)
{
String res = this.showpro.zoomToGeometries();
if (!res.Equals(""))
{
this.message = res;
retval = false;
}
}
}
return retval;
}));
}
public void getPrecintsData(ParcelModel parcel)
{
parcel.precints = properties.precints.Where((precint) =>
{
object precintShape;
precint.precint.TryGetValue("Shape", out precintShape);
object parcelShape;
parcel.parcel.TryGetValue("Shape", out parcelShape);
ArcGIS.Core.Geometry.Polygon precintPolygon = (ArcGIS.Core.Geometry.Polygon)precintShape;
ArcGIS.Core.Geometry.Polygon parcelPolygon = (ArcGIS.Core.Geometry.Polygon)parcelShape;
ArcGIS.Core.Geometry.Geometry geometry = GeometryEngine.Instance.Intersection(precintPolygon, parcelPolygon, GeometryDimension.esriGeometry2Dimension);
return(!geometry.IsEmpty);
}).ToList();
}
protected override Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
try
{
var mp = geometry as MapPoint;
Mediator.NotifyColleagues(VisibilityLibrary.Constants.NEW_MAP_POINT, mp);
}
catch (Exception ex)
{
// do nothing
}
return(base.OnSketchCompleteAsync(geometry));
}
protected override Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
try
{
var mp = geometry as MapPoint;
Mediator.NotifyColleagues(VisibilityLibrary.Constants.NEW_MAP_POINT, mp);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
return(base.OnSketchCompleteAsync(geometry));
}
public void getResolutionData(ParcelModel parcel)
{
parcel.resolutions = properties.resolutions.Where((resolution) =>
{
object resolutionShape;
resolution.resolution.TryGetValue("Shape", out resolutionShape);
object parcelShape;
parcel.parcel.TryGetValue("Shape", out parcelShape);
ArcGIS.Core.Geometry.Polygon resolutionPolygon = (ArcGIS.Core.Geometry.Polygon)resolutionShape;
ArcGIS.Core.Geometry.Polygon parcelPolygon = (ArcGIS.Core.Geometry.Polygon)parcelShape;
ArcGIS.Core.Geometry.Geometry geometry = GeometryEngine.Instance.Intersection(resolutionPolygon, parcelPolygon, GeometryDimension.esriGeometry2Dimension);
return(!geometry.IsEmpty);
}).ToList();
}
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);
}
}
/// <summary>
/// This is a basic FinishSketch method which illustrates the process of using the sketch geometry for a cut.
/// 1. Create edit operation
/// 2. Use the sketch geometry to perform a spatial query
/// 3. Use the found features and use them to set up a cut operation
/// 3. Execute the edit operation
///
/// </summary>
/// <returns>Task of bool</returns>
protected override async Task <bool> FinishSketch(ArcGIS.Core.Geometry.Geometry geometry,
Dictionary <string, object> attributes)
{
if (CurrentTemplate == null)
{
return(false);
}
// intialize a list of ObjectIDs that need to be cut
List <int> cutOIDs = new List <int>();
Table fc = await this.CurrentTemplate.Layer.getFeatureClass();
// on a separate thread
await QueuingTaskFactory.StartNew(() => {
// find the features crossed by the sketch geometry
RowCursor rc = fc.Search(geometry, SpatialRelationship.Crosses);
// add the feature IDs into our prepared list
while (rc.MoveNext())
{
cutOIDs.Add(rc.Current.ObjectID);
}
});
if (!cutOIDs.Any())
{
return(true);//nothing to cut
}
// create an edit operation for the cut
var op = await EditingModule.CreateEditOperationAsync();
op.Name = string.Format("Cut {0}", this.CurrentTemplate.Layer.Name);
op.ProgressMessage = "Working...";
op.CancelMessage = "Operation canceled";
op.ErrorMessage = "Error cutting features";
op.SelectModifiedFeatures = false;
op.SelectNewFeatures = false;
// for each of the found features set up a cut method inside our edit operation
// for multiple ObjectIDs the cuts with will be stacked into one operation
foreach (var oid in cutOIDs)
{
op.Cut(this.CurrentTemplate.Layer, oid, geometry);
}
//execute the operation
return(await op.ExecuteAsync());
}
/// <summary>
/// Method used to check to see if a point is contained by an envelope
/// </summary>
/// <param name="point">MapPoint</param>
/// <param name="env">Envelope</param>
/// <returns>bool</returns>
internal async Task <bool> IsPointWithinExtent(MapPoint point, Envelope env)
{
if ((point == null) || (env == null) || (env.SpatialReference == null))
{
return(false);
}
var result = await QueuedTask.Run(() =>
{
ArcGIS.Core.Geometry.Geometry projectedPoint = GeometryEngine.Instance.Project(point, env.SpatialReference);
return(GeometryEngine.Instance.Contains(env, projectedPoint));
});
return(result);
}
protected async override Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
await QueuedTask.Run(async() =>
{
var polygonTemplate = MapView.Active.Map.FindLayers("Clip_Polygon_Asphalt").FirstOrDefault().GetTemplate("Clip_Polygon_Asphalt");
// Create an edit operation
var createOperation = new EditOperation();
createOperation.Name = string.Format("Create {0}", "Volume Polygon");
createOperation.SelectNewFeatures = true;
createOperation.Create(polygonTemplate, geometry);
// Execute the operation
await createOperation.ExecuteAsync();
});
return(true);
}
public void addResolutionsToParcel(ParcelModel currentParcel)
{
Task t = QueuedTask.Run(() =>
{
var models = propertiesAccepted.resolutions.Where((resolution) =>
{
object resolutionShape;
resolution.resolution.TryGetValue("Shape", out resolutionShape);
object parcelShape;
currentParcel.parcel.TryGetValue("Shape", out parcelShape);
ArcGIS.Core.Geometry.Polygon resolutionPolygon = (ArcGIS.Core.Geometry.Polygon)resolutionShape;
ArcGIS.Core.Geometry.Polygon parcelPolygon = (ArcGIS.Core.Geometry.Polygon)parcelShape;
ArcGIS.Core.Geometry.Geometry geometry = GeometryEngine.Instance.Intersection(resolutionPolygon, parcelPolygon, GeometryDimension.esriGeometry2Dimension);
return(!geometry.IsEmpty);
}).ToList();
currentParcel.resolutions = models;
});
}
private static ArcGIS.Core.Geometry.Geometry GetSearchGeometry(
[NotNull] IList <Feature> intersectingFeatures,
[CanBeNull] Envelope clipExtent)
{
var intersectingGeometries =
GetSearchGeometries(intersectingFeatures, clipExtent);
ArcGIS.Core.Geometry.Geometry result = null;
if (intersectingGeometries.Count != 0)
{
var sr = intersectingGeometries[0].SpatialReference;
result = GeometryBagBuilder.CreateGeometryBag(intersectingGeometries, sr);
//result = GeometryEngine.Instance.Union(intersectingGeometries);
}
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;
}));
}
private static Uri GetImagePath(Geometry geometry)
{
if (geometry.GeometryType == GeometryType.Point)
{
return(new Uri(@"pack://*****:*****@"pack://application:,,,/ProSuite.AGP.Editing;component/PickerUI/Images/LineGeometry.bmp"));
}
if (geometry.GeometryType == GeometryType.Polygon)
{
return(new Uri(
@"pack://application:,,,/ProSuite.AGP.Editing;component/PickerUI/Images/PolygonGeometry.bmp"));
}
return(new Uri(""));
}
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
return(QueuedTask.Run(() =>
{
var mapView = MapView.Active;
if (mapView == null)
{
return true;
}
//Get all the features that intersect the sketch geometry and flash them in the view.
var results = mapView.GetFeatures(geometry);
mapView.FlashFeature(results);
//Show a message box reporting each layer the number of the features.
MessageBox.Show(
String.Join("\n", results.Select(kvp => String.Format("{0}: {1}", kvp.Key.Name, kvp.Value.Count()))),
"Identify Result");
return true;
}));
}
/// <summary>
/// Returns features filtered by spatial relationship. Honors definition queries on the layer.
/// </summary>
public static IEnumerable <Feature> FilterLayerFeaturesByGeometry(
BasicFeatureLayer layer, ArcGIS.Core.Geometry.Geometry filterGeometry,
SpatialRelationship spatialRelationship = SpatialRelationship.Intersects)
{
var qf = new SpatialQueryFilter()
{
FilterGeometry = filterGeometry,
SpatialRelationship = spatialRelationship
};
var features = new List <Feature>();
using (RowCursor rowCursor = layer.Search(qf))
{
while (rowCursor.MoveNext())
{
features.Add((Feature)rowCursor.Current);
}
}
return(features);
}
/// <summary>
/// Returns oids of features filtered by spatial relationship. Honors definition queries on the layer.
/// </summary>
public static IEnumerable <long> FilterLayerOidsByGeometry(
BasicFeatureLayer layer, ArcGIS.Core.Geometry.Geometry filterGeometry,
SpatialRelationship spatialRelationship = SpatialRelationship.Intersects)
{
var qf = new SpatialQueryFilter()
{
FilterGeometry = filterGeometry,
SpatialRelationship = spatialRelationship
};
var oids = new List <long>();
using (RowCursor rowCursor = layer.Search(qf))
{
while (rowCursor.MoveNext())
{
oids.Add(rowCursor.Current.GetObjectID());
}
}
return(oids);
}
public void CIMPictureGraphicOverlay(Geometry geometry, ArcGIS.Core.Geometry.Envelope envelope)
{
#region Graphic Overlay with CIMPictureGraphic
// get the current mapview
var mapView = MapView.Active;
if (mapView == null)
{
return;
}
//Valid formats for PictureURL are:
// e.g. local file URL:
// file:///<path>
// file:///c:/images/symbol.png
//
// e.g. network file URL:
// file://<host>/<path>
// file://server/share/symbol.png
//
// e.g. data URL:
// data:<mediatype>;base64,<data>
// data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAU ...
//
// image/bmp
// image/gif
// image/jpeg
// image/png
// image/tiff
// image/x-esri-bglf
var pictureGraphic = new CIMPictureGraphic
{
PictureURL = @"file:///C:/Images/MyImage.png",
Box = envelope
};
IDisposable _graphic = mapView.AddOverlay(pictureGraphic);
#endregion
}
private void GetOwnShip()
{
var task = QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
FeatureClass ownShip = geodatabase.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_OwnShip);
string shapeField = ownShip.GetDefinition().GetShapeField();
QueryFilter qf = new QueryFilter()
{
ObjectIDs = new List <long>()
{
1
}
};
using (RowCursor rowCursor = ownShip.Search(qf, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
sog = row[ConstDefintion.ConstFieldName_sog].ToString();
cog = row[ConstDefintion.ConstFieldName_cog].ToString();
length = row[ConstDefintion.ConstFieldName_length].ToString();
width = row[ConstDefintion.ConstFieldName_width].ToString();
ArcGIS.Core.Geometry.Geometry geometry = row[shapeField] as ArcGIS.Core.Geometry.Geometry;
MapPoint p = geometry as MapPoint;
MapPoint p_project = GeometryEngine.Instance.Project(p, SpatialReferenceBuilder.CreateSpatialReference(4326)) as MapPoint;
locationX = p_project.X.ToString("0.0000");
locationY = p_project.Y.ToString("0.0000");
}
}
}
}
});
task.Wait();
}
async private void Image_MouseEnter(object sender, MouseEventArgs e)
{
Polygon polygon;
var blackSolidLineSymbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlueRGB, 5, SimpleLineStyle.Solid);
Geometry geometry = null;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
SpatialReference inSR = SpatialReferenceBuilder.CreateSpatialReference(32604);
SpatialReference sr4326 = SpatialReferences.WGS84;
SpatialReference sr3857 = SpatialReferences.WebMercator;
ProjectionTransformation projTransFromSRs = ArcGIS.Core.Geometry.ProjectionTransformation.Create(inSR, sr3857);
List <Coordinate2D> coordinates = new List <Coordinate2D>()
{
//new Coordinate2D(-159.20168702818188, 21.876487211082708),
//new Coordinate2D(-159.42653907783114, 21.838951660451173),
//new Coordinate2D(-159.44077880308507, 21.94718691051718),
//new Coordinate2D(-159.21630329750306, 21.94718691051718),
//new Coordinate2D(-159.21413990271841, 21.9365008022738),
//new Coordinate2D(-159.21383956606297, 21.93655454291286),
//new Coordinate2D(-159.20168702818188, 21.876487211082708),
new Coordinate2D(-17773406.8675, 2478583.7239999995),
new Coordinate2D(-17773406.8675, 2578583.7239999995),
new Coordinate2D(-16773406.8675, 2578583.7239999995),
new Coordinate2D(-17773406.8675, 2478583.7239999995)
};
//MapPoint point = new MapPointBuilder.FromGeoCoordinateString()
//List<MapPoint> mapPoints = new List<MapPoint>();
//foreach (Coordinate2D item in coordinates)
//{
// MapPoint point = new MapPointBuilder()
//}
//mapPoints.Add( coordinates[0].ToMapPoint());
MapPointBuilder asas = new MapPointBuilder(new Coordinate2D(-159.20168702818188, 21.876487211082708), MapView.Active.Extent.SpatialReference);
_polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.BlackRGB, SimpleFillStyle.Null, SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid));
MapPoint point = asas.ToGeometry();
MapPoint point2 = MapPointBuilder.FromGeoCoordinateString(point.ToGeoCoordinateString(new ToGeoCoordinateParameter(GeoCoordinateType.DD)), MapView.Active.Extent.SpatialReference, GeoCoordinateType.DD);
using (PolygonBuilder polygonBuilder = new PolygonBuilder(coordinates, inSR))
{
polygonBuilder.SpatialReference = inSR;
polygon = polygonBuilder.ToGeometry();
geometry = polygonBuilder.ToGeometry();
Geometry geometry2 = GeometryEngine.Instance.ProjectEx(geometry, projTransFromSRs);
_graphic = MapView.Active.AddOverlayAsync(geometry, _polygonSymbol.MakeSymbolReference());
//Application.Current.
}
});
//await QueuedTask.Run(() =>
//{
// MapView.Active.UpdateOverlay(_graphic, point, SymbolFactory.Instance.ConstructPointSymbol(
// ColorFactory.Instance.BlueRGB, 20.0, SimpleMarkerStyle.Circle).MakeSymbolReference());
//});
//_graphic = await this.AddOverlayAsync(geometry, _lineSymbol.MakeSymbolReference());
Console.WriteLine(sender.ToString());
//_graphic = MapView.Active.AddOverlay(geometry, _lineSymbol.MakeSymbolReference());
//Geometry geometry = new PolygonBuilder.CreatePolygon(coordinates, inSR); ;
}
/// <summary>
/// Called when a sketch is completed.
/// </summary>
protected override async Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
List <PopupContent> popupContent = await QueuedTask.Run(() =>
{
//Get the features that intersect the sketch geometry.
var mapPoint = geometry as MapPoint;
var sb = new StringBuilder();
sb.AppendLine(string.Format("OnSketchCompleteAsync X: {0}", mapPoint.X));
sb.Append(string.Format("Y: {0}", mapPoint.Y));
if (mapPoint.HasZ)
{
sb.AppendLine();
sb.Append(string.Format("Z: {0}", mapPoint.Z));
}
MessageBox.Show(sb.ToString());
var result = ActiveMapView.GetFeatures(geometry);
//For each feature in the result create a new instance of our custom pop-up content class.
List <PopupContent> popups = new List <PopupContent>();
foreach (var kvp in result)
{
//kvp.Value.ForEach(id => popups.Add(new DynamicPopupContent(kvp.Key, id)));
//kvp.Value.ForEach(id => popups.Add(new PopupContent(new Uri("https://www.google.com/webhp?ie=UTF-8&rct=j"), "xxxx")));
//popups.Add(new PopupContent("<b>This text is bold.</b>", "Custom tooltip from HTML string"));
var layer = kvp.Key as BasicFeatureLayer;
if (layer == null)
{
continue;
}
var fields = layer.GetFieldDescriptions().Where(f => f.Name == "DI_JI_HAO");
var tableDef = layer.GetTable().GetDefinition();
var oidField = tableDef.GetObjectIDField();
foreach (var id in kvp.Value)
{
//获取地级编号
//DI_JI_HAO
var qf = new QueryFilter()
{
WhereClause = $"{oidField} = {id}", SubFields = string.Join(",", fields.Select(f => f.Name))
};
var rows = layer.Search(qf);
if (!rows.MoveNext())
{
continue;
}
using (var row = rows.Current)
{
foreach (var field in fields)
{
var val = row[field.Name];
if (field.Name == "DI_JI_HAO")
{
PopupContent pc = new PopupContent(new Uri("http://59.42.105.34:5001/client/?id=" + val), "林业");
popups.Add(pc);
}
}
}
}
}
//Flash the features that intersected the sketch geometry.
ActiveMapView.FlashFeature(result);
//return the collection of pop-up content object.
return(popups);
});
var height = System.Windows.SystemParameters.WorkArea.Height / 2;
var width = System.Windows.SystemParameters.WorkArea.Width / 2;
var topLeftCornerPoint = new System.Windows.Point(0, 0);
var popupDef = new PopupDefinition()
{
Append = true, // if true new record is appended to existing (if any)
Dockable = true, // if true popup is dockable - if false Append is not applicable
Position = topLeftCornerPoint, // Position of top left corner of the popup (in pixels)
Size = new System.Windows.Size(width, height) // size of the popup (in pixels)
};
//Show the custom pop-up with the custom commands and the default pop-up commands.
ActiveMapView.ShowCustomPopup(popupContent, null, true, popupDef);
return(true);
}
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
return(base.OnSketchCompleteAsync(geometry));
}
protected override Task <bool> OnSketchCompleteAsync(Geometry userClickGeometry)
{
return(QueuedTask.Run(() =>
{
var mapView = MapView.Active;
if (mapView == null)
{
return true;
}
// Get all the features that intersect the sketch userClickGeometry and flash them in the view.
var results = mapView.GetFeatures(userClickGeometry);
// Filter out layers that don't contain the name roads
var selectedRoads = results.Where(x => x.Key.Name.ToLower().Contains("road"))
.ToDictionary(key => key.Key, value => value.Value);
mapView.FlashFeature(selectedRoads);
foreach (var kvp in selectedRoads)
{
var fields = kvp.Key.GetFieldDescriptions();
var rangeFields = new Dictionary <string, string>
{
{ "leftFrom", fields.Single(x => _leftsFroms.Contains(x.Name.ToUpper())).Name },
{ "leftTo", fields.Single(x => _leftsTos.Contains(x.Name.ToUpper())).Name },
{ "rightFrom", fields.Single(x => _rightFroms.Contains(x.Name.ToUpper())).Name },
{ "rightTo", fields.Single(x => _rightTos.Contains(x.Name.ToUpper())).Name },
};
var filter = new QueryFilter
{
WhereClause = $"OBJECTID = {kvp.Value[0]}",
SubFields = "*"
};
using (var cursor = kvp.Key.Search(filter))
{
while (cursor.MoveNext())
{
using (var row = cursor.Current)
{
var lf = row[rangeFields["leftFrom"]];
var lt = row[rangeFields["leftTo"]];
var rf = row[rangeFields["rightFrom"]];
var rt = row[rangeFields["rightTo"]];
var shape = (Polyline)row["Shape"];
var point = (MapPoint)GeometryEngine.Instance.Project(userClickGeometry, shape.SpatialReference);
var proximity = GeometryEngine.Instance.NearestPoint(shape, point);
var distance = proximity.Distance * 2;
var vertices = new List <Coordinate2D>
{
new Coordinate2D(point),
new Coordinate2D(proximity.Point),
};
var polyline = PolylineBuilder.CreatePolyline(vertices, point.SpatialReference);
var extension = GeometryEngine.Instance.MovePointAlongLine(polyline, distance, false, 0,
SegmentExtension.ExtendEmbedded);
vertices.Add(new Coordinate2D(extension));
polyline = PolylineBuilder.CreatePolyline(vertices, point.SpatialReference);
var parts = GeometryEngine.Instance.Cut(shape, polyline);
var totalLength = shape.Length;
var polylines = parts.Select(x => (Polyline)x).ToArray();
var template = $"Left From {lf} To {lt}\n" +
$"Right From: {rf} To: {rt}\n" +
$"Part one: {polylines[0].Length / totalLength:P2}\n" +
$"Part two: {polylines[1].Length/totalLength:P2}\n";
MessageBox.Show(template, "Range Finder 2000");
}
}
}
}
return true;
}));
}
