public static IEnvelope EnsureMinimumSize([NotNull] IEnvelope envelope,
double minSize)
{
if (envelope.IsEmpty ||
envelope.Width >= minSize && envelope.Height >= minSize)
{
return(envelope);
}
_msg.DebugFormat("Enlarging envelope to minimum size {0}", minSize);
return(GeometryFactory.CreateEnvelope(
((IArea)envelope).Centroid,
Math.Max(envelope.Width, minSize),
Math.Max(envelope.Height, minSize)));
}
public static Geometry CreateMarkerGeometry(MarkerStyle style)
{
switch (style)
{
case MarkerStyle.Circle:
return(GeometryFactory.CreateBezierCircle(5));
case MarkerStyle.Square:
var envelope = GeometryFactory.CreateEnvelope(-5, -5, 5, 5);
return(GeometryFactory.CreatePolygon(envelope));
default:
throw new NotImplementedException(
"Sorry, this MarkerStyle is not yet implemented");
}
}
public void CannotCutPolygonWithDisjointCutLine()
{
ISpatialReference lv95 = SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV95);
IPolygon originalPoly = GeometryFactory.CreatePolygon(
GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 100, 100, lv95));
IPolygon innerRingPoly = GeometryFactory.CreatePolygon(
GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 10, 10, lv95));
((IGeometryCollection)originalPoly).AddGeometryCollection(
(IGeometryCollection)innerRingPoly);
GeometryUtils.Simplify(originalPoly);
// The cut line runs almost (within tolerance) along the inner ring
IPolyline cutLine = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(2600000 + 1000, 1200000),
GeometryFactory.CreatePoint(2600000 + 1000, 1200000),
GeometryFactory.CreatePoint(2600000 + 1000, 1200000));
cutLine.SpatialReference = lv95;
bool customIntersectOrig = IntersectionUtils.UseCustomIntersect;
try
{
IntersectionUtils.UseCustomIntersect = false;
const ChangeAlongZSource zSource = ChangeAlongZSource.InterpolatedSource;
var resultsAo =
CutGeometryUtils.TryCut(originalPoly, cutLine, zSource);
IntersectionUtils.UseCustomIntersect = true;
var resultsGeom =
CutGeometryUtils.TryCut(originalPoly, cutLine, zSource);
Assert.Null(resultsAo);
Assert.Null(resultsGeom);
}
finally
{
IntersectionUtils.UseCustomIntersect = customIntersectOrig;
}
}
public void CanDetectBorderGapBackslashed()
{
IFeatureClass fcArea1;
IFeatureClass fcArea2;
IFeatureClass fcBorder1;
IFeatureClass fcBorder2;
CreateFeatureClasses(out fcArea1, out fcArea2, out fcBorder1, out fcBorder2);
// border lines are not coincident
AddLineFeature(fcBorder1, -2, 2, 1, -2, stateId: "A");
AddLineFeature(fcBorder2, 1.01, -2, -1.99, 2, stateId: "B");
AddFeature(fcArea1,
CurveConstruction.StartPoly(-2, 2)
.LineTo(1, -2)
.LineTo(-5, -10)
.ClosePolygon(), stateId: "A"); // connected
AddFeature(fcArea2,
CurveConstruction.StartPoly(1.01, -2)
.LineTo(-1.99, 2)
.LineTo(5, 10)
.ClosePolygon(), stateId: "B"); // connected
var test = new QaEdgeMatchCrossingAreas(fcArea1, fcBorder1,
fcArea2, fcBorder2,
searchDistance: 0.2,
boundingClasses1: null,
boundingClasses2: null)
{
AreaClass1BorderMatchCondition = "AREA.STATE = BORDER.STATE",
AreaClass2BorderMatchCondition = "AREA.STATE = BORDER.STATE",
CrossingAreaMatchCondition = "AREA1.STATE <> AREA2.STATE"
};
AssertUtils.ExpectedErrors(3, Run(test, 1000));
AssertUtils.ExpectedErrors(3, Run(test, 1));
var runner = new QaContainerTestRunner(1, test)
{
KeepGeometry = true
};
runner.Execute(GeometryFactory.CreateEnvelope(-9, -4, 9, 8));
AssertUtils.ExpectedErrors(3, runner.Errors);
}
public void MeasurePerformance_GetSubCurve()
{
ISpatialReference sref =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV03);
IEnvelope envelope =
GeometryFactory.CreateEnvelope(1000, 1000, 2000, 2000, sref);
IPolygon polygon = GeometryFactory.CreatePolygon(envelope);
polygon.Densify(0.5, 1);
((ISpatialIndex)polygon).AllowIndexing = true; // ENABLE the index
Console.WriteLine($@"point count: {GeometryUtils.GetPointCount(polygon)}");
var watch = new Stopwatch();
watch.Start();
const int count = 1000;
for (var i = 0; i < count; i++)
{
ICurve subcurve;
((ICurve)polygon).GetSubcurve(0, 100, false, out subcurve);
//var subcurve = GeometryEngine.GetSubCurve(polygon, 0, 100, GeometryEngine.AsRatioOrLength.AsLength);
//Assert.True(((IRelationalOperator) polygon).Contains(point));
double length = 0;
foreach (IGeometry part in GeometryUtils.GetParts(
(IGeometryCollection)subcurve))
{
foreach (var segment in GeometryUtils.GetSegments(
((ISegmentCollection)part).EnumSegments, true))
{
length += segment.Length;
}
}
}
watch.Stop();
Console.WriteLine(
$@"{watch.ElapsedMilliseconds / (double) count} ms per operation");
// just GetSubcurve, per operation: AO: 0.088 ms
// with segment access: AO: 0.56 ms
}
/// <summary>
/// Boundingbox of the dataset
/// </summary>
/// <returns>boundingbox</returns>
public virtual IEnvelope GetExtents()
{
if (this.envelope == null)
{
using (var ogrEnvelope = new Envelope())
{
int i = ogrLayer.GetExtent(ogrEnvelope, 1);
envelope = GeometryFactory.CreateEnvelope(ogrEnvelope.MinX,
ogrEnvelope.MaxX,
ogrEnvelope.MinY,
ogrEnvelope.MaxY);
}
}
return(envelope);
}
public void CanTestMultiPatch()
{
IPolygon polygon =
GeometryFactory.CreatePolygon(GeometryFactory.CreateEnvelope(0, 0, 10, 10,
100, 100));
IMultiPatch multiPatch = GeometryFactory.CreateMultiPatch(polygon, 10);
multiPatch.SpatialReference = CreateSpatialReference();
multiPatch.SnapToSpatialReference();
AssertFulfilled("$ISCLOSED IS NULL", multiPatch);
AssertFulfilled("$CIRCULARARCCOUNT = 0", multiPatch);
AssertFulfilled("$ELLIPTICARCCOUNT = 0", multiPatch);
AssertFulfilled("$BEZIERCOUNT = 0", multiPatch);
AssertFulfilled("$SEGMENTCOUNT = 0", multiPatch);
AssertFulfilled("$LINEARSEGMENTCOUNT = 0", multiPatch);
AssertFulfilled("$NONLINEARSEGMENTCOUNT = 0", multiPatch);
AssertFulfilled("$PARTCOUNT = 3", multiPatch); // 2 rings, one triangle strip
AssertFulfilled("$VERTEXCOUNT = 20", multiPatch);
AssertFulfilled("$ISMULTIPART", multiPatch);
AssertFulfilled("$AREA = 100", multiPatch);
AssertFulfilled("$LENGTH = 40", multiPatch);
AssertFulfilled("$SLIVERRATIO = 16", multiPatch);
AssertFulfilled("$DIMENSION = 2", multiPatch);
AssertFulfilled("$INTERIORRINGCOUNT = 0", multiPatch);
AssertFulfilled("$EXTERIORRINGCOUNT = 2", multiPatch);
AssertFulfilled("$RINGCOUNT = 2", multiPatch);
AssertFulfilled("$TRIANGLEFANCOUNT = 0", multiPatch);
AssertFulfilled("$TRIANGLESTRIPCOUNT = 1", multiPatch);
AssertFulfilled("$TRIANGLESPATCHCOUNT = 0", multiPatch);
AssertFulfilled("NOT $ISEXTERIORRING", multiPatch);
AssertFulfilled("NOT $ISINTERIORRING", multiPatch);
AssertFulfilled("$XMIN = 0", multiPatch);
AssertFulfilled("$YMIN = 0", multiPatch);
AssertFulfilled("$XMAX = 10", multiPatch);
AssertFulfilled("$YMAX = 10", multiPatch);
AssertFulfilled("$ZMIN = 100", multiPatch);
AssertFulfilled("$ZMAX = 110", multiPatch);
AssertFulfilled("$MMIN IS NULL", multiPatch);
AssertFulfilled("$MMAX IS NULL", multiPatch);
AssertFulfilled("$UNDEFINEDMVALUECOUNT = 20", multiPatch);
AssertFulfilled("$CONTROLPOINTCOUNT = 0", multiPatch);
}
public void CanCutMultipatch()
{
ISpatialReference lv95 = SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV95);
IPolygon originalPoly = GeometryFactory.CreatePolygon(
GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 50, 20, lv95));
IMultiPatch multiPatch = GeometryFactory.CreateMultiPatch(originalPoly);
IPolyline cutLine = GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(2600000 - 100, 1200000),
GeometryFactory.CreatePoint(2600000 + 100, 1200000));
cutLine.SpatialReference = lv95;
IFeature mockFeature = TestUtils.CreateMockFeature(multiPatch);
var cutter = new FeatureCutter(new[] { mockFeature });
cutter.ZSourceProvider =
new DatasetSpecificSettingProvider <ChangeAlongZSource>(
string.Empty, ChangeAlongZSource.SourcePlane);
cutter.Cut(cutLine);
IList <IGeometry> results = cutter.ResultGeometriesByFeature[mockFeature];
Assert.AreEqual(2, results.Count);
double areaSum = 0;
foreach (IGeometry result in cutter.ResultGeometriesByFeature[mockFeature])
{
Assert.IsFalse(GeometryUtils.HasUndefinedZValues(result));
areaSum +=
GeometryUtils.GetParts((IGeometryCollection)result)
.Sum(part => ((IArea)part).Area);
}
Assert.IsTrue(MathUtils.AreEqual(((IArea)originalPoly).Area, areaSum));
}
public void CanGetIntersectedTilesExtentExactMatch()
{
var tiling =
new RectangularTilingStructure(0, 10000, 10, 100,
BorderPointTileAllocationPolicy.BottomLeft,
null);
IEnvelope extent = GeometryFactory.CreateEnvelope(0, 10000, 10, 10100);
IEnvelope constraintExtent =
GeometryFactory.CreateEnvelope(-1, 9999, 11, 10101);
IEnvelope tileExtent =
tiling.GetIntersectedTilesExtent(extent, constraintExtent);
Assert.AreEqual(0, tileExtent.XMin);
Assert.AreEqual(10000, tileExtent.YMin);
Assert.AreEqual(10, tileExtent.XMax);
Assert.AreEqual(10100, tileExtent.YMax);
}
public void MeasurePerformance_DisjointLargeAOI_InvalidateSpatialIndex()
{
ISpatialReference sref =
SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV03);
IEnvelope envelope =
GeometryFactory.CreateEnvelope(1000, 1000, 2000, 2000, sref);
foreach (var length in new[]
{
0.2, 0.3, 0.4, 0.5, 0.75, 1, 1.25, 2, 4, 8, 16
})
{
IPolygon polygon = GeometryFactory.CreatePolygon(envelope);
polygon.Densify(length, 1);
((ISpatialIndex)polygon).AllowIndexing = true; // ENABLE the index
int pointCount = GeometryUtils.GetPointCount(polygon);
IPoint point = GeometryFactory.CreatePoint(1500, 1500, sref);
// try to make sure there's no GC run within the measurement
GC.Collect();
GC.WaitForPendingFinalizers();
var watch = new Stopwatch();
watch.Start();
const int count = 1000;
for (var i = 0; i < count; i++)
{
// invalidate the index each time, to measure the cost of index creation
((ISpatialIndex)polygon).Invalidate();
((IRelationalOperator)polygon).Disjoint(point);
}
watch.Stop();
Console.WriteLine($@"Vertex count {pointCount}: {
watch.ElapsedMilliseconds / (double) count
} ms per operation" );
}
}
public void CanDetectBorderGapVertical()
{
IFeatureClass fcArea1;
IFeatureClass fcArea2;
IFeatureClass fcBorder1;
IFeatureClass fcBorder2;
CreateFeatureClasses(out fcArea1, out fcArea2, out fcBorder1, out fcBorder2);
// border lines are not coincident
AddLineFeature(fcBorder1, 0, 0, 0, 10, stateId: "A");
AddLineFeature(fcBorder1, 0.7, -0.3, 10, -0.3, stateId: "A");
AddLineFeature(fcBorder2, 0.3, 10, 0.3, 0, stateId: "B");
AddLineFeature(fcBorder2, 10, 0, 0.7, 0, stateId: "B");
AddAreaFeature(fcArea1, -10, 0, 0, 10, stateId: "A"); // connected
AddAreaFeature(fcArea1, 0.7, -5, 10, -0.3, stateId: "A"); // connected
AddAreaFeature(fcArea2, 0.3, 0, 10, 10, stateId: "B"); // connected
var test = new QaEdgeMatchCrossingAreas(fcArea1, fcBorder1,
fcArea2, fcBorder2,
searchDistance: 0.5,
boundingClasses1: null,
boundingClasses2: null)
{
AreaClass1BorderMatchCondition = "AREA.STATE = BORDER.STATE",
AreaClass2BorderMatchCondition = "AREA.STATE = BORDER.STATE",
CrossingAreaMatchCondition = "AREA1.STATE <> AREA2.STATE"
};
AssertUtils.ExpectedErrors(2, Run(test, 1000));
AssertUtils.ExpectedErrors(2, Run(test, 3));
var runner = new QaContainerTestRunner(3, test)
{
KeepGeometry = true
};
runner.Execute(GeometryFactory.CreateEnvelope(-9, -4, 9, 8));
AssertUtils.ExpectedErrors(2, runner.Errors);
}
/// <summary>
/// Transforms a <see cref="GisSharpBlog.NetTopologySuite.Geometries.Envelope"/>.
/// </summary>
/// <param name="box">BoundingBox to transform</param>
/// <param name="transform">Math Transform</param>
/// <returns>Transformed object</returns>
public static GeoAPI.Geometries.IEnvelope TransformBox(GeoAPI.Geometries.IEnvelope box, IMathTransform transform)
{
if (box == null)
{
return(null);
}
double[][] corners = new double[4][];
corners[0] = transform.Transform(ToLightStruct(box.MinX, box.MinY)); //LL
corners[1] = transform.Transform(ToLightStruct(box.MaxX, box.MaxY)); //UR
corners[2] = transform.Transform(ToLightStruct(box.MinX, box.MaxY)); //UL
corners[3] = transform.Transform(ToLightStruct(box.MaxX, box.MinY)); //LR
IEnvelope result = GeometryFactory.CreateEnvelope();
foreach (double[] p in corners)
{
result.ExpandToInclude(p[0], p[1]);
}
return(result);
}
private static void RunTest([NotNull] IFeatureClass polygonFeatureClass,
[NotNull] IFeatureClass pointFeatureClass,
int minimumPointCount,
int maximumPointCount,
[CanBeNull] string relevantPointCondition,
bool countPointOnPolygonBorder,
int expectedErrorCount)
{
RunTest(polygonFeatureClass, pointFeatureClass,
minimumPointCount, maximumPointCount,
relevantPointCondition, countPointOnPolygonBorder,
null, expectedErrorCount);
IEnvelope envelope = GeometryFactory.CreateEnvelope(-100, -100, 400, 400);
RunTest(polygonFeatureClass, pointFeatureClass,
minimumPointCount, maximumPointCount,
relevantPointCondition, countPointOnPolygonBorder,
envelope, expectedErrorCount);
}
private void PrintWmsInfo()
{
SharpMap.Layers.WmsLayer layWms = MapHelper.GetWmsLayer();
//Get request url for WMS
hlWmsImage.NavigateUrl = layWms.GetRequestUrl(
GeometryFactory.CreateEnvelope(
Center.X - Zoom * 0.5,
Center.X + Zoom * 0.5,
Center.Y - Zoom * 0.25,
Center.Y + Zoom * 0.25),
new Size((int)imgMap.Width.Value, (int)imgMap.Height.Value));
litLayers.Text = "<p><b>WMS Title</b>: " + layWms.ServiceDescription.Title + "<br/>Abstract: <i>" + layWms.ServiceDescription.Abstract + "</i>";
litLayers.Text += "<br/><b>WMS Layers:</b><br/>";
foreach (SharpMap.Web.Wms.Client.WmsServerLayer layer in layWms.RootLayer.ChildLayers)
{
PrintLayers(layer, layWms);
}
litLayers.Text += "</ul></p>";
}
public void CanTestEllipticArc()
{
IFeatureClass fc = CreateLineClass(_testWs, "CanTestEllipticArc");
IFeature row1 = fc.CreateFeature();
IConstructEllipticArc arc = new EllipticArcClass();
arc.ConstructEnvelope(GeometryFactory.CreateEnvelope(0, 0, 100, 10));
row1.Shape = CreatePolyLine((ISegment)arc);
row1.Store();
var test = new QaMinSegAngle(fc, 0.1, true);
var runner = new QaContainerTestRunner(1000, test);
runner.Execute();
Assert.AreEqual(0, runner.Errors.Count);
}
public void TestUniqueStrings()
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001, 0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField("Unique", 100),
FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000));
IFeatureClass featureClass = DatasetUtils.CreateSimpleFeatureClass(_pgdbWorkspace,
"TestUniqueStrings",
fields);
for (var i = 0; i < 10; i++)
{
IFeature feature = featureClass.CreateFeature();
feature.set_Value(1, string.Format("A'{0}{1}", i, "\""));
feature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
feature.Store();
}
IEnvelope testEnvelope = GeometryFactory.CreateEnvelope(0, 0, 200, 200, sref);
foreach (bool forceInMemoryTableSort in new[] { false, true })
{
var test = new QaUnique((ITable)featureClass, "Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute(testEnvelope);
AssertUtils.NoError(runner);
}
}
public void PerformanceTest()
{
var ws = (IFeatureWorkspace)TestDataUtils.OpenTopgisTlm();
IFeatureClass ptFc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_EINZELBAUM_GEBUESCH");
IFeatureClass polyFc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_BODENBEDECKUNG");
var test = new QaPointNotNear(ptFc, polyFc, 2);
test.SetConstraint(1, "Objektart = 12"); // wald
double tileSize = 10000;
var runner = new QaContainerTestRunner(tileSize, test);
IEnvelope testBox = GeometryFactory.CreateEnvelope(2554000, 1147000, 2561000, 1151000);
var w = new Stopwatch();
w.Start();
runner.Execute(testBox);
w.Stop();
string msg = $"Direct:{w.ElapsedMilliseconds} ms";
Console.WriteLine(msg);
int nDirect = runner.Errors.Count;
QaPointNotNear.UseQueryPointAndDistance = true;
runner.ClearErrors();
w.Reset();
w.Start();
runner.Execute(testBox);
w.Stop();
msg = $"QueryDistance:{w.ElapsedMilliseconds} ms";
Console.WriteLine(msg);
int nQuery = runner.Errors.Count;
QaPointNotNear.UseQueryPointAndDistance = false;
Assert.AreEqual(nQuery, nDirect);
}
public void CanReportPointZError()
{
const string testName = "CanReportPointZError";
IFeatureClass vertexClass = CreateFeatureClass(
$"{testName}_vertex", esriGeometryType.esriGeometryPoint, zAware: true);
IFeature vertexRow = vertexClass.CreateFeature();
vertexRow.Shape = GeometryFactory.CreatePoint(199, 199, 10);
vertexRow.Store();
vertexRow = vertexClass.CreateFeature();
vertexRow.Shape = GeometryFactory.CreatePoint(199, 199, 11);
vertexRow.Store();
vertexRow = vertexClass.CreateFeature();
vertexRow.Shape = GeometryFactory.CreatePoint(150, 150, 10);
vertexRow.Store();
vertexRow = vertexClass.CreateFeature();
vertexRow.Shape =
GeometryFactory.CreatePoint(150, 150, 13); // dz > ZTolerance
vertexRow.Store();
IEnvelope verificationEnvelope =
GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaVertexCoincidenceSelf(vertexClass)
{
PointTolerance = 3,
ZTolerance = 2,
ZCoincidenceTolerance = -1
};
var runner = new QaContainerTestRunner(500, test);
runner.Execute(verificationEnvelope);
Assert.AreEqual(1, runner.Errors.Count);
}
public void CanReportNearlyCoincidentSectionErrorInLeftTile()
{
const string testName = "CanReportNearlyCoincidentSectionErrorInLeftTile";
IFeatureClass testedClass =
CreateFeatureClass(string.Format("{0}_tested", testName),
esriGeometryType.esriGeometryPolyline);
IFeatureClass referenceClass =
CreateFeatureClass(string.Format("{0}_reference", testName),
esriGeometryType.esriGeometryPolyline);
IFeature testedRow = testedClass.CreateFeature();
testedRow.Shape =
CurveConstruction.StartLine(201, 150)
.LineTo(201, 50)
.Curve;
testedRow.Store();
IFeature referenceRow = referenceClass.CreateFeature();
referenceRow.Shape =
CurveConstruction.StartLine(199, 150)
.LineTo(199, 50)
.Curve;
referenceRow.Store();
IEnvelope verificationEnvelope =
GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaPartCoincidenceOther(testedClass, referenceClass, 3, 50);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"NearCoincidence.NearlyCoincidentSection.BetweenFeatures");
}
/// <summary>
/// Reads and parses the header of the .shx index file
/// </summary>
private void ParseHeader()
{
fsShapeIndex = new FileStream(System.IO.Path.ChangeExtension(path, ".shx"), FileMode.Open, FileAccess.Read);
brShapeIndex = new BinaryReader(fsShapeIndex, Encoding.Unicode);
brShapeIndex.BaseStream.Seek(0, 0);
//Check file header
if (brShapeIndex.ReadInt32() != 170328064)
{
//File Code is actually 9994, but in Little Endian Byte Order this is '170328064'
throw (new ApplicationException("Invalid Shapefile Index (.shx)"));
}
brShapeIndex.BaseStream.Seek(24, 0); //seek to File Length
int IndexFileSize = SwapByteOrder(brShapeIndex.ReadInt32());
//Read filelength as big-endian. The length is based on 16bit words
_FeatureCount = (2 * IndexFileSize - 100) / 8;
//Calculate FeatureCount. Each feature takes up 8 bytes. The header is 100 bytes
brShapeIndex.BaseStream.Seek(32, 0); //seek to ShapeType
_ShapeType = (ShapeType)brShapeIndex.ReadInt32();
//Read the spatial bounding box of the contents
brShapeIndex.BaseStream.Seek(36, 0); //seek to box
double x1, x2, y1, y2;
x1 = brShapeIndex.ReadDouble();
y1 = brShapeIndex.ReadDouble();
x2 = brShapeIndex.ReadDouble();
y2 = brShapeIndex.ReadDouble();
_Envelope = GeometryFactory.CreateEnvelope(x1, x2, y1, y2);
brShapeIndex.Close();
fsShapeIndex.Close();
}
public static Envelope GetExtents([NotNull] Dataset dataset)
{
if (dataset == null) return null;
var geoTrans = new double[6];
dataset.GetGeoTransform(geoTrans);
var err = (CPLErr)Gdal.GetLastErrorType();
if (CPLErr.CE_None != err)
{
throw new ApplicationException("GetGeoTransform() failed.");
}
var regularGridGeoTransform = new RegularGridGeoTransform(geoTrans);
return GeometryFactory.CreateEnvelope(regularGridGeoTransform.Left,
regularGridGeoTransform.Left +
(regularGridGeoTransform.HorizontalPixelResolution*
dataset.RasterXSize),
regularGridGeoTransform.Top -
(regularGridGeoTransform.VerticalPixelResolution*
dataset.RasterYSize),
regularGridGeoTransform.Top);
}
public void GeometryMemoryUsage()
{
ISpatialReference sref =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV03);
IEnvelope envelope =
GeometryFactory.CreateEnvelope(1000, 1000, 2000, 2000, sref);
GC.Collect();
GC.WaitForPendingFinalizers();
var process = Process.GetCurrentProcess();
var privateBytes = process.PrivateMemorySize64;
var polygons = new List <IPolygon>();
const int count = 100;
for (var i = 0; i < count; i++)
{
IPolygon polygon = GeometryFactory.CreatePolygon(envelope);
polygon.Densify(0.5, 1);
//var segment = ((ISegmentCollection) polygon).Segment[100];
var point = ((IPointCollection)polygon).Point[100];
var parts = GeometryUtils.GetParts((IGeometryCollection)polygon).Count();
var segments =
GeometryUtils
.GetSegments(((ISegmentCollection)polygon).EnumSegments, true)
.Count();
polygons.Add(polygon);
}
GC.Collect();
GC.WaitForPendingFinalizers();
process.Refresh();
var delta = process.PrivateMemorySize64 - privateBytes;
Console.WriteLine($@"{delta / (double) count / 1024} KB per geometry");
}
public void CanAllowVertexWithinCoincidenceTolerance()
{
const string testName = "CanAllowVertexWithinCoincidenceTolerance";
IFeatureClass nodeClass = CreateFeatureClass(string.Format("{0}_node", testName),
esriGeometryType.esriGeometryPoint);
IFeatureClass nearClass = CreateFeatureClass(string.Format("{0}_near", testName),
esriGeometryType.esriGeometryPolyline);
var nearClasses = new List <IFeatureClass> {
nearClass
};
IFeature nodeRow = nodeClass.CreateFeature();
nodeRow.Shape = GeometryFactory.CreatePoint(1, 0.1);
nodeRow.Store();
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = CurveConstruction.StartLine(0, 0)
.LineTo(2, 0)
.Curve;
nearRow.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(nodeClass, nearClasses, 2)
{
CoincidenceTolerance = 0.2
};
var runner = new QaContainerTestRunner(1000, test);
runner.Execute(verificationEnvelope);
AssertUtils.NoError(runner);
}
/// <summary>
/// Reads all boundingboxes of features in the shapefile. This is used for spatial indexing.
/// </summary>
/// <returns></returns>
private List <IEnvelope> GetAllFeatureBoundingBoxes()
{
int[] offsetOfRecord = ReadIndex(); //Read the whole .idx file
List <IEnvelope> boxes = new List <IEnvelope>();
if (_ShapeType == ShapeType.Point)
{
for (int a = 0; a < _FeatureCount; ++a)
{
fsShapeFile.Seek(offsetOfRecord[a] + 8, 0); //skip record number and content length
if ((ShapeType)brShapeFile.ReadInt32() != ShapeType.Null)
{
double x = brShapeFile.ReadDouble();
double y = brShapeFile.ReadDouble();
boxes.Add(GeometryFactory.CreateEnvelope(x, x, y, y));
}
}
}
else
{
for (int a = 0; a < _FeatureCount; ++a)
{
fsShapeFile.Seek(offsetOfRecord[a] + 8, 0); //skip record number and content length
if ((ShapeType)brShapeFile.ReadInt32() != ShapeType.Null)
{
double x1, x2, y1, y2;
x1 = brShapeFile.ReadDouble();
y1 = brShapeFile.ReadDouble();
x2 = brShapeFile.ReadDouble();
y2 = brShapeFile.ReadDouble();
boxes.Add(GeometryFactory.CreateEnvelope(x1, x2, y1, y2));
}
}
}
return(boxes);
}
public void CanReportVertexInLeftTileByNearDistance()
{
const string testName = "CanReportVertexInLeftTileByNearDistance";
IFeatureClass nodeClass = CreateFeatureClass(string.Format("{0}_node", testName),
esriGeometryType.esriGeometryPoint);
IFeatureClass nearClass = CreateFeatureClass(string.Format("{0}_near", testName),
esriGeometryType.esriGeometryPolyline);
var nearClasses = new List <IFeatureClass> {
nearClass
};
IFeature nodeRow = nodeClass.CreateFeature();
nodeRow.Shape = GeometryFactory.CreatePoint(201, 100);
nodeRow.Store();
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = CurveConstruction.StartLine(100, 100)
.LineTo(100, 199)
.LineTo(199, 199)
.LineTo(199, 100)
.Curve;
nearRow.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(nodeClass, nearClasses, 2.1);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"NodeLineCoincidence.NodeTooCloseToLine.BetweenFeatures");
}
public void CanCreateSpatialFilterWithMultipatch()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
ISpatialReference spatialReference = DatasetUtils.GetSpatialReference(fc);
IEnvelope largeEnvelope = GeometryFactory.CreateEnvelope(2600000, 1200000,
2601000, 1201000,
445, spatialReference);
IMultiPatch multiPatch =
GeometryFactory.CreateMultiPatch(GeometryFactory.CreatePolygon(largeEnvelope));
double xyResolution =
SpatialReferenceUtils.GetXyResolution(Assert.NotNull(spatialReference));
// NOTE: Multipatch implements IRelationalOperator since a while!
IGeometry validGeometry;
string message;
Assert.True(GdbQueryUtils.IsValidFilterGeometry(
multiPatch, xyResolution, out validGeometry, out message),
"Multipatch should be valid");
Assert.NotNull(validGeometry);
Assert.True(multiPatch == validGeometry,
"Multipatch should be valid");
Assert.True(GdbQueryUtils.IsValidFilterGeometry(
validGeometry, xyResolution, out validGeometry, out message),
"Corrected geometry should be valid");
IQueryFilter filter = GdbQueryUtils.CreateSpatialFilter(
fc, multiPatch, esriSpatialRelEnum.esriSpatialRelIntersects, false,
spatialReference);
Assert.True(GdbQueryUtils.GetFeatures(fc, filter, true).Any(), "No features found.");
}
public void CanGetGeometryToStoreForZeroAreaLinearPolygon()
{
IPolygon polygon = GeometryFactory.CreatePolygon(CreateSpatialReference());
((ISegmentCollection)polygon).SetRectangle(
GeometryFactory.CreateEnvelope(0, 0, 10, 0, polygon.SpatialReference));
GeometryUtils.MakeZAware(polygon);
GeometryUtils.ApplyConstantZ(polygon, 100);
IGeometry result = ErrorRepositoryUtils.GetGeometryToStore(polygon,
polygon.SpatialReference,
_storedGeometryTypes);
Console.WriteLine(GeometryUtils.ToString(result));
IPolyline expectedPolyline = GeometryFactory.CreatePolyline(0, 0, 10, 0);
GeometryUtils.MakeZAware(expectedPolyline);
GeometryUtils.ApplyConstantZ(expectedPolyline, 100);
expectedPolyline.SpatialReference = polygon.SpatialReference;
Assert.IsTrue(GeometryUtils.AreEqual(expectedPolyline, result));
}
public void CanReportWithinFeature()
{
const string testName = "CanReportWithinFeature";
IFeatureClass lineClass = CreateFeatureClass(string.Format("{0}_near", testName),
esriGeometryType.esriGeometryPolyline);
var nearClasses = new List <IFeatureClass> {
lineClass
};
IPolycurve multipartLine = CurveConstruction.StartLine(0, 0)
.LineTo(100, 0)
.LineTo(101, 0)
.LineTo(100, 0)
.LineTo(100, 100)
.Curve;
GeometryUtils.Simplify(multipartLine, true, true);
IFeature nearRow = lineClass.CreateFeature();
nearRow.Shape = multipartLine;
nearRow.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(lineClass, nearClasses, 2);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.ExpectedErrors(2, runner.Errors,
"NodeLineCoincidence.NodeTooCloseToLine.WithinFeature");
}
private static void TestGeomGroupConstraints(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateTextField("Kostenstelle", 20));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestGeomGroupContraints",
fields,
null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
IFeature row1 = fc.CreateFeature();
row1.set_Value(1, "123456-10");
row1.Shape = GeometryFactory.CreatePoint(200, 100);
row1.Store();
IFeature row2 = fc.CreateFeature();
row2.set_Value(1, "123456-11");
row2.Shape = GeometryFactory.CreatePoint(200, 200);
row2.Store();
IFeature row3 = fc.CreateFeature();
row3.set_Value(1, "123456-11");
row3.Shape = GeometryFactory.CreatePoint(200, 300);
row3.Store();
IFeature row4 = fc.CreateFeature();
row4.set_Value(1, "023456-10");
row4.Shape = GeometryFactory.CreatePoint(200, 150);
row4.Store();
const bool limitToTestedRows = false;
var test = new QaGroupConstraints((ITable)fc,
"IIF(LEN(Kostenstelle) >=6, SUBSTRING(Kostenstelle, 1, 6), '')",
"SUBSTRING(Kostenstelle, 8, 9)", 1,
limitToTestedRows);
{
IEnvelope box = GeometryFactory.CreateEnvelope(150, 120, 250, 170);
using (var runner = new QaTestRunner(test))
{
runner.Execute(box);
Assert.AreEqual(0, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute(box);
Assert.AreEqual(0, containerRunner.Errors.Count);
}
{
IEnvelope box = GeometryFactory.CreateEnvelope(150, 80, 250, 170);
using (var runner = new QaTestRunner(test))
{
runner.Execute(box);
Assert.AreEqual(1, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute(box);
Assert.AreEqual(1, containerRunner.Errors.Count);
}
{
IEnvelope box = GeometryFactory.CreateEnvelope(150, 80, 250, 220);
using (var runner = new QaTestRunner(test))
{
runner.Execute(box);
Assert.AreEqual(1, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute(box);
Assert.AreEqual(1, containerRunner.Errors.Count);
}
{
IRow row = fc.GetFeature(1);
using (var runner = new QaTestRunner(test))
{
runner.Execute(row);
Assert.AreEqual(1, runner.Errors.Count);
}
//var containerRunner = new QaContainerTestRunner(100, test);
//containerRunner.Execute(row);
//Assert.AreEqual(1, containerRunner.Errors.Count);
}
{
IRow row = fc.GetFeature(4);
using (var runner = new QaTestRunner(test))
{
runner.Execute(row);
Assert.AreEqual(0, runner.Errors.Count);
}
//var containerRunner = new QaContainerTestRunner(100, test);
//containerRunner.Execute(row);
//Assert.AreEqual(1, containerRunner.Errors.Count);
}
{
IQueryFilter filter = new QueryFilterClass {
WhereClause = "ObjectId < 3"
};
ISelectionSet set = fc.Select(
filter, esriSelectionType.esriSelectionTypeIDSet,
esriSelectionOption.esriSelectionOptionNormal, null);
using (var runner = new QaTestRunner(test))
{
runner.Execute(new EnumCursor(set, null, false));
Assert.AreEqual(1, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute(new[] { set });
Assert.AreEqual(1, containerRunner.Errors.Count);
}
{
IQueryFilter filter = new QueryFilterClass {
WhereClause = "ObjectId > 3"
};
ISelectionSet set = fc.Select(
filter, esriSelectionType.esriSelectionTypeIDSet,
esriSelectionOption.esriSelectionOptionNormal, null);
using (var runner = new QaTestRunner(test))
{
runner.Execute(new EnumCursor(set, null, false));
Assert.AreEqual(0, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute(new[] { set });
Assert.AreEqual(0, containerRunner.Errors.Count);
}
}
private static IEnumerable <IEnvelope> GetSubtilesByWidth(
[NotNull] IEnvelope tileEnvelope,
double subtileWidth,
double minimumSubtileWidth)
{
Assert.ArgumentNotNull(tileEnvelope, nameof(tileEnvelope));
Assert.ArgumentCondition(subtileWidth > minimumSubtileWidth,
"Invalid subtile width: {0} minimum value: {1}",
subtileWidth, minimumSubtileWidth);
// subdivide along X axis only
// (subdividing along Y axis breaks the per-row processing of main tiles,
// changes to the 'completed tile' logic would be needed)
double tileWidth = tileEnvelope.Width;
if (subtileWidth + minimumSubtileWidth > tileWidth)
{
// the second subTile would be below the minimum width
// -> return entire tile
yield return(tileEnvelope);
yield break;
}
double xMin;
double yMin;
double xMax;
double yMax;
tileEnvelope.QueryCoords(out xMin, out yMin, out xMax, out yMax);
double subTileXMin = xMin;
ISpatialReference spatialReference = tileEnvelope.SpatialReference;
var lastTile = false;
do
{
double remainder = xMax - (subTileXMin + subtileWidth);
double subTileXMax;
if (remainder >= minimumSubtileWidth)
{
subTileXMax = subTileXMin + subtileWidth;
}
else
{
// remainder is too small, return last tile to xMax
subTileXMax = xMax;
lastTile = true;
}
yield return(GeometryFactory.CreateEnvelope(subTileXMin, yMin,
subTileXMax, yMax,
spatialReference));
subTileXMin = subTileXMax;
} while (!lastTile);
}
