/// <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; })); }