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 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 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 CanConvertPolygonToFromShapeMsg() { string xmlFile = TestData.GetDensifiedWorkUnitPerimeterPath(); var polygon = (IPolygon)GeometryUtils.FromXmlFile(xmlFile); var shapeMsg = ProtobufGeometryUtils.ToShapeMsg( polygon, ShapeMsg.FormatOneofCase.EsriShape, SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml); IGeometry rehydrated = ProtobufGeometryUtils.FromShapeMsg(shapeMsg); Assert.NotNull(rehydrated); Assert.IsTrue(GeometryUtils.AreEqual(polygon, rehydrated)); Assert.IsTrue(SpatialReferenceUtils.AreEqual(polygon.SpatialReference, rehydrated.SpatialReference, true, true)); // ... and WKB var wkbWriter = new WkbGeometryWriter(); byte[] wkb = wkbWriter.WriteGeometry(polygon); var wkbShapeMsg = new ShapeMsg() { Wkb = ByteString.CopyFrom(wkb) }; IGeometry rehydratedFromWkb = ProtobufGeometryUtils.FromShapeMsg(wkbShapeMsg); Assert.IsTrue(GeometryUtils.AreEqual(polygon, rehydratedFromWkb)); Assert.IsTrue( SpatialReferenceUtils.AreEqual(polygon.SpatialReference, rehydrated.SpatialReference)); // ... and envelope IEnvelope envelope = polygon.Envelope; var envShapeMsg = new ShapeMsg() { Envelope = new EnvelopeMsg() { XMin = envelope.XMin, YMin = envelope.YMin, XMax = envelope.XMax, YMax = envelope.YMax }, SpatialReference = new SpatialReferenceMsg() { SpatialReferenceWkid = (int)WellKnownHorizontalCS.LV95 } }; IEnvelope rehydratedEnvelope = (IEnvelope)ProtobufGeometryUtils.FromShapeMsg(envShapeMsg); Assert.IsTrue(GeometryUtils.AreEqual(envelope, rehydratedEnvelope)); }
public void CanCheckAreEqualCheckCSTypeDifference() { const bool comparePrecision = true; const bool compareVCS = true; Assert.IsFalse( SpatialReferenceUtils.AreEqual(_wgs84, _lv95_xytol_01_ztol_01, comparePrecision, compareVCS)); }
public void CanCheckAreEqualIgnoreXyResolutionDifference() { const bool comparePrecision = false; const bool compareVCS = true; Assert.IsTrue( SpatialReferenceUtils.AreEqual(_lv95_xyres_001_zres_001, _lv95_xyres_002_zres_001, comparePrecision, compareVCS)); }
public void CanCheckAreEqualIgnoreXyToleranceDifference() { const bool comparePrecision = false; const bool compareVCS = true; Assert.IsTrue( SpatialReferenceUtils.AreEqual(_lv95_xytol_01_ztol_01, _lv95_xytol_02_ztol_01, comparePrecision, compareVCS)); }
private static void ValidateSpatialReferences( [NotNull] IFeatureClass targetFeatureClass, [NotNull] IFeatureClass importFeatureClass) { if (!SpatialReferenceUtils.AreEqual( DatasetUtils.GetSpatialReference(targetFeatureClass), DatasetUtils.GetSpatialReference(importFeatureClass), comparePrecisionAndTolerance: false, compareVerticalCoordinateSystems: false)) { // TODO throw exception } }
public void CanGetInteriorBoundaryIntersections() { const string matrixString = "*T*******"; IPolygon g1 = GeometryFactory.CreatePolygon(0, 0, 10, 10, 100); IPolyline g2line = GeometryFactory.CreatePolyline( _spatialReference, GeometryFactory.CreatePoint(0, 10, 100), // start/endpoint touches polygon GeometryFactory.CreatePoint(0, 20, 100), GeometryFactory .CreatePoint(10, 10, 100), // next segment touches the polygon GeometryFactory .CreatePoint(10, 9, 100), // next segment is inside the polygon GeometryFactory .CreatePoint(6, 9, 100), // next segment is partly inside the polygon GeometryFactory.CreatePoint(6, 11, 100), GeometryFactory.CreatePoint(4, 11, 100), GeometryFactory.CreatePoint(4, 10, 100), // next segment touches polygon GeometryFactory.CreatePoint(2, 10, 100), GeometryFactory.CreatePoint(2, 11, 100), GeometryFactory.CreatePoint(1, 11, 100), GeometryFactory .CreatePoint(0, 10, 100)); // start/endpoint touches polygon GeometryUtils.MakeZAware(g2line); IPolygon g2 = GeometryFactory.CreatePolygon(g2line); GeometryUtils.Simplify(g2); g1.SpatialReference = _spatialReference; g2.SpatialReference = _spatialReference; var matrix = new IntersectionMatrix(matrixString); IList <IGeometry> intersections = matrix.GetIntersections(g1, g2); WriteGeometries(intersections); Assert.AreEqual(1, intersections.Count); var polyline = (IPolyline)intersections[0]; Assert.AreEqual(1, GeometryUtils.GetPartCount(polyline)); Assert.AreEqual(3, GeometryUtils.GetPointCount(polyline)); Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference, polyline.SpatialReference)); }
public void CanCheckAreEqualCheckXyToleranceIgnoreZToleranceDifference() { const bool comparePrecision = true; const bool compareVCS = false; var watch = new Stopwatch(); watch.Start(); Assert.IsTrue( SpatialReferenceUtils.AreEqual(_lv95_xytol_01_ztol_01, _lv95lhn95_xytol_01_ztol_02, comparePrecision, compareVCS)); Console.WriteLine(@"AreEqual (precision compare): {0:N2} ms", watch.ElapsedMilliseconds); }
public void CanCompareComponents() { Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95lhn95_xytol_01_ztol_02, _lv95ln02_xytol_01_ztol_01, true, true, true, // xy, z, m precisions false, false)); // tolerances, vcs Assert.IsFalse(SpatialReferenceUtils.AreEqual(_lv95lhn95_xytol_01_ztol_02, _lv95ln02_xytol_01_ztol_01, true, true, true, false, true)); Assert.IsFalse(SpatialReferenceUtils.AreEqual(_lv95lhn95_xytol_01_ztol_02, _lv95ln02_xytol_01_ztol_01, true, true, true, true, false)); }
public GeometryComparison([NotNull] IGeometry baseGeometry, [NotNull] IGeometry compareGeometry, double xyTolerance, double zTolerance) { // NOTE: Do not use SpatialReferenceUtils.AreEqual with the parameters // comparePrecisionAndTolerance=true and compareVerticalCoordinateSystems= true because // this also compares M resolution which can differ despite EnsureSpatialReference was called // Additionally, M-comparison is currently not implemented. // A specific comparison method should be provided that compares only the relevant aspects of the spatial reference // -> M-resolution/tolerance only if the geometry is M-aware, etc. const bool comparePrecisionAndTolerance = true; const bool compareVerticalCoordinateSystems = false; Assert.ArgumentCondition( SpatialReferenceUtils.AreEqual(baseGeometry.SpatialReference, compareGeometry.SpatialReference, comparePrecisionAndTolerance, compareVerticalCoordinateSystems), "The spatial reference of the base and the compare geometries must be the same."); if (GeometryUtils.IsZAware(baseGeometry) && GeometryUtils.IsZAware(compareGeometry)) { Assert.ArgumentCondition( MathUtils.AreEqual(GeometryUtils.GetZResolution(baseGeometry), GeometryUtils.GetZResolution(compareGeometry)), "The Z-Resolution of the base and the compare geometries must be the same."); } _baseGeometry = baseGeometry; _compareGeometry = compareGeometry; _xyTolerance = xyTolerance; _zTolerance = zTolerance; _pointTemplate = new PointClass(); _pointTemplate.SpatialReference = _baseGeometry.SpatialReference; if (!double.IsNaN(_zTolerance)) { SetZTolerance(_pointTemplate, _zTolerance); } }
public void CanCompareMinimumComponentsFastEnough() { Stopwatch watch = Stopwatch.StartNew(); const int count = 10000; for (int i = 0; i < count; i++) { SpatialReferenceUtils.AreEqual(_lv95lhn95_xytol_01_ztol_02, _lv95lhn95_xytol_01_ztol_01, false, false, false, false, false); } watch.Stop(); Console.WriteLine(@"count={0}: {1:N0} ms; per call: {2:N4} ms", count, watch.ElapsedMilliseconds, watch.ElapsedMilliseconds / (double)count); Assert.Less((double)watch.ElapsedMilliseconds, 1000); }
public void CanExportToXml() { IWorkspace workspace = TestUtils.OpenUserWorkspaceOracle(); IFeatureClass fclass = DatasetUtils.OpenFeatureClass(workspace, "TOPGIS_TLM.TLM_STRASSE"); ISpatialReference spatialReference = ((IGeoDataset)fclass).SpatialReference; string xml = SpatialReferenceUtils.ToXmlString(spatialReference); Console.WriteLine(xml); Assert.IsNotNull(xml); Assert.IsNotEmpty(xml); ISpatialReference imported = SpatialReferenceUtils.FromXmlString(xml); Assert.IsTrue( SpatialReferenceUtils.AreEqual(imported, spatialReference)); }
public void CanGetPolylinePointIntersections() { const string matrixString = "T********"; IPoint g1 = GeometryFactory.CreatePoint(10, 5, 1000); IPolyline g2 = GeometryFactory.CreatePolyline(5, 5, 1000, 15, 5, 1000); g1.SpatialReference = _spatialReference; g2.SpatialReference = _spatialReference; var matrix = new IntersectionMatrix(matrixString); IList <IGeometry> intersections = matrix.GetIntersections(g1, g2); WriteGeometries(intersections); Assert.AreEqual(1, intersections.Count); Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference, intersections[0] .SpatialReference)); }
public void CanCompareDomainOffsetDifferences() { Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001, _lv95_xyres_001_zres_001_offsetdomains, false, false, false, // xy, z, m precisions true, true)); // tolerances, vcs Assert.IsFalse(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001, _lv95_xyres_001_zres_001_offsetdomains, true, false, false, // xy, z, m precisions true, true)); // tolerances, vcs // NOTE: the z domain has an offset smaller than the z resolution, but IsZPrecisionEqual still returns true!! Assert.IsTrue(SpatialReferenceUtils.AreEqual( _lv95_xyres_001_zres_001, _lv95_xyres_001_zres_001_offsetdomains, false, true, false, // xy, z, m precisions true, true)); // tolerances, vcs }
private static void AssertSameFeature(IFeature feature, IFeature rehydrated) { Assert.AreEqual(feature.OID, rehydrated.OID); Assert.AreEqual(feature.FeatureType, rehydrated.FeatureType); Assert.AreEqual(GdbObjectUtils.GetSubtypeCode(feature), GdbObjectUtils.GetSubtypeCode(rehydrated)); Assert.AreEqual(feature.Fields.FieldCount, rehydrated.Fields.FieldCount); Assert.AreEqual(feature.Class.ObjectClassID, rehydrated.Class.ObjectClassID); Assert.IsTrue(GeometryUtils.AreEqual(feature.Shape, rehydrated.Shape)); Assert.IsTrue(GeometryUtils.AreEqual(feature.Extent, rehydrated.Extent)); if (feature.Shape != null) { Assert.IsTrue(SpatialReferenceUtils.AreEqual(feature.Shape.SpatialReference, rehydrated.Shape.SpatialReference, true, true)); } }
private static ISpatialReference GetUniqueSpatialReference( [NotNull] IEnumerable <IFeatureClass> featureClasses, out double tolerance) { Assert.ArgumentNotNull(featureClasses, nameof(featureClasses)); ISpatialReference result = null; tolerance = 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 = spatialReference; tolerance = ((ISpatialReferenceTolerance)result).XYTolerance; } else { const bool comparePrecisionAndTolerance = true; const bool compareVerticalCoordinateSystems = false; if (!SpatialReferenceUtils.AreEqual(result, spatialReference, comparePrecisionAndTolerance, compareVerticalCoordinateSystems)) { throw new ArgumentException( "All datasets must have the same spatial reference (with equal tolerance/resolution)"); } } } return(Assert.NotNull( result, "No feature classes with spatial reference specified")); }
private static void AssertDifferences([NotNull] ISpatialReference sref1, [NotNull] ISpatialReference sref2, bool equal, bool projectionEqual, bool vcsEqual, bool xyPrecisionEqual, bool zPrecisionEqual, bool mPrecisionEqual, bool xyToleranceEqual, bool zToleranceEqual, bool mToleranceEqual) { bool projectionDifferent; bool vcsDifferent; bool xyPrecisionDifferent; bool zPrecisionDifferent; bool mPrecisionDifferent; bool xyToleranceDifferent; bool zToleranceDifferent; bool mToleranceDifferent; bool isEqual = SpatialReferenceUtils.AreEqual(sref1, sref2, out projectionDifferent, out vcsDifferent, out xyPrecisionDifferent, out zPrecisionDifferent, out mPrecisionDifferent, out xyToleranceDifferent, out zToleranceDifferent, out mToleranceDifferent); Assert.AreEqual(equal, isEqual); Assert.AreEqual(projectionEqual, !projectionDifferent); Assert.AreEqual(vcsEqual, !vcsDifferent); Assert.AreEqual(xyPrecisionEqual, !xyPrecisionDifferent); Assert.AreEqual(zPrecisionEqual, !zPrecisionDifferent); Assert.AreEqual(mPrecisionEqual, !mPrecisionDifferent); Assert.AreEqual(xyToleranceEqual, !xyToleranceDifferent); Assert.AreEqual(zToleranceEqual, !zToleranceDifferent); Assert.AreEqual(mToleranceEqual, !mToleranceDifferent); }
public void CanGetInteriorInteriorPolygon() { 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(1, intersections.Count); var polygon = (IPolygon)intersections[0]; Assert.AreEqual(1, GeometryUtils.GetPartCount(polygon)); Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference, polygon.SpatialReference)); }
public void CanCheckAreEqualWithPrecisionCompareFastEnough() { const bool comparePrecision = true; const bool compareVCS = false; var watch = new Stopwatch(); watch.Start(); const int iterations = 1000; for (int i = 0; i < iterations; i++) { SpatialReferenceUtils.AreEqual(_lv95_xytol_01_ztol_01, _lv95lhn95_xytol_01_ztol_02, comparePrecision, compareVCS); } double perIteration = ((double)watch.ElapsedMilliseconds) / iterations; Console.WriteLine(@"AreEqual (precision compare): {0:N6} ms", perIteration); Assert.Less(perIteration, 0.05, "AreEqual takes too long"); }
public void CanCreateGdbRowFromRealData() { IWorkspace ws = TestUtils.OpenUserWorkspaceOracle(); const string tlmStrasse = "TOPGIS_TLM.TLM_STRASSE"; IFeatureClass realFeatureClass = DatasetUtils.OpenFeatureClass(ws, tlmStrasse); var objectClassMsg = ProtobufGdbUtils.ToObjectClassMsg(realFeatureClass, true); GdbTableContainer gdbTableContainer = ProtobufConversionUtils.CreateGdbTableContainer( new[] { objectClassMsg }, null, out GdbWorkspace _); var virtualFeatureClass = (IFeatureClass)gdbTableContainer.OpenTable(tlmStrasse); Assert.AreEqual(realFeatureClass.ObjectClassID, virtualFeatureClass.ObjectClassID); Assert.AreEqual(DatasetUtils.GetName(realFeatureClass), DatasetUtils.GetName(virtualFeatureClass)); Assert.AreEqual(realFeatureClass.AliasName, virtualFeatureClass.AliasName); Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName); Assert.AreEqual(realFeatureClass.OIDFieldName, virtualFeatureClass.OIDFieldName); Assert.AreEqual(realFeatureClass.FeatureClassID, virtualFeatureClass.FeatureClassID); Assert.AreEqual(realFeatureClass.FeatureType, virtualFeatureClass.FeatureType); Assert.AreEqual(realFeatureClass.HasOID, virtualFeatureClass.HasOID); Assert.AreEqual(realFeatureClass.ShapeType, virtualFeatureClass.ShapeType); Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName); Assert.IsTrue(SpatialReferenceUtils.AreEqual( DatasetUtils.GetSpatialReference(realFeatureClass), DatasetUtils.GetSpatialReference(virtualFeatureClass), true, true)); Assert.AreEqual(realFeatureClass.Fields.FieldCount, virtualFeatureClass.Fields.FieldCount); int featureCount = 0; foreach (var feature in GdbQueryUtils.GetFeatures(realFeatureClass, true)) { // TODO: Move all this to separate project referenced by both client and server GdbObjectMsg gdbObjectMsg = ProtobufGdbUtils.ToGdbObjectMsg(feature, false, true); GdbRow gdbRow = ProtobufConversionUtils.FromGdbObjectMsg( gdbObjectMsg, (ITable)realFeatureClass); for (int i = 0; i < feature.Fields.FieldCount; i++) { object expected = feature.get_Value(i); object actual = gdbRow.get_Value(i); if (expected is IGeometry shape) { Assert.IsTrue( GeometryUtils.AreEqual(shape, (IGeometry)actual)); } else { Assert.AreEqual(expected, actual); } } featureCount++; if (featureCount > 250) { return; } } }
public override int Execute() { ISpatialReference actualSpatialReference = GetSpatialReference(_featureClass); //const bool comparePrecisionAndTolerance = true; //const bool compareVerticalCoordinateSystems = true; bool coordinateSystemDifferent; bool vcsDifferent; bool xyPrecisionDifferent; bool zPrecisionDifferent; bool mPrecisionDifferent; bool xyToleranceDifferent; bool zToleranceDifferent; bool mToleranceDifferent; bool equal = SpatialReferenceUtils.AreEqual(_expectedSpatialReference, actualSpatialReference, out coordinateSystemDifferent, out vcsDifferent, out xyPrecisionDifferent, out zPrecisionDifferent, out mPrecisionDifferent, out xyToleranceDifferent, out zToleranceDifferent, out mToleranceDifferent); if (equal) { return(NoError); } int errorCount = 0; if (coordinateSystemDifferent) { errorCount += Report( Codes[Code.CoordinateSystemDifferent_XY], LocalizableStrings.QaSchemaSpatialReference_CoordinateSystemDifferent, _expectedSpatialReference.Name, actualSpatialReference.Name); } if (_compareVerticalCoordinateSystems && vcsDifferent) { errorCount += Report( Codes[Code.CoordinateSystemDifferent_Z], LocalizableStrings.QaSchemaSpatialReference_VerticalCoordinateSystemDifferent, GetVCSDisplayName(_expectedSpatialReference), GetVCSDisplayName(actualSpatialReference)); } if (_compareXyPrecision && xyPrecisionDifferent) { errorCount += Report( Codes[Code.PrecisionDifferent_XY], LocalizableStrings.QaSchemaSpatialReference_XYDomainOrPrecisionDifferent, GetXyPrecisionString(_expectedSpatialReference), GetXyPrecisionString(actualSpatialReference)); } if (_compareZPrecision && zPrecisionDifferent) { errorCount += Report( Codes[Code.PrecisionDifferent_Z], LocalizableStrings.QaSchemaSpatialReference_ZDomainOrPrecisionDifferent, GetZPrecisionString(_expectedSpatialReference), GetZPrecisionString(actualSpatialReference)); } if (_compareMPrecision && mPrecisionDifferent) { errorCount += Report( Codes[Code.PrecisionDifferent_M], LocalizableStrings.QaSchemaSpatialReference_MDomainOrPrecisionDifferent, GetMPrecisionString(_expectedSpatialReference), GetMPrecisionString(actualSpatialReference)); } if (_compareXyTolerance && xyToleranceDifferent) { errorCount += Report( Codes[Code.ToleranceDifferent_XY], LocalizableStrings.QaSchemaSpatialReference_XYToleranceDifferent, GetXYToleranceString(_expectedSpatialReference), GetXYToleranceString(actualSpatialReference)); } if (_compareZTolerance && zToleranceDifferent) { errorCount += Report( Codes[Code.ToleranceDifferent_Z], LocalizableStrings.QaSchemaSpatialReference_ZToleranceDifferent, GetZToleranceString(_expectedSpatialReference), GetZToleranceString(actualSpatialReference)); } if (_compareMTolerance && mToleranceDifferent) { errorCount += Report( Codes[Code.ToleranceDifferent_M], LocalizableStrings.QaSchemaSpatialReference_MToleranceDifferent, GetMToleranceString(_expectedSpatialReference), GetMToleranceString(actualSpatialReference)); } return(errorCount); }