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