public static IEnvelope GetEnvelopeForImage(IMap map, ICoordinate centre, double pixelWidth, double pixelHeight)
{
var envelope = new Envelope();
ICoordinate size = ImageToWorld(map, pixelWidth, pixelHeight);
envelope.SetCentre(centre, size.X, size.Y);
return envelope;
}
public void Insert(Envelope envolpe, QuickInfoObject obj)
{
lock (m_QuadTree)
{
m_QuadTree.Insert(envolpe, obj);
}
}
/// <summary>
/// Inserts a node into the tree using <see cref="EntryStrategy"/>
/// </summary>
/// <param name="key">Key for the geometry</param>
/// <param name="region">Bounding box of the geometry to enter into the index</param>
public virtual void Insert(UInt32 key, GisSharpBlog.NetTopologySuite.Geometries.Envelope region)
{
RTreeIndexEntry entry = new RTreeIndexEntry(key, region);
Node newSiblingFromSplit;
EntryInsertStrategy.InsertEntry(entry, Root, _nodeSplitStrategy, Heuristic, out newSiblingFromSplit);
// Add the newly split sibling
if (newSiblingFromSplit is LeafNode)
{
if (Root is LeafNode)
{
LeafNode oldRoot = Root as LeafNode;
Root = CreateIndexNode();
(Root as IndexNode).Add(oldRoot);
}
(Root as IndexNode).Add(newSiblingFromSplit);
newSiblingFromSplit = null;
}
else if (newSiblingFromSplit is IndexNode) // Came from a root split
{
Node oldRoot = Root;
Root = CreateIndexNode();
(Root as IndexNode).Add(oldRoot);
(Root as IndexNode).Add(newSiblingFromSplit);
}
}
/// <summary>
///
/// </summary>
/// <param name="envelope"></param>
/// <returns></returns>
public static IEnvelope GetEnvelopeExternal(IEnvelope envelope)
{
// Get envelope in external coordinates
ICoordinate min = new Coordinate(envelope.MinX, envelope.MinY);
ICoordinate max = new Coordinate(envelope.MaxX, envelope.MaxY);
IEnvelope bounds = new Envelope(min.X, max.X, min.Y, max.Y);
return bounds;
}
protected override IEnvelope AdjustBoundingBox(IEnvelope bbox, double scale, System.Drawing.Size size)
{
double[] points = m_transform.MathTransform.Transform(new double[] { bbox.MinX, bbox.MinY, bbox.MaxX, bbox.MaxY });
IEnvelope localEnv = new Envelope(points[0], points[2], points[1], points[3]);
localEnv = base.AdjustBoundingBox(localEnv, scale, size);
points = m_transform.MathTransform.Inverse().Transform(new double[] { localEnv.MinX, localEnv.MinY, localEnv.MaxX, localEnv.MaxY });
return new Envelope(points[0], points[2], points[1], points[3]);
}
/// <summary>
/// Returns a "safe" envelope that is guaranteed to contain the hot pixel.
/// </summary>
/// <returns></returns>
public IEnvelope GetSafeEnvelope()
{
if (safeEnv == null)
{
double safeTolerance = 0.75 / scaleFactor;
safeEnv = new Envelope(originalPt.X - safeTolerance, originalPt.X + safeTolerance,
originalPt.Y - safeTolerance, originalPt.Y + safeTolerance);
}
return safeEnv;
}
/// <summary>
///
/// </summary>
/// <param name="querySeg"></param>
/// <returns></returns>
public IList Query(LineSegment querySeg)
{
Envelope env = new Envelope(querySeg.P0, querySeg.P1);
LineSegmentVisitor visitor = new LineSegmentVisitor(querySeg);
index.Query(env, visitor);
IList itemsFound = visitor.Items;
return itemsFound;
}
public void AddObject(Region path, string layer, ToolTipInfo toolTipInfo, System.Drawing.Graphics g)
{
lock (m_QuadTree)
{
RectangleF rf = path.GetBounds(g);
Envelope env = new Envelope(rf.Left, rf.Right, rf.Bottom, rf.Top);
m_QuadTree.Insert(env, new QuickInfoObject(path, layer, toolTipInfo, env));
}
}
public void EnvelopeChangesWhenCoverageIsCleared()
{
var coverage = new RegularGridCoverage(10, 10, 1, 1);
var layer = new RegularGridCoverageLayer { Coverage = coverage };
var envelope = new Envelope(0, 10, 0, 10);
Assert.AreEqual(envelope, layer.Envelope);
coverage.Clear();
var EmptyEnvelope = new Envelope(0, 0, 0, 0);
Assert.AreEqual(EmptyEnvelope, layer.Envelope);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="addEnv"></param>
/// <returns></returns>
public static Node CreateExpanded(Node node, IEnvelope addEnv)
{
IEnvelope expandEnv = new Envelope(addEnv);
if (node != null)
expandEnv.ExpandToInclude(node.env);
Node largerNode = CreateNode(expandEnv);
if (node != null)
largerNode.InsertNode(node);
return largerNode;
}
/// <summary>
/// Transforms a <see cref="IEnvelope" /> object.
/// </summary>
/// <param name="box"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IEnvelope TransformBox(IEnvelope box, IMathTransform transform)
{
if (box == null) return null;
double[][] corners = new double[4][];
corners[0] = transform.Transform(ToArray(box.MinX, box.MinY)); //LL
corners[1] = transform.Transform(ToArray(box.MaxX, box.MaxY)); //UR
corners[2] = transform.Transform(ToArray(box.MinX, box.MaxY)); //UL
corners[3] = transform.Transform(ToArray(box.MaxX, box.MinY)); //LR
IEnvelope result = new Envelope();
foreach (double[] p in corners)
result.ExpandToInclude(p[0], p[1]);
return result;
}
public System.Collections.IList Query(System.Drawing.Point p)
{
Envelope env = new Envelope(p.X, p.X, p.Y, p.Y);
System.Collections.IList tmpList;
lock (m_QuadTree)
{
tmpList = m_QuadTree.Query(env);
}
List<QuickInfoObject> result = new List<QuickInfoObject>();
foreach (QuickInfoObject qo in tmpList)
{
if (qo.Envelope.Contains(p.X, p.Y))
result.Add(qo);
}
return result;
}
public void GetExtentsComputation()
{
DataTable source = createDataTableSource();
DataTablePoint provider = new DataTablePoint(source, "oid", "x", "y");
double minX = Double.PositiveInfinity, minY = Double.PositiveInfinity,
maxX = Double.NegativeInfinity, maxY = Double.NegativeInfinity;
foreach (DataRowView rowView in source.DefaultView)
{
if (minX > (double)rowView["x"]) minX = (double)rowView["x"];
if (minY > (double)rowView["y"]) minY = (double)rowView["y"];
if (maxX < (double)rowView["x"]) maxX = (double)rowView["x"];
if (maxY < (double)rowView["y"]) maxY = (double)rowView["y"];
}
Envelope expectedBounds = new Envelope(minX, minY, maxX, maxY);
IEnvelope actualBounds = provider.GetExtents();
Assert.AreEqual(expectedBounds, actualBounds);
}
/// <summary>
///
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private Node CreateSubnode(int index)
{
// create a new subquad in the appropriate quadrant
double minx = 0.0;
double maxx = 0.0;
double miny = 0.0;
double maxy = 0.0;
switch (index)
{
case 0:
minx = env.MinX;
maxx = centre.X;
miny = env.MinY;
maxy = centre.Y;
break;
case 1:
minx = centre.X;
maxx = env.MaxX;
miny = env.MinY;
maxy = centre.Y;
break;
case 2:
minx = env.MinX;
maxx = centre.X;
miny = centre.Y;
maxy = env.MaxY;
break;
case 3:
minx = centre.X;
maxx = env.MaxX;
miny = centre.Y;
maxy = env.MaxY;
break;
default:
break;
}
IEnvelope sqEnv = new Envelope(minx, maxx, miny, maxy);
Node node = new Node(sqEnv, level - 1);
return node;
}
/// <summary>
/// Boundingbox of dataset
/// </summary>
/// <returns>boundingbox</returns>
public virtual IEnvelope GetExtents()
{
IEnvelope envelope = new Envelope();
for (int i = 0; i < Geometries.Count; i++)
{
if (!Geometries[i].IsEmpty)
{
envelope.ExpandToInclude(Geometries[i].EnvelopeInternal);
}
}
return envelope;
}
/// <summary>
///
/// </summary>
/// <param name="pt"></param>
/// <returns></returns>
public bool IsInside(ICoordinate pt)
{
crossings = 0;
// test all segments intersected by ray from pt in positive x direction
IEnvelope rayEnv = new Envelope(Double.NegativeInfinity, Double.PositiveInfinity, pt.Y, pt.Y);
interval.Min = pt.Y;
interval.Max = pt.Y;
IList segs = tree.Query(interval);
MCSelecter mcSelecter = new MCSelecter(this, pt);
for (IEnumerator i = segs.GetEnumerator(); i.MoveNext(); )
{
MonotoneChain mc = (MonotoneChain) i.Current;
TestMonotoneChain(rayEnv, mcSelecter, mc);
}
/*
* p is inside if number of crossings is odd.
*/
if ((crossings % 2) == 1)
return true;
return false;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override object ComputeBounds()
{
IEnvelope bounds = null;
for (IEnumerator i = ChildBoundables.GetEnumerator(); i.MoveNext(); )
{
IBoundable childBoundable = (IBoundable) i.Current;
if (bounds == null)
bounds = new Envelope((IEnvelope) childBoundable.Bounds);
else bounds.ExpandToInclude((IEnvelope) childBoundable.Bounds);
}
return bounds;
}
/// <summary>
/// Returns the BoundingBox of the dataset.
/// </summary>
/// <returns>BoundingBox</returns>
public BoundingBox GetExtents()
{
Envelope envelope = new Envelope();
foreach (Feature feature in features)
envelope.ExpandToInclude(feature.Geometry.EnvelopeInternal);
return GeometryConverter.ToSharpMapBoundingBox(envelope);
}
/// <summary>
/// Gets the extents of the map based on the extents of all the layers in the layers collection
/// </summary>
/// <returns>Full map extents</returns>
public virtual IEnvelope GetExtents()
{
if (Layers == null || Layers.Count == 0)
{
return null;
}
IEnvelope envelope = new Envelope();
for (int i = 0; i < Layers.Count; i++)
{
if (Layers[i].IsVisible)
{
if (Layers[i].Envelope != null && !Layers[i].Envelope.IsNull)
{
envelope.ExpandToInclude(Layers[i].Envelope);
}
}
}
return envelope;
}
/// <summary>
/// Test whether a point lies in the envelopes of both input segments.
/// A correctly computed intersection point should return <c>true</c>
/// for this test.
/// Since this test is for debugging purposes only, no attempt is
/// made to optimize the envelope test.
/// </summary>
/// <param name="intPt"></param>
/// <returns><c>true</c> if the input point lies within both input segment envelopes.</returns>
private bool IsInSegmentEnvelopes(ICoordinate intPt)
{
IEnvelope env0 = new Envelope(inputLines[0, 0], inputLines[0, 1]);
IEnvelope env1 = new Envelope(inputLines[1, 0], inputLines[1, 1]);
return env0.Contains(intPt) && env1.Contains(intPt);
}
/// <summary>
/// Retrieves the contents of the specified table, and writes them to a shapefile
/// </summary>
/// <param name="tableName"></param>
/// <returns></returns>
public bool ExportGriddedShapefile(string tableName)
{
try
{
_log.DebugFormat("Retrieving contents of job {0}", tableName);
//don't filter out geometries, we'll do that at the cell level
var exportFeatures = GetShapeFeaturesToExport(tableName, false);
if ((exportFeatures == null) || (exportFeatures.Count == 0))
{
_log.ErrorFormat("Export of Job \"{0}\" failed, no features to export!", tableName);
return false;
}
ICoordinateSystem outputCrs = GeographicCoordinateSystem.WGS84;
if (!string.IsNullOrEmpty(this.OutputProjectionFilename))
{
outputCrs = Utilities.GetCoordinateSystemByWKTFile(this.OutputProjectionFilename);
}
//if we need to reproject:
List<IGeometry> filteringGeoms = GetFilteringGeometries(this.ExportFilterFilename, outputCrs);
//put everything into a basic spatial index
Envelope env = new Envelope();
var index = new GisSharpBlog.NetTopologySuite.Index.Strtree.STRtree();
for (int i = 0; i < exportFeatures.Count; i++)
{
Feature f = exportFeatures[i];
index.Insert(f.Geometry.EnvelopeInternal, f);
env.ExpandToInclude(f.Geometry.EnvelopeInternal);
}
if (IsCancelled()) { _log.Debug("Job Cancelled..."); return false; }
index.Build();
//adjust envelope to only scan area inside filtering geometries
if (!string.IsNullOrEmpty(this.GridEnvelopeFilename))
{
//a specified envelope file overrides the envelope of the filtering geometries
env = GetGridEnvelope();
}
else if ((filteringGeoms != null) && (filteringGeoms.Count > 0))
{
//in the absence ... //TODO: finish--
env = new Envelope();
for (int i = 0; i < filteringGeoms.Count; i++)
{
env.ExpandToInclude(filteringGeoms[i].EnvelopeInternal);
}
}
//progress tracking
DateTime start = DateTime.Now, lastCheck = DateTime.Now;
int lastProgress = 0;
var features = new List<Feature>(exportFeatures.Count);
double cellWidth = GridCellWidth;
double cellHeight = GridCellHeight;
bool discardEmptyGridCells = !IncludeEmptyGridCells;
int numRows = (int)Math.Ceiling(env.Height / cellHeight);
int numCols = (int)Math.Ceiling(env.Width / cellWidth);
int expectedCells = numRows * numCols;
if (expectedCells > 1000000)
{
_log.Warn("**********************");
_log.Warn("Your selected area will produce a shapefile with over a million cells, is that a good idea?");
_log.WarnFormat("Area of {0}, Expected Cell Count of {1}", env.Area, expectedCells);
_log.Warn("**********************");
}
DbaseFileHeader header = null;
using (var conn = DbClient.GetConnection())
{
//Dictionary<string, DataRow> shapeDict = GetShapeRowsByLOGRECNO(conn);
var variablesDT = DataClient.GetMagicTable(conn, DbClient, string.Format("SELECT * FROM \"{0}\" where 0 = 1 ", tableName));
header = ShapefileHelper.SetupHeader(variablesDT);
}
ShapefileHelper.AddColumn(header, "CELLID", typeof(string));
ShapefileHelper.AddColumn(header, "GEOID", typeof(string));
if (this.AddStrippedGEOIDcolumn)
{
ShapefileHelper.AddColumn(header, "GEOID_STRP", typeof(string));
}
//lets not add these to the fishnet exports just yet
//if (this.AddGeometryAttributesToOutput)
//{
// ShapefileHelper.AddColumn(header, "AREA", typeof(double));
// ShapefileHelper.AddColumn(header, "PERIMETER", typeof(double));
// ShapefileHelper.AddColumn(header, "CENTROID", typeof(double));
//}
int cellCount = 0;
int xidx = 0;
for (double x = env.MinX; x < env.MaxX; x += cellWidth)
{
xidx++;
int yidx = 0;
for (double y = env.MinY; y < env.MaxY; y += cellHeight)
{
yidx++;
cellCount++;
string cellID = string.Format("{0}_{1}", xidx, yidx);
Envelope cellEnv = new Envelope(x, x + cellWidth, y, y + cellHeight);
IGeometry cellCenter = new Point(cellEnv.Centre);
IGeometry cellGeom = Utilities.IEnvToIGeometry(cellEnv);
Feature found = null;
IList mightMatch = index.Query(cellGeom.EnvelopeInternal);
foreach (Feature f in mightMatch)
{
if (f.Geometry.Contains(cellCenter))
{
found = f;
break;
}
}
if ((found == null) && (discardEmptyGridCells))
{
//_log.DebugFormat("No feature found for cell {0}", cellID);
continue;
}
//if we have filtering geometries, skip a cell if it isn't included
if (!IsIncluded(cellGeom, filteringGeoms))
{
continue;
}
if ((cellCount % 1000) == 0)
{
int step = (int)((((double)cellCount) / ((double)expectedCells)) * 100.0);
TimeSpan elapsed = (DateTime.Now - lastCheck);
if ((step != lastProgress) && (elapsed.TotalSeconds > 1))
{
_log.DebugFormat("{0:###.##}% complete, {1:#0.0#} seconds, {2} built, {3} checked, {4} left",
step, (DateTime.Now - start).TotalSeconds,
features.Count,
cellCount,
expectedCells - cellCount
);
lastCheck = DateTime.Now;
lastProgress = step;
if (IsCancelled()) { _log.Debug("Job Cancelled..."); return false; }
}
}
//this is a lot of work just to add an id...
AttributesTable attribs = new AttributesTable();
if (found != null)
{
//if (!found.Attributes.GetNames().Contains("GEOID"))
// throw new Exception("GEOID NOT FOUND!!!!");
foreach (string name in found.Attributes.GetNames())
{
attribs.AddAttribute(name, found.Attributes[name]);
}
attribs.AddAttribute("CELLID", cellID);
}
else
{
foreach (var field in header.Fields)
{
attribs.AddAttribute(field.Name, null);
}
attribs["CELLID"] = cellID;
}
features.Add(new Feature(cellGeom, attribs));
}
}
_log.Debug("Done building cells, Saving Shapefile...");
header.NumRecords = features.Count;
if (features.Count == 0)
{
_log.Error("No features found, exiting!");
return false;
}
string newShapefilename = Path.Combine(Environment.CurrentDirectory, tableName);
if (!string.IsNullOrEmpty(OutputFolder))
{
newShapefilename = Path.Combine(OutputFolder, tableName);
}
if (IsCancelled()) { _log.Debug("Job Cancelled..."); return false; }
var writer = new ShapefileDataWriter(newShapefilename, ShapefileHelper.GetGeomFactory());
writer.Header = header;
writer.Write(features);
if (!string.IsNullOrEmpty(this.OutputProjectionFilename))
{
//Reproject everything in this file to the requested projection...
ShapefileHelper.MakeOutputProjFile(this.OutputProjectionFilename, newShapefilename);
}
else
{
ShapefileHelper.MakeCensusProjFile(newShapefilename);
}
_log.Debug("Done! Shapefile exported successfully");
return true;
}
catch (FileNotFoundException notFound)
{
string msg = "A needed file couldn't be found: " + notFound.FileName;
_log.Error(msg);
_log.Fatal("The export cannot continue. Exiting...");
throw new ApplicationException(msg);
}
catch (Exception ex)
{
_log.Error("Error while exporting shapefile", ex);
}
return false;
}
public Envelope GetGridEnvelope()
{
Envelope env = null;
if (!string.IsNullOrEmpty(GridEnvelopeFilename))
{
string[] lines = File.ReadAllLines(GridEnvelopeFilename);
foreach (string line in lines)
{
if (line.StartsWith("#") || line.StartsWith("//"))
continue;
string[] chunks = line.Split(" ,:".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
env = new Envelope(
Utilities.GetAs<double>(chunks[0], -1), //env.MinX
Utilities.GetAs<double>(chunks[2], -1), //env.MaxX
Utilities.GetAs<double>(chunks[1], -1), //env.MinY
Utilities.GetAs<double>(chunks[3], -1) //env.MaxY
);
break;
}
}
return env;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override IEnvelope ComputeEnvelopeInternal()
{
IEnvelope envelope = new Envelope();
for (int i = 0; i < geometries.Length; i++)
envelope.ExpandToInclude(geometries[i].EnvelopeInternal);
return envelope;
}
public override void Start()
{
IPoint interiorPoint = Factory.CreatePoint(new Coordinate(130, 150));
IPoint exteriorPoint = Factory.CreatePoint(new Coordinate(650, 1500));
ILineString aLine = Factory.CreateLineString(new ICoordinate[] { new Coordinate(23, 32.2), new Coordinate(10, 222) });
ILineString anotherLine = Factory.CreateLineString(new ICoordinate[] { new Coordinate(0, 1), new Coordinate(30, 30) });
ILineString intersectLine = Factory.CreateLineString(new ICoordinate[] { new Coordinate(0, 1), new Coordinate(300, 300) });
try
{
Write(polygon.Area);
Write(polygon.Boundary);
Write(polygon.BoundaryDimension);
Write(polygon.Centroid);
Write(polygon.Coordinate);
Write(polygon.Coordinates.Length);
Write(polygon.Dimension);
Write(polygon.Envelope);
Write(polygon.EnvelopeInternal);
Write(polygon.ExteriorRing);
Write(polygon.InteriorPoint);
Write(polygon.InteriorRings.Length);
Write(polygon.IsEmpty);
Write(polygon.IsSimple);
Write(polygon.IsValid);
Write(polygon.Length);
Write(polygon.NumInteriorRings);
Write(polygon.NumPoints);
if (polygon.UserData != null)
Write(polygon.UserData);
else Write("UserData null");
Write(polygon.Buffer(10));
Write(polygon.Buffer(10, BufferStyle.CapButt));
Write(polygon.Buffer(10, BufferStyle.CapSquare));
Write(polygon.Buffer(10, 20));
Write(polygon.Buffer(10, 20, BufferStyle.CapButt));
Write(polygon.Buffer(10, 20, BufferStyle.CapSquare));
Write(polygon.Contains(interiorPoint));
Write(polygon.Contains(exteriorPoint));
Write(polygon.Contains(aLine));
Write(polygon.Contains(anotherLine));
Write(polygon.Crosses(interiorPoint));
Write(polygon.Crosses(exteriorPoint));
Write(polygon.Crosses(aLine));
Write(polygon.Crosses(anotherLine));
Write(polygon.Difference(interiorPoint));
Write(polygon.Difference(exteriorPoint));
Write(polygon.Difference(aLine));
Write(polygon.Difference(anotherLine));
Write(polygon.Disjoint(interiorPoint));
Write(polygon.Disjoint(exteriorPoint));
Write(polygon.Disjoint(aLine));
Write(polygon.Disjoint(anotherLine));
Write(polygon.Distance(interiorPoint));
Write(polygon.Distance(exteriorPoint));
Write(polygon.Distance(aLine));
Write(polygon.Distance(anotherLine));
Write(polygon.Intersection(interiorPoint));
Write(polygon.Intersection(exteriorPoint));
Write(polygon.Intersection(aLine));
Write(polygon.Intersection(anotherLine));
Write(polygon.Intersects(interiorPoint));
Write(polygon.Intersects(exteriorPoint));
Write(polygon.Intersects(aLine));
Write(polygon.Intersects(anotherLine));
Write(polygon.IsWithinDistance(interiorPoint, 300));
Write(polygon.IsWithinDistance(exteriorPoint, 300));
Write(polygon.IsWithinDistance(aLine, 300));
Write(polygon.IsWithinDistance(anotherLine, 300));
Write(polygon.Overlaps(interiorPoint));
Write(polygon.Overlaps(exteriorPoint));
Write(polygon.Overlaps(aLine));
Write(polygon.Overlaps(anotherLine));
Write(polygon.Relate(interiorPoint));
Write(polygon.Relate(exteriorPoint));
Write(polygon.Relate(aLine));
Write(polygon.Relate(anotherLine));
Write(polygon.SymmetricDifference(interiorPoint));
Write(polygon.SymmetricDifference(exteriorPoint));
Write(polygon.SymmetricDifference(aLine));
Write(polygon.SymmetricDifference(anotherLine));
Write(polygon.ToString());
Write(polygon.AsText());
Write(polygon.Touches(interiorPoint));
Write(polygon.Touches(exteriorPoint));
Write(polygon.Touches(aLine));
Write(polygon.Touches(anotherLine));
Write(polygon.Union(interiorPoint));
Write(polygon.Union(exteriorPoint));
Write(polygon.Union(aLine));
Write(polygon.Union(anotherLine));
string aPoly = "POLYGON ((20 20, 100 20, 100 100, 20 100, 20 20))";
string anotherPoly = "POLYGON ((20 20, 100 20, 100 100, 20 100, 20 20), (50 50, 60 50, 60 60, 50 60, 50 50))";
IGeometry geom1 = Reader.Read(aPoly);
Write(geom1.AsText());
IGeometry geom2 = Reader.Read(anotherPoly);
Write(geom2.AsText());
// ExpandToInclude tests
Envelope envelope = new Envelope(0, 0, 0, 0);
envelope.ExpandToInclude(geom1.EnvelopeInternal);
envelope.ExpandToInclude(geom2.EnvelopeInternal);
Write(envelope.ToString());
// The polygon is not correctly ordered! Calling normalize we fix the problem...
polygon.Normalize();
byte[] bytes = polygon.AsBinary();
IGeometry test1 = new WKBReader().Read(bytes);
Write(test1.ToString());
bytes = new GDBWriter().Write(polygon);
test1 = new GDBReader().Read(bytes);
Write(test1.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Returns the BoundingBox of the dataset.
/// </summary>
/// <returns>BoundingBox</returns>
public IEnvelope GetExtents()
{
IEnvelope envelope = new Envelope();
foreach (IFeature feature in features)
envelope.ExpandToInclude(feature.Geometry.EnvelopeInternal);
return envelope;
}
public void TestStrIndex()
{
STRtree ndx = new STRtree();
foreach (var v in CreateTestGeometries(1000, 0.0, 0.0, 3000.0, 3000.0))
ndx.Insert(v.EnvelopeInternal, v);
ndx.Build();
IEnvelope queryExtents = new Envelope(100.0, 120.0, 100.0, 120.0);
IList matches = ndx.Query(queryExtents);
foreach (IGeometry list in matches)
{
Assert.IsTrue(list.EnvelopeInternal.Intersects(queryExtents), "a result from the index does not intersect the query bounds");
}
}
/// <summary>
/// Converts the <see cref="GisSharpBlog.NetTopologySuite.Geometries.Envelope"/> instance <paramref name="envelope"/>
/// into a correspondant <see cref="SharpMap.Geometries.BoundingBox"/>.
/// </summary>
public static BoundingBox ToSharpMapBoundingBox(Envelope envelope)
{
return new BoundingBox(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY);
}
public void ChangingEnvelopeAfterMapControlIsShownWorksCorrectly()
{
var layer = new VectorLayer { DataSource = new DataTableFeatureProvider("POINT(1 1)") };
var map = new Map { Layers = { layer } };
var mapControl = new MapControl { Map = map, AllowDrop = false };
var viewEnvelope = new Envelope(10000, 10010, 10000, 10010);
WindowsFormsTestHelper.Show(mapControl,
delegate
{
map.ZoomToFit(viewEnvelope);
});
for (var i = 0; i < 10; i++)
{
Application.DoEvents();
Thread.Sleep(100);
}
Assert.IsTrue(map.Envelope.Contains(viewEnvelope));
WindowsFormsTestHelper.CloseAll();
}
public void EnvelopeAll()
{
IList results = session.CreateCriteria(typeof(County))
.SetProjection(SpatialProjections.Envelope("Boundaries"))
.List();
Assert.AreEqual(1, results.Count);
IGeometry aggregated = (IGeometry)results[0];
IEnvelope expected = new Envelope(1, 3, 0, 2);
Assert.IsTrue(expected.Equals(aggregated.EnvelopeInternal));
}
/// <summary>
/// Returns the BoundingBox of the dataset.
/// </summary>
/// <returns>BoundingBox</returns>
public override BoundingBox GetExtents()
{
var envelope = new Envelope();
foreach (var feature in _features)
envelope.ExpandToInclude(feature.Geometry.EnvelopeInternal);
return envelope;
}
/// <summary>
/// Converts the <see cref="GisSharpBlog.NetTopologySuite.Geometries.Envelope"/> instance <paramref name="envelope"/>
/// into a correspondant <see cref="SharpMap.Geometries.Geometry"/>.
/// </summary>
public static Geometries.Geometry ToSharpMapGeometry(Envelope envelope)
{
return ToSharpMapGeometry(new BoundingBox(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY));
}
