public void SetupFixture() { _lic.Checkout(); _spatialReference = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95); }
private IFeature CreateEmptyGeometryFeature(IFeatureWorkspace ws, esriGeometryType geometryType, IGeometry andAlso = null) { ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference ((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true); IFeatureClass featureClass = EnsureFeatureClass(ws, geometryType, geometryType.ToString(), sr); IGdbTransaction transaction = new GdbTransaction(); IFeature feature = null; bool inserted = transaction.Execute((IWorkspace)ws, () => { if (andAlso != null) { andAlso.SpatialReference = sr; IFeature nonEmpty = featureClass.CreateFeature(); nonEmpty.Shape = andAlso; nonEmpty.Store(); } feature = featureClass.CreateFeature(); // NOTE: There is no difference when setting an empty geometry feature.Store(); }, "Insert feature"); Assert.IsTrue(inserted); return(feature); }
public void CanGetBoundaryBoundaryIntersectionLinesAndPoints() { const string matrixString = "****T****"; IPolygon g1 = GeometryFactory.CreatePolygon(0, 0, 10, 10, 100); IPolygon g2 = GeometryFactory.CreatePolygon(5, 0, 15, 15, 1000); g1.SpatialReference = _spatialReference; g2.SpatialReference = _spatialReference; var matrix = new IntersectionMatrix(matrixString); IList <IGeometry> intersections = matrix.GetIntersections(g1, g2); WriteGeometries(intersections); Assert.AreEqual(2, intersections.Count); var polyline = (IPolyline)intersections[0]; Assert.AreEqual(1, GeometryUtils.GetPartCount(polyline)); var multipoint = (IMultipoint)intersections[1]; Assert.AreEqual(1, GeometryUtils.GetPartCount(multipoint)); Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference, multipoint.SpatialReference)); }
public void CanGetMultipointPolygonCrossesIntersection() { var matrix = new IntersectionMatrix("T*T******"); IMultipoint g1 = GeometryFactory.CreateMultipoint( GeometryFactory.CreatePoint(5, 5, 0), GeometryFactory.CreatePoint(10, 5, 0), GeometryFactory.CreatePoint(15, 5, 0)); IPolygon g2 = GeometryFactory.CreatePolygon(0, 0, 10, 10, 0); g1.SpatialReference = _spatialReference; g2.SpatialReference = _spatialReference; IList <IGeometry> result12 = matrix.GetIntersections(g1, g2); Assert.AreEqual(1, result12.Count); Console.WriteLine(GeometryUtils.ToString(result12[0])); Assert.AreEqual(2, GeometryUtils.GetPointCount(result12)); Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference, result12[0].SpatialReference)); IList <IGeometry> result21 = matrix.GetIntersections(g2, g1); Assert.AreEqual(1, result21.Count); Console.WriteLine(GeometryUtils.ToString(result21[0])); Assert.IsTrue( GeometryUtils.AreEqualInXY(result21[0], g2)); // can't subtract, same as g2 }
public void CanCreateSpatialFilterWithNonZSimpleGeometry() { IFeatureWorkspace ws = OpenTestWorkspace(); IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE"); IEnvelope nonZSimpleEnvelope = GeometryFactory.CreateEnvelope(2600000, 1200000, 2700000, 1300000); GeometryUtils.MakeZAware(nonZSimpleEnvelope); Assert.False(((IZAware)nonZSimpleEnvelope).ZSimple, "Must be non-Z-simple"); ISpatialReference spatialReference = Assert.NotNull(DatasetUtils.GetSpatialReference(fc)); IGeometry validGeometry; string message; Assert.False(GdbQueryUtils.IsValidFilterGeometry( nonZSimpleEnvelope, SpatialReferenceUtils.GetXyResolution(spatialReference), out validGeometry, out message), "Search geometry should not be valid"); Assert.NotNull(validGeometry); IQueryFilter filter = GdbQueryUtils.CreateSpatialFilter(fc, nonZSimpleEnvelope); Assert.True(GdbQueryUtils.GetFeatures(fc, filter, true).Any(), "No features found"); }
public void CanCreateFeatureWithoutTableSchema() { ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95); IPolygon shape = GeometryFactory.CreatePolygon( GeometryFactory.CreatePoint(2600000, 1200000, sr), GeometryFactory.CreatePoint(2600050, 1200080, sr)); GdbObjectMsg featureMsg = new GdbObjectMsg { ClassHandle = -1, ObjectId = 42, Shape = ProtobufGeometryUtils.ToShapeMsg(shape) }; GdbFeatureClass fClass = new GdbFeatureClass(1, "Test", esriGeometryType.esriGeometryPolygon); GdbRow gdbRow = ProtobufConversionUtils.FromGdbObjectMsg(featureMsg, fClass); GdbFeature feature = (GdbFeature)gdbRow; Assert.AreEqual(42, feature.OID); Assert.True(GeometryUtils.AreEqual(shape, feature.Shape)); Assert.AreEqual(1, feature.Class.ObjectClassID); }
private ISpatialReference GetUniqueErrorFeatureClassSpatialReference() { ISpatialReference result = null; foreach (IssueDatasetWriter issueWriter in GetIssueWriters()) { if (issueWriter.SpatialReference == null) { continue; } if (result == null) { result = issueWriter.SpatialReference; } else { const bool compareTolerances = false; if (!SpatialReferenceUtils.AreEqualXYZ(result, issueWriter.SpatialReference, compareTolerances)) { throw new InvalidOperationException( "The spatial references of all issue feature classes " + "(including xy and z precision and tolerances) must be equal"); } } } return(Assert.NotNull(result, "spatialReference")); }
private static void VerifyErrorHasZ(IFeatureWorkspace ws) { IFieldsEdit fields = new FieldsClass(); fields.AddField(FieldUtils.CreateOIDField()); fields.AddField(FieldUtils.CreateShapeField( "Shape", esriGeometryType.esriGeometryPolyline, SpatialReferenceUtils.CreateSpatialReference ((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true), 1000, true, false)); IFeatureClass featureClass = DatasetUtils.CreateSimpleFeatureClass(ws, "VerifyErrorHasZ", fields, null); // make sure the table is known by the workspace ((IWorkspaceEdit)ws).StartEditing(false); ((IWorkspaceEdit)ws).StopEditing(true); IPolycurve line1 = CurveConstruction.StartLine(0, 0, 5) .LineTo(2, 0, 5) .Curve; IFeature row1 = featureClass.CreateFeature(); row1.Shape = line1; row1.Store(); IPolycurve line2 = CurveConstruction.StartLine(-1, 0.02, 5) .LineTo(1, 0.02, 5) .Curve; IFeature row2 = featureClass.CreateFeature(); row2.Shape = line2; row2.Store(); var test = new QaNotNear(featureClass, 0.1, 0.5); var runners = new List <QaTestRunnerBase> { new QaTestRunner(test) { KeepGeometry = true }, new QaContainerTestRunner(1000, test) { KeepGeometry = true } }; foreach (QaTestRunnerBase runner in runners) { runner.Execute(); Assert.True(runner.ErrorGeometries.Count > 0); foreach (IGeometry errorGeometry in runner.ErrorGeometries) { Assert.AreEqual(5, errorGeometry.Envelope.ZMin); } } }
private static IGeometryDef CreateGeometryDef( esriGeometryType geometryType, [NotNull] ISpatialReference spatialReference, double gridSize1, double gridSize2, double gridSize3, bool hasZ, bool hasM) { IGeometryDefEdit result = new GeometryDefClass(); ISpatialReference highPrecisionSpatialReference; SpatialReferenceUtils.EnsureHighPrecision(spatialReference, out highPrecisionSpatialReference); result.GeometryType_2 = geometryType; result.HasZ_2 = hasZ; result.HasM_2 = hasM; result.SpatialReference_2 = highPrecisionSpatialReference; ConfigureSpatialIndexGrid(result, gridSize1, gridSize2, gridSize3); return(result); }
public IssueRepository([NotNull] IssueRowWriter rowWriter, [NotNull] IEnumerable <IssueFeatureWriter> featureWriters, [NotNull] IIssueTableFields fields, [NotNull] IFeatureWorkspace featureWorkspace) { Assert.ArgumentNotNull(rowWriter, nameof(rowWriter)); Assert.ArgumentNotNull(featureWriters, nameof(featureWriters)); Assert.ArgumentNotNull(fields, nameof(fields)); Assert.ArgumentNotNull(featureWorkspace, nameof(featureWorkspace)); FeatureWorkspace = featureWorkspace; _rowWriter = rowWriter; _featureWriters = featureWriters.ToList(); _issueWritersByGeometryType = GetIssueWritersByGeometryType(rowWriter, _featureWriters); _issueDatasets = GetIssueDatasets(rowWriter, _featureWriters, fields); if (_featureWriters.Count > 0) { _spatialReference = SpatialReferenceUtils.GetUniqueSpatialReference( GetSpatialReferences(_featureWriters), comparePrecisionAndTolerance: true, compareVerticalCoordinateSystems: true); } }
public void CanCutMultipatchWithInnerRingThroughInnerRing() { ISpatialReference lv95 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95); IPolygon originalPoly = GeometryFactory.CreatePolygon( GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 50, 50, lv95)); IPolygon innerRingPoly = GeometryFactory.CreatePolygon( GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 10, 10, lv95)); var innerRing = (IRing)((IGeometryCollection)innerRingPoly).Geometry[0]; innerRing.ReverseOrientation(); IMultiPatch multiPatch = GeometryFactory.CreateMultiPatch(originalPoly); GeometryFactory.AddRingToMultiPatch(innerRing, multiPatch, esriMultiPatchRingType .esriMultiPatchInnerRing); // cut line cuts through the inner ring 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; var partCount = 0; foreach (IGeometry result in cutter.ResultGeometriesByFeature[mockFeature]) { Assert.IsFalse(GeometryUtils.HasUndefinedZValues(result)); areaSum += GeometryUtils.GetParts((IGeometryCollection)result) .Sum(part => ((IArea)part).Area); partCount += GeometryUtils.GetParts((IGeometryCollection)result).Count(); } Assert.AreEqual(2, partCount); Assert.AreEqual(((IArea)originalPoly).Area + ((IArea)innerRing).Area, areaSum, 0.0001); }
public void CanReshapeMultipatch() { ISpatialReference lv95 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95); IPolygon polygon = GeometryFactory.CreatePolygon( GeometryFactory.CreateEnvelope(2600000, 1200000, 500, 50, 20, lv95)); IMultiPatch multiPatch = GeometryFactory.CreateMultiPatch( polygon); IPolyline cutLine = GeometryFactory.CreateLine( GeometryFactory.CreatePoint(2600000 - 100, 1200000), GeometryFactory.CreatePoint(2600000 + 100, 1200000)); cutLine.SpatialReference = lv95; var reshapePath = (IPath)((IGeometryCollection)cutLine).Geometry[0]; var reshapeInfo = new ReshapeInfo(multiPatch, reshapePath, null); IList <ReshapeInfo> singleReshapes; ReshapeUtils.ReshapeAllGeometryParts(reshapeInfo, reshapePath, out singleReshapes); var reshapedRing = (IRing)((IGeometryCollection)multiPatch).Geometry[0]; Assert.True(MathUtils.AreEqual(((IArea)reshapedRing).Area, ((IArea)polygon).Area / 2, 0.1)); }
public void CanConvertToFromFeature() { var sr = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LN02); var fClass = new GdbFeatureClass(123, "TestFC", esriGeometryType.esriGeometryPolygon); fClass.SpatialReference = sr; GdbFeature featureWithNoShape = new GdbFeature(41, fClass); AssertCanConvertToDtoAndBack(featureWithNoShape); IPolygon polygon = GeometryFactory.CreatePolygon( GeometryFactory.CreatePoint(2600000, 1200000, sr), GeometryFactory.CreatePoint(2601000, 1201000, sr)); polygon.SpatialReference = sr; GdbFeature featureWithShape = new GdbFeature(42, fClass) { Shape = polygon }; AssertCanConvertToDtoAndBack(featureWithShape); }
public void CanDetectNonUniqueSpatialReference() { ISpatialReference sref1 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95); ISpatialReference sref2 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV03); ISpatialReference sref3 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LHN95); SpatialReferenceUtils.SetXYDomain(sref1, 0, 0, 1000, 1000, 0.001, 0.01); SpatialReferenceUtils.SetXYDomain(sref2, 0, 0, 1000, 1000, 0.00001, 0.0001); SpatialReferenceUtils.SetXYDomain(sref3, 0, 0, 1000, 1000, 0.0001, 0.001); var spatialReferences = new List <ISpatialReference> { sref1, sref2, sref3 }; string exception = null; try { TestUtils.GetUniqueSpatialReference(spatialReferences, requireEqualVerticalCoordinateSystems : true); } catch (Exception ex) { exception = ex.Message; } Assert.True(exception == "Coordinate systems are not equal: CH1903_LV03, CH1903+_LV95"); }
private static IFeatureWorkspace CreateTestWorkspace( [NotNull] string fgdbName, [NotNull] string fcName, [NotNull] string tableName, [NotNull] string relClassName, [NotNull] out IFeatureClass fc, [NotNull] out ITable table, [NotNull] out IRelationshipClass rc) { IFeatureWorkspace ws = TestWorkspaceUtils.CreateTestFgdbWorkspace(fgdbName); ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference( (int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true); fc = DatasetUtils.CreateSimpleFeatureClass( ws, fcName, null, FieldUtils.CreateOIDField(), FieldUtils.CreateIntegerField("FKEY"), FieldUtils.CreateShapeField( "SHAPE", esriGeometryType.esriGeometryPoint, sref, 1000)); table = DatasetUtils.CreateTable(ws, tableName, FieldUtils.CreateOIDField(), FieldUtils.CreateTextField("TEXT", 100)); rc = TestWorkspaceUtils.CreateSimple1NRelationship( ws, relClassName, table, (ITable)fc, table.OIDFieldName, "FKEY"); return(ws); }
private static ISpatialReference CreateDefaultSpatialReference() { const string xml = @"<ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/9.3'><WKT>PROJCS["CH1903+_LV95",GEOGCS["GCS_CH1903+",DATUM["D_CH1903+",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Hotine_Oblique_Mercator_Azimuth_Center"],PARAMETER["False_Easting",2600000.0],PARAMETER["False_Northing",1200000.0],PARAMETER["Scale_Factor",1.0],PARAMETER["Azimuth",90.0],PARAMETER["Longitude_Of_Center",7.439583333333333],PARAMETER["Latitude_Of_Center",46.95240555555556],UNIT["Meter",1.0],AUTHORITY["EPSG",2056]]</WKT><XOrigin>-27386400</XOrigin><YOrigin>-32067900</YOrigin><XYScale>800</XYScale><ZOrigin>-100000</ZOrigin><ZScale>800</ZScale><MOrigin>0</MOrigin><MScale>1</MScale><XYTolerance>0.0125</XYTolerance><ZTolerance>0.0125</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>2056</WKID></ProjectedCoordinateSystem>"; return(SpatialReferenceUtils.FromXmlString(xml)); }
public void CanGetChangedVerticesSimplifiedZigZag() { // the source polyline visits the same points several times by going back and forth ISpatialReference lv95 = SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95); IPolyline sourcePolyline = GeometryFactory.CreatePolyline( lv95, GeometryFactory.CreatePoint(0, 0), GeometryFactory.CreatePoint(10, 0), GeometryFactory.CreatePoint(20, 0), GeometryFactory.CreatePoint(10, 0), GeometryFactory.CreatePoint(20, 0), GeometryFactory.CreatePoint(30, 10)); IPolyline simplifiedPolyline = GeometryFactory.Clone(sourcePolyline); const bool allowNonPlanarLines = false; string nonSimpleReasonDescription; GeometryNonSimpleReason?nonSimpleReason; bool isSimple = GeometryUtils.IsGeometrySimple(sourcePolyline, lv95, allowNonPlanarLines, out nonSimpleReasonDescription, out nonSimpleReason); Assert.IsFalse(isSimple); GeometryUtils.Simplify(simplifiedPolyline, true, !allowNonPlanarLines); var geometryComparison = new GeometryComparison( sourcePolyline, simplifiedPolyline, 0.00125, 0.0125); const bool reportDuplicateVertices = true; IList <WKSPointZ> changes = geometryComparison.GetDifferentVertices(false, reportDuplicateVertices); Assert.AreEqual(2, changes.Count); changes = geometryComparison.GetDifferentVertices(true, reportDuplicateVertices); Assert.AreEqual(2, changes.Count); changes = geometryComparison.GetDifferentVertices(true, false); Assert.AreEqual(0, changes.Count); geometryComparison = new GeometryComparison( simplifiedPolyline, sourcePolyline, 0.00125, 0.0125); changes = geometryComparison.GetDifferentVertices(false, reportDuplicateVertices); Assert.AreEqual(0, changes.Count); changes = geometryComparison.GetDifferentVertices(true, reportDuplicateVertices); Assert.AreEqual(2, changes.Count); changes = geometryComparison.GetDifferentVertices(true, false); Assert.AreEqual(0, changes.Count); }
protected override int ExecuteCore(IRow row, int tableIndex) { var feature = row as IFeature; var multiPatch = feature?.Shape as IMultiPatch; if (multiPatch == null) { return(NoError); } if (_reducedResolutionSpatialReference == null && _resolutionFactor > 1) { _reducedResolutionSpatialReference = SpatialReferenceUtils.CreateSpatialReferenceWithMinimumTolerance( _spatialReference, _resolutionFactor); // for eliminating vertical walls, don't use the resolution factor, // but the original resolution with the minimum tolerance (2x) for it _minimumToleranceSpatialReference = SpatialReferenceUtils.CreateSpatialReferenceWithMinimumTolerance( _spatialReference); } return(CheckRings(multiPatch, feature)); }
public void CanCompareDomainOnlyDifferences() { Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001, _lv95_xyres_001_zres_001_largerdomains, true, true, true, // xy, z, m precisions false, false)); // tolerances, vcs Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001, _lv95_xyres_001_zres_001_largerdomains, true, true, true, // xy, z, m precisions true, true)); // tolerances, vcs Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001_largerdomains, _lv95_xyres_001_zres_001, true, true, true, // xy, z, m precisions false, false)); // tolerances, vcs Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001_largerdomains, _lv95_xyres_001_zres_001, true, true, true, // xy, z, m precisions true, true)); // tolerances, vcs }
public void CanDeterminePolygonReshapeSideInsideOnlySeveralParts() { ISpatialReference spatialReference = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LHN95); IGeometry geometryToReshape = GeometryFactory.CreatePolygon(100, 100, 200, 200, spatialReference); IGeometry reshapeLine = GeometryFactory.CreatePolyline(spatialReference, GeometryFactory.CreatePoint(100, 200), GeometryFactory.CreatePoint(150, 100), GeometryFactory.CreatePoint(200, 200)); ReshapeInfo reshapeInfo = Reshape(GeometryFactory.Clone(geometryToReshape), reshapeLine, false); ExpectResult(reshapeInfo, RingReshapeSideOfLine.Left, 5000, 1, 1); const bool useNonDefaultSide = true; reshapeInfo = Reshape(GeometryFactory.Clone(geometryToReshape), reshapeLine, useNonDefaultSide); ExpectResult(reshapeInfo, RingReshapeSideOfLine.Right, 5000, 2, 2); }
public void CanValidateReshapeLine() { ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LHN95); IPath reshapePath = GeometryFactory.CreatePath( GeometryFactory.CreatePoint(2600000.12, 1200000.12, sr), GeometryFactory.CreatePoint(2600000.121, 1200000.121, sr)); IPolyline polyline = GeometryFactory.CreatePolyline(2600000, 1200000, 2600001, 1200001); var reshapeInfo = new ReshapeInfo(polyline, reshapePath, null); // It says it's closed but it's just a bit short Assert.IsTrue(reshapePath.IsClosed); Assert.IsFalse(reshapeInfo.ValidateReshapePath()); // even with 3 points: WKSPoint middlePoint; middlePoint.X = 2600000.1205; middlePoint.Y = 1200000.1205; ((IPointCollection)reshapePath).InsertWKSPoints(1, 1, middlePoint); reshapeInfo = new ReshapeInfo(polyline, reshapePath, null); Assert.IsTrue(reshapePath.IsClosed); Assert.IsFalse(reshapeInfo.ValidateReshapePath()); }
/// <summary> /// Returns two overlapping square polygons: /// /// _____________ /// | | /// | target | /// ______|______ | /// | | | | /// | | | | /// | |______|______| /// | | /// | source | /// |_____________| /// /// </summary> /// <param name="sourceFeature"></param> /// <param name="targetFeature"></param> /// <returns></returns> private static void GetOverlappingPolygons(out GdbFeature sourceFeature, out GdbFeature targetFeature) { var fClass = new GdbFeatureClass(123, "TestFC", esriGeometryType.esriGeometryPolygon); var sr = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LN02); fClass.SpatialReference = sr; IPolygon polygon1 = GeometryFactory.CreatePolygon( GeometryFactory.CreatePoint(2600000, 1200000, sr), GeometryFactory.CreatePoint(2601000, 1201000, sr)); polygon1.SpatialReference = sr; sourceFeature = new GdbFeature(42, fClass) { Shape = polygon1 }; IPolygon polygon2 = GeometryFactory.CreatePolygon( GeometryFactory.CreatePoint(2600500, 1200500, sr), GeometryFactory.CreatePoint(2601500, 1201500, sr)); polygon2.SpatialReference = sr; targetFeature = new GdbFeature(43, fClass) { Shape = polygon2 }; }
/// <summary> /// Initializes a new instance of the <see cref="PolylineGraphConnectivity"/> class. /// </summary> /// <param name="spatialReference"></param> /// <param name="areaOfInterest">An optional area of interest which is used to /// filter connectivities at points outside the AoI. This can be important if the /// node degree must be determined correctly (Example: two of three line features /// intersect the AoI and are connected -> the node is incorrectly determined to /// have degree 2 because the third line has never been added to the graph.</param> public PolylineGraphConnectivity(ISpatialReference spatialReference, [CanBeNull] IGeometry areaOfInterest = null) { SpatialReference = spatialReference; AreaOfInterest = areaOfInterest; _queryPointFrom = new PointClass { SpatialReference = SpatialReference }; _queryPointTo = new PointClass { SpatialReference = SpatialReference }; if (spatialReference != null) { double xMax, yMax; spatialReference.GetDomain(out _originX, out xMax, out _originY, out yMax); _resolution = SpatialReferenceUtils.GetXyResolution(spatialReference); } NodeIndexesByNode = new Dictionary <Node, int>(); EdgeReferences = new List <GdbObjectReference>(); // Two lists with corresponding indexes: The nodes and the list of connections for each node: Nodes = new List <Node>(); Connections = new List <List <AdjacentNode> >(); EdgeInteriorNodesByEdge = new Dictionary <GdbObjectReference, List <int> >(); }
public void CanCreateBagWithCopies() { ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95); IGeometry pt1 = GeometryFactory.CreatePoint(100, 200, 0); IGeometry pt2 = GeometryFactory.CreatePoint(100, 200, 0); pt1.SpatialReference = sref; IGeometryBag bag = GeometryFactory.CreateBag(pt1, pt2); var collection = (IGeometryCollection)bag; Assert.AreEqual(2, collection.GeometryCount); IGeometry bagPt1 = collection.get_Geometry(0); IGeometry bagPt2 = collection.get_Geometry(1); // expect copies in the bag Assert.AreNotEqual(pt1, bagPt1); Assert.AreNotEqual(pt2, bagPt2); Assert.IsTrue( SpatialReferenceUtils.AreEqual(sref, bag.SpatialReference, true, true)); Assert.IsTrue( SpatialReferenceUtils.AreEqual(sref, bagPt1.SpatialReference, true, true)); Assert.IsTrue( SpatialReferenceUtils.AreEqual(sref, bagPt2.SpatialReference, true, true)); }
public void CanGetUniqueSpatialReferenceIgnoringVerticalCoordinateSystems() { ISpatialReference sref1 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95); ISpatialReference sref2 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LN02); ISpatialReference sref3 = SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LHN95); const double maxRes = 0.00001; SpatialReferenceUtils.SetXYDomain(sref1, 0, 0, 1000, 1000, maxRes * 100, 0.01); SpatialReferenceUtils.SetXYDomain(sref2, 0, 0, 1000, 1000, maxRes * 10, 0.001); SpatialReferenceUtils.SetXYDomain(sref3, 0, 0, 1000, 1000, maxRes, 0.0001); var spatialReferences = new List <ISpatialReference> { sref1, sref2, sref3 }; ISpatialReference uniqueSpatialReference = TestUtils.GetUniqueSpatialReference( spatialReferences, requireEqualVerticalCoordinateSystems: false); Assert.IsNotNull(uniqueSpatialReference); Assert.AreEqual(maxRes, SpatialReferenceUtils.GetXyResolution( uniqueSpatialReference)); }
private static ISpatialReference GetSpatialReferenceAtMaximumResolution( [NotNull] IEnumerable <IFeatureClass> featureClasses, out double maxResolution) { Assert.ArgumentNotNull(featureClasses, nameof(featureClasses)); ISpatialReference result = null; maxResolution = 0; foreach (IFeatureClass featureClass in featureClasses) { var geoDataset = (IGeoDataset)featureClass; ISpatialReference spatialReference = geoDataset.SpatialReference; Assert.NotNull(spatialReference, "Dataset without spatial reference"); if (result == null) { result = Clone(spatialReference); } double xyResolution = SpatialReferenceUtils.GetXyResolution(spatialReference); maxResolution = Math.Max(xyResolution, maxResolution); } Assert.NotNull(result, "no spatial reference found"); ((ISpatialReferenceTolerance)result).XYTolerance = maxResolution; return(result); }
private static ISpatialReference CreateDefaultSpatialReference() { var spatialReference = (ISpatialReference3) SpatialReferenceUtils.CreateSpatialReference( WellKnownHorizontalCS.LV95, WellKnownVerticalCS.LHN95); var controlPrecision = (IControlPrecision2)spatialReference; //Determines whether you are constructing a high or low. controlPrecision.IsHighPrecision = true; var spatialReferenceResolution = (ISpatialReferenceResolution)spatialReference; //These three methods are the keys, construct horizon, then set the default x,y resolution and tolerance. spatialReferenceResolution.ConstructFromHorizon(); //Set the default x,y resolution value. spatialReferenceResolution.SetDefaultXYResolution(); spatialReferenceResolution.set_XYResolution(true, 0.00001); spatialReferenceResolution.set_ZResolution(true, 0.00001); //Set the default x,y tolerance value. var spatialReferenceTolerance = (ISpatialReferenceTolerance)spatialReference; spatialReferenceTolerance.XYTolerance = 0.0001; spatialReferenceTolerance.ZTolerance = 0.0001; return(spatialReference); }
public void CanReadWriteMultipointXy() { var points = new WKSPointZ[4]; points[0] = new WKSPointZ { X = 2600000, Y = 1200000, Z = double.NaN }; points[1] = new WKSPointZ { X = 2600030, Y = 1200020, Z = double.NaN }; points[2] = new WKSPointZ { X = 2600020, Y = 1200030, Z = double.NaN }; points[3] = new WKSPointZ { X = 2600040, Y = 1200040, Z = double.NaN }; ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95); IMultipoint multipoint = GeometryFactory.CreateMultipoint(points, sr); GeometryUtils.MakeNonZAware(multipoint); WkbGeometryWriter writer = new WkbGeometryWriter(); byte[] wkb = writer.WriteMultipoint(multipoint); // ArcObjects byte[] arcObjectsWkb = GeometryUtils.ToWkb(multipoint); Assert.AreEqual(wkb, arcObjectsWkb); // Wkx byte[] wkx = ToChristianSchwarzWkb(ToWkxMultipoint(points, Ordinates.Xy)); Assert.AreEqual(wkx, wkb); // Bonus test: Geom WkbGeomWriter geomWriter = new WkbGeomWriter(); Multipoint <IPnt> multipnt = GeometryConversionUtils.CreateMultipoint(multipoint); byte[] wkbGeom = geomWriter.WriteMultipoint(multipnt, Ordinates.Xy); Assert.AreEqual(wkb, wkbGeom); WkbGeometryReader reader = new WkbGeometryReader(); IMultipoint restored = reader.ReadMultipoint(new MemoryStream(wkb)); Assert.IsTrue(GeometryUtils.AreEqual(multipoint, restored)); // Geom WkbGeomReader geomReader = new WkbGeomReader(); Multipoint <IPnt> deserializedPnts = geomReader.ReadMultiPoint(new MemoryStream(wkbGeom)); Assert.IsTrue( GeomRelationUtils.AreMultipointsEqualXY(multipnt, deserializedPnts, double.Epsilon)); }
private static ISpatialReference CreateSpatialReference() { ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95, true); ((ISpatialReferenceResolution)sref).set_XYResolution(true, 0.01); return(sref); }
public WKSPointZComparer([NotNull] ISpatialReference spatialReference, bool compare3D) : this(SpatialReferenceUtils.GetXyResolution(spatialReference), compare3D ? GeometryUtils.GetZResolution(spatialReference) : double.NaN, spatialReference) { }