async public Task <IFeature> NextFeature()
{
try
{
if (_cursor == null)
{
if (index >= _keys.Count)
{
return(null);
}
T key = _keys[index++];
_cursor = await _fcs[key].GetFeatures(_filters[key]);
if (_cursor == null)
{
return(await NextFeature());
}
}
IFeature feature = await _cursor.NextFeature();
if (feature == null)
{
_cursor.Dispose();
_cursor = null;
return(await NextFeature());
}
if (_fcs.ContainsKey(_keys[index - 1]))
{
var fc = _fcs[_keys[index - 1]];
if (fc != null)
{
feature.Fields.Add(new FieldValue("_classname", fc.Name));
}
}
if (_additionalFields != null)
{
var fcDictionary = _additionalFields[_keys[index - 1]];
if (fcDictionary != null && fcDictionary.ContainsKey(feature.OID) && fcDictionary[feature.OID] != null)
{
var fields = fcDictionary[feature.OID];
foreach (var fieldValue in fields)
{
feature.Fields.Add(fieldValue);
}
}
}
return(feature);
}
catch
{
return(null);
}
}
async public Task <IFeature> NextFeature()
{
if (_edgeCursor == null && _edgeFcs != null && _edgeFcIndex < _edgeFcs.Count)
{
IFeatureClass fc = _edgeFcs[_edgeFcIndex++];
_fcid = await _fdb.FeatureClassID(await _fdb.DatasetID(fc.Dataset.DatasetName), fc.Name);
if (_fcid < 0)
{
return(await NextFeature());
}
if (fc.Name == _networkName + "_ComplexEdges")
{
_fcid = -1;
}
IQueryFilter f = (IQueryFilter)_filter.Clone();
if (f.SubFields != "*")
{
f.AddField(fc.IDFieldName);
f.AddField(fc.ShapeFieldName);
}
_edgeCursor = await fc.GetFeatures(f);
if (_edgeCursor == null)
{
return(await NextFeature());
}
}
if (_edgeCursor != null)
{
IFeature feature = await _edgeCursor.NextFeature();
if (feature != null)
{
feature.Fields.Add(new FieldValue("NETWORK#FCID", _fcid));
return(feature);
}
_edgeCursor.Dispose();
_edgeCursor = null;
return(await NextFeature());
}
if (_nodeCursor == null && _nodeFc != null)
{
_nodeCursor = await _nodeFc.GetFeatures(_filter);
}
if (_nodeCursor != null)
{
return(await _nodeCursor.NextFeature());
}
return(null);
}
async private Task <bool> CopyFeatures2(IFeatureClass source, IFeatureUpdater fdb, IFeatureClass dest, FieldTranslation fTrans, BinaryTree2Builder treeBuilder)
{
List <BinaryTree2BuilderNode> nodes;
if (treeBuilder == null || (nodes = treeBuilder.Nodes) == null)
{
_errMsg = "Spatial Index is not defined...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Copy Features (" + dest.Name + ")");
}
int featcounter = 0;
foreach (BinaryTree2BuilderNode node in nodes)
{
if (!_cancelTracker.Continue)
{
break;
}
RowIDFilter filter = new RowIDFilter(source.IDFieldName);
filter.IDs = node.OIDs;
filter.SubFields = "*";
using (IFeatureCursor fCursor = await source.GetFeatures(filter))
{
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(false);
}
int copycounter = await CopyFeatures(fCursor, node.Number, fdb, dest, fTrans, featcounter);
if (copycounter < 0)
{
fCursor.Dispose();
return(false);
}
featcounter = copycounter;
fCursor.Dispose();
}
}
if (ReportProgress != null)
{
ReportProgress(this, featcounter);
}
return(true);
}
public ISelectionSet Select(IQueryFilter filter)
{
filter.SubFields = this.IDFieldName;
filter.AddField("FDB_OID");
filter.AddField("FDB_SHAPE");
IFeatureCursor cursor = (IFeatureCursor)_fdb.Query(this, filter);
IFeature feat;
SpatialIndexedIDSelectionSet selSet = new SpatialIndexedIDSelectionSet(this.Envelope);
while ((feat = cursor.NextFeature) != null)
{
int nid = 0;
foreach (FieldValue fv in feat.Fields)
{
//if (fv.Name == "FDB_NID")
//{
// nid = (int)fv.Value;
// break;
//}
}
selSet.AddID(feat.OID, feat.Shape);
}
cursor.Dispose();
return(selSet);
}
async public Task <ISelectionSet> Select(IQueryFilter filter)
{
filter.SubFields = this.IDFieldName;
filter.AddField("FDB_SHAPE");
filter.AddField("FDB_OID");
IFeatureCursor cursor = await _fdb.Query(this, filter);
IFeature feat;
SpatialIndexedIDSelectionSet selSet = new SpatialIndexedIDSelectionSet(this.Envelope);
while ((feat = await cursor.NextFeature()) != null)
{
//long nid = 0;
foreach (FieldValue fv in feat.Fields)
{
//if (fv.Name == "FDB_NID")
//{
// nid = Convert.ToInt64(fv.Value);
// break;
//}
}
selSet.AddID(feat.OID, feat.Shape);
}
cursor.Dispose();
return(selSet);
}
public gView.Framework.Data.ISelectionSet Select(gView.Framework.Data.IQueryFilter filter)
{
if (filter is IBufferQueryFilter)
{
ISpatialFilter sFilter = BufferQueryFilter.ConvertToSpatialFilter(filter as IBufferQueryFilter);
if (sFilter == null)
{
return(null);
}
return(Select(sFilter));
}
filter.SubFields = this.IDFieldName;
IFeatureCursor cursor = (IFeatureCursor)(new ShapeFeatureCursor(this, _file, filter, _tree));
IFeature feat;
IDSelectionSet selSet = new IDSelectionSet();
while ((feat = cursor.NextFeature) != null)
{
selSet.AddID((int)((uint)feat.OID));
}
cursor.Dispose();
return(selSet);
}
async public Task <IFeature> GetFeature(string filename)
{
IFeatureCursor cursor = null;
try
{
if (_fc == null)
{
return(null);
}
QueryFilter filter = new QueryFilter();
filter.AddField("*");
filter.WhereClause = "PATH='" + filename + "'";
cursor = await _fc.Search(filter) as IFeatureCursor;
if (cursor == null)
{
return(null);
}
return(await cursor.NextFeature());
}
catch
{
return(null);
}
finally
{
if (cursor != null)
{
cursor.Dispose();
}
}
}
private void treeObjects_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is RelationTreeNode)
{
IFeatureCursor cursor = null;
RelationTreeNode rtn = (RelationTreeNode)e.Node;
try
{
rtn.Nodes.Clear();
FeatureTreeNode ftn = (FeatureTreeNode)rtn.Parent;
ITableRelation relation = rtn.TableRelation;
ILayer target = null;
if (relation.LeftTable == ftn.Layer && ftn.Feature[relation.LeftTableField] != null)
{
target = relation.RightTable as ILayer;
cursor = relation.GetRightRows(TargetFields(target), ftn.Feature[relation.LeftTableField]) as IFeatureCursor;
}
else if (relation.RightTable == ftn.Layer)
{
target = relation.LeftTable as ILayer;
cursor = relation.GetLeftRows(TargetFields(target), ftn.Feature[relation.RightTableField]) as IFeatureCursor;
}
if (cursor == null || target == null)
{
return;
}
string primaryDisplayField = String.Empty;
if (target is IFeatureLayer && ((IFeatureLayer)target).Fields.PrimaryDisplayField != null)
{
primaryDisplayField = ((IFeatureLayer)target).Fields.PrimaryDisplayField.name;
}
IFeature feature = null;
while ((feature = cursor.NextFeature) != null)
{
rtn.Nodes.Add(new FeatureTreeNode(_doc, feature,
_doc.FocusMap.Display.SpatialReference,
target,
(target is IFeatureLayer ? ((IFeatureLayer)target).Fields.PrimaryDisplayField.name : String.Empty),
1));
}
}
finally
{
if (cursor != null)
{
cursor.Dispose();
}
if (rtn.Nodes.Count == 0)
{
rtn.Nodes.Add(new TreeNode());
rtn.Collapse();
}
}
}
}
private bool CopyFeatures(IFeatureClass source, IFeatureUpdater fdb, IFeatureClass dest, FieldTranslation fTrans, DualTree tree)
{
if (tree == null || tree.Nodes == null)
{
_errMsg = "Spatial Index is not defined...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Copy Features (" + dest.Name + ")");
}
int featcounter = 0;
foreach (SpatialIndexNode node in tree.Nodes)
{
if (!_cancelTracker.Continue)
{
break;
}
RowIDFilter filter = new RowIDFilter(source.IDFieldName);
filter.IDs = node.IDs;
filter.SubFields = "*";
using (IFeatureCursor fCursor = source.GetFeatures(filter))
{
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(false);
}
if (!CopyFeatures(fCursor, node.NID, fdb, dest, fTrans, ref featcounter))
{
fCursor.Dispose();
return(false);
}
fCursor.Dispose();
}
}
if (ReportProgress != null)
{
ReportProgress(this, featcounter);
}
return(true);
}
public void Dispose()
{
if (_cursor != null)
{
_cursor.Dispose();
}
_cursor = null;
}
public void Dispose()
{
if (_cursor != null)
{
_cursor.Dispose();
_cursor = null;
}
foreach (IFeatureLayerJoin join in _joins)
{
join.Dispose();
}
}
public void Dispose()
{
if (_edgeCursor != null)
{
_edgeCursor.Dispose();
_edgeCursor = null;
}
if (_nodeCursor != null)
{
_nodeCursor.Dispose();
_nodeCursor = null;
}
}
public void Dispose()
{
if (_cursor != null)
{
_cursor.Dispose();
_cursor = null;
if (!_released)
{
FeatureCache.RemoveFeatureCollection(_cfCollection);
}
}
}
public override bool Exexute()
{
IFeatureCursor cursor = inFeatureClass.Update();
IFeature feature;
while (null != (feature = cursor.NextFeature()))
{
string guid = Guid.NewGuid().ToString();
feature.SetValue(fieldName, guid);
feature.Store();
}
cursor.Flush();
cursor.Dispose();
Output = inFeatureClass;
return(Output != null);
}
async public Task <IFeature> GetEdgeFeature(int eid)
{
RowIDFilter filter = new RowIDFilter(String.Empty);
filter.IDs.Add(eid);
filter.AddField("*");
IFeatureCursor cursor = await GetEdgeFeatures(filter);
if (cursor == null)
{
return(null);
}
IFeature feature = await cursor.NextFeature();
cursor.Dispose();
if (feature != null && feature.FindField("FCID") != null && feature.FindField("OID") != null &&
_edgeFcs.ContainsKey((int)feature["FCID"]))
{
IGraphEdge edge = _pageManager.GetEdge(eid);
try
{
if (edge != null && edge.FcId == -1) // Complex Edge
{
filter = new RowIDFilter("FDB_OID");
filter.IDs.Add((int)feature["OID"]);
filter.AddField("*");
IFeatureClass fc = _edgeFcs[(int)feature["FCID"]];
using (IFeatureCursor c = await fc.GetFeatures(filter))
{
return(await c.NextFeature());
}
}
}
catch { }
}
return(feature);
}
public ISelectionSet Select(IQueryFilter filter)
{
filter.SubFields = this.IDFieldName;
IFeatureCursor cursor = this.GetFeatures(filter);
if (cursor == null)
{
return(null);
}
IFeature feat;
IDSelectionSet selSet = new IDSelectionSet();
while ((feat = cursor.NextFeature) != null)
{
selSet.AddID((int)((uint)feat.OID));
}
cursor.Dispose();
return(selSet);
}
public IFeature this[string filename]
{
get
{
IFeatureCursor cursor = null;
try
{
if (_fc == null)
{
return(null);
}
QueryFilter filter = new QueryFilter();
filter.AddField("*");
filter.WhereClause = "\"PATH\"='" + filename + "'";
cursor = _fc.Search(filter) as IFeatureCursor;
if (cursor == null)
{
return(null);
}
return(cursor.NextFeature);
}
catch
{
return(null);
}
finally
{
if (cursor != null)
{
cursor.Dispose();
}
}
}
}
private void worker_DoWork(object sender, DoWorkEventArgs e)
{
if (!(e.Argument is IFeatureCursor))
{
return;
}
_cursor = (IFeatureCursor)e.Argument;
IFeature row;
while ((row = _cursor.NextFeature) != null)
{
row.CaseSensitivFieldnameMatching = false; // sollte auch pgSQL funktionieren
string[] items = { row["PATH"].ToString(),
row["MANAGED"].ToString() };
ListViewItem item = new ListViewItem(items);
try
{
FileInfo fi = new FileInfo(items[0]);
if (fi.Exists)
{
DateTime t = (DateTime)row["LAST_MODIFIED"];
int span = (int)Math.Abs(((TimeSpan)(fi.LastWriteTimeUtc - t)).TotalSeconds);
try
{
FileInfo fi2 = new FileInfo(row["PATH2"].ToString());
if (fi2.Exists)
{
t = (DateTime)row["LAST_MODIFIED2"];
span = Math.Max((int)Math.Abs(((TimeSpan)(fi2.LastWriteTimeUtc - t)).TotalSeconds), span);
}
}
catch { }
if (span < 1)
{
item.ImageIndex = 0;
}
else
{
item.ImageIndex = 1;
}
}
else
{
item.ImageIndex = 3;
}
}
catch
{
item.ImageIndex = 3;
}
AddListItemCached(item);
if (_cancelWorker)
{
break;
}
}
AddListItems(_itemCollection);
_itemCollection.Clear();
SetStatusLabel1Text(listView.Items.Count + " Items...");
_cursor.Dispose();
_cursor = null;
}
private bool InsertImage(IFeatureUpdater fdb, IFeatureClass rasterFC, FileInfo fi, Dictionary <string, Guid> providers)
{
if (!_cancelTracker.Continue)
{
_errMsg = "Canceled by user...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Insert Image: " + fi.FullName);
}
if (ReportProgress != null)
{
ReportProgress(this, 1);
}
System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Jpeg;
switch (fi.Extension.ToLower())
{
case ".png":
format = System.Drawing.Imaging.ImageFormat.Png;
break;
case ".tif":
case ".tiff":
format = System.Drawing.Imaging.ImageFormat.Tiff;
break;
}
#region RasterFileDataset bestimmen
List <IRasterFileDataset> rFileDatasets = new List <IRasterFileDataset>();
IRasterFileDataset rFileDataset = null;
IRasterLayer rasterLayer = null;
PlugInManager compMan = new PlugInManager();
foreach (XmlNode ds in compMan.GetPluginNodes(Plugins.Type.IDataset))
{
IRasterFileDataset rds = compMan.CreateInstance(ds) as IRasterFileDataset;
if (rds == null)
{
continue;
}
if (rds.SupportsFormat(fi.Extension) < 0)
{
continue;
}
if (providers != null && providers.ContainsKey(fi.Extension.ToLower()))
{
if (!providers[fi.Extension.ToLower()].Equals(PlugInManager.PlugInID(rds)))
{
continue;
}
}
rFileDatasets.Add(rds);
}
if (rFileDatasets.Count == 0)
{
_errMsg = "No Rasterfile Provider for " + fi.Extension;
return(false);
}
// RasterFileDataset nach priorität sortieren
rFileDatasets.Sort(new RasterFileDatasetComparer(fi.Extension));
// RasterFileDataset suchen, mit dem sich Bild öffnen läßt
foreach (IRasterFileDataset rfd in rFileDatasets)
{
rfd.AddRasterFile(fi.FullName);
if (rfd.Elements.Count == 0)
{
//Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster File...");
continue;
}
IDatasetElement element = rfd.Elements[0];
if (!(element is IRasterLayer))
{
//Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
rFileDataset.Dispose();
continue;
}
// gefunden...
rasterLayer = (IRasterLayer)element;
rFileDataset = rfd;
break;
}
if (rasterLayer == null || rFileDataset == null)
{
Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
return(false);
}
#endregion
FileInfo fiWorld = null;
double cellX = 1;
double cellY = 1;
IRasterFile rasterFile = null;
if (rasterLayer is IRasterFile)
{
rasterFile = (IRasterFile)rasterLayer;
}
if (rasterLayer.RasterClass != null)
{
if (rasterLayer.RasterClass is IRasterFile &&
((IRasterFile)rasterLayer.RasterClass).WorldFile != null)
{
rasterFile = (IRasterFile)rasterLayer.RasterClass;
}
else
{
IRasterClass c = (IRasterClass)rasterLayer.RasterClass;
cellX = Math.Sqrt(c.dx1 * c.dx1 + c.dx2 * c.dx2);
cellY = Math.Sqrt(c.dy1 * c.dy1 + c.dy2 * c.dy2);
}
}
if (rasterFile != null)
{
try
{
IRasterWorldFile world = rasterFile.WorldFile;
if (world != null)
{
if (!world.isGeoReferenced)
{
if (handleNonGeorefAsError)
{
_errMsg = "Can't add non georeferenced images: " + fi.FullName;
return(false);
}
else
{
return(true);
}
}
cellX = Math.Sqrt(world.dx_X * world.dx_X + world.dx_Y * world.dx_Y);
cellY = Math.Sqrt(world.dy_X * world.dy_X + world.dy_Y * world.dy_Y);
fiWorld = new FileInfo(rasterFile.WorldFile.Filename);
if (!fiWorld.Exists)
{
fiWorld = null;
}
}
}
catch
{
fiWorld = null;
}
}
#region Check if already Exits
//
// Suchen, ob Image mit gleichen Pfad schon vorhanden ist, wenn ja
// nur weitermachen, wenn sich das änderungsdatum unterscheidet...
//
QueryFilter filter = new QueryFilter();
filter.AddField("FDB_OID");
filter.AddField("PATH");
filter.AddField("LAST_MODIFIED");
filter.AddField("PATH2");
filter.AddField("LAST_MODIFIED2");
string fullName = fi.FullName.Replace(@"\", @"\\");
if (_fdb is AccessFDB)
{
filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fullName + "'";
}
else
{
filter.WhereClause = "PATH='" + fullName + "'";
}
int deleteOID = -1;
using (IFeatureCursor cursor = rasterFC.GetFeatures(filter))
{
IFeature existingFeature = cursor.NextFeature;
if (existingFeature != null)
{
DateTime dt1 = (DateTime)existingFeature["LAST_MODIFIED"];
if (Math.Abs(((TimeSpan)(dt1 - fi.LastWriteTimeUtc)).TotalSeconds) > 1.0)
{
deleteOID = existingFeature.OID;
}
else if (fiWorld != null &&
existingFeature["PATH2"] != System.DBNull.Value &&
existingFeature["PATH2"].ToString() != String.Empty)
{
DateTime dt2 = (DateTime)existingFeature["LAST_MODIFIED2"];
if (existingFeature["PATH2"].ToString().ToLower() != fiWorld.FullName.ToLower() ||
Math.Abs(((TimeSpan)(dt2 - fiWorld.LastWriteTimeUtc)).TotalSeconds) > 1.0)
{
deleteOID = existingFeature.OID;
}
}
if (deleteOID == -1)
{
Console.Write(".");
//Console.WriteLine(fi.FullName + " already exists...");
return(true);
}
}
}
if (deleteOID != -1)
{
if (!fdb.Delete(rasterFC, deleteOID))
{
Console.WriteLine(_errMsg = "Can't delete old record " + fi.FullName + "\n" + fdb.lastErrorMsg);
return(false);
}
}
//
///////////////////////////////////////////////////////////////////
//
#endregion
Feature feature = new Feature();
feature.Shape = rasterLayer.RasterClass.Polygon;
feature.Fields.Add(new FieldValue("PATH", fi.FullName));
feature.Fields.Add(new FieldValue("LAST_MODIFIED", fi.LastWriteTimeUtc));
if (fiWorld != null)
{
feature.Fields.Add(new FieldValue("PATH2", fiWorld.FullName));
feature.Fields.Add(new FieldValue("LAST_MODIFIED2", fiWorld.LastWriteTimeUtc));
}
else
{
feature.Fields.Add(new FieldValue("PATH2", ""));
}
feature.Fields.Add(new FieldValue("RF_PROVIDER", PlugInManager.PlugInID(rFileDataset).ToString()));
feature.Fields.Add(new FieldValue("MANAGED", _managed && (rasterLayer is IBitmap)));
feature.Fields.Add(new FieldValue("FORMAT", fi.Extension.Replace(".", "")));
feature.Fields.Add(new FieldValue("CELLX", cellX));
feature.Fields.Add(new FieldValue("CELLY", cellY));
feature.Fields.Add(new FieldValue("LEVELS", (_managed) ? Math.Max(_levels, 1) : 0));
if (!fdb.Insert(rasterFC, feature))
{
Console.WriteLine("\nERROR@" + fi.FullName + ": " + fdb.lastErrorMsg);
}
else
{
if (_managed && (rasterLayer is IBitmap) && (fdb is SqlFDB))
{
QueryFilter qfilter = new QueryFilter();
qfilter.SubFields = "FDB_OID";
if (_fdb is AccessFDB)
{
filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fi.FullName + "'";
}
else
{
qfilter.WhereClause = "PATH='" + fi.FullName + "'";
}
IFeatureCursor cursor = ((SqlFDB)fdb).Query(rasterFC, qfilter);
if (cursor != null)
{
IFeature feat = cursor.NextFeature;
if (feat != null)
{
InsertImageDatasetBitmap(feat.OID, rasterLayer, _levels, format);
}
cursor.Dispose();
}
}
Console.WriteLine(">" + fi.FullName + " added...");
}
rFileDataset.Dispose();
return(true);
}
async public Task Render()
{
if (_layer == null)
{
return;
}
if (_layer.SelectionRenderer == null)
{
return;
}
if (!(_layer is IFeatureSelection))
{
return;
}
IFeatureClass fClass = _layer.FeatureClass;
if (fClass == null)
{
return;
}
ISelectionSet selectionSet = ((IFeatureSelection)_layer).SelectionSet;
if (selectionSet == null)
{
return;
}
IDataset dataset = _map[_layer];
if (dataset == null)
{
return;
}
if (!(dataset is IFeatureDataset))
{
return;
}
IGeometry filterGeom = _map.Display.Envelope;
if (_map.Display.GeometricTransformer != null)
{
filterGeom = MapHelper.Project(fClass, _map.Display);
//filterGeom = (IGeometry)_map.Display.GeometricTransformer.InvTransform2D(filterGeom);
}
IQueryFilter filter = null;
//List<int> IDs=new List<int>(); // Sollte nicht null sein...
if (selectionSet is ISpatialIndexedIDSelectionSet)
{
List <int> IDs = ((ISpatialIndexedIDSelectionSet)selectionSet).IDsInEnvelope(filterGeom.Envelope);
filter = new RowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IIDSelectionSet)
{
List <int> IDs = ((IIDSelectionSet)selectionSet).IDs;
filter = new RowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is ISpatialIndexedGlobalIDSelectionSet)
{
List <long> IDs = ((ISpatialIndexedGlobalIDSelectionSet)selectionSet).IDsInEnvelope(filterGeom.Envelope);
filter = new GlobalRowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IGlobalIDSelectionSet)
{
List <long> IDs = ((IGlobalIDSelectionSet)selectionSet).IDs;
filter = new GlobalRowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IQueryFilteredSelectionSet)
{
filter = ((IQueryFilteredSelectionSet)selectionSet).QueryFilter.Clone() as IQueryFilter;
}
if (filter == null)
{
return;
}
filter.AddField(fClass.ShapeFieldName);
#region Clone Layer
IFeatureRenderer selectionRenderer = null;
lock (lockThis)
{
// Beim Clonen sprerren...
// Da sonst bei der Servicemap bei gleichzeitigen Requests
// Exception "Objekt wird bereits an anderer Stelle verwendet" auftreten kann!
selectionRenderer = (IFeatureRenderer)_layer.SelectionRenderer.Clone(new CloneOptions(_map,
false,
maxLabelRefscaleFactor: _layer.MaxRefScaleFactor));
}
#endregion
selectionRenderer.PrepareQueryFilter(_layer, filter);
using (IFeatureCursor fCursor = (fClass is ISelectionCache) ? ((ISelectionCache)fClass).GetSelectedFeatures(_map.Display) : await fClass.GetFeatures(filter))
{
if (fCursor != null)
{
//_layer.SelectionRenderer.Draw(_map, fCursor, DrawPhase.Geography, _cancelTracker);
IFeature feature;
while ((feature = await fCursor.NextFeature()) != null)
{
if (_cancelTracker != null)
{
if (!_cancelTracker.Continue)
{
break;
}
}
selectionRenderer.Draw(_map, feature);
}
fCursor.Dispose();
}
}
}
async private Task <BinaryTree2Builder> SpatialIndex2(IFeatureDatabase fdb, IFeatureClass fc, ISpatialIndexDef def, List <IQueryFilter> filters)
{
if (fc == null)
{
return(null);
}
IEnvelope bounds = null;
if (fc.Envelope != null)
{
bounds = fc.Envelope;
}
else if (fc.Dataset is IFeatureDataset && await((IFeatureDataset)fc.Dataset).Envelope() != null)
{
bounds = await((IFeatureDataset)fc.Dataset).Envelope();
}
if (bounds == null)
{
return(null);
}
if (_transformer != null)
{
IGeometry transBounds = _transformer.Transform2D(bounds) as IGeometry;
if (transBounds != null)
{
bounds = transBounds.Envelope;
}
}
int maxAllowedLevel = ((fdb is SqlFDB) ? 62 : 30);
BinaryTree2Builder treeBuilder =
((Envelope.IsNull(def.SpatialIndexBounds)) ?
new BinaryTree2Builder(bounds,
((def.Levels != 0) ? def.Levels : maxAllowedLevel),
((def.MaxPerNode != 0) ? def.MaxPerNode : 500),
((def.SplitRatio != 0.0) ? def.SplitRatio : 0.55)) :
new BinaryTree2Builder2(def.SpatialIndexBounds, def.Levels, def.MaxPerNode, def.SplitRatio));
if (filters == null)
{
QueryFilter filter = new QueryFilter();
filter.AddField(fc.ShapeFieldName);
filters = new List <IQueryFilter>();
filters.Add(filter);
}
foreach (IQueryFilter filter in filters)
{
using (IFeatureCursor fCursor = await fc.GetFeatures(filter))
{
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(null);
}
if (ReportAction != null)
{
ReportAction(this, "Calculate spatial index");
}
IEnvelope fcEnvelope = bounds;
if (_transformer != null)
{
IGeometry geom = _transformer.Transform2D(fcEnvelope) as IGeometry;
if (geom == null)
{
_errMsg = "SpatialIndex: Can't project featureclass extent!";
return(null);
}
fcEnvelope = geom.Envelope;
}
//treeBuilder = new BinaryTree2Builder(fcEnvelope, maxLevels, maxPerNode);
int counter = 0;
IFeature feat;
while ((feat = await fCursor.NextFeature()) != null)
{
if (!_cancelTracker.Continue)
{
break;
}
IGeometry shape = feat.Shape;
if (_transformer != null)
{
shape = _transformer.Transform2D(shape) as IGeometry;
}
feat.Shape = shape;
treeBuilder.AddFeature(feat);
if ((counter % 1000) == 0 && ReportProgress != null)
{
ReportProgress(this, counter);
}
counter++;
}
fCursor.Dispose();
}
}
treeBuilder.Trim();
return(treeBuilder);
}
async private Task <DualTree> SpatialIndex(IFeatureClass fc, int maxPerNode, List <IQueryFilter> filters)
{
if (fc == null || fc.Envelope == null)
{
return(null);
}
if (filters == null)
{
QueryFilter filter = new QueryFilter();
filter.AddField(fc.ShapeFieldName);
filters = new List <IQueryFilter>();
filters.Add(filter);
}
DualTree dualTree = new DualTree(maxPerNode);
foreach (IQueryFilter filter in filters)
{
IFeatureCursor fCursor = await fc.GetFeatures(filter);
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(null);
}
if (ReportAction != null)
{
ReportAction(this, "Calculate spatial index");
}
IEnvelope fcEnvelope = fc.Envelope;
if (_transformer != null)
{
IGeometry geom = _transformer.Transform2D(fcEnvelope) as IGeometry;
if (geom == null)
{
_errMsg = "SpatialIndex: Can't project featureclass extent!";
return(null);
}
fcEnvelope = geom.Envelope;
}
dualTree.CreateTree(fcEnvelope); // hier projezieren
int counter = 0;
IFeature feat;
while ((feat = await fCursor.NextFeature()) != null)
{
if (!_cancelTracker.Continue)
{
break;
}
SHPObject shpObj;
IGeometry shape = feat.Shape;
if (_transformer != null)
{
shape = _transformer.Transform2D(shape) as IGeometry;
}
if (shape != null)
{
shpObj = new SHPObject((int)((uint)feat.OID), shape.Envelope);
}
else
{
shpObj = new SHPObject((int)((uint)feat.OID), null);
}
dualTree.AddShape(shpObj);
if ((counter % 1000) == 0 && ReportProgress != null)
{
ReportProgress(this, counter);
}
counter++;
}
dualTree.FinishIt();
fCursor.Dispose();
if (ReportProgress != null)
{
ReportProgress(this, counter);
}
}
return(dualTree);
}
