async private Task <bool> CopyFeatures2(IFeatureClass source, IFeatureUpdater fdb, IFeatureClass dest, FieldTranslation fTrans, BinaryTree2Builder treeBuilder)
{
List <BinaryTree2BuilderNode> nodes;
if (treeBuilder == null || (nodes = treeBuilder.Nodes) == null)
{
_errMsg = "Spatial Index is not defined...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Copy Features (" + dest.Name + ")");
}
int featcounter = 0;
foreach (BinaryTree2BuilderNode node in nodes)
{
if (!_cancelTracker.Continue)
{
break;
}
RowIDFilter filter = new RowIDFilter(source.IDFieldName);
filter.IDs = node.OIDs;
filter.SubFields = "*";
using (IFeatureCursor fCursor = await source.GetFeatures(filter))
{
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(false);
}
int copycounter = await CopyFeatures(fCursor, node.Number, fdb, dest, fTrans, featcounter);
if (copycounter < 0)
{
fCursor.Dispose();
return(false);
}
featcounter = copycounter;
fCursor.Dispose();
}
}
if (ReportProgress != null)
{
ReportProgress(this, featcounter);
}
return(true);
}
async public Task <IFeatureCursor> NetworkPathEdges(NetworkEdgeCollectionOutput edgeCollection)
{
if (_nfc == null)
{
return(null);
}
RowIDFilter filter = new RowIDFilter(String.Empty);
foreach (NetworkEdgeOutput edge in edgeCollection)
{
filter.IDs.Add(edge.EdgeId);
}
return(await _nfc.GetEdgeFeatures(filter));
}
async public Task <IFeatureCursor> NetworkPathEdges(Dijkstra.NetworkPath networkPath)
{
if (_nfc == null)
{
return(null);
}
RowIDFilter filter = new RowIDFilter(String.Empty);
foreach (Dijkstra.NetworkPathEdge edge in networkPath)
{
filter.IDs.Add(edge.EId);
}
return(await _nfc.GetEdgeFeatures(filter));
}
private bool CopyFeatures(IFeatureClass source, IFeatureUpdater fdb, IFeatureClass dest, FieldTranslation fTrans, DualTree tree)
{
if (tree == null || tree.Nodes == null)
{
_errMsg = "Spatial Index is not defined...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Copy Features (" + dest.Name + ")");
}
int featcounter = 0;
foreach (SpatialIndexNode node in tree.Nodes)
{
if (!_cancelTracker.Continue)
{
break;
}
RowIDFilter filter = new RowIDFilter(source.IDFieldName);
filter.IDs = node.IDs;
filter.SubFields = "*";
using (IFeatureCursor fCursor = source.GetFeatures(filter))
{
if (fCursor == null)
{
_errMsg = "Fatal error: sourcedb query failed...";
return(false);
}
if (!CopyFeatures(fCursor, node.NID, fdb, dest, fTrans, ref featcounter))
{
fCursor.Dispose();
return(false);
}
fCursor.Dispose();
}
}
if (ReportProgress != null)
{
ReportProgress(this, featcounter);
}
return(true);
}
private void RelationTreeNode_Click(object sender, EventArgs e)
{
IFeatureSelection target = (this.TableRelation.LeftTable == this.DatasetElement ? this.TableRelation.RightTable : this.TableRelation.LeftTable) as IFeatureSelection;
if (target == null)
{
return;
}
target.ClearSelection();
if (this.DatasetElement is IFeatureSelection &&
((IFeatureSelection)this.DatasetElement).SelectionSet is IIDSelectionSet)
{
IIDSelectionSet selSet = (IIDSelectionSet)((IFeatureSelection)this.DatasetElement).SelectionSet;
if (selSet != null && selSet.IDs != null && selSet.IDs.Count > 0)
{
string relationField = this.TableRelation.LeftTable == this.DatasetElement ? this.TableRelation.LeftTableField : this.TableRelation.RightTableField;
RowIDFilter filter = new RowIDFilter(((ITableClass)this.DatasetElement.Class).IDFieldName);
filter.IDs = selSet.IDs;
filter.SubFields = relationField;
ICursor cursor = ((ITableClass)this.DatasetElement.Class).Search(filter);
IRow row = null;
while ((row = Next(cursor)) != null)
{
object val = row[relationField];
if (val == null)
{
continue;
}
IQueryFilter selFilter = this.TableRelation.LeftTable == this.DatasetElement ? this.TableRelation.GetRightFilter("*", val) : this.TableRelation.GetLeftFilter("*", val);
target.Select(selFilter, CombinationMethod.Union);
}
}
}
target.FireSelectionChangedEvent();
if (_mapDocument != null && _mapDocument.Application is IMapApplication)
{
((IMapApplication)_mapDocument.Application).RefreshActiveMap(DrawPhase.Selection);
}
}
async public Task <IFeatureCursor> NetworkPathEdges(Dijkstra.Nodes nodes, string fields)
{
if (_nfc == null)
{
return(null);
}
//StringBuilder sb = new StringBuilder();
//sb.Append("FDB_OID in (");
//foreach (Dijkstra.Node node in nodes)
//{
// //if (node.Dist > maxDistance)
// // continue;
// if (sb.Length > 12)
// sb.Append(",");
// sb.Append(node.EId);
//}
//sb.Append(")");
//QueryFilter filter = new QueryFilter();
//filter.AddField("FDB_OID");
//filter.AddField("FDB_SHAPE");
//if (!String.IsNullOrEmpty(fields))
//{
// foreach (string field in fields.Split(','))
// filter.AddField(field);
//}
//filter.WhereClause = sb.ToString();
RowIDFilter filter = new RowIDFilter(String.Empty);
foreach (Dijkstra.Node node in nodes)
{
filter.IDs.Add(node.EId);
}
if (!String.IsNullOrEmpty(fields))
{
foreach (string field in fields.Split(','))
{
filter.AddField(field);
}
}
return(await _nfc.GetEdgeFeatures(filter));
}
async public Task <IFeature> GetEdgeFeature(int eid)
{
RowIDFilter filter = new RowIDFilter(String.Empty);
filter.IDs.Add(eid);
filter.AddField("*");
IFeatureCursor cursor = await GetEdgeFeatures(filter);
if (cursor == null)
{
return(null);
}
IFeature feature = await cursor.NextFeature();
cursor.Dispose();
if (feature != null && feature.FindField("FCID") != null && feature.FindField("OID") != null &&
_edgeFcs.ContainsKey((int)feature["FCID"]))
{
IGraphEdge edge = _pageManager.GetEdge(eid);
try
{
if (edge != null && edge.FcId == -1) // Complex Edge
{
filter = new RowIDFilter("FDB_OID");
filter.IDs.Add((int)feature["OID"]);
filter.AddField("*");
IFeatureClass fc = _edgeFcs[(int)feature["FCID"]];
using (IFeatureCursor c = await fc.GetFeatures(filter))
{
return(await c.NextFeature());
}
}
}
catch { }
}
return(feature);
}
public IFeature GetEdgeFeature(int eid)
{
RowIDFilter filter = new RowIDFilter(String.Empty);
filter.IDs.Add(eid);
filter.AddField("*");
IFeature feature = null;
using (IFeatureCursor cursor = GetEdgeFeatures(filter))
{
feature = cursor.NextFeature;
}
if (feature != null && feature.FindField("FCID") != null && feature.FindField("OID") != null &&
_edgeFcs.ContainsKey(Convert.ToInt32(feature["FCID"])))
{
IGraphEdge edge = _pageManager.GetEdge(eid);
try
{
if (edge != null && edge.FcId == -1) // Complex Edge
{
filter = new RowIDFilter("FDB_OID");
filter.IDs.Add(Convert.ToInt32(feature["OID"]));
filter.AddField("*");
IFeatureClass fc = _edgeFcs[Convert.ToInt32(feature["FCID"])];
using (IFeatureCursor c = fc.GetFeatures(filter))
{
return(c.NextFeature);
}
}
}
catch { }
}
return(feature);
}
public ExportFeatureClassDialog(IDisplay display, IFeatureLayer sourceFeatureLayer)
{
InitializeComponent();
_sourceFeatureClass = sourceFeatureLayer.Class as IFeatureClass;
#region Filter
//All Features
//Selected Features
//Features in actual extent
cmbExport.Items.Add(new ExportMethodItem("All Features", null));
if (sourceFeatureLayer is IFeatureSelection &&
((IFeatureSelection)sourceFeatureLayer).SelectionSet != null &&
((IFeatureSelection)sourceFeatureLayer).SelectionSet.Count > 0)
{
ISelectionSet selectionSet = ((IFeatureSelection)sourceFeatureLayer).SelectionSet;
IQueryFilter selFilter = null;
if (selectionSet is IIDSelectionSet)
{
selFilter = new RowIDFilter(_sourceFeatureClass.IDFieldName, ((IIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IGlobalIDSelectionSet)
{
selFilter = new GlobalRowIDFilter(_sourceFeatureClass.IDFieldName, ((IGlobalIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IQueryFilteredSelectionSet)
{
selFilter = ((IQueryFilteredSelectionSet)selectionSet).QueryFilter.Clone() as IQueryFilter;
}
if (selFilter != null)
{
selFilter.SubFields = "*";
ExportMethodItem item = new ExportMethodItem("Selected Features", selFilter);
cmbExport.Items.Add(item);
cmbExport.SelectedItem = item;
}
}
if (display != null && display.Envelope != null)
{
SpatialFilter dispFilter = new SpatialFilter();
dispFilter.SubFields = "*";
dispFilter.FilterSpatialReference = display.SpatialReference;
dispFilter.Geometry = display.Envelope;
dispFilter.SpatialRelation = spatialRelation.SpatialRelationIntersects;
cmbExport.Items.Add(new ExportMethodItem("Features in actual extent", dispFilter));
}
if (cmbExport.SelectedIndex == -1)
{
cmbExport.SelectedIndex = 0;
}
#endregion
_listViewItem = new FeatureClassListViewItem(_sourceFeatureClass, 255);
gvFields.DataSource = _listViewItem.Fields;
panelStep1.Dock = panelStep2.Dock = DockStyle.Fill;
SetPanelVisibity();
}
private void FormChartWizard_Load(object sender, EventArgs e)
{
#region Tab Chart Type
foreach (gvChart.gvChartType chartType in gvChart.ChartTypes)
{
lstChartTypes.Items.Add(chartType);
}
lstChartTypes.SelectedItem = 0;
Series ser1 = new Series("Serie 1");
ser1.Points.AddXY("A", 10);
ser1.Points.AddXY("B", 6);
ser1.Points.AddXY("C", 8);
ser1.Points.AddXY("D", 12);
ser1.Points.AddXY("E", 3);
ser1.Color = Color.Red;
ser1.ChartArea = "Area1";
Series ser2 = new Series("Serie 2");
ser2.Points.AddXY("A", 5);
ser2.Points.AddXY("B", 3);
ser2.Points.AddXY("C", 7);
ser2.Points.AddXY("D", 8);
ser2.Points.AddXY("E", 6);
ser2.Color = Color.Blue;
ser2.ChartArea = "Area1";
_gvChart.Series.Add(ser1);
_gvChart.Series.Add(ser2);
_gvChart.Refresh();
#endregion
#region Tab Data
ITableClass tc = (ITableClass)_layer.Class;
foreach (IField field in _layer.Fields)
{
if (field.type == FieldType.biginteger ||
field.type == FieldType.Double ||
field.type == FieldType.Float ||
field.type == FieldType.integer ||
field.type == FieldType.smallinteger)
{
lstSeries.Items.Add(new FieldItem()
{
Field = field
});
}
if (field.type != FieldType.binary &&
field.type != FieldType.GEOGRAPHY &&
field.type != FieldType.GEOMETRY &&
field.type != FieldType.Shape)
{
cmbDataFields.Items.Add(new FieldItem()
{
Field = field
});
}
}
if (cmbDataFields.Items.Count > 0)
{
cmbDataFields.SelectedIndex = 0;
}
#region Filter
//All Features
//Selected Features
//Features in actual extent
cmbFeatures.Items.Add(new ExportMethodItem("All Features", new QueryFilter()));
if (_layer is IFeatureSelection &&
((IFeatureSelection)_layer).SelectionSet != null &&
((IFeatureSelection)_layer).SelectionSet.Count > 0)
{
ISelectionSet selectionSet = ((IFeatureSelection)_layer).SelectionSet;
IQueryFilter selFilter = null;
if (selectionSet is IIDSelectionSet)
{
selFilter = new RowIDFilter(tc.IDFieldName, ((IIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IGlobalIDSelectionSet)
{
selFilter = new GlobalRowIDFilter(tc.IDFieldName, ((IGlobalIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IQueryFilteredSelectionSet)
{
selFilter = ((IQueryFilteredSelectionSet)selectionSet).QueryFilter.Clone() as IQueryFilter;
}
if (selFilter != null)
{
selFilter.SubFields = "*";
ExportMethodItem item = new ExportMethodItem("Selected Features", selFilter);
cmbFeatures.Items.Add(item);
cmbFeatures.SelectedItem = item;
}
}
if (_display != null && _display.Envelope != null)
{
SpatialFilter dispFilter = new SpatialFilter();
dispFilter.SubFields = "*";
dispFilter.FilterSpatialReference = _display.SpatialReference;
dispFilter.Geometry = _display.Envelope;
dispFilter.SpatialRelation = spatialRelation.SpatialRelationIntersects;
cmbFeatures.Items.Add(new ExportMethodItem("Features in actual extent", dispFilter));
}
if (cmbFeatures.SelectedIndex == -1)
{
cmbFeatures.SelectedIndex = 0;
}
#endregion
#endregion
}
async public Task <NetworkTracerOutputCollection> Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, gView.Framework.system.ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput source = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
NetworkWeighInput weight =
input.Contains(NetworkTracerInputType.Weight) ?
input.Collect(NetworkTracerInputType.Weight)[0] as NetworkWeighInput :
null;
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
dijkstra.MaxDistance = _properties.Distance;
if (weight != null)
{
dijkstra.GraphWeight = weight.Weight;
dijkstra.WeightApplying = weight.WeightApplying;
}
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
Dijkstra.ApplyInputIds(dijkstra, input);
dijkstra.Calculate(gt, source.NodeId);
NetworkTracerOutputCollection output = new NetworkTracerOutputCollection();
#region Knoten/Kanten <= Distance
Dijkstra.Nodes dijkstraNodes = dijkstra.DijkstraNodesWithMaxDistance(_properties.Distance);
if (dijkstraNodes == null)
{
return(null);
}
List <int> edgeIds = new List <int>();
foreach (Dijkstra.Node dijkstraNode in dijkstraNodes)
{
if (dijkstraNode.EId < 0)
{
continue;
}
int index = edgeIds.BinarySearch(dijkstraNode.EId);
if (index < 0)
{
edgeIds.Insert(~index, dijkstraNode.EId);
}
if (Math.Abs(dijkstraNode.Dist - _properties.Distance) < double.Epsilon)
{
// ToDo: Flag einfügen!!
}
}
output.Add(new NetworkEdgeCollectionOutput(edgeIds));
#endregion
#region Knoten/Kanten > Distance
Dijkstra.Nodes cnodes = dijkstra.DijkstraNodesDistanceGreaterThan(_properties.Distance);
foreach (Dijkstra.Node cnode in cnodes)
{
Dijkstra.Node node = dijkstra.DijkstraNodes.ById(cnode.Pre);
if (node == null)
{
continue;
}
IGraphEdge graphEdge = gt.QueryEdge(cnode.EId);
if (graphEdge == null)
{
continue;
}
RowIDFilter filter = new RowIDFilter(String.Empty);
filter.IDs.Add(graphEdge.Eid);
IFeatureCursor cursor = await network.GetEdgeFeatures(filter);
if (cursor == null)
{
continue;
}
IFeature feature = await cursor.NextFeature();
if (feature == null)
{
continue;
}
IPath path = null;
if (cnode.Id != graphEdge.N2 && cnode.Id == graphEdge.N1)
{
((Polyline)feature.Shape)[0].ChangeDirection();
}
double trimDist = _properties.Distance - node.Dist;
string label = _properties.Distance.ToString();
if (weight != null)
{
double w = gt.QueryEdgeWeight(weight.Weight.Guid, cnode.EId);
switch (weight.WeightApplying)
{
case WeightApplying.Weight:
trimDist *= w;
break;
case WeightApplying.ActualCosts:
trimDist = ((IPolyline)feature.Shape)[0].Length * trimDist * w; // ??? Prüfen
break;
}
label += "\n(" + Math.Round(node.GeoDist + trimDist, 2).ToString() + ")";
}
path = ((IPolyline)feature.Shape)[0].Trim(trimDist);
Polyline polyline = new Polyline();
polyline.AddPath(path);
output.Add(new NetworkEdgePolylineOutput(cnode.EId, polyline));
output.Add(new NetworkFlagOutput(
polyline[0][polyline[0].PointCount - 1],
label));
}
#endregion
return(output);
}
async public Task Render()
{
if (_layer == null)
{
return;
}
if (_layer.SelectionRenderer == null)
{
return;
}
if (!(_layer is IFeatureSelection))
{
return;
}
IFeatureClass fClass = _layer.FeatureClass;
if (fClass == null)
{
return;
}
ISelectionSet selectionSet = ((IFeatureSelection)_layer).SelectionSet;
if (selectionSet == null)
{
return;
}
IDataset dataset = _map[_layer];
if (dataset == null)
{
return;
}
if (!(dataset is IFeatureDataset))
{
return;
}
IGeometry filterGeom = _map.Display.Envelope;
if (_map.Display.GeometricTransformer != null)
{
filterGeom = MapHelper.Project(fClass, _map.Display);
//filterGeom = (IGeometry)_map.Display.GeometricTransformer.InvTransform2D(filterGeom);
}
IQueryFilter filter = null;
//List<int> IDs=new List<int>(); // Sollte nicht null sein...
if (selectionSet is ISpatialIndexedIDSelectionSet)
{
List <int> IDs = ((ISpatialIndexedIDSelectionSet)selectionSet).IDsInEnvelope(filterGeom.Envelope);
filter = new RowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IIDSelectionSet)
{
List <int> IDs = ((IIDSelectionSet)selectionSet).IDs;
filter = new RowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is ISpatialIndexedGlobalIDSelectionSet)
{
List <long> IDs = ((ISpatialIndexedGlobalIDSelectionSet)selectionSet).IDsInEnvelope(filterGeom.Envelope);
filter = new GlobalRowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IGlobalIDSelectionSet)
{
List <long> IDs = ((IGlobalIDSelectionSet)selectionSet).IDs;
filter = new GlobalRowIDFilter(fClass.IDFieldName, IDs);
}
else if (selectionSet is IQueryFilteredSelectionSet)
{
filter = ((IQueryFilteredSelectionSet)selectionSet).QueryFilter.Clone() as IQueryFilter;
}
if (filter == null)
{
return;
}
filter.AddField(fClass.ShapeFieldName);
#region Clone Layer
IFeatureRenderer selectionRenderer = null;
lock (lockThis)
{
// Beim Clonen sprerren...
// Da sonst bei der Servicemap bei gleichzeitigen Requests
// Exception "Objekt wird bereits an anderer Stelle verwendet" auftreten kann!
selectionRenderer = (IFeatureRenderer)_layer.SelectionRenderer.Clone(new CloneOptions(_map,
false,
maxLabelRefscaleFactor: _layer.MaxRefScaleFactor));
}
#endregion
selectionRenderer.PrepareQueryFilter(_layer, filter);
using (IFeatureCursor fCursor = (fClass is ISelectionCache) ? ((ISelectionCache)fClass).GetSelectedFeatures(_map.Display) : await fClass.GetFeatures(filter))
{
if (fCursor != null)
{
//_layer.SelectionRenderer.Draw(_map, fCursor, DrawPhase.Geography, _cancelTracker);
IFeature feature;
while ((feature = await fCursor.NextFeature()) != null)
{
if (_cancelTracker != null)
{
if (!_cancelTracker.Continue)
{
break;
}
}
selectionRenderer.Draw(_map, feature);
}
fCursor.Dispose();
}
}
}
async public Task <IFeatureCursor> GetEdgeFeatures(IQueryFilter filter)
{
if (_edgeFcs.Count == 0)
{
return(null);
}
if (filter is SpatialFilter)
{
List <IFeatureClass> edgeFcs = new List <IFeatureClass>();
if (_edgeFcs != null)
{
foreach (IFeatureClass fc in _edgeFcs.Values)
{
edgeFcs.Add(fc);
}
}
return(new NetworkFeatureCursor(_fdb, _name, edgeFcs, null, filter));
}
if (filter is RowIDFilter)
{
RowIDFilter idFilter = (RowIDFilter)filter;
Dictionary <int, QueryFilter> rfilters = new Dictionary <int, QueryFilter>();
Dictionary <int, Dictionary <int, List <FieldValue> > > additionalFields = new Dictionary <int, Dictionary <int, List <FieldValue> > >();
foreach (int eid in idFilter.IDs)
{
IGraphEdge edge = _pageManager.GetEdge(eid);
if (edge == null || _edgeFcs.ContainsKey(edge.FcId) == false)
{
continue;
}
if (!rfilters.ContainsKey(edge.FcId))
{
string idFieldName = "FDB_OID";
string shapeFieldName = "FDB_SHAPE";
IFeatureClass fc = edge.FcId >= 0 ? await _fdb.GetFeatureclass(edge.FcId) : null;
if (fc != null)
{
idFieldName = fc.IDFieldName;
shapeFieldName = fc.ShapeFieldName;
}
rfilters.Add(edge.FcId, new RowIDFilter(edge.FcId >= 0 ? idFieldName : "EID"));
rfilters[edge.FcId].AddField(shapeFieldName);
additionalFields.Add(edge.FcId, new Dictionary <int, List <FieldValue> >());
rfilters[edge.FcId].IgnoreUndefinedFields = true;
rfilters[edge.FcId].AddField(shapeFieldName);
if (filter.SubFields.IndexOf("*") != -1)
{
rfilters[edge.FcId].AddField("*");
}
else
{
foreach (string field in filter.SubFields.Split(' '))
{
if (field == shapeFieldName)
{
continue;
}
if (fc.Fields.FindField(field) != null)
{
rfilters[edge.FcId].AddField(fc.Fields.FindField(field).name);
}
}
}
}
((RowIDFilter)rfilters[edge.FcId]).IDs.Add(edge.FcId >= 0 ? edge.Oid : edge.Eid);
additionalFields[edge.FcId].Add(edge.FcId >= 0 ? edge.Oid : edge.Eid, new List <FieldValue>()
{
new FieldValue("_eid", edge.Eid)
});
}
if (rfilters.ContainsKey(-1))
{
RowIDFilter complexEdgeFilter = (RowIDFilter)rfilters[-1];
QueryFilter ceFilter = new QueryFilter(complexEdgeFilter);
ceFilter.WhereClause = complexEdgeFilter.RowIDWhereClause;
rfilters[-1] = ceFilter;
}
return(new CursorCollection <int>(_edgeFcs, rfilters, additionalFields));
}
return(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...");
}
