async public Task <IExplorerObject> CreateExplorerObject(IExplorerObject parentExObject)
{
SQLiteFDBDatasetExplorerObject parent = (SQLiteFDBDatasetExplorerObject)parentExObject;
IFeatureDataset dataset = await parent.GetInstanceAsync() as IFeatureDataset;
if (dataset == null)
{
return(null);
}
AccessFDB fdb = dataset.Database as AccessFDB;
if (fdb == null)
{
return(null);
}
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenFeatureclassFilter());
ExplorerDialog dlg = new ExplorerDialog("Select Featureclass", filters, true);
IExplorerObject ret = null;
if (dlg.ShowDialog() == DialogResult.OK &&
dlg.ExplorerObjects != null)
{
foreach (IExplorerObject exObj in dlg.ExplorerObjects)
{
var exObjectInstance = await exObj?.GetInstanceAsync();
if (exObjectInstance is IFeatureClass)
{
int fcid = await fdb.CreateLinkedFeatureClass(dataset.DatasetName, (IFeatureClass)exObjectInstance);
if (ret == null)
{
IDatasetElement element = await dataset.Element(((IFeatureClass)exObjectInstance).Name);
if (element != null)
{
ret = new SQLiteFDBFeatureClassExplorerObject(
parent,
parent.FileName,
parent.Name,
element);
}
}
}
}
}
return(ret);
}
async public Task <IExplorerObject> CreateExplorerObject(IExplorerObject parentExObject)
{
if (!(parentExObject is SQLiteFDBDatasetExplorerObject))
{
return(null);
}
SQLiteFDBDatasetExplorerObject parent = (SQLiteFDBDatasetExplorerObject)parentExObject;
IFeatureDataset dataset = await((SQLiteFDBDatasetExplorerObject)parentExObject).GetInstanceAsync() as IFeatureDataset;
if (dataset == null || !(dataset.Database is SQLiteFDB))
{
return(null);
}
FormNewNetworkclass dlg = new FormNewNetworkclass(dataset, typeof(CreateFDBNetworkFeatureclass));
if (dlg.ShowDialog() != DialogResult.OK)
{
return(null);
}
CreateFDBNetworkFeatureclass creator = new CreateFDBNetworkFeatureclass(
dataset, dlg.NetworkName,
dlg.EdgeFeatureclasses,
dlg.NodeFeatureclasses);
creator.SnapTolerance = dlg.SnapTolerance;
creator.ComplexEdgeFcIds = await dlg.ComplexEdgeFcIds();
creator.GraphWeights = dlg.GraphWeights;
creator.SwitchNodeFcIdAndFieldnames = dlg.SwitchNodeFcIds;
creator.NodeTypeFcIds = dlg.NetworkNodeTypeFcIds;
FormTaskProgress progress = new FormTaskProgress();
progress.ShowProgressDialog(creator, creator.Run());
IDatasetElement element = await dataset.Element(dlg.NetworkName);
return(new SQLiteFDBFeatureClassExplorerObject(
parent,
parent.FileName,
parent.Name,
element));
}
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;
}
}
}
async public Task Run(string[] args)
{
string inFile = String.Empty;
string outFile = String.Empty;
string targetConnectionString = String.Empty;
IEnumerable <string> dontCopyFeatues = null;
Guid targetGuid = new Guid();
for (int i = 1; i < args.Length - 1; i++)
{
switch (args[i].ToLower())
{
case "-mxl":
inFile = args[++i];
break;
case "-target-connectionstring":
targetConnectionString = args[++i];
break;
case "-target-guid":
var guid = args[++i];
switch (guid.ToLower())
{
case "sqlserver":
targetGuid = new Guid("3B870AB5-8BE0-4a00-911D-ECC6C83DD6B4");
break;
case "postgres":
targetGuid = new Guid("33254063-133D-4b17-AAE2-46AF7A7DA733");
break;
case "sqlite":
targetGuid = new Guid("36DEB6AC-EA0C-4B37-91F1-B2E397351555");
break;
default:
targetGuid = new Guid(guid);
break;
}
break;
case "-out-mxl":
outFile = args[++i];
break;
case "-dont-copy-features-from":
dontCopyFeatues = args[++i].Split(',').Select(n => n.Trim().ToLower());
break;
}
}
if (String.IsNullOrEmpty(inFile) ||
String.IsNullOrEmpty(targetConnectionString) ||
targetGuid.Equals(new Guid()))
{
throw new IncompleteArgumentsException();
}
if (String.IsNullOrEmpty(outFile))
{
outFile = String.IsNullOrEmpty(inFile) ? String.Empty : inFile.Substring(0, inFile.LastIndexOf(".")) + "_fdb.mxl";
}
XmlStream stream = new XmlStream("");
stream.ReadStream(inFile);
MxlDocument doc = new MxlDocument();
await stream.LoadAsync("MapDocument", doc);
var pluginManager = new PlugInManager();
#region Destination Dataset
IFeatureDataset targetFeatureDataset = pluginManager.CreateInstance(targetGuid) as IFeatureDataset;
if (targetFeatureDataset == null)
{
throw new Exception("Plugin with GUID '" + targetGuid.ToString() + "' is not a feature dataset...");
}
await targetFeatureDataset.SetConnectionString(targetConnectionString);
await targetFeatureDataset.Open();
var targetDatabase = (IFDBDatabase)targetFeatureDataset.Database;
#endregion Destination Dataset
var map = doc.Maps.FirstOrDefault() as Map;
var featureLayers = map.TOC.Layers.Where(l => l is IFeatureLayer)
.Select(l => (IFeatureLayer)l);
if (map.Datasets != null)
{
int datasetId = 0;
foreach (var dataset in map.Datasets.ToArray())
{
Console.WriteLine();
Console.WriteLine($"Dataset: { dataset.DatasetName }");
Console.WriteLine($" { dataset.GetType() }");
Console.WriteLine("-------------------------------------------------------");
foreach (var dsElement in map.MapElements.Where(e => e.DatasetID == datasetId))
{
if (dsElement?.Class == null)
{
continue;
}
var featureLayer = featureLayers.Where(l => l.DatasetID == datasetId && l.Class == dsElement.Class)
.FirstOrDefault();
if (featureLayer == null)
{
continue;
}
Console.WriteLine();
Console.WriteLine($"FeatureLayer: { featureLayer.Title }");
Console.WriteLine($" Class: { dsElement.Class.Name }");
Console.WriteLine($" { dsElement.Class.GetType() }");
Console.WriteLine();
var sourceFc = dsElement.Class as IFeatureClass;
if (sourceFc == null)
{
Console.WriteLine("Class is not a FeatureClass");
continue;
}
#region Create Target Featureclass (if not exists)
string targetFcName = dsElement.Class.Name;
if (targetFcName.Contains("."))
{
targetFcName = targetFcName.Substring(targetFcName.LastIndexOf(".") + 1);
}
var targetFc = (await targetFeatureDataset.Element(targetFcName))?.Class as IFeatureClass;
if (targetFc != null)
{
var count = await targetFc.CountFeatures();
if (count > 0)
{
Console.Write($"Already exists in target fdb ({ count } features)");
}
else
{
if (!await targetDatabase.DeleteFeatureClass(targetFcName))
{
throw new Exception($"Can't delete existing (empty) featureclass { targetFcName }");
}
}
}
else
{
var fcId = await targetDatabase.CreateFeatureClass(
targetFeatureDataset.DatasetName,
targetFcName,
new GeometryDef()
{
GeometryType = sourceFc.GeometryType,
HasM = sourceFc.HasM,
HasZ = sourceFc.HasZ,
SpatialReference = sourceFc.SpatialReference
},
new Fields(sourceFc.Fields.ToEnumerable().Select(f =>
{
if (f != null && f.type == FieldType.ID && f.name.ToUpper().Equals("FDB_OID") == false) // also include original ID Column
{
return(new Field(f.name, FieldType.integer));
}
return(f);
})));
if (fcId <= 0)
{
throw new Exception($"Can't create featureclass { targetFcName }: { targetDatabase.LastErrorMessage }");
}
targetFc = (await targetFeatureDataset.Element(targetFcName)).Class as IFeatureClass;
if (targetFc == null)
{
throw new Exception($"Can't load target FeatureClass { targetFcName }");
}
var copyFeatures = dontCopyFeatues == null ||
(!dontCopyFeatues.Contains(sourceFc.Name.ToLower()) && !dontCopyFeatues.Contains(targetFc.Name.ToLower()));
if (copyFeatures)
{
var sIndexDef = new gViewSpatialIndexDef(null, 62);
var tree2 = await SpatialIndex2(
targetDatabase,
sourceFc,
sIndexDef);
tree2.Trim();
List <long> nids = new List <long>();
foreach (BinaryTree2BuilderNode node in tree2.Nodes)
{
nids.Add(node.Number);
}
await((AccessFDB)targetDatabase).ShrinkSpatialIndex(targetFcName, nids);
await((AccessFDB)targetDatabase).SetSpatialIndexBounds(targetFcName, "BinaryTree2", tree2.Bounds, tree2.SplitRatio, tree2.MaxPerNode, tree2.maxLevels);
await((AccessFDB)targetDatabase).SetFeatureclassExtent(targetFcName, tree2.Bounds);
#endregion Create Target Featureclass (if not exists)
var featureBag = new List <IFeature>();
IFeature feature = null;
int counter = 0;
Console.WriteLine("Copy features:");
if (sourceFc is IFeatureClassPerformanceInfo && ((IFeatureClassPerformanceInfo)sourceFc).SupportsHighperformanceOidQueries == false)
{
using (var memoryFeatureBag = new FeatureBag())
{
#region Read all Features to FeatureBag (Memory)
//
// eg. SDE Multiversion Views are very slow, queiried win OID Filter!!
//
Console.WriteLine("Source feature class do not support high performance oid quries!");
QueryFilter filter = new QueryFilter()
{
WhereClause = "1=1"
};
filter.AddField("*");
Console.WriteLine("Read all features to memory feature bag...");
using (var featureCursor = await sourceFc.GetFeatures(filter))
{
if (featureCursor == null)
{
throw new Exception($"Can't query features from soure featureclass: { (sourceFc is IDebugging ? ((IDebugging)sourceFc).LastException?.Message : "") }");
}
while ((feature = await featureCursor.NextFeature()) != null)
{
memoryFeatureBag.AddFeature(feature);
counter++;
if (counter % 10000 == 0)
{
Console.Write($"...{ counter }");
}
}
}
#endregion Read all Features to FeatureBag (Memory)
#region Write to target featureclass
Console.WriteLine($"...{ counter }");
Console.WriteLine("copy feature to target feature class");
counter = 0;
foreach (BinaryTree2BuilderNode node in tree2.Nodes)
{
foreach (var memoryFeature in memoryFeatureBag.GetFeatures(node.OIDs))
{
memoryFeature.Fields.Add(new FieldValue("$FDB_NID", node.Number));
featureBag.Add(memoryFeature);
counter++;
if (counter % 10000 == 0)
{
await Store(targetDatabase, targetFc, featureBag, counter);
}
}
}
#endregion Write to target featureclass
}
GC.Collect();
}
else
{
#region Query all per Oid and Node
foreach (BinaryTree2BuilderNode node in tree2.Nodes)
{
RowIDFilter filter = new RowIDFilter(sourceFc.IDFieldName);
filter.IDs = node.OIDs;
filter.SubFields = "*";
using (var featureCursor = await sourceFc.GetFeatures(filter))
{
if (featureCursor == null)
{
throw new Exception($"Can't query features from soure featureclass: { (sourceFc is IDebugging ? ((IDebugging)sourceFc).LastException?.Message : "") }");
}
while ((feature = await featureCursor.NextFeature()) != null)
{
feature.Fields.Add(new FieldValue("$FDB_NID", node.Number));
featureBag.Add(feature);
counter++;
if (counter % 10000 == 0)
{
await Store(targetDatabase, targetFc, featureBag, counter);
}
}
}
}
#endregion Query all per Oid and Node
}
await Store(targetDatabase, targetFc, featureBag, counter);
await((AccessFDB)targetDatabase).CalculateExtent(targetFcName);
}
}
dsElement.Title = targetFc.Name;
((DatasetElement)dsElement).Class = targetFc;
}
((MapPersist)map).SetDataset(datasetId, targetFeatureDataset);
datasetId++;
}
}
map.Compress();
stream = new XmlStream("");
stream.Save("MapDocument", doc);
Console.WriteLine($"Write: { outFile }");
stream.WriteStream(outFile);
Console.WriteLine("succeeded...");
}
async private Task <bool> ImportToNewFeatureclass(IFeatureDataset destDS, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters, DatasetNameCase namecase, geometryType?sourceGeometryType = null)
{
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 = await destDS.Element(fcname);
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)
{
await fdb.DeleteFeatureClass(fcname);
}
GeometryDef geomDef = new GeometryDef(sourceFC);
if (geomDef.GeometryType == geometryType.Unknown && sourceGeometryType != null)
{
geomDef.GeometryType = sourceGeometryType.Value;
}
int 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);
}
var importBufferSizeAttribute = destFC.GetType().GetCustomAttribute <ImportFeaturesBufferSizeAttribute>();
if (importBufferSizeAttribute != null && importBufferSizeAttribute.BufferSize > 0)
{
this.FeatureBufferSize = importBufferSizeAttribute.BufferSize;
}
if (_cancelTracker.Continue)
{
bool result = true;
if (fdb is IFeatureImportEvents)
{
((IFeatureImportEvents)fdb).BeforeInsertFeaturesEvent(sourceFC, destFC);
}
if (!_schemaOnly)
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
if (!result)
{
await 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..." + fdb.LastErrorMessage;
return(false);
}
}
destDS.Dispose();
if (_cancelTracker.Continue)
{
return(true);
}
else
{
await fdb.DeleteFeatureClass(fcname);
_errMsg = "Import is canceled by the user...";
return(false);
}
}
finally
{
if (_transformer != null)
{
_transformer.Release();
_transformer = null;
}
}
}
async public Task Run()
{
if (_dataset == null || !(_fdb is IFeatureDatabaseReplication) || _edgeFcs == null)
{
return;
}
IFeatureDatabaseReplication db = (IFeatureDatabaseReplication)_fdb;
if (_dataset.Element(_networkName) != null)
{
MessageBox.Show("Featureclass '" + _networkName + "' already exists!");
return;
}
bool succeeded = false;
List <int> FcIds = new List <int>();
try
{
ProgressReport report = new ProgressReport();
int datasetId = await _fdb.DatasetID(_dataset.DatasetName);
if (datasetId == -1)
{
return;
}
NetworkBuilder networkBuilder = new NetworkBuilder(await _dataset.Envelope(), _tolerance);
if (ReportProgress != null)
{
networkBuilder.reportProgress += new ProgressReporterEvent(networkBuilder_reportProgress);
}
#region Spatial Index
BinaryTreeDef edgeTreeDef = null, nodeTreeDef = null;
foreach (IFeatureClass fc in _edgeFcs)
{
BinaryTreeDef treeDef = await _fdb.BinaryTreeDef(fc.Name);
if (treeDef == null)
{
IEnvelope bounds = fc.Envelope;
if (Envelope.IsNull(bounds))
{
continue;
}
treeDef = new BinaryTreeDef(fc.Envelope, 10);
}
if (edgeTreeDef == null)
{
edgeTreeDef = new BinaryTreeDef(treeDef.Bounds, Math.Min(treeDef.MaxLevel, 10));
}
else
{
Envelope bounds = edgeTreeDef.Bounds;
bounds.Union(treeDef.Bounds);
edgeTreeDef = new BinaryTreeDef(bounds, Math.Min(Math.Max(edgeTreeDef.MaxLevel, treeDef.MaxLevel), 10));
}
}
foreach (IFeatureClass fc in _nodeFcs)
{
BinaryTreeDef treeDef = await _fdb.BinaryTreeDef(fc.Name);
if (treeDef == null)
{
IEnvelope bounds = fc.Envelope;
if (Envelope.IsNull(bounds))
{
continue;
}
treeDef = new BinaryTreeDef(fc.Envelope, 10);
}
if (nodeTreeDef == null)
{
nodeTreeDef = new BinaryTreeDef(treeDef.Bounds, Math.Min(treeDef.MaxLevel, 10));
}
else
{
Envelope bounds = nodeTreeDef.Bounds;
bounds.Union(treeDef.Bounds);
nodeTreeDef = new BinaryTreeDef(bounds, Math.Min(Math.Max(nodeTreeDef.MaxLevel, treeDef.MaxLevel), 10));
}
}
#endregion
#region Add Edges
foreach (IFeatureClass fc in _edgeFcs)
{
int fcId = await _fdb.FeatureClassID(datasetId, fc.Name);
if (fcId == -1)
{
continue;
}
FcIds.Add(fcId);
bool useOneway = false;
QueryFilter filter = new QueryFilter();
filter.AddField(fc.IDFieldName);
filter.AddField(fc.ShapeFieldName);
if (!String.IsNullOrEmpty(_onewayFieldName) && fc.FindField(_onewayFieldName) != null)
{
filter.AddField(_onewayFieldName);
useOneway = true;
}
Dictionary <Guid, IGraphWeightFeatureClass> gwfcs = new Dictionary <Guid, IGraphWeightFeatureClass>();
if (_graphWeights != null)
{
foreach (IGraphWeight weight in _graphWeights)
{
foreach (IGraphWeightFeatureClass gwfc in weight.FeatureClasses)
{
if (gwfc.FcId == fcId && !String.IsNullOrEmpty(gwfc.FieldName))
{
gwfcs.Add(weight.Guid, gwfc);
filter.AddField(gwfc.FieldName);
}
}
}
}
if (gwfcs.Keys.Count == 0)
{
gwfcs = null;
}
bool useWithComplexEdges = false;
if (_complexEdgeFcs != null &&
(_complexEdgeFcs.Contains(fcId) || _complexEdgeFcs.Contains(-1)))
{
useWithComplexEdges = true;
}
using (IFeatureCursor cursor = await fc.GetFeatures(filter))
{
#region Report
report.Message = "Analize Edges: " + fc.Name;
report.featureMax = await fc.CountFeatures();
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
IFeature feature;
while ((feature = await cursor.NextFeature()) != null)
{
bool oneway = false;
if (useOneway)
{
int ow = Convert.ToInt32(feature[_onewayFieldName]);
oneway = (ow != 0);
}
Hashtable gw = null;
if (gwfcs != null)
{
foreach (Guid weightGuid in gwfcs.Keys)
{
IGraphWeightFeatureClass gwfc = gwfcs[weightGuid];
object objVal = feature[gwfc.FieldName];
double val = (objVal == DBNull.Value) ? 0.0 : Convert.ToDouble(feature[gwfc.FieldName]);
if (gwfc.SimpleNumberCalculation != null)
{
val = gwfc.SimpleNumberCalculation.Calculate(val);
}
if (gw == null)
{
gw = new Hashtable();
}
gw.Add(weightGuid, val);
}
}
networkBuilder.AddEdgeFeature(fcId, feature, oneway, gw, useWithComplexEdges);
#region Report
report.featurePos++;
if (report.featurePos % 1000 == 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
}
#endregion
}
}
}
#endregion
#region Calculate ComplexEdges
if (_complexEdgeFcs != null && _complexEdgeFcs.Count > 0)
{
List <NetworkNode> networkNodes = networkBuilder.NetworkNodes.ToList();
#region Report
report.Message = "Create Complex Edges...";
report.featureMax = networkNodes.Count;
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
foreach (NetworkNode node in networkNodes)
{
networkBuilder.SplitToComplexEdges(node);
#region Report
report.featurePos++;
if (report.featurePos % 1000 == 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
}
#endregion
}
}
#endregion
#region Add Nodes
if (_nodeFcs != null)
{
foreach (IFeatureClass fc in _nodeFcs)
{
int fcId = await _fdb.FeatureClassID(datasetId, fc.Name);
if (fcId == -1)
{
continue;
}
FcIds.Add(fcId);
bool isSwitchable = false;
string switchStateFieldname = String.Empty;
if (_switchNodeFcs != null && _switchNodeFcs.ContainsKey(fcId))
{
isSwitchable = true;
switchStateFieldname = _switchNodeFcs[fcId];
}
NetworkNodeType nodeType = NetworkNodeType.Unknown;
if (_nodeTypeFcs != null && _nodeTypeFcs.ContainsKey(fcId))
{
nodeType = _nodeTypeFcs[fcId];
}
QueryFilter filter = new QueryFilter();
filter.AddField(fc.IDFieldName);
filter.AddField(fc.ShapeFieldName);
filter.AddField(switchStateFieldname);
using (IFeatureCursor cursor = await fc.GetFeatures(filter))
{
#region Report
report.Message = "Analize Nodes: " + fc.Name;
report.featureMax = await fc.CountFeatures();
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
IFeature feature;
while ((feature = await cursor.NextFeature()) != null)
{
bool switchState = isSwitchable;
if (isSwitchable && !String.IsNullOrEmpty(switchStateFieldname))
{
object so = feature[switchStateFieldname];
if (so != null)
{
if (so is bool)
{
switchState = (bool)so;
}
else
{
try
{
switchState = Convert.ToInt32(so) > 0;
}
catch { switchState = false; }
}
}
}
networkBuilder.AddNodeFeature(fcId, feature, isSwitchable, switchState, nodeType);
#region Report
report.featurePos++;
if (report.featurePos % 1000 == 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
}
#endregion
}
}
}
}
#endregion
#region CreateGraph
#region Report
report.Message = "Create Graph";
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
networkBuilder.CreateGraph();
#endregion
#region Create Edge Featureclass
#region Simple Edges Table
Fields fields = new Fields();
fields.Add(new Field("Page", FieldType.integer));
fields.Add(new Field("Data", FieldType.binary));
await db.CreateIfNotExists(_networkName + "_Edges", fields);
#endregion
#region Edge Index Table
fields = new Fields();
fields.Add(new Field("EID", FieldType.integer));
fields.Add(new Field("FCID", FieldType.integer));
fields.Add(new Field("OID", FieldType.integer));
fields.Add(new Field("ISCOMPLEX", FieldType.boolean));
await db.CreateIfNotExists(_networkName + "_EdgeIndex", fields);
#endregion
#region Complex Edges FeatureClass
fields = new Fields();
fields.Add(new Field("EID", FieldType.integer));
fields.Add(new Field("N1", FieldType.integer));
fields.Add(new Field("N2", FieldType.integer));
fields.Add(new Field("FCID", FieldType.integer));
fields.Add(new Field("OID", FieldType.integer));
//fields.Add(new Field("Length", FieldType.integer));
//fields.Add(new Field("GeoLength", FieldType.integer));
await _fdb.ReplaceFeatureClass(_dataset.DatasetName,
_networkName + "_ComplexEdges",
new GeometryDef(geometryType.Polyline),
fields);
IDatasetElement element = await _dataset.Element(_networkName + "_ComplexEdges");
if (element == null || !(element.Class is IFeatureClass))
{
return;
}
if (edgeTreeDef != null)
{
await _fdb.SetSpatialIndexBounds(_networkName + "_ComplexEdges", "BinaryTree2", edgeTreeDef.Bounds, edgeTreeDef.SplitRatio, edgeTreeDef.MaxPerNode, edgeTreeDef.MaxLevel);
}
#endregion
int edge_page = 0;
List <IFeature> features = new List <IFeature>(), features2 = new List <IFeature>();
List <IRow> rows = new List <IRow>();
IFeatureClass edgeFc = (IFeatureClass)element.Class;
IFeatureCursor c = networkBuilder.Edges;
IFeature f;
#region Report
report.Message = "Create Edges";
if (c is ICount)
{
report.featureMax = ((ICount)c).Count;
}
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
string tabEdgesName = _fdb.TableName(_networkName + "_Edges");
string tabEdgeIndexName = _fdb.TableName(_networkName + "_EdgeIndex");
while ((f = await c.NextFeature()) != null)
{
int eid = (int)f["EID"];
if ((bool)f["ISCOMPLEX"] == true)
{
#region Complex Edges
features.Add(f);
report.featurePos++;
if (features.Count > 0 && features.Count % 1000 == 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
await _fdb.Insert(edgeFc, features);
features.Clear();
}
#endregion
}
#region Edges Table
features2.Add(f);
if (NetworkObjectSerializer.Page(eid + 1) > edge_page)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", edge_page++));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.SerializeEdges(features2)));
db.InsertRow(tabEdgesName, row, null);
features2.Clear();
}
#endregion
#region Edge Index
IRow eir = new Row();
eir.Fields.Add(new FieldValue("EID", (int)f["EID"]));
eir.Fields.Add(new FieldValue("FCID", (int)f["FCID"]));
eir.Fields.Add(new FieldValue("OID", (int)f["OID"]));
eir.Fields.Add(new FieldValue("ISCOMPLEX", (bool)f["ISCOMPLEX"]));
rows.Add(eir);
if (rows.Count > 0 && rows.Count % 1000 == 0)
{
_fdb.InsertRows(tabEdgeIndexName, rows, null);
rows.Clear();
}
#endregion
}
if (rows.Count > 0)
{
_fdb.InsertRows(tabEdgeIndexName, rows, null);
rows.Clear();
}
if (features2.Count > 0)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", edge_page));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.SerializeEdges(features2)));
db.InsertRow(tabEdgesName, row, null);
features2.Clear();
}
if (features.Count > 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
await _fdb.Insert(edgeFc, features);
}
await _fdb.CalculateExtent(edgeFc);
#endregion
#region Create Weights
if (_graphWeights != null)
{
foreach (IGraphWeight weight in _graphWeights)
{
fields = new Fields();
fields.Add(new Field("Page", FieldType.integer));
fields.Add(new Field("Data", FieldType.binary));
await db.CreateIfNotExists(_networkName + "_Weights_" + weight.Guid.ToString("N").ToLower(), fields);
string tabWeightName = _fdb.TableName(_networkName + "_Weights_" + weight.Guid.ToString("N").ToLower());
NetworkEdges edges = networkBuilder.NetworkEdges;
int weight_page = 0;
int counter = 0;
BinaryWriter bw = NetworkObjectSerializer.GetBinaryWriter();
foreach (NetworkEdge edge in edges)
{
counter++;
if (NetworkObjectSerializer.Page(counter) > weight_page)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", weight_page++));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.GetBuffer(bw)));
db.InsertRow(tabWeightName, row, null);
bw = NetworkObjectSerializer.GetBinaryWriter();
}
if (edge.Weights != null && edge.Weights.ContainsKey(weight.Guid))
{
NetworkObjectSerializer.WriteWeight(bw, weight, (double)edge.Weights[weight.Guid]);
}
else
{
NetworkObjectSerializer.WriteWeight(bw, weight, (double)0.0);
}
}
if (bw.BaseStream.Position > 0)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", weight_page++));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.GetBuffer(bw)));
db.InsertRow(tabWeightName, row, null);
}
}
}
#endregion
#region Create Node Featureclass
fields = new Fields();
//fields.Add(new Field("NID", FieldType.integer));
//fields.Add(new Field("G1", FieldType.integer));
//fields.Add(new Field("G2", FieldType.integer));
fields.Add(new Field("SWITCH", FieldType.boolean));
fields.Add(new Field("STATE", FieldType.boolean));
fields.Add(new Field("FCID", FieldType.integer));
fields.Add(new Field("OID", FieldType.integer));
fields.Add(new Field("NODETYPE", FieldType.integer));
await _fdb.ReplaceFeatureClass(_dataset.DatasetName,
_networkName + "_Nodes",
new GeometryDef(geometryType.Point),
fields);
element = await _dataset.Element(_networkName + "_Nodes");
if (element == null || !(element.Class is IFeatureClass))
{
return;
}
if (nodeTreeDef != null)
{
await _fdb.SetSpatialIndexBounds(_networkName + "_Nodes", "BinaryTree2", nodeTreeDef.Bounds, nodeTreeDef.SplitRatio, nodeTreeDef.MaxPerNode, nodeTreeDef.MaxLevel);
}
else if (edgeTreeDef != null)
{
await _fdb.SetSpatialIndexBounds(_networkName + "_Nodes", "BinaryTree2", edgeTreeDef.Bounds, edgeTreeDef.SplitRatio, edgeTreeDef.MaxPerNode, edgeTreeDef.MaxLevel);
}
features.Clear();
IFeatureClass nodeFc = (IFeatureClass)element.Class;
c = networkBuilder.Nodes;
#region Report
report.Message = "Create Nodes";
if (c is ICount)
{
report.featureMax = ((ICount)c).Count;
}
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
while ((f = await c.NextFeature()) != null)
{
features.Add(f);
report.featurePos++;
if (features.Count > 0 && features.Count % 1000 == 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
await _fdb.Insert(nodeFc, features);
features.Clear();
}
}
if (features.Count > 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
await _fdb.Insert(nodeFc, features);
}
await _fdb.CalculateExtent(nodeFc);
#endregion
#region Create Graph Class
int graph_page = 0;
fields = new Fields();
fields.Add(new Field("Page", FieldType.integer));
fields.Add(new Field("Data", FieldType.binary));
//fields.Add(new Field("N1", FieldType.integer));
//fields.Add(new Field("N2", FieldType.integer));
//fields.Add(new Field("EID", FieldType.integer));
//fields.Add(new Field("LENGTH", FieldType.Double));
//fields.Add(new Field("GEOLENGTH", FieldType.Double));
await _fdb.ReplaceFeatureClass(_dataset.DatasetName,
_networkName,
new GeometryDef(geometryType.Network),
fields);
element = await _dataset.Element(_networkName);
if (element == null || !(element.Class is IFeatureClass))
{
return;
}
features.Clear();
IFeatureClass networkFc = (IFeatureClass)element.Class;
c = networkBuilder.Graph;
#region Report
report.Message = "Create Network";
if (c is ICount)
{
report.featureMax = ((ICount)c).Count;
}
report.featurePos = 0;
if (ReportProgress != null)
{
ReportProgress(report);
}
#endregion
string fcNetworkName = _fdb.TableName("FC_" + _networkName);
while ((f = await c.NextFeature()) != null)
{
report.featurePos++;
// Wenn aktuelles Feature in neue Page gehört ->
// bestehende, vor neuem Einfügen speichern und pageIndex erhöhen (graph_page++)
if (NetworkObjectSerializer.Page((int)f["N1"]) > graph_page)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", graph_page++));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.SerializeGraph(features)));
db.InsertRow(fcNetworkName, row, null);
features.Clear();
}
features.Add(f);
}
if (features.Count > 0)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("Page", graph_page));
row.Fields.Add(new FieldValue("Data", NetworkObjectSerializer.SerializeGraph(features)));
db.InsertRow(fcNetworkName, row, null);
features.Clear();
}
#endregion
#region Create FDB_Networks
int netId = await _fdb.GetFeatureClassID(_networkName);
fields = new Fields();
fields.Add(new Field("ID", FieldType.integer));
fields.Add(new Field("Properties", FieldType.binary));
await db.CreateIfNotExists("FDB_Networks", fields);
NetworkObjectSerializer.NetworkProperties networkProps = new NetworkObjectSerializer.NetworkProperties(
NetworkObjectSerializer.PageSize, _tolerance);
IRow row2 = new Row();
row2.Fields.Add(new FieldValue("ID", netId));
row2.Fields.Add(new FieldValue("Properties", networkProps.Serialize()));
db.InsertRow(_fdb.TableName("FDB_Networks"), row2, null);
#endregion
#region Create FDB_NetworkClasses
fields = new Fields();
fields.Add(new Field("NetworkId", FieldType.integer));
fields.Add(new Field("FCID", FieldType.integer));
fields.Add(new Field("Properties", FieldType.binary));
await db.CreateIfNotExists("FDB_NetworkClasses", fields);
foreach (int fcId in FcIds)
{
bool isSwitchable = (_switchNodeFcs != null && _switchNodeFcs.ContainsKey(fcId));
string switchStateFieldname = (isSwitchable ? _switchNodeFcs[fcId] : String.Empty);
NetworkObjectSerializer.NetworkClassProperties nwclsProps = new NetworkObjectSerializer.NetworkClassProperties(
_complexEdgeFcs.Contains(fcId),
isSwitchable, switchStateFieldname);
IRow row = new Row();
row.Fields.Add(new FieldValue("NetworkId", netId));
row.Fields.Add(new FieldValue("FCID", fcId));
row.Fields.Add(new FieldValue("Properties", nwclsProps.Serialize()));
db.InsertRow(_fdb.TableName("FDB_NetworkClasses"), row, null);
}
#endregion
#region FDB_NetworkWeighs
fields = new Fields();
fields.Add(new Field("NetworkId", FieldType.integer));
fields.Add(new Field("Name", FieldType.String));
fields.Add(new Field("WeightGuid", FieldType.guid));
fields.Add(new Field("Properties", FieldType.binary));
await db.CreateIfNotExists("FDB_NetworkWeights", fields);
if (_graphWeights != null)
{
foreach (IGraphWeight weight in _graphWeights)
{
IRow row = new Row();
row.Fields.Add(new FieldValue("NetworkId", netId));
row.Fields.Add(new FieldValue("Name", weight.Name));
row.Fields.Add(new FieldValue("WeightGuid", weight.Guid));
row.Fields.Add(new FieldValue("Properties", NetworkObjectSerializer.SerializeWeight(weight)));
db.InsertRow(_fdb.TableName("FDB_NetworkWeights"), row, null);
}
}
#endregion
succeeded = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
if (!succeeded)
{
if (_fdb is IAlterDatabase)
{
((IAlterDatabase)_fdb).DropTable(_networkName + "_Edges");
}
await _fdb.DeleteFeatureClass(_networkName + "_ComplexEdges");
await _fdb.DeleteFeatureClass(_networkName + "_Nodes");
await _fdb.DeleteFeatureClass(_networkName);
}
}
}
// Thread
async private Task Run()
{
if (_targetDataset == null || _fdb == null || _sourceDataset == null)
{
return;
}
//if (_targetDataset[_name] != null)
//{
// MessageBox.Show("Featureclass '" + _name + "' already exists!");
// return;
//}
bool succeeded = false;
try
{
Envelope bounds = new Envelope(_spatialIndexDef.SpatialIndexBounds);
Envelope iBounds = new Envelope(bounds.minx - _tileSizeX, bounds.miny - _tileSizeY,
bounds.maxx + _tileSizeX, bounds.maxy + _tileSizeY);
_cacheDirectory += @"/" + _name;
if (!String.IsNullOrEmpty(_cacheDirectory))
{
DirectoryInfo di = new DirectoryInfo(_cacheDirectory);
if (!di.Exists)
{
di.Create();
}
StringBuilder sb = new StringBuilder();
sb.Append("<TileCacheDefinition>\r\n");
sb.Append(" <General levels='" + _levels + "' origin='lowerleft' />\r\n");
sb.Append(" <Envelope minx='" + bounds.minx.ToString(_nhi) + "' miny='" + bounds.miny.ToString(_nhi) + "' maxx='" + bounds.maxx.ToString(_nhi) + "' maxy='" + bounds.maxy.ToString(_nhi) + "' />\r\n");
sb.Append(" <TileSize x='" + _tileSizeX.ToString(_nhi) + "' y='" + _tileSizeY.ToString(_nhi) + "' />\r\n");
sb.Append(" <TileResolution x='" + _resX.ToString(_nhi) + "' y='" + _resY.ToString(_nhi) + "' />\r\n");
sb.Append("</TileCacheDefinition>");
StreamWriter sw = new StreamWriter(di.FullName + @"/tilecache.xml");
sw.WriteLine(sb.ToString());
sw.Close();
}
ProgressReport report = new ProgressReport();
int datasetId = await _fdb.DatasetID(_targetDataset.DatasetName);
if (datasetId == -1)
{
return;
}
IClass cls = null;
try
{
cls = (await _sourceDataset.Elements())[0].Class;
}
catch { cls = null; }
IMultiGridIdentify gridClass = cls as IMultiGridIdentify;
if (_gridType == TileGridType.binary_float && gridClass == null)
{
return;
}
IFeatureClass sourceFc = cls as IFeatureClass;
Map map = null;
if (_gridType == TileGridType.image_jpg || _gridType == TileGridType.image_png)
{
map = new Map();
ILayer layer = LayerFactory.Create(cls);
map.AddLayer(layer);
//map.iWidth = (int)(_tileSizeX / _resX);
//map.iHeight = (int)(_tileSizeY / _resY);
}
#region Create Featureclass
IFeatureClass fc = null;
IDatasetElement element = await _targetDataset.Element(_name);
if (element != null && element.Class is IFeatureClass)
{
fc = (IFeatureClass)element.Class;
if (fc.GeometryType == geometryType.Polygon &&
fc.FindField("GRID_LEVEL") != null &&
fc.FindField("GRID_ROW") != null &&
fc.FindField("GRID_COLUMN") != null &&
fc.FindField("FILE") != null)
{
if (MessageBox.Show("TileGridClass already exists. Do you wan't to append to this Grid?",
"Warning",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) != DialogResult.Yes)
{
return;
}
}
else
{
await _fdb.DeleteFeatureClass(_name);
fc = null;
}
}
if (fc == null)
{
Fields fields = new Fields();
fields.Add(new Field("GRID_LEVEL", FieldType.integer));
fields.Add(new Field("GRID_ROW", FieldType.integer));
fields.Add(new Field("GRID_COLUMN", FieldType.integer));
fields.Add(new Field("FILE", FieldType.String, 512));
await _fdb.CreateFeatureClass(_targetDataset.DatasetName, _name,
new GeometryDef(geometryType.Polygon),
fields);
element = await _targetDataset.Element(_name);
if (element == null || !(element.Class is IFeatureClass))
{
return;
}
await _fdb.SetSpatialIndexBounds(_name, "BinaryTree2", iBounds, _spatialIndexDef.SplitRatio, _spatialIndexDef.MaxPerNode, _spatialIndexDef.Levels);
fc = (IFeatureClass)element.Class;
}
#endregion
#region Create Tiles
#region Report
double tx = _tileSizeX, ty = _tileSizeY;
if (ReportProgress != null)
{
report.featureMax = 0;
for (int i = 0; i < _levels; i++)
{
if (_createLevels.Contains(i))
{
for (double y = bounds.miny; y < bounds.maxy; y += ty)
{
for (double x = bounds.minx; x < bounds.maxx; x += tx)
{
report.featureMax++;
}
}
}
if (_levelType == TileLevelType.ConstantImagesize)
{
tx *= 2;
ty *= 2;
}
}
report.Message = "Create Tiles";
report.featurePos = 0;
ReportProgress(report);
}
int reportInterval = (_createTiles ? 10 : 1000);
#endregion
List <IFeature> features = new List <IFeature>();
for (int level = 0; level < _levels; level++)
{
if (map != null)
{
map.iWidth = (int)(_tileSizeX / _resX);
map.iHeight = (int)(_tileSizeY / _resY);
}
if (_createLevels.Contains(level))
{
int row = 0;
for (double y = bounds.miny; y < bounds.maxy; y += _tileSizeY)
{
DirectoryInfo di = new DirectoryInfo(_cacheDirectory + @"/" + level + @"/" + row);
if (!di.Exists)
{
di.Create();
}
int column = 0;
for (double x = bounds.minx; x < bounds.maxx; x += _tileSizeX)
{
#region Polygon
Polygon polygon = new Polygon();
Ring ring = new Ring();
ring.AddPoint(new Point(x, y));
ring.AddPoint(new Point(Math.Min(x + _tileSizeX, bounds.maxx), y));
ring.AddPoint(new Point(Math.Min(x + _tileSizeX, bounds.maxx), Math.Min(y + _tileSizeY, bounds.maxy)));
ring.AddPoint(new Point(x, Math.Min(y + _tileSizeY, bounds.maxy)));
ring.Close();
polygon.AddRing(ring);
#endregion
if (sourceFc != null)
{
SpatialFilter filter = new SpatialFilter();
filter.AddField(sourceFc.IDFieldName);
filter.Geometry = polygon;
filter.FilterSpatialReference = fc.SpatialReference;
using (IFeatureCursor cursor = await sourceFc.GetFeatures(filter))
{
if (await cursor.NextFeature() == null)
{
column++;
report.featurePos++;
if (ReportProgress != null && report.featurePos % reportInterval == 0)
{
ReportProgress(report);
}
continue;
}
}
}
string relFilename = level + "/" + row + "/" + column + ".bin";
if (_createTiles)
{
string filename = di.FullName + @"/" + column;
if (_gridType == TileGridType.binary_float)
{
float[] vals = await gridClass.MultiGridQuery(
null,
new IPoint[] { ring[0], ring[1], ring[3] },
_resX, _resY,
fc.SpatialReference, null);
if (!HasFloatArrayData(vals))
{
column++;
report.featurePos++;
if (ReportProgress != null && report.featurePos % reportInterval == 0)
{
ReportProgress(report);
}
continue;
}
StoreFloatArray(filename + ".bin", x, y, _resX, _resY, vals);
}
else if (map != null)
{
map.ZoomTo(new Envelope(x, y, x + _tileSizeX, y + _tileSizeY));
await map.RefreshMap(DrawPhase.All, _cancelTracker);
if (_gridType == TileGridType.image_png)
{
map.Bitmap.Save(filename + ".png", GraphicsEngine.ImageFormat.Png);
}
else if (_gridType == TileGridType.image_jpg)
{
map.Bitmap.Save(filename + ".jpg", GraphicsEngine.ImageFormat.Jpeg);
}
}
}
Feature feature = new Feature();
feature.Shape = polygon;
feature.Fields.Add(new FieldValue("GRID_LEVEL", level));
feature.Fields.Add(new FieldValue("GRID_ROW", row));
feature.Fields.Add(new FieldValue("GRID_COLUMN", column));
feature.Fields.Add(new FieldValue("FILE", relFilename));
features.Add(feature);
column++;
report.featurePos++;
if (features.Count >= reportInterval)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
if (!await _fdb.Insert(fc, features))
{
MessageBox.Show(_fdb.LastErrorMessage, "DB Insert Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
features.Clear();
if (!_cancelTracker.Continue)
{
succeeded = true;
return;
}
}
}
row++;
}
}
if (_levelType == TileLevelType.ConstantImagesize)
{
_tileSizeX *= 2;
_tileSizeY *= 2;
}
_resX *= 2;
_resY *= 2;
}
if (features.Count > 0)
{
if (ReportProgress != null)
{
ReportProgress(report);
}
await _fdb.Insert(fc, features);
}
await _fdb.CalculateExtent(fc);
#endregion
succeeded = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
if (!succeeded)
{
await _fdb.DeleteFeatureClass(_name);
}
}
}
