private static IFeatureClass EnsureFeatureClass(IFeatureWorkspace ws,
esriGeometryType geometryType,
string name,
ISpatialReference sr)
{
try
{
IFeatureClass existing = DatasetUtils.OpenFeatureClass(ws, name);
DatasetUtils.DeleteFeatureClass(existing);
}
catch (Exception e)
{
Console.WriteLine(e);
}
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", geometryType,
sr, 1000, true));
IFeatureClass fc = DatasetUtils.CreateSimpleFeatureClass(ws, name, fields);
if (fc is IVersionedTable)
{
DatasetUtils.RegisterAsVersioned(fc);
}
return(fc);
}
public void MultipartTest()
{
IFeatureWorkspace workspace =
TestWorkspaceUtils.CreateInMemoryWorkspace("MultipartTest");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, CreateLV95(),
1000));
IFeatureClass linesFc = DatasetUtils.CreateSimpleFeatureClass(workspace, "Flow",
fields);
AddFeature(
linesFc,
CurveConstruction.StartLine(0, 0).LineTo(4, 0).MoveTo(6, 0).LineTo(6, 10).Curve);
AddFeature(linesFc, CurveConstruction.StartLine(4, 0).LineTo(6, 0).Curve);
AddFeature(linesFc, CurveConstruction.StartLine(0, 20).LineTo(4, 20).Curve);
AddFeature(
linesFc,
CurveConstruction.StartLine(0, 30).LineTo(4, 30).MoveTo(0, 32).LineTo(4, 30)
.MoveTo(4, 30).LineTo(8, 30).Curve);
// expect counter-clockwise: 0 errors
var runner = new QaContainerTestRunner(
1000, new QaFlowLogic(linesFc));
Assert.AreEqual(3, runner.Execute());
}
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 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);
}
public void MultipartTest()
{
IFeatureWorkspace workspace =
TestWorkspaceUtils.CreateInMemoryWorkspace("MultipartTest");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, CreateLV95(),
1000));
IFeatureClass featureClass = DatasetUtils.CreateSimpleFeatureClass(
workspace, "Border", fields);
AddFeature(featureClass,
CurveConstruction.StartLine(0, 0).LineTo(4, 0).MoveTo(6, 0).LineTo(6, 10)
.Curve);
AddFeature(featureClass, CurveConstruction.StartLine(6, 10).LineTo(4, 10).Curve);
AddFeature(featureClass,
CurveConstruction.StartLine(4, 0).LineTo(6, 0).MoveTo(4, 10).LineTo(0, 0)
.Curve);
// expect counter-clockwise: 0 errors
var runnerCounterClockwise = new QaContainerTestRunner(
1000, new QaBorderSense(featureClass, false));
Assert.AreEqual(0, runnerCounterClockwise.Execute());
// expect clockwise: 1 error
var runnerClockwise = new QaContainerTestRunner(
1000, new QaBorderSense(featureClass, true));
Assert.AreEqual(1, runnerClockwise.Execute());
}
private void TestConnections(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LineTyp", "LineTyp"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConnections", fields,
null);
IList <ITable> tbls = new[] { (ITable)fc };
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 1);
row.Shape =
CurveConstruction.StartLine(100, 100).LineTo(200, 200).Curve;
row.Store();
}
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 2);
row.Shape =
CurveConstruction.StartLine(100, 100.1).LineTo(100, 200).Curve;
row.Store();
}
IList <QaConnectionRule> rules = new[]
{
new QaConnectionRule(tbls, new[] { "LineTyp = 1" }),
new QaConnectionRule(tbls, new[] { "LineTyp = 2" })
};
var test = new QaConnections(new[] { fc }, rules, 0);
test.QaError += Test_QaError;
_errorCount = 0;
test.Execute();
Assert.AreEqual(0, _errorCount);
test.QaError -= Test_QaError;
var container = new TestContainer();
container.AddTest(test);
container.QaError += Test_QaError;
_errorCount = 0;
container.Execute();
Assert.AreEqual(0, _errorCount);
}
public void CanCreateGdbFeatureClass()
{
// An in-memory backing dataset is created automatically, if no factory method is provided
GdbFeatureClass gdbFeatureClass =
new GdbFeatureClass(41, "TESTABLE", esriGeometryType.esriGeometryPoint,
"Test table");
IFeatureClass featureClass = gdbFeatureClass;
Assert.AreEqual(41, featureClass.ObjectClassID);
Assert.AreEqual("TESTABLE", DatasetUtils.GetName(featureClass));
Assert.AreEqual("Test table",
DatasetUtils.GetAliasName(featureClass));
Assert.AreEqual(esriGeometryType.esriGeometryPoint,
featureClass.ShapeType);
Assert.False(featureClass.HasOID);
Assert.Null(featureClass.OIDFieldName);
Assert.AreEqual(0, GdbQueryUtils.Count(featureClass, ""));
// Add OID field
gdbFeatureClass.AddField(FieldUtils.CreateOIDField());
// Add Shape field
gdbFeatureClass.AddField(
FieldUtils.CreateShapeField(
esriGeometryType.esriGeometryPoint,
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95)));
Assert.True(featureClass.HasOID);
Assert.AreEqual("OBJECTID", featureClass.OIDFieldName);
Assert.AreEqual("SHAPE", featureClass.ShapeFieldName);
IQueryFilter queryFilter = GdbQueryUtils.CreateQueryFilter("OBJECTID");
queryFilter.WhereClause = "OBJECTID < 0";
Assert.AreEqual(0,
GdbQueryUtils.Count(featureClass, queryFilter));
var backingDataset = gdbFeatureClass.BackingDataset as InMemoryDataset;
Assert.NotNull(backingDataset);
backingDataset.AllRows.Add(new GdbRow(1, gdbFeatureClass));
Assert.AreEqual(0,
GdbQueryUtils.Count(featureClass, queryFilter));
queryFilter.WhereClause = "OBJECTID > 0";
Assert.AreEqual(1,
GdbQueryUtils.Count(featureClass, queryFilter));
}
private static void TestConditionCoincidence(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LandId"));
fields.AddField(FieldUtils.CreateIntegerField("OtherId"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc1 =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConditionCoincidence1",
fields,
null);
IFeatureClass fc2 =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConditionCoincidence2",
fields,
null);
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = fc1.CreateFeature();
row.set_Value(1, 1);
row.Shape = CurveConstruction.StartLine(100, 100).LineTo(200, 200).Curve;
row.Store();
}
{
IFeature row = fc2.CreateFeature();
row.set_Value(1, 1);
row.Shape = CurveConstruction
.StartLine(100.5, 100).LineTo(200.5, 200).Curve;
row.Store();
}
// test without ignore conditions --> line is near, but not coincident
var test = new QaPartCoincidenceOther(fc1, fc2, 1, 10);
var testRunner = new QaTestRunner(test);
testRunner.Execute();
Assert.AreEqual(1, testRunner.Errors.Count);
// Same test with ignore conditions --> nothing near
test = new QaPartCoincidenceOther(fc1, fc2, 1, 10);
test.IgnoreNeighborCondition = "G1.LandID = G2.LandID";
testRunner = new QaTestRunner(test);
testRunner.Execute();
Assert.AreEqual(0, testRunner.Errors.Count);
}
private static LinearNetworkGdbFeatureFinder CreateTestGdbSchema(
string fgdbName,
out IFeatureClass edgeClass, out IFeatureClass junctionClass)
{
const string unitTestDir = @"C:\Temp\UnitTestData";
try
{
FileSystemUtils.DeleteDirectory(Path.Combine(unitTestDir, fgdbName), true,
true);
}
catch (Exception)
{
// ignored
}
IWorkspaceName workspaceName =
WorkspaceUtils.CreateFileGdbWorkspace(unitTestDir,
fgdbName);
IWorkspace workspace = WorkspaceUtils.OpenWorkspace(workspaceName);
ISpatialReference lv95 =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95);
IFieldsEdit fieldsReference = new FieldsClass();
fieldsReference.AddField(FieldUtils.CreateOIDField());
fieldsReference.AddField(
FieldUtils.CreateShapeField(esriGeometryType.esriGeometryPolyline, lv95));
edgeClass = DatasetUtils.CreateSimpleFeatureClass(
(IFeatureWorkspace)workspace, "Edges", string.Empty,
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField(esriGeometryType.esriGeometryPolyline, lv95));
junctionClass = DatasetUtils.CreateSimpleFeatureClass(
(IFeatureWorkspace)workspace, "Junctions", string.Empty,
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField(esriGeometryType.esriGeometryPoint, lv95));
List <LinearNetworkClassDef> networkClassDefinitions =
new List <LinearNetworkClassDef>
{
new LinearNetworkClassDef(edgeClass),
new LinearNetworkClassDef(junctionClass)
};
LinearNetworkGdbFeatureFinder featureFinder =
new LinearNetworkGdbFeatureFinder(networkClassDefinitions);
return(featureFinder);
}
private static IFeatureClass CreateLineFeatureClass(
[NotNull] IFeatureWorkspace workspace, [NotNull] string name)
{
ISpatialReference spatialReference = CreateSpatialReference();
return(DatasetUtils.CreateSimpleFeatureClass(
workspace, name,
FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField(
"SHAPE", esriGeometryType.esriGeometryPolyline,
spatialReference, 1000, false, false)),
null));
}
public void TestMultipart()
{
IFeatureWorkspace ws = TestWorkspaceUtils.CreateInMemoryWorkspace("Testmultipart");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LineTyp", "LineTyp"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConnections", fields,
null);
IList <ITable> tbls = new[] { (ITable)fc };
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 1);
row.Shape =
CurveConstruction.StartLine(1, 1).LineTo(2, 2).MoveTo(3, 2).LineTo(4, 2).Curve;
row.Store();
}
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 2);
row.Shape =
CurveConstruction.StartLine(1, 5).LineTo(2, 2).Curve;
row.Store();
}
IList <QaConnectionRule> rules = new List <QaConnectionRule>
{
new QaConnectionRule(tbls, new[] { "LineTyp = 1" }),
new QaConnectionRule(tbls, new[] { "LineTyp = 2" })
};
var test = new QaConnections(new[] { fc }, rules, 0);
test.UseMultiParts = false;
var runner = new QaContainerTestRunner(1000, test);
Assert.AreEqual(0, runner.Execute());
test.UseMultiParts = true;
runner = new QaContainerTestRunner(1000, test);
Assert.AreEqual(1, runner.Execute());
}
private static IFeatureClass CreateLineClass([NotNull] IFeatureWorkspace ws,
[NotNull] string name)
{
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));
return(DatasetUtils.CreateSimpleFeatureClass(ws, name, fields));
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType geometryType)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", geometryType, _spatialReference, 1000));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
return(DatasetUtils.CreateSimpleFeatureClass(
_testWs, name, fields));
}
public void TestUniqueGuid()
{
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.CreateField("UniqueValue", esriFieldType.esriFieldTypeGUID),
FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000));
IFeatureClass featureClass1 = DatasetUtils.CreateSimpleFeatureClass(_fgdbWorkspace,
"TestUniqueGuid",
fields);
for (var i = 0; i < 10; i++)
{
IFeature feature = featureClass1.CreateFeature();
feature.set_Value(1, Guid.NewGuid().ToString("B"));
feature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
feature.Store();
}
for (var i = 0; i < 2; i++)
{
IFeature emptyFeature = featureClass1.CreateFeature();
emptyFeature.set_Value(1, null);
emptyFeature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
emptyFeature.Store();
}
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique((ITable)featureClass1, "UniqueValue")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
}
private IFeatureClass CreateFeatureClass(string name, esriGeometryType geometryType)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", geometryType, _spatialReference, 1000));
fields.AddField(FieldUtils.CreateTextField(_stateIdFieldName, 100));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
fields.AddField(FieldUtils.CreateDoubleField(_doubleFieldName));
fields.AddField(FieldUtils.CreateDateField(_dateFieldName));
return(DatasetUtils.CreateSimpleFeatureClass(
_featureWorkspace, name, fields));
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType type,
bool zAware = false)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
setDefaultXyDomain: true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000,
0.0001, 0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape", type, sref, 1000, zAware));
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name, fields));
}
public static IFeatureClass CreateSimpleFeatureClass(
[NotNull] IFeatureWorkspace workspace,
[NotNull] string name,
[CanBeNull] IFieldsEdit fieldsWithoutShapeField,
esriGeometryType geometryType,
esriSRProjCS2Type projType,
double xyTolerance = 0,
bool hasZ = false)
{
if (fieldsWithoutShapeField == null)
{
fieldsWithoutShapeField = new FieldsClass();
fieldsWithoutShapeField.AddField(FieldUtils.CreateOIDField());
}
ISpatialReference spatialReference = SpatialReferenceUtils
.CreateSpatialReference
((int)projType, true);
if (xyTolerance > 0)
{
((ISpatialReferenceTolerance)spatialReference).XYTolerance =
xyTolerance;
}
if (hasZ)
{
SpatialReferenceUtils.SetZDomain(spatialReference, -10000, 10000,
0.0001, 0.001);
}
fieldsWithoutShapeField.AddField(
FieldUtils.CreateShapeField("Shape", geometryType, spatialReference, 1000, hasZ));
IFeatureClass featureClass =
DatasetUtils.CreateSimpleFeatureClass(
workspace, name, fieldsWithoutShapeField);
// make sure the table is known by the workspace
((IWorkspaceEdit)workspace).StartEditing(false);
((IWorkspaceEdit)workspace).StopEditing(true);
return(featureClass);
}
private void CreateTestFeatureClasses(
string polygonsName,
string pointsName,
[NotNull] out IFeatureClass polygonFeatureClass,
[NotNull] out IFeatureClass pointFeatureClass,
IFeatureWorkspace ws = null, bool polygonAsClosedLines = false)
{
ws = ws ?? _testWs;
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
var geomType = polygonAsClosedLines
? esriGeometryType.esriGeometryPolyline
: esriGeometryType.esriGeometryPolygon;
IFieldsEdit polygonFields = new FieldsClass();
polygonFields.AddField(FieldUtils.CreateOIDField());
polygonFields.AddField(FieldUtils.CreateShapeField(
"Shape", geomType,
sref, 1000, false, false));
polygonFeatureClass = DatasetUtils.CreateSimpleFeatureClass(ws, polygonsName,
polygonFields,
null);
IFieldsEdit pointFields = new FieldsClass();
pointFields.AddField(FieldUtils.CreateOIDField());
pointFields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000, false, false));
pointFeatureClass = DatasetUtils.CreateSimpleFeatureClass(ws, pointsName,
pointFields,
null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
}
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);
}
}
private static IFeatureClass CreateFeatureClass(
IFeatureWorkspace ws, string fcName)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryMultiPatch,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, true, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, fcName, fields, null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
((IWorkspaceEdit)ws).StartEditing(false);
return(fc);
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType geometryType,
params IField[] attributeFields)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001,
0.001);
var fields = new List <IField>
{
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape", geometryType, sref, 1000)
};
fields.AddRange(attributeFields);
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name,
FieldUtils.CreateFields(fields)));
}
private static IFeatureClass CreateLineClass([NotNull] IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(_nrFieldName));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
Thread.Sleep(10);
IFeatureClass featureClass =
DatasetUtils.CreateSimpleFeatureClass(
ws, "line_" + Environment.TickCount, fields, null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
return(featureClass);
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType type,
[NotNull] string urlFieldName)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int) esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001,
0.001);
const bool mAware = false;
const bool hasZ = false;
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape",
type,
sref, 1000,
hasZ, mAware),
FieldUtils.CreateTextField(urlFieldName, 500));
return DatasetUtils.CreateSimpleFeatureClass(_testWs, name, fields);
}
private static IFeatureClass CreateFeatureClass(
[NotNull] string name,
[NotNull] IFeatureWorkspace workspace,
[NotNull] IIssueTableFieldManagement fields,
esriGeometryType geometryType,
[NotNull] ISpatialReference spatialReference,
double gridSize1, double gridSize2, double gridSize3)
{
const bool zAware = true;
var list = new List <IField>
{
FieldUtils.CreateShapeField(
geometryType, spatialReference,
gridSize1, gridSize2, gridSize3,
zAware)
};
list.AddRange(CreateAttributeFields(fields));
return(DatasetUtils.CreateSimpleFeatureClass(workspace, name,
FieldUtils.CreateFields(list)));
}
private IEnumerable <IField> GetFields([NotNull] ISpatialReference spatialReference,
bool hasZ = false,
bool hasM = false)
{
yield return(FieldUtils.CreateShapeField(esriGeometryType.esriGeometryPolygon,
spatialReference,
hasZ: hasZ,
hasM: hasM));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.Description], 2000));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.FeatureSource], 500));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.WhereClause], 2000));
yield return
(FieldUtils.CreateDoubleField(_fieldNames[AttributeRole.BufferDistance]));
yield return
(FieldUtils.CreateDoubleField(_fieldNames[AttributeRole.GeneralizationTolerance]));
}
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 void TestMultiPartErrorCore(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolygon,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass featureClass =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestMultiPartErrorCore1",
fields,
null);
IFieldsEdit refFields = new FieldsClass();
refFields.AddField(FieldUtils.CreateOIDField());
refFields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolygon,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass reference =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestMultiPartErrorCoreRef",
refFields,
null);
IPolygon poly1 = CurveConstruction.StartPoly(0, 0.01)
.LineTo(1, 0.01)
.LineTo(1, 1)
.LineTo(0, 1)
.LineTo(0, 0.01)
.MoveTo(1.001, 0.01)
.LineTo(4, 0.01)
.LineTo(4, 1)
.LineTo(1.001, 1)
.LineTo(1.001, 0.01)
.ClosePolygon();
((ITopologicalOperator)poly1).Simplify();
IFeature row1 = featureClass.CreateFeature();
row1.Shape = poly1;
row1.Store();
IPolygon referencePoly = CurveConstruction.StartPoly(-1, 0)
.LineTo(0.5, 0)
.LineTo(0.5, -10)
.LineTo(-1, -10)
.LineTo(-1, 0)
.MoveTo(0.81, 0)
.LineTo(10, 0)
.LineTo(10, -10)
.LineTo(0.81, 0)
.ClosePolygon();
((ITopologicalOperator)referencePoly).Simplify();
IFeature rowRef = reference.CreateFeature();
rowRef.Shape = referencePoly;
rowRef.Store();
var test = new QaPartCoincidenceOther(featureClass, reference,
0.02, 0.05, 0.1,
false, 5000, 0);
var runner = new QaTestRunner(test);
runner.Execute(row1);
Assert.AreEqual(3, runner.Errors.Count);
}
private static void TestMultipartLines(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 fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestMultipartLines", fields,
null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
// Crossing parts
IFeature row1 = fc.CreateFeature();
row1.Shape = CurveConstruction.StartLine(600000, 200000, 500)
.LineTo(600010, 200010, 505)
.MoveTo(600010, 200000, 600)
.LineTo(600000, 200010, 602)
.Curve;
row1.Store();
IFeature copy = fc.CreateFeature();
copy.Shape = row1.ShapeCopy;
((ITopologicalOperator)copy.Shape).Simplify();
copy.Store();
// 2D identical parts
IFeature row2 = fc.CreateFeature();
row2.Shape = CurveConstruction.StartLine(600000, 200000, 500)
.LineTo(600010, 200010, 505)
.MoveTo(600010, 200010, 600)
.LineTo(600000, 200000, 602)
.Curve;
row2.Store();
copy = fc.CreateFeature();
copy.Shape = row1.ShapeCopy;
((ITopologicalOperator)copy.Shape).Simplify();
copy.Store();
// identical parts
IFeature row = fc.CreateFeature();
row.Shape = CurveConstruction.StartLine(600000, 200000, 500)
.LineTo(600010, 200010, 505)
.MoveTo(600000, 200000, 500)
.LineTo(600010, 200010, 505)
.Curve;
row.Store();
copy = fc.CreateFeature();
copy.Shape = row1.ShapeCopy;
((ITopologicalOperator)copy.Shape).Simplify();
copy.Store();
}
private IField CreateShapeField()
{
return(FieldUtils.CreateShapeField("SHAPE", ShapeType,
_spatialReference,
_gridSize, _hasZ, _hasM));
}
private static void TestTileBorder(IFeatureWorkspace ws)
{
ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true);
IFieldsEdit fieldsPoint = new FieldsClass();
fieldsPoint.AddField(FieldUtils.CreateOIDField());
fieldsPoint.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint, sr, 1000));
IFeatureClass fcPoints =
DatasetUtils.CreateSimpleFeatureClass(ws, "TileBorderPoints", fieldsPoint);
IFieldsEdit fieldsLine = new FieldsClass();
fieldsLine.AddField(FieldUtils.CreateOIDField());
fieldsLine.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, sr, 1000));
IFeatureClass fcLines =
DatasetUtils.CreateSimpleFeatureClass(ws, "TileBorderLines", fieldsLine);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
IFeature point1 = fcPoints.CreateFeature();
point1.Shape = GeometryFactory.CreatePoint(999.5, 100);
// near fLine1, but error from tile 2 ?
point1.Store();
IFeature point2 = fcPoints.CreateFeature();
point2.Shape = GeometryFactory.CreatePoint(999.5, 400);
// near fLine2, but error from tile 1 ?
point2.Store();
IFeature fLine1 = fcLines.CreateFeature();
IPolycurve l1 = CurveConstruction.StartLine(0, 10)
.LineTo(998.7, 10)
.LineTo(998.7, 200)
.Curve;
fLine1.Shape = l1;
fLine1.Store();
IFeature fLine2 = fcLines.CreateFeature();
IPolycurve l2 = CurveConstruction.StartLine(2000, 500)
.LineTo(1000.3, 500)
.LineTo(1000.3, 300)
.Curve;
fLine2.Shape = l2;
fLine2.Store();
var test = new QaPointOnLine(fcPoints, new[] { fcLines }, 1);
using (var r = new QaTestRunner(test)) // no tiling no problem
{
r.Execute();
Assert.AreEqual(0, r.Errors.Count);
}
var container = new QaContainerTestRunner(1000, test);
container.Execute(GeometryFactory.CreateEnvelope(0, 0, 2000, 500));
Assert.AreEqual(0, container.Errors.Count);
}
