protected override Collection<Style> GetStylesCore(FeatureSource featureSource) { // here we generate CustomDotDensityStyle. double totalValue = 0; featureSource.Open(); int featureCount = featureSource.GetCount(); for (int i = 0; i < featureCount; i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; if (double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue)) { totalValue += columnValue; } } featureSource.Close(); CustomDotDensityStyle dotDensityStyle = new CustomDotDensityStyle(); dotDensityStyle.ColumnName = SelectedColumns[0]; dotDensityStyle.PointToValueRatio = DotDensityValue / (totalValue / featureCount); dotDensityStyle.CustomPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(Opacity, Color), 4); return new Collection<Style>() { dotDensityStyle }; }
protected override Collection<Style> GetStylesCore(FeatureSource featureSource) { // here we generated a class break style and a text style. Collection<GeoColor> familyColors = GeoColor.GetColorsInQualityFamily(Color, EndColor, classBreakCount, ColorWheelDirection); featureSource.Open(); int featureCount = featureSource.GetCount(); double[] values = new double[featureCount]; for (int i = 0; i < featureCount; i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; if (double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue)) { values[i] = columnValue; } } featureSource.Close(); ClassBreakStyle classBreakStyle = new ClassBreakStyle(SelectedColumns[0]) { BreakValueInclusion = BreakValueInclusion.IncludeValue }; double[] classBreakValues = GetClusterClassBreaks(values, ClassBreakCount - 1); for (int i = 0; i < classBreakValues.Length; i++) { ClassBreak classBreak = new ClassBreak(classBreakValues[i], AreaStyles.CreateSimpleAreaStyle(new GeoColor(this.Opacity, familyColors[i]), GeoColor.FromHtml("#f05133"), 1)); classBreakStyle.ClassBreaks.Add(classBreak); } return new Collection<Style>() { classBreakStyle, TextStyles.Country1("NAME") }; }
public virtual RoadNetwork CreateNetwork(FeatureSource featureSource) { featureSource.Open(); QTreeSpatialIndex qtree = new QTreeSpatialIndex(featureSource.GetBoundingBox()); #if DEBUG long featureCount = featureSource.GetCount(); #endif RoadNetwork roadNetwork = new RoadNetwork(); Collection<Feature> features = featureSource.GetAllFeatures(ReturningColumnsType.NoColumns); featureSource.Close(); Collection<Collection<Feature>> featureGroups = GroupFeatures(features); int done = 0; var tasks = (from items in featureGroups select Task.Factory.StartNew(() => { var clonedFeatureSource = featureSource.CloneDeep(); clonedFeatureSource.Open(); foreach (var feature in items) { Collection<LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // Get the lineshape of the processing feature. foreach (LineShape processingLineShape in processingLineShapes) { BuildNetworkNode(clonedFeatureSource, qtree, roadNetwork, processingLineShape.Vertices[0]); BuildNetworkNode(clonedFeatureSource, qtree, roadNetwork, processingLineShape.Vertices[processingLineShape.Vertices.Count - 1]); } done++; Console.WriteLine(string.Format("Done {0} in {1}", feature.Id, done)); } })).ToArray(); //foreach (Feature feature in features) //{ // Task.Factory.StartNew(() => // { // Collection<LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // // Get the lineshape of the processing feature. // foreach (LineShape processingLineShape in processingLineShapes) // { // BuildNetworkNode(featureSource, qtree, roadNetwork, processingLineShape.Vertices[0]); // BuildNetworkNode(featureSource, qtree, roadNetwork, processingLineShape.Vertices[processingLineShape.Vertices.Count - 1]); // } // } // ); Task.WaitAll(tasks); #if DEBUG #endif //} //featureSource.Close(); return roadNetwork; }
protected override Collection<Style> GetStylesCore(FeatureSource featureSource) { // here we generated the PieZedGraphStyle. PieZedGraphStyle zedGraphStyle = new PieZedGraphStyle(); zedGraphStyle.ZedGraphDrawing += ZedGraphStyle_ZedGraphDrawing; pieColors = GeoColor.GetColorsInQualityFamily(GeoColor.FromArgb(Opacity, Color), SelectedColumns.Count); for (int i = 0; i < SelectedColumns.Count; i++) { zedGraphStyle.RequiredColumnNames.Add(SelectedColumns[i]); zedGraphStyle.PieSlices.Add(SelectedColumnAliases[i], pieColors[i]); } return new Collection<Style>(){zedGraphStyle}; }
protected override Collection<Style> GetStylesCore(FeatureSource featureSource) { // here we generate a ValueCircle Style. double minValue = double.MaxValue; double maxValue = double.MinValue; featureSource.Open(); for (int i = 0; i < featureSource.GetCount(); i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; if (double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue)) { if (columnValue < minValue) { minValue = columnValue; } else if (columnValue > maxValue) { maxValue = columnValue; } } } featureSource.Close(); ValueCircleStyle valueCircleStyle = new ValueCircleStyle(); valueCircleStyle.ColumnName = SelectedColumns[0]; valueCircleStyle.DrawingRadiusRatio = radiusRatio; valueCircleStyle.MinValidValue = minValue; valueCircleStyle.MaxValidValue = maxValue; valueCircleStyle.MinCircleAreaInDefaultZoomLevel = 80; valueCircleStyle.MaxCircleAreaInDefaultZoomLevel = 10000; valueCircleStyle.InnerColor = GeoColor.FromArgb(this.Opacity, Color); valueCircleStyle.OuterColor = GeoColor.SimpleColors.White; return new Collection<Style>(){valueCircleStyle}; }
protected override Collection <Style> GetStylesCore(FeatureSource featureSource) { // here we generated a class break style and a text style. Collection <GeoColor> familyColors = GeoColor.GetColorsInQualityFamily(Color, EndColor, classBreakCount, ColorWheelDirection); featureSource.Open(); int featureCount = featureSource.GetCount(); double[] values = new double[featureCount]; for (int i = 0; i < featureCount; i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; if (double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue)) { values[i] = columnValue; } } featureSource.Close(); ClassBreakStyle classBreakStyle = new ClassBreakStyle(SelectedColumns[0]) { BreakValueInclusion = BreakValueInclusion.IncludeValue }; double[] classBreakValues = GetClusterClassBreaks(values, ClassBreakCount - 1); for (int i = 0; i < classBreakValues.Length; i++) { ClassBreak classBreak = new ClassBreak(classBreakValues[i], AreaStyles.CreateSimpleAreaStyle(new GeoColor(this.Opacity, familyColors[i]), GeoColor.FromHtml("#f05133"), 1)); classBreakStyle.ClassBreaks.Add(classBreak); } return(new Collection <Style>() { classBreakStyle, TextStyles.CreateSimpleTextStyle("NAME", "Arial", 8, DrawingFontStyles.Bold, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3) }); }
protected override Style GetStyleCore(FeatureSource featureSource) { double minValue = double.MaxValue; double maxValue = double.MinValue; featureSource.Open(); for (int i = 0; i < featureSource.GetCount(); i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; if (double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue)) { if (columnValue < minValue) { minValue = columnValue; } else if (columnValue > maxValue) { maxValue = columnValue; } } } featureSource.Close(); ValueCircleStyle valueCircleStyle = new ValueCircleStyle(); valueCircleStyle.ColumnName = SelectedColumns[0]; valueCircleStyle.DrawingRadiusRatio = radiusRatio; valueCircleStyle.MinValidValue = minValue; valueCircleStyle.MaxValidValue = maxValue; valueCircleStyle.MinCircleAreaInDefaultZoomLevel = 80; valueCircleStyle.MaxCircleAreaInDefaultZoomLevel = 10000; valueCircleStyle.InnerColor = GeoColor.FromArgb(this.Opacity, Color); valueCircleStyle.OuterColor = GeoColor.SimpleColors.White; return(valueCircleStyle); }
public Collection <Feature> Clip(FeatureSource featureSource, IEnumerable <Feature> areaBaseShape, ClipType clipMode) { Collection <Feature> clipedFeatures = new Collection <Feature>(); switch (clipMode) { case ClipType.Inverse: foreach (var feature in InverseClip(featureSource, areaBaseShape)) { clipedFeatures.Add(feature); } break; case ClipType.Standard: default: foreach (var feature in StandardClip(featureSource, areaBaseShape)) { clipedFeatures.Add(feature); } break; } return(clipedFeatures); }
public static void SafeProcess(this FeatureSource featureSource, Action process) { bool isClosed = false; if (!featureSource.IsOpen) { featureSource.Open(); isClosed = true; } if (process != null) { process(); } if (isClosed) { featureSource.Close(); if (featureSource.Projection != null) { featureSource.Projection.Close(); } } }
protected override Collection <Style> GetStylesCore(FeatureSource featureSource) { Collection <GeoColor> familyColors = GeoColor.GetColorsInQualityFamily(Color, EndColor, classBreakCount, ColorWheelDirection); featureSource.Open(); int featureCount = featureSource.GetCount(); double[] values = new double[featureCount]; for (int i = 0; i < featureCount; i++) { Feature feature = featureSource.GetFeatureById((i + 1).ToString(CultureInfo.InvariantCulture), SelectedColumns); double columnValue; double.TryParse(feature.ColumnValues[SelectedColumns[0]], out columnValue); values[i] = columnValue; } featureSource.Close(); ClassBreakStyle classBreakStyle = new ClassBreakStyle(SelectedColumns[0]) { BreakValueInclusion = BreakValueInclusion.IncludeValue }; double[] classBreakValues = GetClusterClassBreaks(values, ClassBreakCount - 1); for (int i = 0; i < classBreakValues.Length; i++) { ClassBreak classBreak = new ClassBreak(classBreakValues[i], AreaStyles.CreateSimpleAreaStyle(new GeoColor(this.Opacity, familyColors[i]), GeoColor.FromHtml("#f05133"), 1)); classBreakStyle.ClassBreaks.Add(classBreak); } TextStyle textStyle = TextStyles.Country1("NAME"); return(new Collection <Style>() { classBreakStyle, textStyle }); }
private static void GetAdjacentFeataureIds(FeatureSource featureSource, LineShape sourceShape, Collection <string> startIds, Collection <string> endIds) { Vertex startVertex = sourceShape.Vertices[0]; Vertex endVertex = sourceShape.Vertices[sourceShape.Vertices.Count - 1]; Collection <Feature> tempfeatures = featureSource.GetFeaturesInsideBoundingBox(sourceShape.GetBoundingBox(), ReturningColumnsType.NoColumns); foreach (Feature tempFeature in tempfeatures) { LineShape tempShape = ((MultilineShape)tempFeature.GetShape()).Lines[0]; if (sourceShape.Id == tempFeature.Id) { continue; } if (tempShape.Vertices.Contains(startVertex)) { startIds.Add(tempFeature.Id); } else if (tempShape.Vertices.Contains(endVertex)) { endIds.Add(tempFeature.Id); } } }
private static Feature ConvertToExternalProjection(Feature feature, FeatureSource featureSource) { //Validators.CheckParameterIsNotNull(feature, "feature"); Feature newFeature = feature; if (featureSource.Projection != null) { try { newFeature = featureSource.Projection.ConvertToExternalProjection(feature); } catch { if (!feature.IsValid() && feature.CanMakeValid) { feature = feature.MakeValid(); newFeature = featureSource.Projection.ConvertToExternalProjection(feature); } } } return(newFeature); }
/// <summary> /// 用户向已有gdb中添加一个新的图层,该图层必须已存在shp文件 /// 向该mapcontent中添加一个layer /// </summary> /// <param name="gdb"></param> /// <param name="layerpath"></param> /// <param name="stylepath"></param> /// <returns></returns> public string addLayer(string layerpath, string stylepath, string guid, string layername) { if (layerpath == null) { return(null); } FeatureSource featuresource = null; PGGeoDatabase gdb = (PGGeoDatabase)this.gdb; //string layername = gdb.AddSHPFeatureSource(layerpath, guid); if (!this.gdb.featureSources.TryGetValue(guid, out featuresource)) { return(null); } Style style = null; try { if (stylepath != null) { style = Style.parseStyleFile(stylepath); } } catch (Exception e) { } if (style == null) { style = Style.createSimpleStyle(featuresource); } Layer layer = new Layer(layername, featuresource, style); this.layerlist.Insert(0, layer); return(layername); }
private bool TryParseParameters(Dictionary <string, string> parameters) { string[] parameterNames = { "OutputPath", "Wkt", "MatchColumns", "OperatorPairs", "FeatureSourceXml" }; bool allExist = parameterNames.All(name => parameters.ContainsKey(name)); if (allExist) { outputPath = parameters[parameterNames[0]]; Wkt = parameters[parameterNames[1]]; matchColumns = GetMatchColumnsFromString(parameters[parameterNames[2]]); operatorPairs = GetOperatorPairsFromString(parameters[parameterNames[3]]); featureSource = GetFeatureSourceFromString(parameters[parameterNames[4]]); } return(allExist); }
private void WriteFeaturesIntoQueue(Collection <Feature> features, FeatureSource featureSource) { foreach (Feature feature in features) { Collection <LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // Get the lineshape of the processing feature. foreach (LineShape processingLineShape in processingLineShapes) { // Define a variable to save the points where the adjacent lines intersect with current processing line. Collection <PointShape> crossingPoints = new Collection <PointShape>(); // Get all the lines in current processing shape bounds. Collection <Feature> adjacentFeatures = featureSource.GetFeaturesInsideBoundingBox(processingLineShape.GetBoundingBox(), ReturningColumnsType.NoColumns); // Loop and see if the queried shape is intersected with processing shape. foreach (Feature adjacentFeature in adjacentFeatures) { LineBaseShape adjacentLineShape = adjacentFeature.GetShape() as LineBaseShape; MultipointShape tempCrossingPoints = processingLineShape.GetCrossing(adjacentLineShape); // The queried shape is intersected with processing shape. foreach (PointShape point in tempCrossingPoints.Points) { bool hasAdded = false; foreach (var item in crossingPoints) { if (point.X == item.X && point.Y == item.Y) { hasAdded = true; break; } } if (!hasAdded) { crossingPoints.Add(point); } } } // Order the crossing points following the sequence of line vertex. Collection <FlagedVertex> vertecesOfNewLine = GeometryHelper.AddCrossingPointToLine(processingLineShape, crossingPoints); Collection <Vertex> verteces = new Collection <Vertex>(); Collection <Feature> lineFeatures = new Collection <Feature>(); foreach (var vertex in vertecesOfNewLine) { verteces.Add(vertex.Vertex); if (vertex.Flag) { if (verteces.Count >= 2) { LineShape segment = new LineShape(verteces); lineFeatures.Add(new Feature(segment, feature.ColumnValues)); verteces.RemoveAt(0); } } } if (lineFeatures.Count > 0) { queue.Enqueue(lineFeatures); } } #if DEBUG Console.WriteLine(string.Format("Done {0} in {1}", feature.Id, features.Count)); #endif } }
public Collection <Style> GetStyles(FeatureSource featureSource) { return(GetStylesCore(featureSource)); }
private FeatureSource CombineWith(FeatureSource source) => new CompoundFeatureSource(source, SpecData.FeatureSource);
private void WriteFeaturesIntoQueue(Collection<Feature> features, FeatureSource featureSource) { foreach (Feature feature in features) { Collection<LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // Get the lineshape of the processing feature. foreach (LineShape processingLineShape in processingLineShapes) { // Define a variable to save the points where the adjacent lines intersect with current processing line. Collection<PointShape> crossingPoints = new Collection<PointShape>(); // Get all the lines in current processing shape bounds. Collection<Feature> adjacentFeatures = featureSource.GetFeaturesInsideBoundingBox(processingLineShape.GetBoundingBox(), ReturningColumnsType.NoColumns); // Loop and see if the queried shape is intersected with processing shape. foreach (Feature adjacentFeature in adjacentFeatures) { LineBaseShape adjacentLineShape = adjacentFeature.GetShape() as LineBaseShape; MultipointShape tempCrossingPoints = processingLineShape.GetCrossing(adjacentLineShape); // The queried shape is intersected with processing shape. foreach (PointShape point in tempCrossingPoints.Points) { bool hasAdded = false; foreach (var item in crossingPoints) { if (point.X == item.X && point.Y == item.Y) { hasAdded = true; break; } } if (!hasAdded) { crossingPoints.Add(point); } } } // Order the crossing points following the sequence of line vertex. Collection<FlagedVertex> vertecesOfNewLine = GeometryHelper.AddCrossingPointToLine(processingLineShape, crossingPoints); Collection<Vertex> verteces = new Collection<Vertex>(); Collection<Feature> lineFeatures = new Collection<Feature>(); foreach (var vertex in vertecesOfNewLine) { verteces.Add(vertex.Vertex); if (vertex.Flag) { if (verteces.Count >= 2) { LineShape segment = new LineShape(verteces); lineFeatures.Add(new Feature(segment, feature.ColumnValues)); verteces.RemoveAt(0); } } } if (lineFeatures.Count > 0) { queue.Enqueue(lineFeatures); } } #if DEBUG Console.WriteLine(string.Format("Done {0} in {1}", feature.Id, features.Count)); #endif } }
private Collection<Feature> GetAdjacentFeaturesOfVertex(FeatureSource featureSource, Vertex vertex) { RectangleShape startSmallBounds = GeometryHelper.CreateSmallRectangle(vertex, tolerance); // Get all the lines in current processing shape bounds. Collection<Feature> adjacentFeatures = featureSource.GetFeaturesInsideBoundingBox(startSmallBounds, ReturningColumnsType.AllColumns); return adjacentFeatures; }
private void BuildNetworkNode(FeatureSource featureSource, QTreeSpatialIndex qtree, RoadNetwork roadNetwork, Vertex vertex) { RectangleShape startSmallBounds = GeometryHelper.CreateSmallRectangle(vertex, tolerance); Collection<string> idsInside = qtree.GetFeatureIdsIntersectingBoundingBox(startSmallBounds); if (idsInside.Count <= 0) { Node startNode = CreateNode(featureSource, roadNetwork, vertex); roadNetwork.Nodes.Add(startNode); qtree.Add(new PointShape(vertex)); } }
public SimpleFeatureSelector(FeatureSource source) { this.source = source; }
public static void ProcessTransaction(RectangleShape boundingBox, Collection <Feature> returnFeatures, FeatureSource featureSource, bool needUpdateProjection = false) { if (featureSource.IsInTransaction && featureSource.IsTransactionLive) { foreach (Feature feature in featureSource.TransactionBuffer.AddBuffer.Values) { if (boundingBox.Intersects(feature.GetBoundingBox())) { var newFeature = needUpdateProjection ? ConvertToExternalProjection(feature, featureSource) : feature; returnFeatures.Add(newFeature); } } Dictionary <string, Feature> recordsInDictionary = new Dictionary <string, Feature>(); if (featureSource.TransactionBuffer.EditBuffer.Count > 0 || featureSource.TransactionBuffer.DeleteBuffer.Count > 0) { recordsInDictionary = GetFeaturesDictionaryFromCollecion(returnFeatures); } foreach (Feature feature in featureSource.TransactionBuffer.EditBuffer.Values) { bool isContained = boundingBox.Intersects(feature.GetBoundingBox()); if (isContained) { if (recordsInDictionary.ContainsKey(feature.Id)) { Feature oringalFeature = recordsInDictionary[feature.Id]; returnFeatures.Remove(oringalFeature); } var newFeature = needUpdateProjection ? ConvertToExternalProjection(feature, featureSource) : feature; returnFeatures.Add(newFeature); } else if (!isContained && recordsInDictionary.ContainsKey(feature.Id)) { Feature oringalFeature = recordsInDictionary[feature.Id]; returnFeatures.Remove(oringalFeature); } } foreach (string id in featureSource.TransactionBuffer.DeleteBuffer) { if (recordsInDictionary.ContainsKey(id)) { if (boundingBox.Intersects(recordsInDictionary[id].GetBoundingBox()) && recordsInDictionary.ContainsKey(id)) { Feature feature = recordsInDictionary[id]; returnFeatures.Remove(feature); } } } } }
public static void RemoveEmptyAndExcludeFeatures(Collection <Feature> sourceFeatures, FeatureSource featureSource) { Collection <int> features = new Collection <int>(); for (int i = 0; i < sourceFeatures.Count; i++) { if (sourceFeatures[i] == null || sourceFeatures[i].GetWellKnownBinary() == null || sourceFeatures[i].GetWellKnownBinary().Length == 0 || featureSource.FeatureIdsToExclude.Contains(sourceFeatures[i].Id)) { features.Add(i); } } for (int i = features.Count - 1; i >= 0; i--) { sourceFeatures.RemoveAt(features[i]); } }
public static RectangleShape ConvertToInternalProjectionCall(RectangleShape rectangle, FeatureSource featureSource) { RectangleShape newRectangle = rectangle; if (featureSource.Projection != null) { newRectangle = featureSource.Projection.ConvertToInternalProjection(newRectangle); } return(newRectangle); }
private static Collection <Feature> ConvertToExternalProjection(IEnumerable <Feature> features, FeatureSource featureSource) { //Validators.CheckParameterIsNotNull(features, "features"); Collection <Feature> returnFeatures = new Collection <Feature>(); foreach (Feature feature in features) { if (feature.GetWellKnownBinary().Length != 0) { returnFeatures.Add(ConvertToExternalProjection(feature, featureSource)); } else { returnFeatures.Add(feature); } } return(returnFeatures); }
private IEnumerable <Feature> StandardClip(FeatureSource featureSource, IEnumerable <Feature> features) { lock (featureSource) { Collection <Feature> results = new Collection <Feature>(); //There is a bug about projection boundingbox, here is a workaround for it. 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(); } Collection <Feature> sourceFeatures = featureSource.GetFeaturesInsideBoundingBox(ExtentHelper.GetBoundingBoxOfItems(features), ReturningColumnsType.AllColumns); if (tmpProjection != null) { featureSource.Projection = tmpProjection; if (isOpen) { featureSource.Open(); } } ShapeFileType shapeFileType = ((ShapeFileFeatureSource)featureSource).GetShapeFileType(); if (featureSource.IsOpen) { featureSource.Close(); } int index = 1; int count = sourceFeatures.Count; if (shapeFileType == ShapeFileType.Point || shapeFileType == ShapeFileType.Multipoint) { return(StandardClipPoints(sourceFeatures, features, shapeFileType)); } else if (shapeFileType == ShapeFileType.Polyline) { MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(features)); foreach (var feature in sourceFeatures) { ReportProgress(index * 100 / count); index++; try { if (areaBaseShape.Contains(feature)) { results.Add(feature); } else { var clippedShape = ((LineBaseShape)feature.GetShape()).GetIntersection(areaBaseShape); if (clippedShape != null && clippedShape.Lines.Count > 0) { results.Add(new Feature(clippedShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues)); } } } catch (Exception ex) { HandleExceptionFromInvalidFeature(feature.Id, ex.Message); } } } else if (shapeFileType == ShapeFileType.Polygon) { MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(features)); foreach (var feature in sourceFeatures) { ReportProgress(index * 100 / count); try { index++; if (areaBaseShape.Contains(feature)) { results.Add(feature); } else { var clippedShape = areaBaseShape.GetIntersection(feature); 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 Collection <string> GetRequiredColumnNamesForLink(IEnumerable <string> returningColumnNames, FeatureSource featureSource) { //IEnumerable<string> requiredLinkColumnNames = GetRequiredLinkColumnNames(featureSource); //IEnumerable<string> tempColumnNames = returningColumnNames // .Where(c => !requiredLinkColumnNames.Contains(c.ToUpperInvariant())) // .Concat(requiredLinkColumnNames) // .Distinct(); Collection <string> resultColumnNames = new Collection <string>(); returningColumnNames.ForEach(columnName => resultColumnNames.Add(columnName)); return(resultColumnNames); }
public Layer(string layername, FeatureSource featuresource, Style style) { this.layername = layername; this.featuresource = featuresource; this.style = style; }
///////////////////////////////////////////////////////////////////////////////////////////// // create a shapefile public IFeatureClass CreateShapefile(string strShapeFolder, FeatureSource selLayer, string shpFileName) { Console.WriteLine(shpFileName); // prepared the shapefile fodler try { if (!System.IO.Directory.Exists(strShapeFolder)) System.IO.Directory.CreateDirectory(strShapeFolder); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } // if shapefile already exists, overwrite? string shpfileName = strShapeFolder + "\\" + shpFileName + ".shp"; string dbffileName = strShapeFolder + "\\" + shpFileName + ".dbf"; string shxfileName = strShapeFolder + "\\" + shpFileName + ".shx"; if (File.Exists(shpfileName) || File.Exists(dbffileName) || File.Exists(shxfileName)) { if (MessageBox.Show("shape file: " + strShapeFolder + "\\" + selLayer.Name + " already exists", "overwrite?", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) return null; else { File.Delete(shpfileName); File.Delete(dbffileName); File.Delete(shxfileName); } } // create workspace IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass(); IFeatureWorkspace pWS = (IFeatureWorkspace)pWSF.OpenFromFile(strShapeFolder, 0); // get the feature table FeatureDataTable ftable = selLayer.GetDataTable(); int rowCount = ftable.Rows.Count; int colCount = ftable.Columns.Count; int geometryColIndex = ftable.GeometryColumnIndex; // create fields //fields ESRI.ArcGIS.Geodatabase.IFields pFields = new FieldsClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields; pFieldsEdit.FieldCount_2 = colCount; Console.WriteLine("Colume Counts = " + colCount.ToString()); //field IField pField; IFieldEdit pFieldEdit; string shpFldName = ""; for (int col = 0; col < colCount; col++) { DataColumn dc = ftable.Columns[col]; pField = new FieldClass(); pFieldEdit = (IFieldEdit)pField; String colname = dc.ColumnName; if (colname.Length > 10) { colname = colname.Substring(0, 8) + col.ToString(); } pFieldEdit.AliasName_2 = colname; pFieldEdit.Name_2 = colname; pFieldEdit.IsNullable_2 = true; pFieldEdit.Editable_2 = true; Type dt = dc.DataType; Console.WriteLine(dc.ColumnName + "\t\t" + colname + "\t\t" + dt.ToString()); if (dt == typeof(String)) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; else if ((dt == typeof(Boolean))) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeSmallInteger; else if ((dt == typeof(Int16)) || (dt == typeof(Int32)) || (dt == typeof(Int64))) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger; else if (dt == typeof(Double)) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; else if (dt == typeof(Single)) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeSingle; else if (dt == typeof(DateTime)) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDate; else if (dt == typeof(Guid)) //pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGUID; // not supported by shapefile pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; else if (dt == typeof(ESRI.ArcGIS.Mobile.GlobalId)) pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; //pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGlobalID; // not supported by shapefile else if (dt == typeof(Bitmap)) // raster or blob, not supported by shapefile, { Console.WriteLine(dc.ColumnName + ": raster field found\n"); string folder = strShapeFolder + "\\" + dc.ColumnName; try { if (!Directory.Exists(folder)) Directory.CreateDirectory(folder); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return null; } pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; } else if (dt == typeof(System.Byte[])) // raster or blob, not supported by shapefile, { Console.WriteLine(dc.ColumnName + ": blob field found\n"); pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; } else if (dt == typeof(Bitmap)) // raster or blob, not supported by shapefile, { Console.WriteLine(dc.ColumnName + ": raster field found\n"); string folder = strShapeFolder + "\\" + dc.ColumnName; try { if (!Directory.Exists(folder)) Directory.CreateDirectory(folder); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return null; } pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; } else if (dt == typeof(System.Byte[])) // raster or blob, not supported by shapefile, { Console.WriteLine(dc.ColumnName + ": blob field found\n"); pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; } else if (dt == typeof(ESRI.ArcGIS.Mobile.Geometries.Geometry)) { Console.WriteLine("geometry field found\n"); shpFldName = dc.ColumnName; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry; IGeometryDef pGeoDef = new GeometryDefClass(); IGeometryDefEdit pGeoDefEdit = (IGeometryDefEdit)pGeoDef; pGeoDefEdit.GeometryType_2 = (ESRI.ArcGIS.Geometry.esriGeometryType)selLayer.GeometryType; pGeoDefEdit.SpatialReference_2 = new ESRI.ArcGIS.Geometry.UnknownCoordinateSystemClass(); pFieldEdit.GeometryDef_2 = pGeoDef; } else { throw (new Exception("different data type found, modify the code")); } // add the field to fields pFieldsEdit.set_Field(col, pFieldEdit); } for (int ii = 0; ii < pFields.FieldCount; ii++) { Console.WriteLine(pFields.get_Field(ii).Name + "\t\t" + pFields.get_Field(ii).Type.ToString()); } //create shapefile IFeatureClass fc = null; try { fc = pWS.CreateFeatureClass(shpFileName, pFields, null, null, esriFeatureType.esriFTSimple, shpFldName, ""); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } if (fc != null) return fc; else return null; }
public virtual void ImportData(FeatureSource featureSourceForRead, FeatureSource featureSourceForSave) { bool readCompleted = false; featureSourceForRead.Open(); featureSourceForSave.Open(); #if DEBUG long featureCount = featureSourceForRead.GetCount(); #endif Collection<Feature> features = featureSourceForRead.GetAllFeatures(ReturningColumnsType.AllColumns); Collection<Collection<Feature>> featureGroups = GroupFeatures(features); var writeTasks = (from items in featureGroups select Task.Factory.StartNew(() => WriteFeaturesIntoQueue(items, featureSourceForRead))).ToArray(); var readTask = Task.Factory.StartNew(() => { while (!readCompleted || queue.Count > 0) { while (queue.Count > 0) { Collection<Feature> lineFeatures = queue.Dequeue(); SaveFeatures(lineFeatures, featureSourceForSave); } } }); Task.WaitAll(writeTasks); readCompleted = true; Task.WaitAny(readTask); #region Old version //foreach (Feature feature in features) //{ // Collection<LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // // Get the lineshape of the processing feature. // foreach (LineShape processingLineShape in processingLineShapes) // { // // Define a variable to save the points where the adjacent lines intersect with current processing line. // Collection<PointShape> crossingPoints = new Collection<PointShape>(); // // Get all the lines in current processing shape bounds. // Collection<Feature> adjacentFeatures = featureSourceForRead.GetFeaturesInsideBoundingBox(processingLineShape.GetBoundingBox(), ReturningColumnsType.NoColumns); // // Loop and see if the queried shape is intersected with processing shape. // foreach (Feature adjacentFeature in adjacentFeatures) // { // LineBaseShape adjacentLineShape = adjacentFeature.GetShape() as LineBaseShape; // MultipointShape tempCrossingPoints = processingLineShape.GetCrossing(adjacentLineShape); // // The queried shape is intersected with processing shape. // foreach (PointShape point in tempCrossingPoints.Points) // { // bool hasAdded = false; // foreach (var item in crossingPoints) // { // if (point.X == item.X && point.Y == item.Y) // { // hasAdded = true; // break; // } // } // if (!hasAdded) // { // crossingPoints.Add(point); // } // } // } // // Order the crossing points following the sequence of line vertex. // Collection<FlagedVertex> vertecesOfNewLine = GeometryHelper.AddCrossingPointToLine(processingLineShape, crossingPoints); // // Split current processing lineshape into segments. // featureSourceForSave.BeginTransaction(); // Collection<Vertex> verteces = new Collection<Vertex>(); // foreach (var vertex in vertecesOfNewLine) // { // verteces.Add(vertex.Vertex); // if (vertex.Flag) // { // if (verteces.Count >= 2) // { // LineShape segment = new LineShape(verteces); // featureSourceForSave.AddFeature(new Feature(segment, feature.ColumnValues)); // verteces.RemoveAt(0); // } // } // } // featureSourceForSave.CommitTransaction(); // } //#if DEBUG //Console.WriteLine(string.Format("Done {0} in {1}", feature.Id, featureCount)); //#endif //} #endregion featureSourceForRead.Close(); featureSourceForSave.Close(); }
public EarthquakeHeatFeatureLayer(FeatureSource featureSource) : base() { FeatureSource = featureSource; }
private Node CreateNode(FeatureSource featureSource, RoadNetwork roadNetwork, Vertex vertex) { // Create node based on vertex. // Todo: check if it has been existed. Collection<Feature> adjacentTailNodeFeatures = GetAdjacentFeaturesOfVertex(featureSource, vertex); Node tailNode = InitializeNodeFromVeterx(vertex, adjacentTailNodeFeatures); roadNetwork.Nodes.Add(tailNode); // Loop and see if the queried shape is intersected with processing shape. foreach (Feature adjacentTailNodeFeature in adjacentTailNodeFeatures) { // Given the adjacent line is line shape, and create adjacent list without un-direction consideration. LineShape adjacentLineShape = GeometryHelper.GetLineShapes(adjacentTailNodeFeature)[0]; adjacentLineShape.Id = adjacentTailNodeFeature.Id; // Check if it's start vertext or end vertex of the adjacent line shape. int vertexIndex = 0; if (GeometryHelper.IsSamePoint(vertex, adjacentLineShape.Vertices[adjacentLineShape.Vertices.Count - 1], tolerance)) { vertexIndex = adjacentLineShape.Vertices.Count - 1; } // Todo: check if it has been existed. Collection<Feature> adjacentHeadNodeFeatures = GetAdjacentFeaturesOfVertex(featureSource, adjacentLineShape.Vertices[vertexIndex]); Node headNode = InitializeNodeFromVeterx(adjacentLineShape.Vertices[vertexIndex], adjacentHeadNodeFeatures); roadNetwork.Nodes.Add(headNode); Arc adjacentArc = new Arc(adjacentTailNodeFeature.Id, headNode, tailNode, CalculateRoadCost(adjacentLineShape)); // Check if the direction is the allowed of current segment? RoadDirection roadDirection = CalculateRoadDirection(adjacentTailNodeFeature, adjacentLineShape, vertex); if (roadDirection == RoadDirection.Forward) { tailNode.OutgoingArcs.Add(adjacentArc); } else if (roadDirection == RoadDirection.Backward) { tailNode.IncomingArcs.Add(adjacentArc); } } return tailNode; }
//指定表名读出成一个FeatureSource public FeatureSource ReadFromTable(string table) { string connStr = "Server=" + server + ";Port=" + port + ";UserId=" + user + ";Password="******";Database=" + database + ";"; try { //获得图层类型和参考坐标系 Dictionary <string, string> dt1 = GetSchemePara(table); OSGeo.OGR.wkbGeometryType geometryType = String2Type.String2wkbGeometryType(dt1["type"]); ReferenceSystem rs = new SRS(new OSGeo.OSR.SpatialReference(Int2SRText(int.Parse(dt1["srid"])))); NpgsqlConnection conn = new NpgsqlConnection(connStr); conn.Open(); IDbCommand dbcmd = conn.CreateCommand(); dbcmd.CommandText = "SELECT *,ST_AsText(geom) AS geom1 FROM \"" + table + "\""; IDataReader dr = dbcmd.ExecuteReader(); Dictionary <string, OSGeo.OGR.FieldDefn> fields = new Dictionary <string, OSGeo.OGR.FieldDefn>(); string[] fieldNames = new string[dr.FieldCount - 2]; for (int i = 0; i < dr.FieldCount - 2; i++) { OSGeo.OGR.FieldDefn d = GetFieldDefn(dr.GetName(i), dr.GetDataTypeName(i)); fields.Add(dr.GetName(i), d); fieldNames[i] = dr.GetName(i); } Schema schema = new Schema(table, geometryType, rs, fields); List <Feature> flst = new List <Feature>(); while (dr.Read()) { int featureID = int.Parse(dr[0].ToString()); Geometry.Geometry geometry = WKT2Feature.WKT2Geometry(dr[dr.FieldCount - 1].ToString()); Dictionary <string, Object> attributes = new Dictionary <string, object>(); for (int i = 0; i < dr.FieldCount - 2; i++) { Object o; switch (fields[fieldNames[i]].GetFieldType()) { case OSGeo.OGR.FieldType.OFTInteger: o = int.Parse(dr[i].ToString()); break; case OSGeo.OGR.FieldType.OFTReal: o = double.Parse(dr[i].ToString()); break; default: o = dr[i].ToString(); break; } attributes.Add(fieldNames[i], o); } Feature feature = new Feature(featureID, schema, geometry, attributes); flst.Add(feature); } FeatureCollection fc = new FeatureCollection(flst); FeatureSource fs = new FeatureSource(schema, fc); return(fs); conn.Close(); } catch (Exception e) { return(null); } }
private void SaveFeatures(Collection<Feature> features, FeatureSource featureSource) { featureSource.BeginTransaction(); foreach (var feature in features) { featureSource.AddFeature(feature); } featureSource.CommitTransaction(); }
protected abstract Collection<Style> GetStylesCore(FeatureSource featureSource);
public VectorOverlay() { FeatureSource = new FeatureSource(); ZoomLevelSet = new ZoomLevelSet(); }
void layersMenuHandler(object sender, EventArgs e) { // unchecks the last selected layer if (currentLayerMenuItem != null) currentLayerMenuItem.CheckState = CheckState.Unchecked; // sets selected layer to the current one currentLayerMenuItem = sender as ToolStripMenuItem; currentLayerMenuItem.CheckState = CheckState.Checked; selLayerName = sender.ToString(); selLayer = mobileCache1.FeatureSources[selLayerName] as FeatureSource; selectionMapAction1.SelectionFeatureSources.Clear(); selectionMapAction1.SelectionFeatureSources.Add(selLayer); int originalcount = selLayer.GetFeatureCount(EditState.Original); int addedcount = selLayer.GetFeatureCount(EditState.Added); int modifiedcount = selLayer.GetFeatureCount(EditState.Modified); int deletedcount = selLayer.GetFeatureCount(EditState.Deleted); int currentcount = selLayer.GetFeatureCount(EditState.Current); // message on the status bar layerToolStripStatusLabel.Text = selLayerName + " [" + originalcount.ToString() + " Original, " + addedcount.ToString() + " Added, " + modifiedcount.ToString() + " Modified, " + deletedcount.ToString() + " deleted, " + currentcount.ToString() + " Current ]"; }
public CompoundFeatureSource(FeatureSource first, FeatureSource second) { this.first = first; this.second = second; }
public EarthquakeHeatFeatureLayer(FeatureSource featureSource) : base() { FeatureSource = featureSource; }
protected abstract Collection <Style> GetStylesCore(FeatureSource featureSource);
public Style GetStyle(FeatureSource featureSource) { return(GetStyleCore(featureSource)); }
public virtual void ImportData(FeatureSource featureSourceForRead, FeatureSource featureSourceForSave) { bool readCompleted = false; featureSourceForRead.Open(); featureSourceForSave.Open(); #if DEBUG long featureCount = featureSourceForRead.GetCount(); #endif Collection <Feature> features = featureSourceForRead.GetAllFeatures(ReturningColumnsType.AllColumns); Collection <Collection <Feature> > featureGroups = GroupFeatures(features); var writeTasks = (from items in featureGroups select Task.Factory.StartNew(() => WriteFeaturesIntoQueue(items, featureSourceForRead))).ToArray(); var readTask = Task.Factory.StartNew(() => { while (!readCompleted || queue.Count > 0) { while (queue.Count > 0) { Collection <Feature> lineFeatures = queue.Dequeue(); SaveFeatures(lineFeatures, featureSourceForSave); } } }); Task.WaitAll(writeTasks); readCompleted = true; Task.WaitAny(readTask); #region Old version //foreach (Feature feature in features) //{ // Collection<LineShape> processingLineShapes = GeometryHelper.GetLineShapes(feature); // // Get the lineshape of the processing feature. // foreach (LineShape processingLineShape in processingLineShapes) // { // // Define a variable to save the points where the adjacent lines intersect with current processing line. // Collection<PointShape> crossingPoints = new Collection<PointShape>(); // // Get all the lines in current processing shape bounds. // Collection<Feature> adjacentFeatures = featureSourceForRead.GetFeaturesInsideBoundingBox(processingLineShape.GetBoundingBox(), ReturningColumnsType.NoColumns); // // Loop and see if the queried shape is intersected with processing shape. // foreach (Feature adjacentFeature in adjacentFeatures) // { // LineBaseShape adjacentLineShape = adjacentFeature.GetShape() as LineBaseShape; // MultipointShape tempCrossingPoints = processingLineShape.GetCrossing(adjacentLineShape); // // The queried shape is intersected with processing shape. // foreach (PointShape point in tempCrossingPoints.Points) // { // bool hasAdded = false; // foreach (var item in crossingPoints) // { // if (point.X == item.X && point.Y == item.Y) // { // hasAdded = true; // break; // } // } // if (!hasAdded) // { // crossingPoints.Add(point); // } // } // } // // Order the crossing points following the sequence of line vertex. // Collection<FlagedVertex> vertecesOfNewLine = GeometryHelper.AddCrossingPointToLine(processingLineShape, crossingPoints); // // Split current processing lineshape into segments. // featureSourceForSave.BeginTransaction(); // Collection<Vertex> verteces = new Collection<Vertex>(); // foreach (var vertex in vertecesOfNewLine) // { // verteces.Add(vertex.Vertex); // if (vertex.Flag) // { // if (verteces.Count >= 2) // { // LineShape segment = new LineShape(verteces); // featureSourceForSave.AddFeature(new Feature(segment, feature.ColumnValues)); // verteces.RemoveAt(0); // } // } // } // featureSourceForSave.CommitTransaction(); // } //#if DEBUG //Console.WriteLine(string.Format("Done {0} in {1}", feature.Id, featureCount)); //#endif //} #endregion featureSourceForRead.Close(); featureSourceForSave.Close(); }
protected abstract Style GetStyleCore(FeatureSource featureSource);
public static bool Prefix([NotNull] LevelUpState state, [NotNull] UnitDescriptor unit, [NotNull] IList <BlueprintFeatureBase> features, [CanBeNull] FeatureSource source, int level) { if (!Main.IsInGame) { return(false); } #if true //Logger.Log($"feature count = {features.ToArray().Count()} "); var description = source.Blueprint.GetDescription() ?? "nil"; //Logger.Log($"source: {source.Blueprint.name} - {description}"); foreach (BlueprintFeature blueprintFeature in features.OfType <BlueprintFeature>()) { if (blueprintFeature.MeetsPrerequisites((FeatureSelectionState)null, unit, state, true)) { //Logger.Log($" name: {blueprintFeature.Name} : {blueprintFeature.GetType()}"); if (blueprintFeature is IFeatureSelection selection) { // Bug Fix - due to issues in the implementation of FeatureSelectionState.CanSelectAnything we can get level up blocked so this is an attempt to work around for that var numToAdd = settings.featsMultiplier; if (selection is BlueprintFeatureSelection bpFS) { var bpFeatures = bpFS; var items = bpFS.ExtractSelectionItems(unit, null); //Logger.Log($" items: {items.Count()}"); var availableCount = 0; foreach (var item in items) { #if false if (bpFS.is BlueprintParametrizedFeature bppF) { Logger.Log($"checking parameterized feature {bppF.Name}"); if (selection.CanSelect(unit, state, null, item)) { Logger.Log($" {item.Feature.name} is avaiable"); availableCount++; } } else #endif if (!unit.Progression.Features.HasFact(item.Feature)) { availableCount++; // Logger.Log($" {item.Feature.name} is avaiable"); } #if false if (selection.CanSelect(unit, state, null, item)) { Logger.Log($" {item.Feature.name} is avaiable"); availableCount++; } else { Logger.Log($" {item.Feature.name} is NOT avaiable"); } if (!unit.Progression.Features.HasFact(item.Feature)) { if (item.Feature.MeetsPrerequisites(null, unit, state, true)) { Logger.Log($" {item.Feature.name} is avaiable"); availableCount++; } } else { Logger.Log($" has Fact {item.Feature.Name}"); } #endif } if (numToAdd > availableCount) { Logger.Log($"reduced numToAdd: {numToAdd} -> {availableCount}"); numToAdd = availableCount; } } //Logger.Log($" IFeatureSelection: {selection} adding: {numToAdd}"); for (int i = 0; i < numToAdd; ++i) { state.AddSelection((FeatureSelectionState)null, source, selection, level); } } Kingmaker.UnitLogic.Feature feature = (Kingmaker.UnitLogic.Feature)unit.AddFact((BlueprintUnitFact)blueprintFeature); BlueprintProgression progression = blueprintFeature as BlueprintProgression; if ((UnityEngine.Object)progression != (UnityEngine.Object)null) { //Logger.Log($" BlueprintProgression: {progression}"); LevelUpHelper.UpdateProgression(state, unit, progression); } FeatureSource source1 = source; int level1 = level; feature.SetSource(source1, level1); }
public static Style createRankStyle(FeatureSource featuresource, string attributename, int num, Color startcolor, Color endcolor) { Schema schema = featuresource.schema; SymbolizerType sign = SymbolizerType.POINT; switch (schema.geometryType) { case OSGeo.OGR.wkbGeometryType.wkbPoint: sign = SymbolizerType.POINT; break; case OSGeo.OGR.wkbGeometryType.wkbLineString: sign = SymbolizerType.LINE; break; case OSGeo.OGR.wkbGeometryType.wkbPolygon: sign = SymbolizerType.POLYGON; break; } FieldDefn fielddefn = null; if (schema.fields.TryGetValue(attributename, out fielddefn) || attributename.Equals("FeatureID")) { FieldType type = FieldType.OFTString; if (!attributename.Equals("FeatureID")) { type = fielddefn.GetFieldType(); } if (type == FieldType.OFTInteger || type == FieldType.OFTReal || attributename.Equals("FeatureID")) { double maxvalue = double.MinValue; double minvalue = double.MaxValue; foreach (GisSmartTools.Data.Feature feature in featuresource.features.featureList) { double value = 0; if (type == FieldType.OFTInteger || attributename.Equals("FeatureID")) { value = (int)feature.GetArrtributeByName(attributename); } if (type == FieldType.OFTReal) { value = (double)feature.GetArrtributeByName(attributename); } if (value > maxvalue) { maxvalue = value; } if (value < minvalue) { minvalue = value; } } if (num == 0) { return(null); } double x = (maxvalue - minvalue) / num; //逐个创建对应的rule Color[] colorarray = Utils.GetLinearColorList(startcolor, endcolor, num); double temp_minvalue = minvalue; double temp_maxvalue = minvalue + x; List <RenderRule> rulelist = new List <RenderRule>(); // Printer.printnode("min=" + minvalue + " max=" + maxvalue, ""); for (int i = 0; i < num; i++) { RenderRule rule = RenderRule.createDefaultRule(sign, colorarray[i]); Filter_Larger larger = new Filter_Larger(attributename, temp_minvalue); Filter_Less less = new Filter_Less(attributename, temp_maxvalue); List <Filter.Filter> filterlist = new List <Filter.Filter>(); filterlist.Add(larger); filterlist.Add(less); Filter_And andfilter = new Filter_And(filterlist); rule.filter = andfilter; rulelist.Add(rule); // Printer.printnode("temp_" + i, "min=" + temp_minvalue + " max=" + temp_maxvalue); temp_minvalue += x; temp_maxvalue += x; } Style rankstyle = new Style("RankStyle", StyleType.RANKSTYLE, RenderRule.createDefaultRule(sign, startcolor)); rankstyle.rulelist = rulelist; Printer.printnode("rulist,count=", "" + rulelist.Count); return(rankstyle); } } return(null); }
public List <Feature> ParseFeatures(List <string> featureTextLines, string sourceName, FeatureSource featureSource, ContentType contentType) { var features = new List <Feature>(); var featureNameLineIndexes = featureTextLines.FindAllIndexOf(f => f.StartsWith("### ")); for (var i = 0; i < featureNameLineIndexes.Count - 1; i++) { var currentFeatureNameLineIndex = featureNameLineIndexes[i]; var nextFeatureNameLineIndex = featureNameLineIndexes.ElementAtOrDefault(i + 1); var featureLines = nextFeatureNameLineIndex == 0 ? featureTextLines.Skip(currentFeatureNameLineIndex).RemoveEmptyLines().ToList() : featureTextLines.Skip(currentFeatureNameLineIndex) .Take(nextFeatureNameLineIndex - currentFeatureNameLineIndex).RemoveEmptyLines().ToList(); var name = featureLines[0].Split("# ")[1].Trim(); var levels = GetFeatureLevels(featureLines.Skip(1).CleanListOfStrings().ToList()); foreach (var level in levels) { var feature = new Feature { Name = name, SourceEnum = featureSource, Text = string.Join("\r\n", featureLines.Skip(1).CleanListOfStrings()), PartitionKey = contentType.ToString(), SourceName = sourceName, Level = level, RowKey = $"{featureSource}-{sourceName}-{name}-{level}".Replace("/", string.Empty) .Replace(@"\", string.Empty) }; features.Add(feature); } } return(features); }
public Collection<Style> GetStyles(FeatureSource featureSource) { return GetStylesCore(featureSource); }