private void btnEdit_Click(object sender, EventArgs e) { LayerOverlay layerOverlay = (LayerOverlay)winformsMap1.Overlays["StreetsOverlay"]; ShapeFileFeatureLayer layer1 = (ShapeFileFeatureLayer)layerOverlay.Layers["Streets"]; //Edit the geometry of a street feature. layer1.Open(); layer1.FeatureSource.BeginTransaction(); Collection <Feature> features = layer1.FeatureSource.GetFeaturesByColumnValue("RECID", "13762", ReturningColumnsType.AllColumns); //Gets the MultilineShape and add a vertes MultilineShape newMultiLineShape = (MultilineShape)features[0].GetShape(); newMultiLineShape.Lines[0].Vertices.Add(new Vertex(-97.8015, 30.2880)); //Sets the Id of the MultilineShape the same as the feature newMultiLineShape.Id = features[0].Id; //Updates the feature with the new geometry. layer1.FeatureSource.UpdateFeature(newMultiLineShape, features[0].ColumnValues); layer1.FeatureSource.CommitTransaction(); layer1.Close(); winformsMap1.Refresh(layerOverlay); btnEdit.Enabled = false; }
public static MultilineShape GetDifference(this LineShape masterLine, AreaBaseShape clippingArea) { MultilineShape resultMultiLineShape = new MultilineShape(); var masterGeoLine = SqlGeometry.STGeomFromWKB(new SqlBytes(masterLine.GetWellKnownBinary()), 0); var clippingGeoArea = SqlGeometry.STGeomFromWKB(new SqlBytes(clippingArea.GetWellKnownBinary()), 0); var resultWkb = masterGeoLine.STSymDifference(clippingGeoArea).MakeValid().STAsBinary().Value; var resultFeature = new Feature(resultWkb); var resultShape = resultFeature.GetShape(); if (resultShape is GeometryCollectionShape) { foreach (var line in ((GeometryCollectionShape)resultFeature.GetShape()).Shapes.OfType <LineShape>()) { resultMultiLineShape.Lines.Add(line); } } else if (resultShape is MultilineShape) { foreach (var item in ((MultilineShape)resultShape).Lines) { resultMultiLineShape.Lines.Add(item); } } else if (resultShape is LineShape) { resultMultiLineShape.Lines.Add((LineShape)resultShape); } return(resultMultiLineShape); }
private void mapView_Loaded(object sender, RoutedEventArgs e) { mapView.MapUnit = GeographyUnit.Meter; mapView.ZoomLevelSet = new ThinkGeoCloudMapsZoomLevelSet(); mapView.CurrentExtent = new RectangleShape(-15495673, 20037508, 13458526, -20037508); // Create background world map with vector tile requested from ThinkGeo Cloud Service. ThinkGeoCloudVectorMapsOverlay thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay(SampleHelper.ThinkGeoCloudId, SampleHelper.ThinkGeoCloudSecret, ThinkGeoCloudVectorMapsMapType.Light); mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay); // Setup the shapefile layer. ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(SampleHelper.Get("Countries02_3857.shp")); worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyle.CreateSimpleAreaStyle(GeoColors.Transparent, GeoColor.FromArgb(100, GeoColors.Green)); worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; // Setup the mapshape layer. InMemoryFeatureLayer bitmapLayer = new InMemoryFeatureLayer(); bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Image; bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(SampleHelper.Get("Prop Plane.png")); bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Red, 1F, LineDashStyle.Dash, false); bitmapLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; ProjectionConverter project = new ProjectionConverter(4326, 3857); project.Open(); PointShape planeShape = new PointShape(-95.2806, 38.9554); PointShape destinationPoint = new PointShape(36.04, 48.49); MultilineShape airLineShape = (MultilineShape)project.ConvertToExternalProjection(planeShape.GreatCircle(destinationPoint)); airLineShape.Id = "AirLine"; bitmapLayer.Open(); bitmapLayer.EditTools.BeginTransaction(); bitmapLayer.EditTools.Add(new Feature(project.ConvertToExternalProjection(planeShape).GetWellKnownBinary(), "Plane")); bitmapLayer.EditTools.Add(new Feature(airLineShape.GetWellKnownBinary(), "AirLine")); bitmapLayer.EditTools.CommitTransaction(); bitmapLayer.Close(); project.Close(); LayerOverlay worldOverlay = new LayerOverlay(); worldOverlay.Layers.Add("WorldLayer", worldLayer); mapView.Overlays.Add("WorldOverlay", worldOverlay); LayerOverlay planeOverlay = new LayerOverlay(); planeOverlay.TileType = TileType.SingleTile; planeOverlay.Layers.Add("BitmapLayer", bitmapLayer); mapView.Overlays.Add("PlaneOverlay", planeOverlay); mapView.Refresh(); timer.Start(); }
private static IEnumerable <PointShape> CollectPoints(MultilineShape mline) { foreach (var line in mline.Lines) { foreach (var point in CollectPoints(line)) { yield return(point); } } }
protected override void DrawCore(IEnumerable <Feature> features, GeoCanvas canvas, Collection <SimpleCandidate> labelsInThisLayer, Collection <SimpleCandidate> labelsInAllLayers) { PointStyle pointStyle = new PointStyle(geoImage); foreach (Feature feature in features) { MultilineShape lineShape = (MultilineShape)feature.GetShape(); lineStyle.Draw(new BaseShape[] { lineShape }, canvas, labelsInThisLayer, labelsInAllLayers); List <Vertex> allVertices = lineShape.Lines.SelectMany(l => l.Vertices).ToList(); double totalDistance = 0; for (int i = 0; i < allVertices.Count - 1; i++) { PointShape pointShape1 = new PointShape(allVertices[i]); PointShape pointShape2 = new PointShape(allVertices[i + 1]); LineShape tempLineShape = new LineShape(); tempLineShape.Vertices.Add(allVertices[i]); tempLineShape.Vertices.Add(allVertices[i + 1]); double angle = GetAngleFromTwoVertices(allVertices[i], allVertices[i + 1]); // Left side if (imageDirection == ImageDirection.Left) { if (angle >= 270) { angle -= 180; } } // Right side else { if (angle <= 90) { angle += 180; } } pointStyle.RotationAngle = (float)angle; float screenDistance = ExtentHelper.GetScreenDistanceBetweenTwoWorldPoints(canvas.CurrentWorldExtent, pointShape1, pointShape2, canvas.Width, canvas.Height); double currentDistance = Math.Round(pointShape1.GetDistanceTo(pointShape2, canvas.MapUnit, DistanceUnit.Meter), 2); double worldInterval = (currentDistance * imageSpacing) / screenDistance; while (totalDistance <= currentDistance) { PointShape tempPointShape = tempLineShape.GetPointOnALine(StartingPoint.FirstPoint, totalDistance, canvas.MapUnit, DistanceUnit.Meter); pointStyle.Draw(new BaseShape[] { tempPointShape }, canvas, labelsInThisLayer, labelsInAllLayers); totalDistance = totalDistance + worldInterval; } totalDistance = totalDistance - currentDistance; } } }
private void btnGetShortestLine_Click(object sender, EventArgs e) { InMemoryFeatureLayer inMemoryLayer = (InMemoryFeatureLayer)winformsMap1.FindFeatureLayer("InMemoryFeatureLayer"); InMemoryFeatureLayer shortestLineLayer = (InMemoryFeatureLayer)winformsMap1.FindFeatureLayer("ShortestLineLayer"); BaseShape areaShape1 = inMemoryLayer.InternalFeatures["AreaShape1"].GetShape(); BaseShape areaShape2 = inMemoryLayer.InternalFeatures["AreaShape2"].GetShape(); MultilineShape multiLineShape = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter); shortestLineLayer.InternalFeatures.Clear(); shortestLineLayer.InternalFeatures.Add("ShortestLine", new Feature(multiLineShape.GetWellKnownBinary(), "ShortestLine")); winformsMap1.Refresh(winformsMap1.Overlays["ShortestLineOverlay"]); }
private void EfficientlyMoveAPlaneImage_Load(object sender, EventArgs e) { timer.Interval = 200; timer.Tick += new EventHandler(timer_Tick); winformsMap1.MapUnit = GeographyUnit.DecimalDegree; winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean); WorldMapKitWmsDesktopOverlay worldMapKitDesktopOverlay = new WorldMapKitWmsDesktopOverlay(); winformsMap1.Overlays.Add(worldMapKitDesktopOverlay); // Setup the shapefile layer. ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(Samples.RootDirectory + @"Data\Countries02.shp"); worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green)); worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; // Setup the mapshape layer. InMemoryFeatureLayer bitmapLayer = new InMemoryFeatureLayer(); bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap; bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(Samples.RootDirectory + @"Data\Prop Plane.png"); bitmapLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.ContestedBorder2; bitmapLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; PointShape planeShape = new PointShape(-95.2806, 38.9554); PointShape destinationPoint = new PointShape(36.04, 48.49); MultilineShape airLineShape = planeShape.GreatCircle(destinationPoint); bitmapLayer.InternalFeatures.Add("Plane", new Feature(planeShape)); bitmapLayer.InternalFeatures.Add("AirLine", new Feature(airLineShape)); LayerOverlay worldOverlay = new LayerOverlay(); worldOverlay.Layers.Add("WorldLayer", worldLayer); winformsMap1.Overlays.Add("WorldOverlay", worldOverlay); LayerOverlay planeOverlay = new LayerOverlay(); planeOverlay.Layers.Add("BitmapLayer", bitmapLayer); winformsMap1.Overlays.Add("PlaneOverlay", planeOverlay); winformsMap1.CurrentExtent = new RectangleShape(-139.2, 92.4, 120.9, -93.2); winformsMap1.Refresh(); timer.Start(); }
public void ShortestLineFeature(Map map, GeoCollection <object> args) { if (null != map) { InMemoryFeatureLayer mapShapeLayer = (InMemoryFeatureLayer)((LayerOverlay)map.CustomOverlays[1]).Layers["InMemoryFeatureLayer"]; InMemoryFeatureLayer shortestLineLayer = (InMemoryFeatureLayer)((LayerOverlay)map.CustomOverlays[1]).Layers["ShortestLineLayer"]; BaseShape areaShape1 = mapShapeLayer.InternalFeatures["AreaShape1"].GetShape(); BaseShape areaShape2 = mapShapeLayer.InternalFeatures["AreaShape2"].GetShape(); MultilineShape multiLineShape = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter); shortestLineLayer.InternalFeatures.Clear(); shortestLineLayer.InternalFeatures.Add("ShortestLine", new Feature(multiLineShape)); ((LayerOverlay)map.CustomOverlays[1]).Redraw(); } }
protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); SetContentView(Resource.Layout.DisplayASimpleMap); androidMap = FindViewById <MapView>(Resource.Id.androidmap); androidMap.MapUnit = GeographyUnit.DecimalDegree; androidMap.CurrentExtent = new RectangleShape(0, 100, 100, 0); LayerOverlay inMemoryOverlay = new LayerOverlay(); androidMap.Overlays.Add("InMemoryOverlay", inMemoryOverlay); LayerOverlay shortestLineOverlay = new LayerOverlay(); shortestLineOverlay.TileType = TileType.SingleTile; androidMap.Overlays.Add("ShortestLineOverlay", shortestLineOverlay); BaseShape areaShape1 = BaseShape.CreateShapeFromWellKnownData("POLYGON((10 20,30 60,40 10,10 20))"); BaseShape areaShape2 = new EllipseShape(new PointShape(70, 70), 10, 20); InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer(); inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(125, GeoColor.StandardColors.Gray); inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black; inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; inMemoryLayer.InternalFeatures.Add("AreaShape1", new Feature(areaShape1)); inMemoryLayer.InternalFeatures.Add("AreaShape2", new Feature(areaShape2)); inMemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer); InMemoryFeatureLayer shortestLineLayer = new InMemoryFeatureLayer(); shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Color = GeoColor.StandardColors.Red; shortestLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; shortestLineOverlay.Layers.Add("ShortestLineLayer", shortestLineLayer); MultilineShape shortestLine = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter); shortestLineLayer.InternalFeatures.Add("ShortestLine", new Feature(shortestLine)); SampleViewHelper.InitializeInstruction(this, FindViewById <RelativeLayout>(Resource.Id.MainLayout), GetType()); }
private void winformsMap1_MouseMove(object sender, MouseEventArgs e) { if (isDrawing) { LayerOverlay lineOverlay = (LayerOverlay)winformsMap1.Overlays["LineOverlay"]; InMemoryFeatureLayer shapeLayer = (InMemoryFeatureLayer)lineOverlay.Layers["Shape"]; InMemoryFeatureLayer shadowLayer = (InMemoryFeatureLayer)lineOverlay.Layers["Shadow"]; try { shapeLayer.InternalFeatures.Clear(); shadowLayer.InternalFeatures.Clear(); Point screenPointEnd = e.Location; RectangleShape extent = winformsMap1.CurrentExtent; ScreenPointF currentPoint = new ScreenPointF(screenPointEnd.X, screenPointEnd.Y); PointShape endPoint = ExtentHelper.ToWorldCoordinate(extent, currentPoint, winformsMap1.Width, winformsMap1.Height); shapeLayer.InternalFeatures.Add(new Feature(startPoint)); shapeLayer.InternalFeatures.Add(new Feature(endPoint)); MultilineShape line = startPoint.GetShortestLineTo(endPoint, GeographyUnit.DecimalDegree); if (line != null) { shapeLayer.InternalFeatures.Add(new Feature(line)); LineShape shadow = new LineShape(new Collection <Vertex>() { new Vertex(startPoint.X, startPoint.Y), new Vertex(endPoint.X, endPoint.Y) }); shadowLayer.InternalFeatures.Add(new Feature(shadow)); } label2.Text = startPoint.GetDistanceTo(endPoint, GeographyUnit.DecimalDegree, DistanceUnit.Kilometer).ToString("N2") + " km."; winformsMap1.Refresh(); } catch { return; } } }
internal static Collection <LineShape> GetLineShapes(Feature feature) { Collection <LineShape> lineShapes = new Collection <LineShape>(); LineBaseShape lineBaseShape = feature.GetShape() as LineBaseShape; if (lineBaseShape is MultilineShape) { MultilineShape multiLineShape = lineBaseShape as MultilineShape; lineShapes = multiLineShape.Lines; } else if (lineBaseShape is LineShape) { lineShapes.Add((LineShape)lineBaseShape); } else { throw new NotSupportedException("Only the data which includes the line shapes is supported."); } return(lineShapes); }
public string GetDistance(Map map, GeoCollection <object> args) { PointShape pointShape = new PointShape(string.Format("POINT ({0} {1})", args[0], args[1])); LayerOverlay dynamicOverlay = (LayerOverlay)map.CustomOverlays["DynamicOverlay"]; InMemoryFeatureLayer pointShapeLayer = (InMemoryFeatureLayer)dynamicOverlay.Layers["pointShapeLayer"]; Feature newPoint = new Feature(pointShape); InMemoryFeatureLayer lineShapeLayer = (InMemoryFeatureLayer)dynamicOverlay.Layers["lineShapeLayer"]; if (Session["StartPoint"] == null) { pointShapeLayer.InternalFeatures.Clear(); lineShapeLayer.InternalFeatures.Clear(); } pointShapeLayer.InternalFeatures.Add(newPoint.Id, newPoint); string popupContentHtml = string.Empty; if (Session["StartPoint"] != null) { PointShape startPoint = (PointShape)Session["StartPoint"]; MultilineShape line = startPoint.GetShortestLineTo(pointShape, GeographyUnit.DecimalDegree); Feature lineFeature = new Feature(line); string distanceValue = String.Format("<span class='popup'>{0} Mile</span>", line.GetLength(GeographyUnit.DecimalDegree, DistanceUnit.Mile).ToString("N2")); lineShapeLayer.InternalFeatures.Add(lineFeature.Id, lineFeature); popupContentHtml = distanceValue; Session["StartPoint"] = null; } else { Session["StartPoint"] = pointShape; } return(popupContentHtml); }
private Feature GetGreatCircle(Feature feature) { LineShape line = feature.GetShape() as LineShape; if (line != null) { MultilineShape greatCircle = new MultilineShape(); for (int i = 0; i < line.Vertices.Count; i++) { if (i != line.Vertices.Count - 1) { PointShape point = new PointShape(line.Vertices[i]); MultilineShape multiline = point.GreatCircle(new PointShape(line.Vertices[i + 1])); if (multiline != null) { foreach (var l in multiline.Lines) { greatCircle.Lines.Add(l); } } } } if (greatCircle.Lines.Count > 0) { Feature wrapperFeature = new Feature(greatCircle); foreach (var columnValue in feature.ColumnValues) { wrapperFeature.ColumnValues.Add(columnValue.Key, columnValue.Value); } return(wrapperFeature); } } return(null); }
private static Feature GetMultiLineFromCollection(Feature feature) { var shapeColleciton = (GeometryCollectionShape)feature.GetShape(); var multiline = new MultilineShape(); foreach (var shape in shapeColleciton.Shapes) { var shapeWellKnownType = shape.GetWellKnownType(); if (shapeWellKnownType == WellKnownType.Polygon) { multiline.Lines.Add(shape as LineShape); } else if (shapeWellKnownType == WellKnownType.Multipolygon) { foreach (var polygon in ((MultilineShape)shape).Lines) { multiline.Lines.Add(polygon); } } } return(new Feature(multiline.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); }
private IEnumerable <Feature> InverseClip(FeatureLayer featureLayer, IEnumerable <Feature> clippingFeatures) { lock (featureLayer) { if (!featureLayer.IsOpen) { featureLayer.Open(); } Collection <Feature> results = featureLayer.FeatureSource.GetFeaturesOutsideBoundingBox(ExtentHelper.GetBoundingBoxOfItems(clippingFeatures), featureLayer.GetDistinctColumnNames()); Collection <Feature> sourceFeatures = new Collection <Feature>(); SimpleShapeType simpleShapeType = GisEditor.LayerManager.GetFeatureSimpleShapeType(featureLayer); int index = 1; if (simpleShapeType == SimpleShapeType.Point) { featureLayer.Open(); Collection <Feature> allFeatures = featureLayer.FeatureSource.GetAllFeatures(featureLayer.GetDistinctColumnNames()); featureLayer.Close(); foreach (Feature f in results) { allFeatures.Remove(f); } foreach (var f in InverseClipPoints(allFeatures, clippingFeatures, simpleShapeType)) { results.Add(f); } } else if (simpleShapeType == SimpleShapeType.Line) { bool isOpen = false; Proj4ProjectionInfo projectionInfo = featureLayer.GetProj4ProjectionInfo(); //MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures)); List <AreaBaseShape> clippingAreaShapes = GetValidFeatures(clippingFeatures) .Select(f => f.GetShape()) .OfType <AreaBaseShape>() .ToList(); MultipolygonShape areaBaseShape = AreaBaseShape.Union(clippingAreaShapes); if (projectionInfo != null && projectionInfo.CanProject) { if (featureLayer.IsOpen) { featureLayer.Close(); projectionInfo.Close(); isOpen = true; } featureLayer.FeatureSource.Projection = null; } featureLayer.Open(); featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), featureLayer.GetDistinctColumnNames()).ForEach(f => { if (!areaBaseShape.Contains(f)) { sourceFeatures.Add(f); } }); int count = sourceFeatures.Count; if (projectionInfo != null) { featureLayer.FeatureSource.Projection = projectionInfo.Projection; if (isOpen) { featureLayer.Open(); } } if (featureLayer.IsOpen) { featureLayer.Close(); } foreach (var feature in sourceFeatures) { isCanceled = ReportProgress(index, count); if (isCanceled) { break; } index++; try { //if (areaBaseShape.IsDisjointed(feature)) if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, feature)) { results.Add(feature); } else { MultilineShape multiLine = (MultilineShape)feature.GetShape(); MultilineShape resultShape = new MultilineShape(); foreach (LineShape lineShape in multiLine.Lines) { //if (areaBaseShape.IsDisjointed(lineShape)) if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, lineShape)) { resultShape.Lines.Add(lineShape); } else { var resultLine = lineShape.GetDifference(areaBaseShape); foreach (var line in resultLine.Lines) { resultShape.Lines.Add(line); } } } if (resultShape != null && resultShape.Lines.Count > 0) { results.Add(new Feature(resultShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); } } } catch (Exception ex) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex)); HandleExceptionFromInvalidFeature(feature.Id, ex.Message); } } } else if (simpleShapeType == SimpleShapeType.Area) { //MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures)); List <AreaBaseShape> clippingAreaShapes = GetValidFeatures(clippingFeatures) .Select(f => f.GetShape()) .OfType <AreaBaseShape>() .ToList(); BaseShape unionResultShape = SqlTypesGeometryHelper.Union(clippingAreaShapes); MultipolygonShape areaBaseShape = ConvertSqlQueryResultToMultiPolygonShape(unionResultShape); bool isOpen = false; Proj4ProjectionInfo projectionInfo = featureLayer.GetProj4ProjectionInfo(); if (projectionInfo != null && projectionInfo.CanProject) { if (featureLayer.IsOpen) { featureLayer.Close(); if (projectionInfo != null) { projectionInfo.Close(); } isOpen = true; } featureLayer.FeatureSource.Projection = null; } if (!featureLayer.IsOpen) { featureLayer.Open(); } featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), featureLayer.GetDistinctColumnNames()).ForEach(f => sourceFeatures.Add(f)); if (featureLayer.IsOpen) { featureLayer.Close(); } if (projectionInfo != null) { featureLayer.FeatureSource.Projection = projectionInfo.Projection; if (isOpen) { featureLayer.Open(); } } int count = sourceFeatures.Count; foreach (var feature in sourceFeatures) { isCanceled = ReportProgress(index, count); if (isCanceled) { break; } index++; try { //if (areaBaseShape.IsDisjointed(feature)) if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, feature)) { results.Add(feature); } else { //var clippedShape = ((AreaBaseShape)feature.GetShape()).GetDifference(areaBaseShape); BaseShape differenceResultShape = SqlTypesGeometryHelper.GetDifference((AreaBaseShape)feature.GetShape(), areaBaseShape); MultipolygonShape clippedShape = ConvertSqlQueryResultToMultiPolygonShape(differenceResultShape); if (clippedShape != null && clippedShape.Polygons.Count > 0) { results.Add(new Feature(clippedShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); } } } catch (Exception ex) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex)); HandleExceptionFromInvalidFeature(feature.Id, ex.Message); } } } else { throw new NotSupportedException("The ShapeFileType is not supported."); } return(results); } }
private IEnumerable <Feature> InverseClip(FeatureSource featureSource, IEnumerable <Feature> clippingFeatures) { lock (featureSource) { if (!featureSource.IsOpen) { featureSource.Open(); } Collection <Feature> results = featureSource.GetFeaturesOutsideBoundingBox(ExtentHelper.GetBoundingBoxOfItems(clippingFeatures), ReturningColumnsType.AllColumns); Collection <Feature> sourceFeatures = new Collection <Feature>(); ShapeFileType shapeFileType = ((ShapeFileFeatureSource)featureSource).GetShapeFileType(); int index = 1; if (shapeFileType == ShapeFileType.Point || shapeFileType == ShapeFileType.Multipoint) { featureSource.Open(); Collection <Feature> allFeatures = featureSource.GetAllFeatures(ReturningColumnsType.AllColumns); featureSource.Close(); foreach (Feature f in results) { allFeatures.Remove(f); } foreach (var f in InverseClipPoints(allFeatures, clippingFeatures, shapeFileType)) { results.Add(f); } } else if (shapeFileType == ShapeFileType.Polyline) { bool isOpen = false; Projection tmpProjection = null; MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures)); if (featureSource.Projection != null && featureSource.Projection is GISEditorManagedProj4Projection && ((GISEditorManagedProj4Projection)featureSource.Projection).IsProjectionParametersEqual) { tmpProjection = featureSource.Projection; if (featureSource.IsOpen) { featureSource.Close(); featureSource.Projection.Close(); isOpen = true; } featureSource.Projection = null; } featureSource.Open(); featureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), ReturningColumnsType.AllColumns).ForEach(f => { if (!areaBaseShape.Contains(f)) { sourceFeatures.Add(f); } }); int count = sourceFeatures.Count; if (tmpProjection != null) { featureSource.Projection = tmpProjection; if (isOpen) { featureSource.Open(); } } if (featureSource.IsOpen) { featureSource.Close(); } foreach (var feature in sourceFeatures) { ReportProgress(index * 100 / count); index++; try { if (areaBaseShape.IsDisjointed(feature)) { results.Add(feature); } else { MultilineShape multiLine = (MultilineShape)feature.GetShape(); MultilineShape resultShape = new MultilineShape(); foreach (LineShape lineShape in multiLine.Lines) { if (areaBaseShape.IsDisjointed(lineShape)) { resultShape.Lines.Add(lineShape); } else { Collection <PointShape> points = new Collection <PointShape>(); points.Add(new PointShape(lineShape.Vertices[0])); lineShape.GetIntersection(areaBaseShape).Lines.ForEach(l => { PointShape p1 = new PointShape(l.Vertices[0]); if (points.Count(p => p.X == p1.X && p.Y == p1.Y && p.Z == p1.Z) <= 0) { points.Add(p1); } PointShape p2 = new PointShape(l.Vertices[l.Vertices.Count - 1]); if (points.Count(p => p.X == p2.X && p.Y == p2.Y && p.Z == p2.Z) <= 0) { points.Add(p2); } }); PointShape endPoint = new PointShape(lineShape.Vertices[lineShape.Vertices.Count - 1]); if (points.Count(p => p.X == endPoint.X && p.Y == endPoint.Y && p.Z == endPoint.Z) <= 0) { points.Add(endPoint); } for (int i = 0; i < points.Count; i++) { if (i != points.Count - 1) { LineBaseShape lineBaseShape = lineShape.GetLineOnALine(points[i], points[i + 1]); if (!areaBaseShape.Intersects(lineBaseShape.GetCenterPoint())) { resultShape.Lines.Add((LineShape)lineBaseShape); } } } } } if (resultShape != null && resultShape.Lines.Count > 0) { results.Add(new Feature(resultShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); } } } catch (Exception ex) { HandleExceptionFromInvalidFeature(feature.Id, ex.Message); } } } else if (shapeFileType == ShapeFileType.Polygon) { MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures)); bool isOpen = false; Projection tmpProjection = null; if (featureSource.Projection != null && featureSource.Projection is GISEditorManagedProj4Projection && ((GISEditorManagedProj4Projection)featureSource.Projection).IsProjectionParametersEqual) { tmpProjection = featureSource.Projection; if (featureSource.IsOpen) { featureSource.Close(); featureSource.Projection.Close(); isOpen = true; } featureSource.Projection = null; } if (!featureSource.IsOpen) { featureSource.Open(); } featureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), ReturningColumnsType.AllColumns).ForEach(f => { if (!areaBaseShape.IsDisjointed(f)) { sourceFeatures.Add(f); } }); if (featureSource.IsOpen) { featureSource.Close(); } if (tmpProjection != null) { featureSource.Projection = tmpProjection; if (isOpen) { featureSource.Open(); } } int count = sourceFeatures.Count; foreach (var feature in sourceFeatures) { ReportProgress(index * 100 / count); index++; try { if (areaBaseShape.IsDisjointed(feature)) { results.Add(feature); } else { var clippedShape = ((AreaBaseShape)feature.GetShape()).GetDifference(areaBaseShape); if (clippedShape != null && clippedShape.Polygons.Count > 0) { results.Add(new Feature(clippedShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); } } } catch (Exception ex) { HandleExceptionFromInvalidFeature(feature.Id, ex.Message); } } } else { throw new NotSupportedException("The ShapeFileType is not supported."); } return(results); } }
private static void ProcessLineShape(int zoom, int tileSize, RectangleInt tileScreenBoundingBox, TileFeature tileFeature, MultilineShape multiLineShape, int simplificationFactor, RectangleShape tileBoundingBox) { foreach (LineShape line in multiLineShape.Lines) { PointInt[] pixelPoints = new PointInt[line.Vertices.Count]; for (int n = 0; n < line.Vertices.Count; ++n) { pixelPoints[n] = WorldPointToTilePoint(line.Vertices[n].X, line.Vertices[n].Y, zoom, tileSize, tileBoundingBox); } PointInt[] simplifiedPixelPoints = SimplifyPointData(pixelPoints, simplificationFactor); //output count may be zero for short records at low zoom levels as //the pixel coordinates wil be a single point after simplification if (simplifiedPixelPoints.Length > 0) { List <int> clippedPoints = new List <int>(); List <int> parts = new List <int>(); ClipPolyline(simplifiedPixelPoints, tileScreenBoundingBox, clippedPoints, parts); if (parts.Count > 0) { //output the clipped polyline for (int n = 0; n < parts.Count; ++n) { int index1 = parts[n]; int index2 = n < parts.Count - 1 ? parts[n + 1] : clippedPoints.Count; List <PointInt> lineString = new List <PointInt>(); tileFeature.Geometry.Add(lineString); //clipped points store separate x/y pairs so there will be two values per measure for (int i = index1; i < index2; i += 2) { lineString.Add(new PointInt(clippedPoints[i], clippedPoints[i + 1])); } } } } } }
private static TileFeature GetVectorTileFeature(Feature feature, int zoom, int tileSize, RectangleInt tileScreenBoundingBox, int simplificationFactor, RectangleShape tileBoundingBox) { TileFeature tileFeature = new TileFeature(); switch (feature.GetWellKnownType()) { case WellKnownType.Line: case WellKnownType.Multiline: tileFeature.Type = GeometryType.LineString; MultilineShape multiLineShape = new MultilineShape(feature.GetWellKnownBinary()); ProcessLineShape(zoom, tileSize, tileScreenBoundingBox, tileFeature, multiLineShape, simplificationFactor, tileBoundingBox); break; case WellKnownType.Polygon: case WellKnownType.Multipolygon: tileFeature.Type = GeometryType.Polygon; MultipolygonShape multiPolygonShape = new MultipolygonShape(feature.GetWellKnownBinary()); foreach (PolygonShape polygonShape in multiPolygonShape.Polygons) { ProcessRingShape(zoom, tileSize, tileScreenBoundingBox, tileFeature, polygonShape.OuterRing, simplificationFactor, tileBoundingBox); foreach (RingShape ringShape in polygonShape.InnerRings) { ProcessRingShape(zoom, tileSize, tileScreenBoundingBox, tileFeature, ringShape, simplificationFactor, tileBoundingBox); } } break; case WellKnownType.Point: case WellKnownType.Multipoint: tileFeature.Type = GeometryType.Point; List <PointInt> coordinates = new List <PointInt>(); MultipointShape multiPointShape = new MultipointShape(); if (feature.GetWellKnownType() == WellKnownType.Point) { PointShape pointShape = new PointShape(feature.GetWellKnownBinary()); multiPointShape.Points.Add(pointShape); } else if (feature.GetWellKnownType() == WellKnownType.Multipoint) { multiPointShape = new MultipointShape(feature.GetWellKnownBinary()); } foreach (PointShape point in multiPointShape.Points) { PointInt pointI = WorldPointToTilePoint(point.X, point.Y, zoom, tileSize, tileBoundingBox); coordinates.Add(new PointInt(pointI.X, pointI.Y)); } if (coordinates.Count > 0) { tileFeature.Geometry.Add(coordinates); } break; default: tileFeature.Type = GeometryType.Unknown; break; } //add the record attributes foreach (var attributes in feature.ColumnValues) { tileFeature.Attributes.Add(new TileAttribute(attributes.Key, attributes.Value)); } return(tileFeature); }
// Tuple // item1: columnName, // item2: columnType, // item3: OperatorMode. public static Collection <Feature> Dissolve(IEnumerable <string> dissolveColumnNames , IEnumerable <Tuple <string, string, DissolveOperatorMode> > pairedColumnStrategies , IEnumerable <Feature> featuresToDissovle) { var featureGroupByShapeType = featuresToDissovle.GroupBy(f => { return(f.GetShape().GetType()); }); Collection <Feature> dissolveFeatures = new Collection <Feature>(); Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > dissolveAction = new Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > ((groupByType, finalProcessAction) => { var groupByColumns = GroupByColumns(groupByType, dissolveColumnNames); groupByColumns.ForEach(groupFeature => { Dictionary <string, string> newColumnValues = new Dictionary <string, string>(); foreach (var tmpMatchColumn in dissolveColumnNames) { newColumnValues.Add(tmpMatchColumn, groupFeature.First().ColumnValues[tmpMatchColumn]); } foreach (var operatorPair in pairedColumnStrategies) { CollectNewColumnValues(groupFeature, newColumnValues, operatorPair); } newColumnValues.Add("Count", groupFeature.Count().ToString()); try { if (finalProcessAction != null) { finalProcessAction(groupFeature, newColumnValues); } } catch (Exception ex) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex)); } }); }); featureGroupByShapeType.ForEach(groupByType => { if (groupByType.Key.IsSubclassOf(typeof(AreaBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultipolygonShape dissolveShape = AreaBaseShape.Union(GetValidFeatures(tmpFeatures)); if (dissolveShape != null) { Feature dissolveFeature = new Feature(dissolveShape, tmpColumnValues); dissolveFeatures.Add(dissolveFeature); } }); } else if (groupByType.Key.IsSubclassOf(typeof(LineBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { //MultilineShape dissolveShape = LineBaseShape.Union(tmpFeatures); //Feature dissolveFeature = new Feature(dissolveShape, tmpColumnValues); //dissolveFeatures.Add(dissolveFeature); MultilineShape dissolveShape = new MultilineShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); LineShape tmpLine = tmpShape as LineShape; MultilineShape tmpMLine = tmpShape as MultilineShape; if (tmpLine != null) { dissolveShape.Lines.Add(tmpLine); } else if (tmpMLine != null) { tmpMLine.Lines.ForEach(tmpLineInMLine => dissolveShape.Lines.Add(tmpLineInMLine)); } }); if (dissolveShape.Lines.Count > 0) { dissolveFeatures.Add(new Feature(dissolveShape, tmpColumnValues)); } }); } else if (groupByType.Key.IsSubclassOf(typeof(PointBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultipointShape multipointShape = new MultipointShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); PointShape tmpPoint = tmpShape as PointShape; MultipointShape tmpMPoint = tmpShape as MultipointShape; if (tmpPoint != null) { multipointShape.Points.Add(tmpPoint); } else if (tmpMPoint != null) { tmpMPoint.Points.ForEach(tmpPointInMPointShape => multipointShape.Points.Add(tmpPointInMPointShape)); } }); dissolveFeatures.Add(new Feature(multipointShape, tmpColumnValues)); }); } }); return(dissolveFeatures); }
private void Dissolve() { try { Collection <Feature> dissolvedFeatures = new Collection <Feature>(); // get features to dissolve. Collection <Feature> featuresToDissolve = GetFeaturesToDissolve(); // group features. var featureGroupByShapeType = featuresToDissolve.GroupBy(f => { return(f.GetShape().GetType()); }); Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > dissolveAction = new Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > ((groupByType, finalProcessAction) => { //CancelTask(this.CancellationSource.Token, content, parameter); var groupByColumns = GroupByColumns(groupByType, this.matchColumns); groupByColumns.ForEach(groupFeature => { //CancelTask(this.CancellationSource.Token, content, parameter); Dictionary <string, string> newColumnValues = new Dictionary <string, string>(); foreach (var tmpMatchColumn in this.matchColumns) { newColumnValues.Add(tmpMatchColumn, groupFeature.First().ColumnValues[tmpMatchColumn]); } foreach (var operatorPair in this.operatorPairs) { //CancelTask(this.CancellationSource.Token, content, parameter); CollectNewColumnValues(groupFeature, newColumnValues, operatorPair); } newColumnValues.Add("Count", groupFeature.Count().ToString()); try { if (finalProcessAction != null) { finalProcessAction(groupFeature, newColumnValues); } } catch { } }); }); featureGroupByShapeType.ForEach(groupByType => { //CancelTask(this.CancellationSource.Token, content, parameter); if (groupByType.Key.IsSubclassOf(typeof(AreaBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultipolygonShape dissolveShape = AreaBaseShape.Union(GetValidFeatures(tmpFeatures)); if (dissolveShape != null) { Feature dissolveFeature = new Feature(dissolveShape, tmpColumnValues); dissolvedFeatures.Add(dissolveFeature); } }); } else if (groupByType.Key.IsSubclassOf(typeof(LineBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { //MultilineShape dissolveShape = LineBaseShape.Union(tmpFeatures); //Feature dissolveFeature = new Feature(dissolveShape, tmpColumnValues); //dissolveFeatures.Add(dissolveFeature); MultilineShape dissolveShape = new MultilineShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); LineShape tmpLine = tmpShape as LineShape; MultilineShape tmpMLine = tmpShape as MultilineShape; if (tmpLine != null) { dissolveShape.Lines.Add(tmpLine); } else if (tmpMLine != null) { tmpMLine.Lines.ForEach(tmpLineInMLine => dissolveShape.Lines.Add(tmpLineInMLine)); } }); if (dissolveShape.Lines.Count > 0) { dissolvedFeatures.Add(new Feature(dissolveShape, tmpColumnValues)); } }); } else if (groupByType.Key.IsSubclassOf(typeof(PointBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultipointShape multipointShape = new MultipointShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); PointShape tmpPoint = tmpShape as PointShape; MultipointShape tmpMPoint = tmpShape as MultipointShape; if (tmpPoint != null) { multipointShape.Points.Add(tmpPoint); } else if (tmpMPoint != null) { tmpMPoint.Points.ForEach(tmpPointInMPointShape => multipointShape.Points.Add(tmpPointInMPointShape)); } }); dissolvedFeatures.Add(new Feature(multipointShape, tmpColumnValues)); }); } }); // collect export columns. var filteredFeatureColumns = new Collection <FeatureSourceColumn>(); foreach (var matchColumn in this.matchColumns) { var tmpColumn = featureColumns.FirstOrDefault(f => f.ColumnName.Equals(matchColumn, StringComparison.Ordinal)); if (tmpColumn != null) { filteredFeatureColumns.Add(tmpColumn); } } foreach (var extraColumn in this.operatorPairs) { var tmpColumn = featureColumns.FirstOrDefault(f => f.ColumnName.Equals(extraColumn.ColumnName, StringComparison.Ordinal)); if (tmpColumn != null) { filteredFeatureColumns.Add(tmpColumn); } } filteredFeatureColumns.Add(new FeatureSourceColumn("Count", "Integer", 8)); string saveFolder = Path.GetDirectoryName(outputPath); if (!Directory.Exists(saveFolder)) { Directory.CreateDirectory(saveFolder); } ShpFileExporter exporter = new ShpFileExporter(); exporter.ExportToFile(new FileExportInfo(dissolvedFeatures, filteredFeatureColumns, outputPath, Wkt)); } catch (Exception e) { } finally { var args = new UpdatingProgressLongRunningTaskPluginEventArgs(LongRunningTaskState.Updating); args.Message = "Finished"; OnUpdatingProgress(args); } }
private void btnCalculate_Click(object sender, RoutedEventArgs e) { //Get a reference to the results MapShapeLayer and clear it so we can display our new results. MapShapeLayer results = (MapShapeLayer)((LayerOverlay)mapView.Overlays["layerOverlay"]).Layers["Results"]; results.MapShapes.Clear(); //Get a reference to the test data layer. InMemoryFeatureLayer testDataLayer = (InMemoryFeatureLayer)((LayerOverlay)mapView.Overlays["layerOverlay"]).Layers["TestData"]; //Check to see if the test data has been edited. if (mapView.EditOverlay.EditShapesLayer.InternalFeatures.Count > 0) { //Loop through the edited test data and update the test data layer. testDataLayer.EditTools.BeginTransaction(); foreach (Feature feature in mapView.EditOverlay.EditShapesLayer.InternalFeatures) { testDataLayer.EditTools.Update(feature.CloneDeep()); } testDataLayer.EditTools.CommitTransaction(); //Clear out the EditOverlay since we are done editing. mapView.EditOverlay.EditShapesLayer.InternalFeatures.Clear(); //Since we are done editing, turn visibility back on the for the layer overlay so we can see our test data again. mapView.Overlays["layerOverlay"].IsVisible = true; } //Get the test point feature from the test data layer. Feature testPointFeature = testDataLayer.QueryTools.GetFeaturesByColumnValue("Name", "TestPoint", ReturningColumnsType.AllColumns)[0]; //Get the test line feature from the test data layer. Feature testLineFeature = testDataLayer.QueryTools.GetFeaturesByColumnValue("Name", "TestLine", ReturningColumnsType.AllColumns)[0]; //Take the test line feature and create a line shape so we can use line-specific APIs for finding the shortest line and line-on-line. LineShape testLine = new MultilineShape(testLineFeature.GetWellKnownText()).Lines[0]; //Calculate the shortest line between our test line and test point. LineShape shortestLineResult = testLine.GetShortestLineTo(testPointFeature.GetShape(), GeographyUnit.Meter).Lines[0]; //Take the result and create a MapShape so we can display the shortest line on the map in a blue color. MapShape shortestLine = new MapShape(new Feature(shortestLineResult)); shortestLine.ZoomLevels.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Blue, 4, false); shortestLine.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; results.MapShapes.Add("ShortestLine", shortestLine); string message = "Length of Blue Line is: " + shortestLineResult.GetLength(GeographyUnit.Meter, DistanceUnit.Kilometer).ToString() + " KM" + '\n'; //Split the test line from the left side based on where the shortest line touches it. LineBaseShape leftSideOfLineResult = testLine.GetLineOnALine(new PointShape(testLine.Vertices[0]), new PointShape(shortestLineResult.Vertices[0])); //Make sure the split was valid and the closest point wasn't at the beginning or end of the line. if (leftSideOfLineResult.Validate(ShapeValidationMode.Simple).IsValid) { MapShape leftSideOfLine = new MapShape(new Feature(leftSideOfLineResult)); leftSideOfLine.ZoomLevels.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Green, 2, false); leftSideOfLine.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; results.MapShapes.Add("LeftSideofLine", leftSideOfLine); message += "Length of Green Line is: " + leftSideOfLineResult.GetLength(GeographyUnit.Meter, DistanceUnit.Kilometer).ToString() + " KM" + '\n'; } //Split the test line from the right side based on where the shortest line touches it. LineBaseShape rightSideOfLineResult = testLine.GetLineOnALine(new PointShape(shortestLineResult.Vertices[0]), new PointShape(testLine.Vertices[testLine.Vertices.Count - 1])); //Make sure the split was valid and the closest point wasn't at the beginning or end of the line. if (rightSideOfLineResult.Validate(ShapeValidationMode.Simple).IsValid) { MapShape rightSideOfLine = new MapShape(new Feature(rightSideOfLineResult)); rightSideOfLine.ZoomLevels.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Yellow, 2, false); rightSideOfLine.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; results.MapShapes.Add("RightSideofLine", rightSideOfLine); message += "Length of Yellow Line is: " + rightSideOfLineResult.GetLength(GeographyUnit.Meter, DistanceUnit.Kilometer).ToString() + " KM" + '\n'; } //Display the length of each line in kilometers. message += "Length of Red Line is: " + testLine.GetLength(GeographyUnit.Meter, DistanceUnit.Kilometer).ToString() + " KM"; mapView.Refresh(); MessageBox.Show(message, "Results"); }
private void btnSearch_Click(object sender, RoutedEventArgs e) { PointShape start = Points[((ComboBoxItem)cmbStart.SelectedItem).Content.ToString()]; PointShape end = Points[((ComboBoxItem)cmbEnd.SelectedItem).Content.ToString()]; LineShape startSegment = GetNearestSegment(start); LineShape endSegment = GetNearestSegment(end); LineShape route = new LineShape(); if (startSegment.Id == endSegment.Id) { route = startSegment.GetLineOnALine(start, end) as LineShape; } else { double tolerance = double.Parse(txtTolerance.Text, CultureInfo.InvariantCulture); PolygonShape bufferedPolygon = endSegment.Buffer(tolerance, GeographyUnit.DecimalDegree, DistanceUnit.Meter).Polygons[0]; MultilineShape intersectedLines = startSegment.GetIntersection(bufferedPolygon) as MultilineShape; if (intersectedLines.Lines.Count > 0) // Just check the intersected within allowed tolerance. { PointShape intersectedPoint = intersectedLines.Lines[0].GetCenterPoint(); PointShape nearestPointOnStart = intersectedPoint.GetClosestPointTo(startSegment, GeographyUnit.DecimalDegree); PointShape nearestPointOnEnd = intersectedPoint.GetClosestPointTo(endSegment, GeographyUnit.DecimalDegree); LineShape routeSegmentOnStart = startSegment.GetLineOnALine(start, nearestPointOnStart) as LineShape; LineShape routeSegmentOnEnd = endSegment.GetLineOnALine(end, nearestPointOnEnd) as LineShape; IEnumerable <Vertex> vertexs = route.Vertices; int index = IndexOf(routeSegmentOnStart.Vertices, new Vertex(nearestPointOnStart)); if (index == 0) { vertexs = vertexs.Concat(routeSegmentOnStart.Vertices.Reverse()); } else { vertexs = vertexs.Concat(routeSegmentOnStart.Vertices); } index = IndexOf(routeSegmentOnEnd.Vertices, new Vertex(nearestPointOnEnd)); if (index == 0) { vertexs = vertexs.Concat(routeSegmentOnEnd.Vertices); } else { vertexs = vertexs.Concat(routeSegmentOnEnd.Vertices.Reverse()); } route = new LineShape(vertexs); } } routeResultLayer.InternalFeatures.Clear(); if (route.Vertices.Count > 1) { routeResultLayer.InternalFeatures.Add(new Feature(route)); } else { MessageBox.Show("No Route Found."); } Map1.Refresh(); }
private static Feature MakeFeatureValidate(Feature feature) { Feature validFeature = feature.MakeValid(); WellKnownType featureType = feature.GetWellKnownType(); WellKnownType validatedType = validFeature.GetWellKnownType(); Feature result = validFeature; if (validatedType != featureType && validatedType == WellKnownType.GeometryCollection) { GeometryCollectionShape geoCollectionShape = validFeature.GetShape() as GeometryCollectionShape; if (geoCollectionShape != null) { BaseShape resultShape = null; switch (featureType) { case WellKnownType.Point: case WellKnownType.Multipoint: Collection <PointShape> points = new Collection <PointShape>(); foreach (var shape in geoCollectionShape.Shapes) { PointShape point = shape as PointShape; if (point != null) { points.Add(point); } } resultShape = new MultipointShape(points); break; case WellKnownType.Line: case WellKnownType.Multiline: Collection <LineShape> lines = new Collection <LineShape>(); foreach (var shape in geoCollectionShape.Shapes) { LineShape line = shape as LineShape; if (line != null) { lines.Add(line); } } resultShape = new MultilineShape(lines); break; case WellKnownType.Polygon: case WellKnownType.Multipolygon: Collection <PolygonShape> polygons = new Collection <PolygonShape>(); foreach (var shape in geoCollectionShape.Shapes) { PolygonShape polygon = shape as PolygonShape; if (polygon != null) { polygons.Add(polygon); } } resultShape = new MultipolygonShape(polygons); break; default: break; } if (resultShape != null) { result = new Feature(resultShape); } } } return(result); }
//private IEnumerable<string> GetMatchColumnsFromString(string matchColumnsInString) //{ // string[] columns = matchColumnsInString.Split(','); // return columns; //} private void Dissolve() { Collection <Feature> dissolvedFeatures = new Collection <Feature>(); // get features to dissolve. Collection <Feature> featuresToDissolve = GetFeaturesToDissolve(); // group features. var featureGroupByShapeType = featuresToDissolve.GroupBy(f => { return(f.GetShape().GetType()); }); // collect export columns. var filteredFeatureColumns = new Collection <FeatureSourceColumn>(); foreach (var matchColumn in this.matchColumns) { var tmpColumn = featureColumns.FirstOrDefault(f => f.ColumnName.Equals(matchColumn, StringComparison.Ordinal)); if (tmpColumn != null) { filteredFeatureColumns.Add(tmpColumn); } } foreach (var extraColumn in this.operatorPairs) { var tmpColumn = featureColumns.FirstOrDefault(f => f.ColumnName.Equals(extraColumn.ColumnName, StringComparison.Ordinal)); if (tmpColumn != null) { filteredFeatureColumns.Add(tmpColumn); } } filteredFeatureColumns.Add(new FeatureSourceColumn("Count", "Integer", 8)); Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > dissolveAction = new Action <IGrouping <Type, Feature>, Action <IEnumerable <Feature>, Dictionary <string, string> > > ((groupByType, finalProcessAction) => { //CancelTask(this.CancellationSource.Token, content, parameter); var groupByColumns = GroupByColumns(groupByType, this.matchColumns); groupByColumns.ForEach(groupFeature => { //CancelTask(this.CancellationSource.Token, content, parameter); Dictionary <string, string> newColumnValues = new Dictionary <string, string>(); foreach (var tmpMatchColumn in this.matchColumns) { newColumnValues.Add(tmpMatchColumn, groupFeature.First().ColumnValues[tmpMatchColumn]); } foreach (var operatorPair in this.operatorPairs) { //CancelTask(this.CancellationSource.Token, content, parameter); CollectNewColumnValues(groupFeature, newColumnValues, operatorPair); var value = newColumnValues[operatorPair.ColumnName]; var resultColumn = filteredFeatureColumns.FirstOrDefault(c => c.ColumnName.Equals(operatorPair.ColumnName)); if (resultColumn != null) { if (resultColumn.MaxLength < value.Length) { var indexOf = filteredFeatureColumns.IndexOf(resultColumn); filteredFeatureColumns.RemoveAt(indexOf); var newColumn = new FeatureSourceColumn(resultColumn.ColumnName, resultColumn.TypeName, value.Length); filteredFeatureColumns.Insert(indexOf, newColumn); } } } newColumnValues.Add("Count", groupFeature.Count().ToString()); try { if (finalProcessAction != null) { finalProcessAction(groupFeature, newColumnValues); } } catch (Exception e) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, e.Message, new ExceptionInfo(e)); throw e; } }); }); foreach (var groupByType in featureGroupByShapeType) { try { //CancelTask(this.CancellationSource.Token, content, parameter); if (groupByType.Key.IsSubclassOf(typeof(AreaBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { //MultipolygonShape dissolveShape = AreaBaseShape.Union(GetValidFeatures(tmpFeatures)); List <AreaBaseShape> areaShapes = GetValidFeatures(tmpFeatures) .Select(f => f.GetShape()) .OfType <AreaBaseShape>() .ToList(); MultipolygonShape dissolveShape = (MultipolygonShape)SqlTypesGeometryHelper.Union(areaShapes); if (dissolveShape != null) { Feature dissolveFeature = new Feature(dissolveShape, tmpColumnValues); dissolvedFeatures.Add(dissolveFeature); } }); } else if (groupByType.Key.IsSubclassOf(typeof(LineBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultilineShape dissolveShape = new MultilineShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); LineShape tmpLine = tmpShape as LineShape; MultilineShape tmpMLine = tmpShape as MultilineShape; if (tmpLine != null) { dissolveShape.Lines.Add(tmpLine); } else if (tmpMLine != null) { tmpMLine.Lines.ForEach(tmpLineInMLine => dissolveShape.Lines.Add(tmpLineInMLine)); } }); if (dissolveShape.Lines.Count > 0) { dissolvedFeatures.Add(new Feature(dissolveShape, tmpColumnValues)); } }); } else if (groupByType.Key.IsSubclassOf(typeof(PointBaseShape))) { dissolveAction(groupByType, (tmpFeatures, tmpColumnValues) => { MultipointShape multipointShape = new MultipointShape(); tmpFeatures.ForEach(tmpFeature => { BaseShape tmpShape = tmpFeature.GetShape(); PointShape tmpPoint = tmpShape as PointShape; MultipointShape tmpMPoint = tmpShape as MultipointShape; if (tmpPoint != null) { multipointShape.Points.Add(tmpPoint); } else if (tmpMPoint != null) { tmpMPoint.Points.ForEach(tmpPointInMPointShape => multipointShape.Points.Add(tmpPointInMPointShape)); } }); dissolvedFeatures.Add(new Feature(multipointShape, tmpColumnValues)); }); } if (isCanceled) { break; } } catch (Exception ex) { var errorEventArgs = new UpdatingTaskProgressEventArgs(TaskState.Error); errorEventArgs.Error = new ExceptionInfo(string.Format(CultureInfo.InvariantCulture, "Feature id: {0}, {1}" , groupByType.FirstOrDefault().Id, ex.Message) , ex.StackTrace , ex.Source); GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex)); errorEventArgs.Message = groupByType.FirstOrDefault().Id; OnUpdatingProgress(errorEventArgs); continue; } } if (!isCanceled) { string saveFolder = Path.GetDirectoryName(outputPathFileName); if (!Directory.Exists(saveFolder)) { Directory.CreateDirectory(saveFolder); } var info = new FileExportInfo(dissolvedFeatures, filteredFeatureColumns, outputPathFileName, Wkt); Export(info); } }