override public List <IActivityData> Process()
{
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
IFeatureClass tFc = base.CreateTargetFeatureclass(sFc, sFc.Fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
ReportProgess("Query Filter: " + SourceData.FilterClause);
using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
{
IFeature feature;
List <IFeature> features = new List <IFeature>();
ReportProgess("Read/Write Features...");
while ((feature = cursor.NextFeature) != null)
{
features.Add(feature);
Report.featurePos++;
if (!CancelTracker.Continue)
{
break;
}
if (features.Count > 100)
{
ReportProgess();
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
features.Clear();
}
}
if (features.Count > 0)
{
ReportProgess();
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}
}
protected IFeatureClass CreateTargetFeatureclass(IGeometryDef geomDef, IFields fields)
{
IFeatureClass sFc = SourceFeatureClass;
BinaryTreeDef sDef = null;
if (sFc.Dataset != null && sFc.Dataset.Database is AccessFDB)
{
AccessFDB sFdb = (AccessFDB)sFc.Dataset.Database;
sDef = sFdb.BinaryTreeDef(sFc.Name);
}
TargetDatasetElement e = this.TargetDatasetElement;
IDataset ds = this.TargetDataset;
IFeatureDatabase db = this.TargetFeatureDatabase;
if (db.CreateFeatureClass(ds.DatasetName, e.Title, geomDef, fields) == -1)
{
throw new Exception("Can't create target featureclass:\n" + db.lastErrorMsg);
}
IDatasetElement element = ds[e.Title];
if (element == null || !(element.Class is IFeatureClass))
{
throw new Exception("Can't open created featureclass");
}
IFeatureClass tFc = element.Class as IFeatureClass;
if (db is AccessFDB)
{
int maxAllowedLevel = ((db is SqlFDB) ? 62 : 30);
if (sDef == null)
{
IEnvelope sEnv = sFc.Envelope;
sDef = (sEnv != null) ? new BinaryTreeDef(sFc.Envelope, 10, 200, 0.55) : new BinaryTreeDef(new Envelope());
}
if (sDef.Bounds != null &&
sDef.SpatialReference != null &&
!sDef.SpatialReference.Equals(tFc.SpatialReference))
{
if (!sDef.ProjectTo(tFc.SpatialReference))
{
throw new Exception("Can't project SpatialIndex Boundaries...");
}
}
((AccessFDB)db).SetSpatialIndexBounds(tFc.Name, "BinaryTree2", sDef.Bounds, sDef.SplitRatio, sDef.MaxPerNode, Math.Min(sDef.MaxLevel, maxAllowedLevel));
((AccessFDB)db).SetFeatureclassExtent(tFc.Name, sDef.Bounds);
}
return(tFc);
}
override public List <IActivityData> Process()
{
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
IFeatureClass tFc = base.CreateTargetFeatureclass(sFc, sFc.Fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
return(null);
}
protected bool FlushFeatureClass(IFeatureClass fc)
{
IFeatureDatabase db = (IFeatureDatabase)fc.Dataset.Database;
bool ret = true;
if (db is IFileFeatureDatabase)
{
ret = ((IFileFeatureDatabase)db).Flush(fc);
}
else if (db is AccessFDB)
{
ret = ((AccessFDB)db).CalculateExtent(fc);
}
return(ret);
}
void _checkinMenuItem_Click(object sender, EventArgs e)
{
//if (_contextItem is ExplorerObjectListViewItem && listView.SelectedItems.Count == 1 && _contextItem == listView.SelectedItems[0])
if (_contextObject != null)
{
IExplorerObject exObject = _contextObject; // _contextItem.ExplorerObject;
if (exObject != null &&
exObject.Object is IFeatureClass &&
((IFeatureClass)exObject.Object).Dataset != null)
{
IFeatureDatabase fdb = ((IFeatureClass)exObject.Object).Dataset.Database as IFeatureDatabase;
if (fdb is IFeatureDatabaseReplication)
{
ReplicationUI.ShowCheckinDialog((IFeatureClass)exObject.Object);
}
}
_contextObject = null;
}
}
async void _checkoutMenuItem_Click(object sender, EventArgs e)
{
//if (_contextItem is ExplorerObjectListViewItem && listView.SelectedItems.Count == 1 && _contextItem == listView.SelectedItems[0])
if (_contextObject != null)
{
IExplorerObject exObject = _contextObject; // _contextItem.ExplorerObject;
var exObjectInstance = await exObject?.GetInstanceAsync();
if (exObjectInstance is IFeatureClass &&
((IFeatureClass)exObjectInstance).Dataset != null)
{
IFeatureDatabase fdb = ((IFeatureClass)exObjectInstance).Dataset.Database as IFeatureDatabase;
if (fdb is IFeatureDatabaseReplication)
{
ReplicationUI.ShowCheckoutDialog((IFeatureClass)exObjectInstance);
}
}
_contextObject = null;
}
}
override public List <IActivityData> Process()
{
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
GeometryDef geomDef = new GeometryDef(
geometryType.Polygon,
null,
false);
IFeatureClass tFc = base.CreateTargetFeatureclass(geomDef, sFc.Fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
ReportProgess("Query Filter: " + SourceData.FilterClause);
using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
{
IFeature feature;
List <IFeature> features = new List <IFeature>();
ReportProgess("Read/Write Features...");
while ((feature = cursor.NextFeature) != null)
{
if (feature.Shape is ITopologicalOperation)
{
feature.Shape = ((ITopologicalOperation)feature.Shape).Buffer(_bufferDistance);
}
else
{
continue;
}
if (feature.Shape == null)
{
continue;
}
features.Add(feature);
Report.featurePos++;
ReportProgess();
if (!CancelTracker.Continue)
{
break;
}
if (features.Count > 100)
{
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
features.Clear();
}
}
if (features.Count > 0)
{
ReportProgess();
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}
}
public override List <IActivityData> Process()
{
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
IFeatureClass tFc = base.CreateTargetFeatureclass(sFc, sFc.Fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
ReportProgess("Query Filter: " + SourceData.FilterClause);
using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
{
IFeature feature;
List <IFeature> features = new List <IFeature>();
ReportProgess("Read/Write Features...");
while ((feature = cursor.NextFeature) != null)
{
if (feature.Shape == null)
{
continue;
}
List <IGeometry> geometries = new List <IGeometry>();
#region Dissolve
if (feature.Shape is IPolygon)
{
foreach (IPolygon polygon in Algorithm.SplitPolygonToDonutsAndPolygons((IPolygon)feature.Shape))
{
geometries.Add(polygon);
}
}
else if (feature.Shape is IPolyline)
{
foreach (IPath path in Algorithm.GeometryPaths((IPolyline)feature.Shape))
{
Polyline pLine = new Polyline();
pLine.AddPath(path);
geometries.Add(pLine);
}
}
else if (feature.Shape is IMultiPoint)
{
for (int i = 0; i < ((IMultiPoint)feature.Shape).PointCount; i++)
{
IPoint p = ((IMultiPoint)feature.Shape)[i];
if (p != null)
{
geometries.Add(p);
}
}
}
#endregion
if (geometries.Count > 0)
{
foreach (IGeometry geometry in geometries)
{
Feature f = new Feature(feature);
f.Shape = geometry;
if (!tDatabase.Insert(tFc, f))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
}
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}
override public List <IActivityData> Process()
{
#region Where Clauses
List <string> whereClauses = new List <string>();
if (_mergeField == null)
{
whereClauses.Add(String.Empty);
}
else
{
foreach (object val in _values)
{
if (val == null)
{
continue;
}
switch (_mergeField.type)
{
case FieldType.smallinteger:
case FieldType.integer:
case FieldType.biginteger:
whereClauses.Add(_mergeField.name + "=" + val.ToString());
break;
case FieldType.Float:
case FieldType.Double:
whereClauses.Add(_mergeField.name + "=" + Convert.ToDouble(val).ToString(_nhi));
break;
case FieldType.boolean:
whereClauses.Add(_mergeField.name + "=" + val.ToString());
break;
case FieldType.String:
whereClauses.Add(_mergeField.name + "='" + val.ToString() + "'");
break;
default:
throw new Exception("Can't merge this fieldtype: " + _mergeField.type.ToString());
}
}
}
#endregion
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
Fields fields = new Fields();
if (_mergeField != null)
{
fields.Add(_mergeField);
}
IFeatureClass tFc = base.CreateTargetFeatureclass(sFc, fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
bool isPolygonFc = (sFc.GeometryType == geometryType.Polygon);
foreach (string whereClause in whereClauses)
{
ReportProgess("Query Filter: " + SourceData.FilterClause + (String.IsNullOrEmpty(whereClause) ? " AND " + whereClause : String.Empty));
Feature mergeFeature = null;;
bool attributeAdded = false;
using (IFeatureCursor cursor = SourceData.GetFeatures(whereClause))
{
IFeature feature;
List <IPolygon> polygons = new List <IPolygon>();
while ((feature = cursor.NextFeature) != null)
{
if (mergeFeature == null)
{
mergeFeature = new Feature();
}
Report.featurePos++;
if (!CancelTracker.Continue)
{
break;
}
if (_mergeField != null && attributeAdded == false)
{
mergeFeature.Fields.Add(new FieldValue(_mergeField.name, feature[_mergeField.name]));
attributeAdded = true;
}
if (isPolygonFc)
{
if (feature.Shape != null)
{
if (!(feature.Shape is IPolygon))
{
throw new Exception("Wrong argument type :" + feature.Shape.GeometryType.ToString());
}
polygons.Add(feature.Shape as IPolygon);
}
}
else
{
if (mergeFeature.Shape == null)
{
mergeFeature.Shape = feature.Shape;
}
else
{
mergeFeature.Shape = Algorithm.Merge(mergeFeature.Shape, feature.Shape, false);
}
}
ReportProgess();
}
if (isPolygonFc && mergeFeature != null)
{
ProgressReporterEvent r = new ProgressReporterEvent(MergePolygonReport);
mergeFeature.Shape = Algorithm.FastMergePolygon(polygons, CancelTracker, r);
}
}
if (mergeFeature != null)
{
if (!tDatabase.Insert(tFc, mergeFeature))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
if (!CancelTracker.Continue)
{
break;
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}
async public Task <bool> ImportToNewFeatureclass(IFeatureDatabase fdb, string dsname, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters, ISpatialIndexDef sIndexDef, geometryType?sourceGeometryType = null)
{
if (!_cancelTracker.Continue)
{
return(true);
}
if (fdb is AccessFDB)
{
ISpatialIndexDef dsSpatialIndexDef = await((AccessFDB)fdb).SpatialIndexDef(dsname);
if (sIndexDef == null)
{
sIndexDef = dsSpatialIndexDef;
}
else if (sIndexDef.GeometryType != dsSpatialIndexDef.GeometryType)
{
_errMsg = "Spatial-Index-Definition-GeometryTypes are not compatible!";
return(false);
}
}
if (sIndexDef == null)
{
sIndexDef = new gViewSpatialIndexDef();
}
bool msSpatial = false;
if (fdb is SqlFDB &&
(sIndexDef.GeometryType == GeometryFieldType.MsGeography ||
sIndexDef.GeometryType == GeometryFieldType.MsGeometry))
{
msSpatial = true;
}
else
{
int maxAllowedLevel = ((fdb is SqlFDB || fdb is pgFDB) ? 62 : 30);
if (sIndexDef.Levels > maxAllowedLevel)
{
ISpatialReference defSRef = sIndexDef.SpatialReference;
sIndexDef = new gViewSpatialIndexDef(
sIndexDef.SpatialIndexBounds,
Math.Min(sIndexDef.Levels, maxAllowedLevel),
sIndexDef.MaxPerNode,
sIndexDef.SplitRatio);
((gViewSpatialIndexDef)sIndexDef).SpatialReference = defSRef;
}
}
try
{
fcname = fcname.Replace(".", "_");
IFeatureDataset destDS = await fdb.GetDataset(dsname);
if (destDS == null)
{
_errMsg = fdb.LastErrorMessage;
return(false);
}
IDatasetElement destLayer = await destDS.Element(fcname);
if (destLayer != null)
{
if (ReportRequest != null)
{
RequestArgs args = new RequestArgs(
"Featureclass " + fcname + " already exists in " + dsname + "\nDo want to replace it?",
MessageBoxButtons.YesNoCancel,
DialogResult.Cancel);
ReportRequest(this, args);
switch (args.Result)
{
case DialogResult.No:
return(true);
case DialogResult.Cancel:
_errMsg = "Import is canceled by the user...";
return(false);
}
}
}
GeometryDef geomDef = new GeometryDef(sourceFC);
if (geomDef.GeometryType == geometryType.Unknown && sourceGeometryType != null)
{
geomDef.GeometryType = sourceGeometryType.Value;
}
int fcID = -1;
if (destLayer != null)
{
if (fdb is AccessFDB)
{
fcID = await((AccessFDB)fdb).ReplaceFeatureClass(destDS.DatasetName,
fcname,
geomDef,
(fieldTranslation == null) ?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
if (fcID < 0)
{
_errMsg = "Can't replace featureclass " + fcname + "...\r\n" + fdb.LastErrorMessage;
destDS.Dispose();
return(false);
}
}
else
{
await fdb.DeleteFeatureClass(fcname);
}
}
if (fcID < 0)
{
fcID = await fdb.CreateFeatureClass(destDS.DatasetName,
fcname,
geomDef,
(fieldTranslation == null)?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
}
if (fcID < 0)
{
_errMsg = "Can't create featureclass " + fcname + "...\r\n" + fdb.LastErrorMessage;
destDS.Dispose();
return(false);
}
destLayer = await destDS.Element(fcname);
if (destLayer == null || !(destLayer.Class is IFeatureClass))
{
_errMsg = "Can't load featureclass " + fcname + "...\r\n" + destDS.LastErrorMessage;
destDS.Dispose();
return(false);
}
IFeatureClass destFC = destLayer.Class as IFeatureClass;
if (project && destFC.SpatialReference != null && !destFC.SpatialReference.Equals(sourceFC.SpatialReference))
{
_transformer = GeometricTransformerFactory.Create();
//_transformer.FromSpatialReference = sourceFC.SpatialReference;
//_transformer.ToSpatialReference = destFC.SpatialReference;
_transformer.SetSpatialReferences(sourceFC.SpatialReference, destFC.SpatialReference);
}
if (!Envelope.IsNull(sIndexDef.SpatialIndexBounds) &&
sIndexDef.SpatialReference != null && !sIndexDef.SpatialReference.Equals(destFC.SpatialReference))
{
if (!sIndexDef.ProjectTo(destFC.SpatialReference))
{
_errMsg = "Can't project SpatialIndex Boundaries...";
destDS.Dispose();
return(false);
}
}
DualTree tree = null;
BinaryTree2Builder tree2 = null;
if (msSpatial)
{
((SqlFDB)fdb).SetMSSpatialIndex((MSSpatialIndex)sIndexDef, destFC.Name);
await((SqlFDB)fdb).SetFeatureclassExtent(destFC.Name, sIndexDef.SpatialIndexBounds);
}
else
{
if (_treeVersion == TreeVersion.BinaryTree)
{
tree = await SpatialIndex(sourceFC, sIndexDef.MaxPerNode, filters);
if (tree == null)
{
return(false);
}
}
else if (_treeVersion == TreeVersion.BinaryTree2)
{
if (_schemaOnly && sourceFC.Dataset.Database is IImplementsBinarayTreeDef)
{
BinaryTreeDef tDef = await((IImplementsBinarayTreeDef)sourceFC.Dataset.Database).BinaryTreeDef(sourceFC.Name);
tree2 = new BinaryTree2Builder(tDef.Bounds, tDef.MaxLevel, tDef.MaxPerNode, tDef.SplitRatio);
}
else
{
tree2 = await SpatialIndex2(fdb, sourceFC, sIndexDef, filters);
if (tree2 == null)
{
return(false);
}
}
}
// Vorab einmal alle "Bounds" festlegen, damit auch
// ein aufzubauender Layer geviewt werden kann
if (_treeVersion == TreeVersion.BinaryTree2 && fdb is AccessFDB)
{
if (ReportAction != null)
{
ReportAction(this, "Insert spatial index nodes");
}
List <long> nids = new List <long>();
foreach (BinaryTree2BuilderNode node in tree2.Nodes)
{
nids.Add(node.Number);
}
await((AccessFDB)fdb).ShrinkSpatialIndex(fcname, nids);
if (ReportAction != null)
{
ReportAction(this, "Set spatial index bounds");
}
//((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree2", tree2.Bounds, sIndexDef.SplitRatio, sIndexDef.MaxPerNode, tree2.maxLevels);
await((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree2", tree2.Bounds, tree2.SplitRatio, tree2.MaxPerNode, tree2.maxLevels);
await((AccessFDB)fdb).SetFeatureclassExtent(fcname, tree2.Bounds);
}
}
if (_cancelTracker.Continue)
{
bool result = true;
if (!_schemaOnly)
{
if (msSpatial)
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else if (_treeVersion == TreeVersion.BinaryTree)
{
if (String.IsNullOrEmpty(sourceFC.IDFieldName)) // SDE Views haben keine ID -> Tree enthält keine Features
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, tree);
}
}
else if (_treeVersion == TreeVersion.BinaryTree2)
{
if (String.IsNullOrEmpty(sourceFC.IDFieldName)) // SDE Views haben keine ID -> Tree enthält keine Features
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else
{
result = await CopyFeatures2(sourceFC, fdb, destFC, fieldTranslation, tree2);
}
}
if (!result)
{
await fdb.DeleteFeatureClass(fcname);
destDS.Dispose();
return(false);
}
}
}
destDS.Dispose();
if (_cancelTracker.Continue && fdb is AccessFDB)
{
if (ReportAction != null)
{
ReportAction(this, "Calculate extent");
}
await((AccessFDB)fdb).CalculateExtent(destFC);
if (msSpatial == false)
{
if (_treeVersion == TreeVersion.BinaryTree)
{
if (ReportAction != null)
{
ReportAction(this, "Set spatial index bounds");
}
await((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree", tree.Bounds, sIndexDef.SplitRatio, sIndexDef.MaxPerNode, 0);
if (ReportAction != null)
{
ReportAction(this, "Insert spatial index nodes");
}
await((AccessFDB)fdb).__intInsertSpatialIndexNodes2(fcname, tree.Nodes);
}
}
return(true);
}
else
{
await fdb.DeleteFeatureClass(fcname);
_errMsg = "Import is canceled by the user...";
return(false);
}
}
finally
{
if (_transformer != null)
{
_transformer.Release();
_transformer = null;
}
}
}
public Task <bool> ImportToNewFeatureclass(IFeatureDatabase fdb, string dsname, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters)
{
return(ImportToNewFeatureclass(fdb, dsname, fcname, sourceFC, fieldTranslation, true, filters, null));
}
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);
}
public bool ImportToNewFeatureclass(IFeatureDatabase fdb, string dsname, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project)
{
return(ImportToNewFeatureclass(fdb, dsname, fcname, sourceFC, fieldTranslation, true, null));
}
private bool ImportToNewFeatureclass(IFeatureDataset destDS, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters, DatasetNameCase namecase)
{
if (!_cancelTracker.Continue)
{
return(true);
}
switch (namecase)
{
case DatasetNameCase.upper:
fcname = fcname.ToUpper();
fieldTranslation.ToUpper();
break;
case DatasetNameCase.lower:
fcname = fcname.ToLower();
fieldTranslation.ToLower();
break;
case DatasetNameCase.classNameUpper:
fcname = fcname.ToUpper();
break;
case DatasetNameCase.classNameLower:
fcname = fcname.ToLower();
break;
case DatasetNameCase.fieldNamesUpper:
fieldTranslation.ToUpper();
break;
case DatasetNameCase.fieldNamesLower:
fieldTranslation.ToLower();
break;
}
try
{
fcname = fcname.Replace(".", "_");
if (destDS == null)
{
_errMsg = "Argument Exception";
return(false);
}
IFeatureDatabase fdb = destDS.Database as IFeatureDatabase;
if (!(fdb is IFeatureUpdater))
{
_errMsg = "Database don't implement IFeatureUpdater...";
return(false);
}
IDatasetElement destLayer = destDS[fcname] as IDatasetElement;
if (destLayer != null)
{
if (ReportRequest != null)
{
RequestArgs args = new RequestArgs(
"Featureclass " + fcname + " already exists in database\nDo want to replace it?",
MessageBoxButtons.YesNoCancel,
DialogResult.Cancel);
ReportRequest(this, args);
switch (args.Result)
{
case DialogResult.No:
return(true);
case DialogResult.Cancel:
_errMsg = "Import is canceled by the user...";
return(false);
}
}
}
if (destLayer != null)
{
fdb.DeleteFeatureClass(fcname);
}
int fcID = fdb.CreateFeatureClass(destDS.DatasetName,
fcname,
sourceFC,
(fieldTranslation == null) ?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
if (fcID < 0)
{
_errMsg = "Can't create featureclass " + fcname + "...\r\n" + fdb.lastErrorMsg;
destDS.Dispose();
return(false);
}
destLayer = destDS[fcname] as IDatasetElement;
if (destLayer == null || !(destLayer.Class is IFeatureClass))
{
_errMsg = "Can't load featureclass " + fcname + "...\r\n" + destDS.lastErrorMsg;
destDS.Dispose();
return(false);
}
IFeatureClass destFC = destLayer.Class as IFeatureClass;
if (project && destFC.SpatialReference != null && !destFC.SpatialReference.Equals(sourceFC.SpatialReference))
{
_transformer = new GeometricTransformer();
//_transformer.FromSpatialReference = sourceFC.SpatialReference;
//_transformer.ToSpatialReference = destFC.SpatialReference;
_transformer.SetSpatialReferences(sourceFC.SpatialReference, destFC.SpatialReference);
}
if (_cancelTracker.Continue)
{
bool result = true;
if (fdb is IFeatureImportEvents)
{
((IFeatureImportEvents)fdb).BeforeInsertFeaturesEvent(sourceFC, destFC);
}
if (!_schemaOnly)
{
result = CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
if (!result)
{
fdb.DeleteFeatureClass(fcname);
destDS.Dispose();
return(false);
}
if (fdb is IFeatureImportEvents)
{
((IFeatureImportEvents)fdb).AfterInsertFeaturesEvent(sourceFC, destFC);
}
}
if (fdb is IFileFeatureDatabase)
{
if (!((IFileFeatureDatabase)fdb).Flush(destFC))
{
_errMsg = "Error executing flush for file database...";
return(false);
}
}
destDS.Dispose();
if (_cancelTracker.Continue)
{
return(true);
}
else
{
fdb.DeleteFeatureClass(fcname);
_errMsg = "Import is canceled by the user...";
return(false);
}
}
finally
{
if (_transformer != null)
{
_transformer.Release();
_transformer = null;
}
}
}
async static private Task <BinaryTree2Builder> SpatialIndex2(IFeatureDatabase fdb, IFeatureClass fc, ISpatialIndexDef def, List <IQueryFilter> filters = null)
{
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),
maxVerticesPerNode: 500 * 50) :
new BinaryTree2Builder2(def.SpatialIndexBounds, def.Levels, def.MaxPerNode, def.SplitRatio));
if (filters == null)
{
QueryFilter filter = new QueryFilter()
{
WhereClause = "1=1"
};
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)
{
throw new Exception("Fatal error: sourcedb query failed...");
}
Console.WriteLine("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;
//}
int counter = 0;
IFeature feat;
while ((feat = await fCursor.NextFeature()) != null)
{
IGeometry shape = feat.Shape;
//if (_transformer != null)
//{
// shape = _transformer.Transform2D(shape) as IGeometry;
//}
feat.Shape = shape;
treeBuilder.AddFeature(feat);
counter++;
if (counter % 10000 == 0)
{
Console.Write($"...{ counter }");
}
}
Console.Write($"...{ counter }");
}
}
treeBuilder.Trim();
Console.WriteLine();
return(treeBuilder);
}
public override List <IActivityData> Process()
{
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
ActivityBase.TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
GeometryDef geomDef = new GeometryDef(
geometryType.Polyline,
null,
false);
IFeatureClass tFc = base.CreateTargetFeatureclass(geomDef, sFc.Fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
ReportProgess("Query Filter: " + SourceData.FilterClause);
Nodes nodes = new Nodes();
using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
{
if (cursor == null)
{
return(null);
}
IFeature feature;
while ((feature = cursor.NextFeature) != null)
{
if (Report.featurePos++ % 100 == 0)
{
ReportProgess();
}
if (feature.Shape is IPoint)
{
nodes.Add((IPoint)feature.Shape);
}
}
}
VoronoiGraph voronoi = new VoronoiGraph();
voronoi.ProgressMessage += new VoronoiGraph.ProgressMessageEventHandler(voronoi_ProgressMessage);
voronoi.Progress += new VoronoiGraph.ProgressEventHandler(voronoi_Progress);
voronoi.Calc(nodes);
List <IPoint> vertices = voronoi.Nodes;
Edges edges = voronoi.Edges;
ReportProgess("Write Lines");
Report.featurePos = 0;
List <IFeature> features = new List <IFeature>();
foreach (Edge edge in edges)
{
Polyline pLine = new Polyline();
Path path = new Path();
path.AddPoint(vertices[edge.p1]);
path.AddPoint(vertices[edge.p2]);
pLine.AddPath(path);
Feature feature = new Feature();
feature.Shape = pLine;
features.Add(feature);
Report.featurePos++;
if (features.Count >= 100)
{
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
features.Clear();
ReportProgess();
}
}
if (features.Count > 0)
{
ReportProgess();
if (!tDatabase.Insert(tFc, features))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}