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); } } }