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