private int CheckPolygonPoints(
[NotNull] IEnumerable <PolygonPoints> polygonPointsToCheck)
{
Assert.ArgumentNotNull(polygonPointsToCheck, nameof(polygonPointsToCheck));
Dictionary <int, List <PolygonPointsError> > errorsByTable =
GetErrorsByTable(polygonPointsToCheck);
int errorCount = 0;
foreach (KeyValuePair <int, List <PolygonPointsError> > pair in errorsByTable)
{
int tableIndex = pair.Key;
List <PolygonPointsError> errors = pair.Value;
var featureClass = (IFeatureClass)InvolvedTables[tableIndex];
Dictionary <int, PolygonPointsError> errorsByOid = GetErrorsByOid(errors);
const bool recycle = true;
foreach (
IFeature polygonFeature in
GdbQueryUtils.GetFeatures(featureClass, errorsByOid.Keys, recycle))
{
IGeometry errorGeometry = polygonFeature.ShapeCopy;
PolygonPointsError error = errorsByOid[polygonFeature.OID];
errorCount += ReportError(error.ErrorDescription, errorGeometry,
error.IssueCode, null,
GetInvolvedRows(polygonFeature, error));
}
}
return(errorCount);
}
private static IEnumerable <Feature> GetFeatures([CanBeNull] BasicFeatureLayer layer,
[NotNull] List <long> oids,
bool recycling = false)
{
if (layer == null)
{
yield break;
}
// TODO: Use layer search (there might habe been an issue with recycling?!)
var featureClass = layer.GetTable();
var filter = new QueryFilter
{
WhereClause =
$"{featureClass.GetDefinition().GetObjectIDField()} IN ({StringUtils.Concatenate(oids, ", ")})"
};
filter.OutputSpatialReference = layer.GetSpatialReference();
foreach (var feature in GdbQueryUtils.GetFeatures(featureClass, filter, recycling))
{
yield return(feature);
}
}
private int ExecuteGeometry([CanBeNull] IGeometry geometry)
{
if (!_canHaveNonLinearSegments)
{
return(NoError);
}
IQueryFilter filter = TestUtils.CreateFilter(geometry, AreaOfInterest,
GetConstraint(0),
(ITable)_featureClass,
null);
GdbQueryUtils.SetSubFields(filter,
_featureClass.OIDFieldName,
_featureClass.ShapeFieldName);
int errorCount = 0;
const bool recycle = true;
foreach (IFeature feature in
GdbQueryUtils.GetFeatures(_featureClass, filter, recycle))
{
errorCount += VerifyFeature(feature);
}
return(errorCount);
}
private static IDictionary <Guid, QualityConditionExceptions> ReadTargetExceptions(
[NotNull] IList <IObjectClass> targetExceptionClasses,
[NotNull] IIssueTableFields fields)
{
Assert.ArgumentNotNull(targetExceptionClasses, nameof(targetExceptionClasses));
Assert.ArgumentCondition(targetExceptionClasses.Count > 0, "no exception classes");
var result = new Dictionary <Guid, QualityConditionExceptions>();
foreach (ITable targetTable in targetExceptionClasses.Cast <ITable>())
{
var factory = new ExceptionObjectFactory(
targetTable, fields,
defaultStatus: ExceptionObjectStatus.Inactive,
includeManagedExceptionAttributes: true);
foreach (IRow row in GdbQueryUtils.GetRows(targetTable, recycle: true))
{
ExceptionObject exceptionObject = factory.CreateExceptionObject(row);
Guid qconVersionUuid = exceptionObject.QualityConditionVersionUuid;
QualityConditionExceptions exceptions;
if (!result.TryGetValue(qconVersionUuid, out exceptions))
{
exceptions = new QualityConditionExceptions(qconVersionUuid, null);
result.Add(qconVersionUuid, exceptions);
}
exceptions.Add(exceptionObject);
}
}
return(result);
}
public void CanGetNullForNonExistingFeatureByGetRow()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
Assert.Null(GdbQueryUtils.GetRow((ITable)fc, 999999999));
}
private static IEnumerable <IRow> GetReferencingRows(
[NotNull] ReferencedTableInfo referencedTableInfo,
[NotNull] ReferencingTableInfo referencingTableInfo)
{
const bool recycle = true;
const int maxKeyCount = 20;
if (referencedTableInfo.KeySet.Count <= maxKeyCount)
{
return(GdbQueryUtils.GetRowsInList(
referencingTableInfo.Table,
referencingTableInfo.ForeignKeyFieldName,
referencedTableInfo.KeySet, recycle,
referencingTableInfo.Filter));
}
var queryFilter =
new QueryFilterClass
{
WhereClause = string.Format("{0} IS NOT NULL",
referencingTableInfo.ForeignKeyFieldName)
};
return(GdbQueryUtils.GetRows(referencingTableInfo.Table, queryFilter,
recycle));
}
private IQueryFilter CreateFilter([NotNull] IFeatureClass featureClass,
[CanBeNull] string filterExpression)
{
IQueryFilter filter =
new QueryFilterClass
{
SubFields = _shapeFieldName,
WhereClause =
GetWhereClause(featureClass, filterExpression,
_dontFilterPolycurvesByZeroLength)
};
var subfields = new List <string> {
_shapeFieldName
};
if (featureClass.HasOID)
{
subfields.Add(featureClass.OIDFieldName);
}
GdbQueryUtils.SetSubFields(filter, subfields);
return(filter);
}
private int ReportErrors([NotNull] ICollection <RowErrorInfo> errorRows)
{
Assert.ArgumentNotNull(errorRows);
var oids = new List <int>(errorRows.Count);
var errorsByOid = new Dictionary <int, ErrorInfo>(errorRows.Count);
foreach (RowErrorInfo errorRow in errorRows)
{
oids.Add(errorRow.RowUrl.Oid);
errorsByOid.Add(errorRow.RowUrl.Oid, errorRow.ErrorInfo);
}
if (oids.Count == 0)
{
return(NoError);
}
var errorCount = 0;
const bool recycling = false;
foreach (IRow row in GdbQueryUtils.GetRowsByObjectIds(_table, oids, recycling))
{
errorCount += ReportError(errorsByOid[row.OID], row);
}
return(errorCount);
}
private static IEnumerable <IRow> GetJoinedRows(
[NotNull] IObject obj,
[NotNull] IList <IRelationshipClass> relationshipChainToFeatureClass)
{
string whereClause = string.Format(
"{0} = {1}",
DatasetUtils.QualifyFieldName(obj.Class, obj.Class.OIDFieldName),
obj.OID);
const IGeometry intersectedGeometry = null;
string postfixClause = null;
string subfields = null;
const bool includeOnlyOIDFields = true;
const bool recycle = false;
foreach (FieldMappingRowProxy rowProxy in GdbQueryUtils.GetRowProxys(
obj.Class,
intersectedGeometry,
whereClause,
relationshipChainToFeatureClass,
postfixClause,
subfields, includeOnlyOIDFields, recycle))
{
yield return(rowProxy.BaseRow);
}
}
private IQueryFilter GetQueryFilter([NotNull] IFeatureClass featureClass,
int tableIndex,
[CanBeNull] IGeometry geometry)
{
Assert.ArgumentNotNull(featureClass, nameof(featureClass));
string routeIdFieldName = GetRouteIdFieldName(featureClass, tableIndex);
IQueryFilter result;
if (geometry == null)
{
result = new QueryFilterClass();
}
else
{
result = new SpatialFilterClass
{
GeometryField = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects,
Geometry = geometry
};
}
result.WhereClause = GetWhereClause(tableIndex, routeIdFieldName);
GdbQueryUtils.SetSubFields(result,
featureClass.OIDFieldName,
featureClass.ShapeFieldName,
routeIdFieldName);
return(result);
}
public void CanCreateSpatialFilterWithSubResolutionPolygon()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
IPolygon subResolutionPoly = GeometryFactory.CreatePolygon(2600000, 1200000,
2600000.0001,
1200000.0001);
subResolutionPoly.SpatialReference = ((IGeoDataset)fc).SpatialReference;
IQueryFilter filter = GdbQueryUtils.CreateSpatialFilter(
fc, subResolutionPoly, esriSpatialRelEnum.esriSpatialRelIntersects, false,
null);
IFeatureCursor cursor = fc.Search(filter, true);
Marshal.ReleaseComObject(cursor);
IPolygon linearPoly = GeometryFactory.CreatePolygon(2600000, 1200000,
2600000.0001, 1200010);
linearPoly.SpatialReference = ((IGeoDataset)fc).SpatialReference;
filter = GdbQueryUtils.CreateSpatialFilter(
fc, linearPoly, esriSpatialRelEnum.esriSpatialRelIntersects, true,
null);
cursor = fc.Search(filter, true);
Marshal.ReleaseComObject(cursor);
}
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 CanGetRowsNotInUUIDList()
{
IFeatureWorkspace ws = OpenTestWorkspace();
ITable tbl = ws.OpenTable("TOPGIS_TLM.TLM_STRASSE");
var nRows = 0;
IQueryFilter filter = new QueryFilterClass();
foreach (
// ReSharper disable once UnusedVariable
IRow row in
GdbQueryUtils.GetRowsNotInList(tbl, filter, true, "UUID",
new[]
{
"{8C5517C9-B19F-4CC1-A6A1-D3DD317BCDD1}"
}))
{
nRows++;
}
filter.WhereClause = "UUID not in ('{8C5517C9-B19F-4CC1-A6A1-D3DD317BCDD1}')";
int n = tbl.RowCount(filter);
Assert.AreEqual(n, nRows, "");
}
public void Learning_CanFindFeaturesWithNonZSimpleSearchGeometry()
{
// 10.2.1: Test fails (correct) with COM Exception on OpenCursor
// 10.4.1: Test fails (correct) with COM Exception on OpenCursor
// 10.6.1: Test passes (incorrectly!), no features found
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 = DatasetUtils.GetSpatialReference(fc);
nonZSimpleEnvelope.SpatialReference = spatialReference;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.GeometryField = fc.ShapeFieldName;
spatialFilter.set_GeometryEx(nonZSimpleEnvelope, true);
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
Assert.AreEqual(0, GdbQueryUtils.GetFeatures(fc, spatialFilter, true).Count(),
"Behaviour changed: Now features are found even with non-Z-simple search geometry.");
}
public void CanGetRowsInLongList()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
// fill list
const int max = 2000;
Dictionary <int, IRow> dic = GetFirstNRows((ITable)fc, max);
var selList = new List <int>(max);
foreach (IRow row in GdbQueryUtils.GetRowsInList((ITable)fc, fc.OIDFieldName,
dic.Keys, false, null))
{
selList.Add(row.OID);
IRow origRow = dic[row.OID];
Assert.AreEqual(origRow.OID, row.OID, "");
//dic[row.OID] = null; REMARK: this changes list dic.Keys and leads to an error in foreach
}
Assert.AreEqual(dic.Count, selList.Count, "List counts differ");
var oidList = new List <int>(dic.Keys);
oidList.Sort();
selList.Sort();
for (var i = 0; i < oidList.Count; i++)
{
Assert.AreEqual(oidList[i], selList[i], "{0}th element differs", i);
}
}
public void CanGetNullForNonExistingRow()
{
IFeatureWorkspace ws = OpenTestWorkspace();
ITable table = ws.OpenTable("TOPGIS_TLM.TLM_WANDERWEG");
Assert.Null(GdbQueryUtils.GetRow(table, 999999999));
}
public void CanGetNullForNonExistingFeatureFastEnough()
{
IFeatureWorkspace ws = OpenTestWorkspace();
IFeatureClass fc = ws.OpenFeatureClass("TOPGIS_TLM.TLM_STRASSE");
const int iterations = 200;
var watch = new Stopwatch();
watch.Start();
for (var iteration = 0; iteration < iterations; iteration++)
{
int oid = 999999999 + iteration;
Assert.Null(GdbQueryUtils.GetFeature(fc, oid));
}
watch.Stop();
double msPerIteration = watch.ElapsedMilliseconds / (double)iterations;
_msg.InfoFormat(@"GetFeature() per iteration: {0} ms", msPerIteration);
const int maxMilliseconds = 35;
Assert.True(msPerIteration < maxMilliseconds,
"GetFeature with non-existing feature takes too long ({0} ms)",
msPerIteration);
}
public void CanConvertMultipatchesSpecialCasesWithInnerRings()
{
IWorkspace workspace = TestUtils.OpenSDEWorkspaceOracle();
IFeatureClass featureClass = DatasetUtils.OpenFeatureClass(
workspace, "TOPGIS_TLM.TLM_GEBAEUDE");
const int rolexLearningCenter = 321430;
const int mediamarktMuriBB = 565844;
const int hintermBahnhofGraenichen = 2269631;
IQueryFilter qf = new QueryFilterClass()
{
WhereClause = "OBJECTID IN (" +
$"{hintermBahnhofGraenichen}, " +
$"{mediamarktMuriBB}, " +
$"{rolexLearningCenter})"
};
int count = 0;
foreach (IFeature feature in GdbQueryUtils.GetFeatures(featureClass, qf, true))
{
count++;
AssertWkbSerialization(feature, false);
AssertWkbSerialization(feature, true);
}
Assert.AreEqual(3, count);
}
public void CanGetExistingRowsFastEnough()
{
IFeatureWorkspace ws = OpenTestWorkspace();
ITable fc = ws.OpenTable("TOPGIS_TLM.TLM_WANDERWEG");
const int max = 100;
IDictionary <int, IRow> rows = GetFirstNRows(fc, max);
var watch = new Stopwatch();
watch.Start();
foreach (int oid in rows.Keys)
{
Assert.NotNull(GdbQueryUtils.GetRow(fc, oid));
_msg.Info($"Oid {oid} time: {watch.ElapsedMilliseconds}");
}
watch.Stop();
double msPerIteration = watch.ElapsedMilliseconds / (double)rows.Count;
_msg.InfoFormat(@"GetRow() per iteration: {0} ms", msPerIteration);
Assert.True(msPerIteration < 50,
"GetFeature with existing feature takes too long ({0} ms, {1} rows)",
msPerIteration, rows.Count);
}
public static IGeometry GetShapeCopy([NotNull] IRow row)
{
if (row is IFeature)
{
var feature = (IFeature)row;
// TODO optimize
// - feature.Extent creates a copy (feature.Shape.QueryEnvelope() does not)
// - the feature may really have no geometry (shapefield was in subfields), in this case the additional get just makes it slow
if (feature.Extent.IsEmpty)
{
// this may be the case when the ShapeField was not queried (i.e. QueryFilter.SubFields = 'OID, Field')
if (row.HasOID && row.Table.HasOID)
{
feature =
GdbQueryUtils.GetFeature((IFeatureClass)row.Table, row.OID);
if (feature != null)
{
return(feature.ShapeCopy);
}
}
}
else
{
return(feature.ShapeCopy);
}
}
return(null);
}
private IList <IRow> GetRowsByRelatedGeometry(
[NotNull] ITable table,
[NotNull] IObjectDataset objectDataset,
[NotNull] ITest testWithTable,
[NotNull] IEnumerable <IList <IRelationshipClass> > relClassChains)
{
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(objectDataset, nameof(objectDataset));
Assert.ArgumentNotNull(testWithTable, nameof(testWithTable));
HashSet <int> oids = ReferenceGeometryUtils.GetOidsByRelatedGeometry(
table, relClassChains, Assert.NotNull(_testPerimeter), testWithTable);
// Add oids of selected rows
if (ObjectSelection != null)
{
oids.UnionWith(ObjectSelection.GetSelectedOIDs(objectDataset));
}
if (oids.Count == 0)
{
return(new List <IRow>());
}
return(new List <IRow>(GdbQueryUtils.GetRowsInList(
table, table.OIDFieldName, oids,
recycle: false)));
}
public void CanCreateQueryLayerFeatureClassForUnegisteredStGeometryTable()
{
IWorkspace workspace = TestUtils.OpenDDxWorkspaceOracle();
const string periFclass = "UNITTEST_MANAGER.TOPDD_WFL_REVISIONPERI_POLY";
const string rpView = "UNITTEST_MANAGER.V_TOPDD_WFL_REVISIONPERIMETER";
string periFK = string.Format("{0}.PERIMETER_OID", rpView);
string periPK = "OBJECTID";
string tables = string.Format("{0}, {1}", periFclass, rpView);
string joinExpression = string.Format("{0} = {1}", periFK, periPK);
string sql = $"SELECT * FROM {tables} WHERE {joinExpression}";
string queryClassName =
DatasetUtils.GetQueryLayerClassName((IFeatureWorkspace)workspace,
"TEST_CLASS");
// Unqualified Name must start with %, and it is owned by the current user:
Assert.AreEqual("UNITTEST.%TEST_CLASS", queryClassName);
double xyTolerance = 0.01;
IFeatureClass fclass = (IFeatureClass)
DatasetUtils.CreateQueryLayerClass((ISqlWorkspace)workspace, sql, queryClassName,
periPK, xyTolerance);
var filter = new SpatialFilterClass
{
Geometry =
GeometryFactory.CreateEnvelope(2600000, 1200000, 2700000, 1300000),
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
IFeatureCursor cursor = fclass.Search(filter, true);
Assert.NotNull(cursor.NextFeature());
Marshal.ReleaseComObject(cursor);
int countInBox = GdbQueryUtils.Count(fclass, filter.Geometry);
int countAll = GdbQueryUtils.Count(fclass);
Assert.AreEqual(78, countInBox);
Assert.AreEqual(260, countAll);
Assert.AreEqual(countInBox, fclass.FeatureCount(filter));
Assert.AreEqual(countAll, fclass.FeatureCount(null));
// solution found elsewhere: only spatial queries work, need to pass spatial filter with geometry
IFeatureCursor cursorWithNullFilter = fclass.Search(null, true);
IFeature feature = cursorWithNullFilter.NextFeature();
Assert.NotNull(feature);
Assert.AreEqual(xyTolerance, GeometryUtils.GetXyTolerance(feature.Shape));
Marshal.ReleaseComObject(cursorWithNullFilter);
}
public IObject GetObject([NotNull] IFeatureWorkspace workspace)
{
Assert.ArgumentNotNull(workspace, nameof(workspace));
IObjectClass objectClass = DatasetUtils.OpenObjectClass(workspace, ClassId);
return(GdbQueryUtils.GetObject(objectClass, ObjectId));
}
/// <summary>
/// Finds the features in the map by the specified criteria, grouped by feature class
/// </summary>
/// <param name="mapView">The map view containing the layers to search</param>
/// <param name="searchGeometry">The search geometry</param>
/// <param name="spatialRelationship">The spatial relationship between the found features
/// and the search geometry.</param>
/// <param name="targetSelectionType">The target selection type that determines which layers
/// are searched.</param>
/// <param name="layerPredicate">An extra layer predicate that allows for a more
/// fine-granular determination of the layers to be searched.</param>
/// <param name="featurePredicate">An extra feature predicate that allows to determine
/// criteria on the feature level.</param>
/// <param name="selectedFeatures">The selected features, relevant only for
/// <see cref="targetSelectionType"/> with value <see cref="TargetFeatureSelection.SameClass"/>. </param>
/// <param name="cancelableProgressor"></param>
/// <returns></returns>
public static IEnumerable <KeyValuePair <FeatureClass, List <Feature> > > FindFeatures(
[NotNull] MapView mapView,
[NotNull] ArcGIS.Core.Geometry.Geometry searchGeometry,
SpatialRelationship spatialRelationship,
TargetFeatureSelection targetSelectionType,
[CanBeNull] Predicate <FeatureLayer> layerPredicate,
[CanBeNull] Predicate <Feature> featurePredicate,
List <Feature> selectedFeatures,
CancelableProgressor cancelableProgressor = null)
{
// NOTE: FeatureLayer.Search is quite useless, as we cannot control recyclability and as soon as the cursor
// is disposed, the feature's geometry is wrong!
// -> Get the distinct feature classes (TODO: include layer definition queries)
IEnumerable <FeatureLayer> featureLayers =
GetLayers <FeatureLayer>(
mapView, fl => IsLayerApplicable(fl, targetSelectionType, layerPredicate,
selectedFeatures));
IEnumerable <IGrouping <IntPtr, FeatureLayer> > layersGroupedByClass =
featureLayers.GroupBy(fl => fl.GetFeatureClass().Handle);
foreach (var layersInClass in layersGroupedByClass)
{
// One query per distinct definition query, then make OIDs distinct
FeatureClass featureClass = null;
List <Feature> features = new List <Feature>();
foreach (IGrouping <string, FeatureLayer> layers in layersInClass.GroupBy(
fl => fl.DefinitionQuery))
{
if (cancelableProgressor != null &&
cancelableProgressor.CancellationToken.IsCancellationRequested)
{
yield break;
}
featureClass = layers.First().GetFeatureClass();
QueryFilter filter =
GdbQueryUtils.CreateSpatialFilter(searchGeometry, spatialRelationship);
filter.WhereClause = layers.Key;
IEnumerable <Feature> foundFeatures = GdbQueryUtils
.GetFeatures(featureClass, filter, false)
.Where(f => featurePredicate == null ||
featurePredicate(f));
features.AddRange(foundFeatures);
}
if (featureClass != null && features.Count > 0)
{
yield return(new KeyValuePair <FeatureClass, List <Feature> >(
featureClass, features.DistinctBy(f => f.GetObjectID()).ToList()));
}
}
}
public void CanGetRasterFileFromMosaicDatasetUsingSpatialQuery()
{
IWorkspace workspace = TestUtils.OpenUserWorkspaceOracle();
IMosaicDataset mosaicDataset = DatasetUtils.OpenMosaicDataset(workspace,
"TOPGIS_TLM.TLM_DTM_MOSAIC");
IFeatureClass rasterCatalog = mosaicDataset.Catalog;
IEnvelope winterthur = GeometryFactory.CreateEnvelope(
2690000, 1254000, 2707500, 1266000,
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95));
winterthur.Expand(-0.1, -0.1, false);
IQueryFilter spatialFilter =
GdbQueryUtils.CreateSpatialFilter(rasterCatalog, winterthur);
IStringArray stringArray;
Stopwatch watch = Stopwatch.StartNew();
int count = 0;
foreach (IFeature catalogFeature in GdbQueryUtils.GetFeatures(
rasterCatalog, spatialFilter, false))
{
// Method 1 (slow):
var rasterCatalogItem = (IRasterCatalogItem)catalogFeature;
IRasterDataset rasterDataset = rasterCatalogItem.RasterDataset;
var itemPaths = (IItemPaths)rasterDataset;
stringArray = itemPaths.GetPaths();
Marshal.ReleaseComObject(rasterDataset);
Assert.AreEqual(1, stringArray.Count);
string resultPathViaRasterDataset = stringArray.Element[0];
// Method 2 (fast):
var itemPathsQuery = (IItemPathsQuery)mosaicDataset;
if (itemPathsQuery.QueryPathsParameters == null)
{
itemPathsQuery.QueryPathsParameters = new QueryPathsParametersClass();
}
stringArray = itemPathsQuery.GetItemPaths(catalogFeature);
Assert.AreEqual(1, stringArray.Count);
string resultPathViaItemPathsQuery = stringArray.Element[0];
Assert.AreEqual(resultPathViaRasterDataset, resultPathViaItemPathsQuery);
count++;
}
Console.WriteLine("Successfully extracted {0} raster paths in {1}s", count,
watch.Elapsed.TotalSeconds);
}
public void Measure_performance_query_items_from_GDB()
{
Polygon polygon = PolygonConstruction
.StartPolygon(0, 0)
.LineTo(0, 20)
.LineTo(20, 20)
.LineTo(20, 0)
.ClosePolygon();
Polygon areaOfInterest = PolygonConstruction
.StartPolygon(0, 0)
.LineTo(0, 100)
.LineTo(100, 100)
.LineTo(100, 0)
.ClosePolygon();
var rowCount = 10000;
TestUtils.InsertRows(_emptyIssuesGdb, _featureClassName, polygon, rowCount);
try
{
var uri = new Uri(_emptyIssuesGdb, UriKind.Absolute);
var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri));
var table = geodatabase.OpenDataset <Table>(_featureClassName);
Dictionary <Geodatabase, List <Table> > tablesByGeodatabase = new Dictionary <Geodatabase, List <Table> >
{
{ geodatabase, new List <Table> {
table
} }
};
IRepository stateRepository = new XmlWorkItemStateRepository(@"C:\temp\states.xml", null, null);
IWorkItemRepository repository = new IssueItemRepository(tablesByGeodatabase, stateRepository);
IWorkList workList = new GdbQueryWorkList(repository, "work list");
workList.AreaOfInterest = areaOfInterest;
var filter = GdbQueryUtils.CreateSpatialFilter(areaOfInterest);
var watch = new Stopwatch();
watch.Start();
IEnumerable <IWorkItem> items = workList.GetItems(filter);
watch.Stop();
Console.WriteLine($"{watch.ElapsedMilliseconds} ms");
Assert.AreEqual(rowCount, items.Count());
}
finally
{
TestUtils.DeleteAllRows(_emptyIssuesGdb, _featureClassName);
}
}
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));
}
public IObject GetObject([NotNull] IFeatureWorkspace workspace)
{
Assert.ArgumentNotNull(workspace, nameof(workspace));
IObjectClass objectClass = DatasetUtils.OpenObjectClass(workspace,
RelationshipClassId);
// TODO consider using ITable.GetRow(oid) and handling exception if not found
// faster?
return(GdbQueryUtils.GetObject(objectClass, ObjectId));
}
private static IQueryFilter GetQueryFilter([NotNull] IEnumerable <string> keyFields,
[CanBeNull] string whereClause)
{
var result = new QueryFilterClass {
WhereClause = whereClause
};
GdbQueryUtils.SetSubFields(result, keyFields);
return(result);
}
private static IEnumerable <IGeometry> GetReferenceGeometries(
[NotNull] IObject obj,
[NotNull] IList <IRelationshipClass> relationshipChainToFeatureClass)
{
if (relationshipChainToFeatureClass.Count == 0)
{
yield break;
}
if (relationshipChainToFeatureClass.Count == 1)
{
foreach (IObject relatedObject in
GdbQueryUtils.GetRelatedObjects(obj, relationshipChainToFeatureClass))
{
var relatedFeature = relatedObject as IFeature;
if (relatedFeature != null)
{
yield return(relatedFeature.Shape);
}
else
{
_msg.DebugFormat("Related object in spatial relation is not a feature: {0}",
GdbObjectUtils.ToString(relatedObject));
}
}
}
else
{
int?shapeFieldIndex = null;
foreach (IRow joinedRow in GetJoinedRows(obj, relationshipChainToFeatureClass))
{
// determine shape field index based on the first row
if (shapeFieldIndex == null)
{
int index;
if (TryGetShapeFieldIndex(joinedRow.Fields, out index))
{
shapeFieldIndex = index;
}
else
{
_msg.WarnFormat(
"Shape field not found in joined table for getting reference geometry for {0}",
DatasetUtils.GetName(obj.Class));
yield break;
}
}
yield return(joinedRow.Value[shapeFieldIndex.Value] as IGeometry);
}
}
}
