public Collection <IGeometry> GetGeometriesInView(Envelope bbox) { var box = _geometryFactory.ToGeometry(bbox); var retCollection = new Collection <IGeometry>(); foreach (var geometryList in _geometrys.Values) { geometryList.Where(box.Intersects).ToList().ForEach(retCollection.Add); } return(retCollection); }
//Build Mask public void BuildMask(string shapefile, string maskName, string position, List <int> levels) { DropMask(maskName); GeometryServiceProvider.Instance = new NetTopologySuite.NtsGeometryServices(); IGeometryFactory geofac = GeometryServiceProvider.Instance.CreateGeometryFactory(); ShapefileReader reader = new ShapefileReader(shapefile); IGeometryCollection shps = reader.ReadAll(); foreach (IGeometry shp in shps.Geometries) { foreach (Tuple <int, double, double> lod in schema.LODs.Reverse <Tuple <int, double, double> >()) { if (levels.Count != 0 && !levels.Contains(lod.Item1)) { continue; } TileInfo tile_start = schema.GetTileInfoFromXY(lod.Item2, shp.Envelope.Coordinates[0].X, shp.Envelope.Coordinates[0].Y); TileInfo tile_end = schema.GetTileInfoFromXY(lod.Item2, shp.Envelope.Coordinates[2].X, shp.Envelope.Coordinates[2].Y); int level = tile_start.Level; for (int x = tile_start.Column; x <= tile_end.Column; x++) { for (int y = tile_end.Row; y <= tile_start.Row; y++) { var loc = schema.GetTileEnvelop(level, y, x); Envelope env = new Envelope(loc.Item1, loc.Item2, loc.Item3, loc.Item4); if (position == "Border") { if (shp.Boundary.Intersects(geofac.ToGeometry(env))) { IDatabase redisClient = redisConnection.GetDatabase(); string tileID = String.Format("L{0}/R{1}/C{2}", level, y, x); redisClient.SetAddAsync(maskName, tileID, CommandFlags.FireAndForget); } } else if (position == "Interior") { if (shp.Contains(geofac.ToGeometry(env))) { IDatabase redisClient = redisConnection.GetDatabase(); string tileID = String.Format("L{0}/R{1}/C{2}", level, y, x); redisClient.SetAddAsync(maskName, tileID, CommandFlags.FireAndForget); } } } } } } }
public override IEnumerable <IFeature> GetFeatures(IEnvelope box, ILayer layer) { var vectorLayer = (VectorLayer)layer; var symbol = vectorLayer.Style.Symbol; var boxExpandedForImageSize = MapHelper.GetEnvelopeForImage(layer.Map, box.Centre, symbol.Width * 1.2, symbol.Height * 1.2); return(layer.GetFeatures(geometryFactory.ToGeometry(boxExpandedForImageSize), false)); }
void checkExpectedEnvelopeGeometry(String wktInput, String wktEnvGeomExpected) { IGeometry input = reader.Read(wktInput); IGeometry envGeomExpected = reader.Read(wktEnvGeomExpected); Envelope env = input.EnvelopeInternal; IGeometry envGeomActual = geometryFactory.ToGeometry(env); bool isEqual = envGeomActual.Equals(envGeomExpected); Assert.IsTrue(isEqual); }
public void test_intersection_bug_clipped() { IGeometryFactory factory = GeometryFactory.Default; WKTReader reader = new WKTReader(factory); IGeometry geom = reader.Read(NonNodedIntersection); Envelope clipEnv = geom.EnvelopeInternal; clipEnv.ExpandBy(BufferValue); IGeometry clip = factory.ToGeometry(clipEnv); Assert.DoesNotThrow(() => DoIntersection(FromWkb(Poly1Wkb, clip), FromWkb(Poly2Wkb, clip), clip)); }
private void printItemEnvelopes(IList tree) { var itemEnv = new Envelope(); foreach (object o in tree) { if (o is IList) { printItemEnvelopes((IList)o); } else if (o is IGeometry) { itemEnv.ExpandToInclude(((IGeometry)o).EnvelopeInternal); } } Console.WriteLine(_factory.ToGeometry(itemEnv).ToString()); }
private static void addBounds(IBoundable<Envelope, IGeometry> bnd, List<IGeometry> bounds, IGeometryFactory factory) { // don't include bounds of leaf nodes if (!(bnd is AbstractNode<Envelope, IGeometry>)) return; var env = (Envelope)bnd.Bounds; bounds.Add(factory.ToGeometry(env)); if (bnd is AbstractNode<Envelope, IGeometry>) { var node = (AbstractNode<Envelope, IGeometry>)bnd; var children = node.ChildBoundables; foreach (var child in children) { addBounds(child, bounds, factory); } } }
private static void addBounds(IBoundable <Envelope, IGeometry> bnd, List <IGeometry> bounds, IGeometryFactory factory) { // don't include bounds of leaf nodes if (!(bnd is AbstractNode <Envelope, IGeometry>)) { return; } var env = (Envelope)bnd.Bounds; bounds.Add(factory.ToGeometry(env)); if (bnd is AbstractNode <Envelope, IGeometry> ) { var node = (AbstractNode <Envelope, IGeometry>)bnd; var children = node.ChildBoundables; foreach (var child in children) { addBounds(child, bounds, factory); } } }
/// <summary> /// Creates a set of rectangular Polygons which /// cover the given envelope. /// The rectangles /// At least nRect rectangles are created. /// </summary> private static IGeometry[] CreateRectangles(Envelope env, int nRect) { int nSide = 1 + (int)Math.Sqrt(nRect); double dx = env.Width / nSide; double dy = env.Height / nSide; var rectList = new List <IGeometry>(); for (int i = 0; i < nSide; i++) { for (int j = 0; j < nSide; j++) { double baseX = env.MinX + i * dx; double baseY = env.MinY + j * dy; var envRect = new Envelope( baseX, baseX + dx, baseY, baseY + dy); var rect = Fact.ToGeometry(envRect); rectList.Add(rect); } } return(GeometryFactory.ToGeometryArray(rectList)); }
private ImageFactory ProcessTile(ImageFactory tile, IList <Processor_conf> processors, TileInfo tileInfo) { foreach (var processor in processors) { if (processor.type == "Watermark") { tile = tile.Watermark(new ImageProcessor.Imaging.TextLayer() { Text = processor.parameters["text"] }); } else if (processor.type == "Fill") { Image fill = new Bitmap(tile.Image.Width, tile.Image.Height); Graphics graphics = Graphics.FromImage(fill); int alpha = int.Parse(processor.parameters["alpha"]); int r = int.Parse(processor.parameters["red"]); int g = int.Parse(processor.parameters["green"]); int b = int.Parse(processor.parameters["blue"]); Color color = Color.FromArgb(alpha, r, g, b); SolidBrush bgBrush = new SolidBrush(color); graphics.FillRectangle(bgBrush, 0, 0, tile.Image.Width, tile.Image.Height); graphics.Save(); tile = tile.Overlay(new ImageProcessor.Imaging.ImageLayer() { Image = fill }); } else if (processor.type == "Clip") { double resolution = 0; foreach (var lod in schema.LODs) { if (lod.Item1 == tileInfo.Level) { resolution = lod.Item3; } } string shapefile = processor.parameters["region"]; IGeometryFactory geofac = GeometryServiceProvider.Instance.CreateGeometryFactory(); ShapefileReader reader = new ShapefileReader(shapefile); IGeometryCollection shps = reader.ReadAll(); foreach (IGeometry shp in shps.Geometries) { var loc = schema.GetTileEnvelop(tileInfo); Envelope env = new Envelope(loc.Item1, loc.Item2, loc.Item3, loc.Item4); if (shp.Intersects(geofac.ToGeometry(env))) { IGeometry overlap = shp.Intersection(geofac.ToGeometry(env)); GraphicsPath path = new GraphicsPath(); PointF[] points = overlap.Coordinates.Select(c => new PointF((float)((c.X - loc.Item1) / resolution), (float)((loc.Item4 - c.Y) / resolution))).ToArray(); path.AddPolygon(points); Graphics graphics = Graphics.FromImage(tile.Image); graphics.ExcludeClip(new Region(path)); SolidBrush bgBrush = new SolidBrush(Color.Transparent); graphics.FillRectangle(bgBrush, 0, 0, tile.Image.Width, tile.Image.Height); //graphics.DrawImageUnscaled(tile.Image, 0, 0); graphics.Save(); } } } } return(tile); }
/// <summary> /// Renders all features on the currently visible part of the map, using the values from the feature coverage. /// </summary> /// <param name="feature">The coverage to render.</param> /// <param name="g">Graphics object to be used as a target for rendering.</param> /// <param name="layer">Layer where coverage belongs to.</param> /// <returns>When rendering succeds returns true, otherwise false.</returns> public virtual bool Render(IFeature feature, Graphics g, ILayer layer) { // Use the FeatureCoverage function to get the coverage values var coverageLayer = (FeatureCoverageLayer)layer; IFeatureCoverage coverage = coverageLayer.FeatureCoverageToRender; var map = coverageLayer.Map; // No theme? No rendering! (This should be set in the FeatureCoverageLayer class' set_Features.) if (coverageLayer.Theme == null) { return(false); } // What features to render? IList featuresToRender; IFeature[] coverageFeatures; double[] values; lock (coverage.Store) // makes sure that features don't change before we get values { featuresToRender = coverageLayer.GetFeatures(geometryFactory.ToGeometry(map.Envelope), false).ToArray(); if (featuresToRender.Count <= 0) { // No features in the envelope, so no rendering required. return(true); } //get the component values in an array values = coverage.Components[0].Values.Cast <double>().ToArray(); if (values.Length == 0) //reset features to render if no values are found..perhaps other arguments are cleared { coverageFeatures = new IFeature[] {}; } else { //render all features coverageFeatures = coverage.FeatureVariable.Values.Cast <IFeature>().ToArray(); } } for (var i = 0; i < coverageFeatures.Length; i++) { var featureToRender = coverageFeatures[i]; if (!featuresToRender.Contains(featureToRender)) { continue; } var geometry = featureToRender.Geometry; if (GeometryForFeatureDelegate != null) { geometry = GeometryForFeatureDelegate(featureToRender); } // Use the GetStyle with the retrieved value var style = coverageLayer.Theme.GetStyle(values[i]) as VectorStyle; if (style != null) { // Draw background of all line-outlines first if (geometry is ILineString) { if (style.Enabled && style.EnableOutline) { VectorRenderingHelper.DrawLineString(g, geometry as ILineString, style.Outline, map); } } else if (geometry is IMultiLineString) { if (style.Enabled && style.EnableOutline) { VectorRenderingHelper.DrawMultiLineString(g, geometry as IMultiLineString, style.Outline, map); } } // Draw actual geometry VectorRenderingHelper.RenderGeometry(g, map, geometry, style, VectorLayer.DefaultPointSymbol, coverageLayer.ClippingEnabled); } else { throw new ArgumentException("No style could be gotten from the theme; the feature cannot be rendered."); } } return(true); }
private static IGeometry CreatePolygon(IGeometryFactory factory, Size size) { return factory.ToGeometry(new Envelope(2, size.Width - 4, 2, size.Height - 4)); }
public virtual IEnumerable <IFeature> GetFeatures(IEnvelope envelope) { return(GetFeatures(geometryFactory.ToGeometry(envelope))); // TODO: ... this can run even faster, otherwise remove this method ... }
private static IGeometry CreatePolygon(IGeometryFactory factory, Size size) { return(factory.ToGeometry(new Envelope(2, size.Width - 4, 2, size.Height - 4))); }