Esempio n. 1
0
        public TileCacheLayerExplorerObject(TileCacheDatasetExplorerObject parent, IDatasetElement element)
            : base(parent, typeof(FeatureClass), 1)
        {
            if (element == null)
            {
                return;
            }

            _parent = parent;
            _fcname = element.Title;

            if (element.Class is IRasterClass)
            {
                _rc = (IRasterClass)element.Class;
            }
        }
Esempio n. 2
0
        async public Task <IDatasetElement> Element(string title)
        {
            if (_fdb == null)
            {
                return(null);
            }

            IDatasetElement element = await _fdb.DatasetElement(this, title);

            if (element != null && element.Class is pgFeatureClass)
            {
                ((pgFeatureClass)element.Class).SpatialReference = _sRef;
            }

            return(element);
        }
Esempio n. 3
0
        private void cmbRightTable_SelectedIndexChanged(object sender, EventArgs e)
        {
            cmbRightTableField.Items.Clear();
            if (cmbRightTable.SelectedItem == null)
            {
                return;
            }

            IDatasetElement element = ((DatasetElementItem)cmbRightTable.SelectedItem).DatasetElement;

            foreach (IField field in ((ITableClass)element.Class).Fields)
            {
                cmbRightTableField.Items.Add(field.name);
            }
            ValidateOk();
        }
Esempio n. 4
0
        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));
        }
Esempio n. 5
0
        async private void btnOK_Click(object sender, EventArgs e)
        {
            if (_dataset != null &&
                _dataset.ConnectionString != _dsConnectionString)
            {
                await _dataset.SetConnectionString(_dsConnectionString);

                await _dataset.Open();

                int      dsIndex = 0;
                IDataset ds;
                while ((ds = _map[dsIndex]) != null)
                {
                    if (ds == _dataset)
                    {
                        break;
                    }
                    dsIndex++;
                }
                if (ds == null)
                {
                    return;
                }

                foreach (IDatasetElement element in _map.MapElements)
                {
                    if (!(element is DatasetElement))
                    {
                        continue;
                    }

                    if (element.DatasetID == dsIndex)
                    {
                        IDatasetElement el = await _dataset.Element(element.Title);

                        if (el == null)
                        {
                            ((DatasetElement)element).Class2 = null;
                        }
                        else
                        {
                            ((DatasetElement)element).Class2 = el.Class;
                        }
                    }
                }
            }
        }
        public IExplorerObject CreateExplorerObject(IExplorerObject parentExObject)
        {
            if (!CanCreate(parentExObject))
            {
                return(null);
            }

            if (!(parentExObject.Object is IFeatureDataset) || !(((IDataset)parentExObject.Object).Database is AccessFDB))
            {
                return(null);
            }
            AccessFDB fdb = ((IDataset)parentExObject.Object).Database as AccessFDB;

            FormNewFeatureclass dlg = new FormNewFeatureclass(parentExObject.Object as IFeatureDataset);

            if (dlg.ShowDialog() != DialogResult.OK)
            {
                return(null);
            }

            IGeometryDef gDef = dlg.GeometryDef;

            int FCID = fdb.CreateFeatureClass(
                parentExObject.Name,
                dlg.FeatureclassName,
                gDef,
                dlg.Fields);

            if (FCID < 0)
            {
                MessageBox.Show("ERROR: " + fdb.lastErrorMsg);
                return(null);
            }

            ISpatialIndexDef sIndexDef = fdb.SpatialIndexDef(parentExObject.Name);

            fdb.SetSpatialIndexBounds(dlg.FeatureclassName, "BinaryTree2", dlg.SpatialIndexExtents, 0.55, 200, dlg.SpatialIndexLevels);

            IDatasetElement element = ((IFeatureDataset)parentExObject.Object)[dlg.FeatureclassName];

            return(new AccessFDBFeatureClassExplorerObject(
                       parentExObject as AccessFDBDatasetExplorerObject,
                       _filename,
                       parentExObject.Name,
                       element));
        }
Esempio n. 7
0
        public IDatasetElement this[string DatasetElementTitle]
        {
            get
            {
                if (_fdb == null)
                {
                    return(null);
                }
                IDatasetElement element = _fdb.DatasetElement(this, DatasetElementTitle);

                if (element != null && element.Class is AccessFDBFeatureClass)
                {
                    ((AccessFDBFeatureClass)element.Class).SpatialReference = _sRef;
                }

                return(element);
            }
        }
Esempio n. 8
0
        public override bool ProcessAble(IDatasetElement data)
        {
            if (data == null || data.Class == null)
            {
                return(false);
            }

            if (data.Class is IFeatureClass)
            {
                if (_geomType == geometryType.Unknown)
                {
                    return(true);
                }

                return(((IFeatureClass)data.Class).GeometryType == _geomType);
            }
            return(false);
        }
Esempio n. 9
0
        async public Task <object> GetInstanceAsync()
        {
            if (_fc != null)
            {
                return(_fc);
            }

            var datdaset = await this.Dataset();

            if (this.Dataset() != null)
            {
                IDatasetElement element = await datdaset.Element(_fcName);

                if (element != null)
                {
                    _fc = element.Class as IFeatureClass;
                }
            }

            return(_fc);
        }
Esempio n. 10
0
		public IMap this[IDatasetElement layer] 
		{
			get 
			{
				foreach(IMap map in _maps) 
				{
                    if (layer is IGroupLayer)
                    {
                        foreach (IDatasetElement element in map.MapElements)
                        {
                            if (layer == element) return map;
                        }
                    }
                    else
                    {
                        if (map[layer] != null) return map;
                    }
				}
				return null;
			}
		}
Esempio n. 11
0
        public OgrLayerExplorerObject(OgrDatasetExplorerObject parent, IDatasetElement element)
            : base(parent, typeof(FeatureClass))
        {
            if (element == null)
            {
                return;
            }

            _parent = parent;
            _fcname = element.Title;

            if (element.Class is IFeatureClass)
            {
                _fc = (IFeatureClass)element.Class;
                switch (_fc.GeometryType)
                {
                case geometryType.Envelope:
                case geometryType.Polygon:
                    _icon = new AccessFDBPolygonIcon();
                    _type = "Polygon Featureclass";
                    break;

                case geometryType.Multipoint:
                case geometryType.Point:
                    _icon = new AccessFDBPointIcon();
                    _type = "Point Featureclass";
                    break;

                case geometryType.Polyline:
                    _icon = new AccessFDBLineIcon();
                    _type = "Polyline Featureclass";
                    break;

                default:
                    _icon = new AccessFDBLineIcon();
                    _type = "Featureclass";
                    break;
                }
            }
        }
Esempio n. 12
0
        private static IFeatureClass GetFeatureclass(IFeatureDataset ds, string name)
        {
            IDatasetElement element = ds[name];

            if (element != null && element.Class is IFeatureClass)
            {
                return(element.Class as IFeatureClass);
            }

            foreach (IDatasetElement element2 in ds.Elements)
            {
                if (element2.Class is IFeatureClass)
                {
                    if (element2.Class.Name == name)
                    {
                        return(element2.Class as IFeatureClass);
                    }
                }
            }

            return(null);
        }
Esempio n. 13
0
        public void AppendElement(string elementName)
        {
            if (_elements == null)
            {
                _elements = new List <IDatasetElement>();
            }

            foreach (IDatasetElement e in _elements)
            {
                if (e.Title == elementName)
                {
                    return;
                }
            }

            IDatasetElement element = this[elementName];

            if (element != null)
            {
                _elements.Add(element);
            }
        }
Esempio n. 14
0
        async public Task AppendElement(string elementName)
        {
            if (_layers == null)
            {
                _layers = new List <IDatasetElement>();
            }

            foreach (IDatasetElement e in _layers)
            {
                if (e.Title == elementName)
                {
                    return;
                }
            }

            IDatasetElement element = await _fdb.DatasetElement(this, elementName);

            if (element != null)
            {
                _layers.Add(element);
            }
        }
Esempio n. 15
0
        public void AppendElement(string elementName)
        {
            if (_layers == null)
            {
                _layers = new List <IDatasetElement>();
            }

            foreach (IDatasetElement e in _layers)
            {
                if (e.Title == elementName)
                {
                    return;
                }
            }

            //IDatasetElement element = _fdb.DatasetElement(this, elementName);
            IDatasetElement element = this[elementName];

            if (element != null)
            {
                _layers.Add(element);
            }
        }
        private void MigrateMapToFeatureDatabaseDialog_Shown(object sender, EventArgs e)
        {
            #region Featureklassen mit gleichen Namen suchen
            List <IDatasetElement> elements = _map.MapElements;
            for (int i = 0; i < elements.Count; i++)
            {
                IDatasetElement elementI = elements[i];
                if (!(elementI.Class is IFeatureClass))
                {
                    continue;
                }

                for (int j = i + 1; j < elements.Count; j++)
                {
                    IDatasetElement elementJ = elements[j];
                    if (!(elementJ.Class is IFeatureClass))
                    {
                        continue;
                    }

                    if (elementI.Class.Name == elementJ.Class.Name)
                    {
                        IFeatureClass fcI = (IFeatureClass)elementI.Class, fcJ = (IFeatureClass)elementJ.Class;
                        if (fcI.Dataset.ConnectionString.ToLower() == fcJ.Dataset.ConnectionString.ToLower())
                        {
                            continue;
                        }

                        MessageBox.Show("There is more than one featureclass with the name '" + elementI.Class.Name + "'!\nEvery featureclass must have different name to run this function...", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        this.Close();
                        return;
                    }
                }
            }
            #endregion
        }
Esempio n. 17
0
        public FormDataTable2(IDatasetElement dsElement)
        {
            InitializeComponent();

            _tableClass = null;
            if (dsElement is IFeatureLayer)
            {
                _tableClass = ((IFeatureLayer)dsElement).FeatureClass;
            }
            else if (dsElement is ITableLayer)
            {
                _tableClass = ((ITableLayer)dsElement).TableClass;
            }

            _dsElement = dsElement;

            cmbShow.SelectedIndex = 0;

            if (_dsElement is IFeatureSelection)
            {
                ((IFeatureSelection)_dsElement).FeatureSelectionChanged -= new FeatureSelectionChangedEvent(FeatureSelectionChanged);
                ((IFeatureSelection)_dsElement).FeatureSelectionChanged += new FeatureSelectionChangedEvent(FeatureSelectionChanged);
            }
        }
Esempio n. 18
0
        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;
                }
            }
        }
Esempio n. 19
0
 public LayerTreeNode(IDatasetElement layer)
 {
     base.ImageIndex = base.SelectedImageIndex = 1;
     this.Layer      = layer;
     base.Text       = this.ToString();
 }
Esempio n. 20
0
        public MsSql2008SpatialSdeFeatureClassExplorerObject(MsSql2008SpatialSdeExplorerObject parent, IDatasetElement element)
            : base(parent, typeof(IFeatureClass), 1)
        {
            if (element == null || !(element.Class is IFeatureClass))
            {
                return;
            }

            _parent = parent;
            _fcname = element.Title;

            if (element.Class is IFeatureClass)
            {
                _fc = (IFeatureClass)element.Class;
                switch (_fc.GeometryType)
                {
                case geometryType.Envelope:
                case geometryType.Polygon:
                    _icon = new MsSql2008SpatialSdePolygonIcon();
                    _type = "Polygon Featureclass";
                    break;

                case geometryType.Multipoint:
                case geometryType.Point:
                    _icon = new MsSql2008SpatialSdePointIcon();
                    _type = "Point Featureclass";
                    break;

                case geometryType.Polyline:
                    _icon = new MsSql2008SpatialSdeLineIcon();
                    _type = "Polyline Featureclass";
                    break;

                default:
                    _icon = new MsSql2008SpatialSdeLineIcon();
                    _type = "Featureclass";
                    break;
                }
            }
        }
Esempio n. 21
0
        override public List <IActivityData> Process()
        {
            IDatasetElement sElement = base.SourceDatasetElement;
            IFeatureClass   sFc      = base.SourceFeatureClass;

            TargetDatasetElement tElement = base.TargetDatasetElement;
            IDataset             tDs      = base.TargetDataset;
            //IFeatureDatabase tDatabase = base.TargetFeatureDatabase;

            GeometryDef geomDef = new GeometryDef(
                geometryType.Polygon,
                null,
                false);

            IFeatureClass    tFc       = base.CreateTargetFeatureclass(geomDef, sFc.Fields);
            IFeatureDatabase tDatabase = FeatureDatabase(tFc);

            Report.featureMax = sFc.CountFeatures;
            Report.featurePos = 0;
            ReportProgess("Query Filter: " + SourceData.FilterClause);

            using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
            {
                IFeature        feature;
                List <IFeature> features = new List <IFeature>();

                ReportProgess("Read/Write Features...");
                while ((feature = cursor.NextFeature) != null)
                {
                    if (feature.Shape is ITopologicalOperation)
                    {
                        feature.Shape = ((ITopologicalOperation)feature.Shape).Buffer(_bufferDistance);
                    }
                    else
                    {
                        continue;
                    }

                    if (feature.Shape == null)
                    {
                        continue;
                    }

                    features.Add(feature);

                    Report.featurePos++;
                    ReportProgess();
                    if (!CancelTracker.Continue)
                    {
                        break;
                    }

                    if (features.Count > 100)
                    {
                        if (!tDatabase.Insert(tFc, features))
                        {
                            throw new Exception(tDatabase.lastErrorMsg);
                        }
                        features.Clear();
                    }
                }

                if (features.Count > 0)
                {
                    ReportProgess();
                    if (!tDatabase.Insert(tFc, features))
                    {
                        throw new Exception(tDatabase.lastErrorMsg);
                    }
                }

                ReportProgess("Flush Features");
                base.FlushFeatureClass(tFc);

                return(base.ToProcessResult(tFc));
            }
        }
Esempio n. 22
0
        public override List <IActivityData> Process()
        {
            IDatasetElement sElement = base.SourceDatasetElement;
            IFeatureClass   sFc      = base.SourceFeatureClass;

            TargetDatasetElement tElement = base.TargetDatasetElement;
            IDataset             tDs      = base.TargetDataset;
            //IFeatureDatabase tDatabase = base.TargetFeatureDatabase;

            IFeatureClass    tFc       = base.CreateTargetFeatureclass(sFc, sFc.Fields);
            IFeatureDatabase tDatabase = FeatureDatabase(tFc);

            Report.featureMax = sFc.CountFeatures;
            Report.featurePos = 0;
            ReportProgess("Query Filter: " + SourceData.FilterClause);

            using (IFeatureCursor cursor = SourceData.GetFeatures(String.Empty))
            {
                IFeature        feature;
                List <IFeature> features = new List <IFeature>();

                ReportProgess("Read/Write Features...");
                while ((feature = cursor.NextFeature) != null)
                {
                    if (feature.Shape == null)
                    {
                        continue;
                    }

                    List <IGeometry> geometries = new List <IGeometry>();
                    #region Dissolve
                    if (feature.Shape is IPolygon)
                    {
                        foreach (IPolygon polygon in Algorithm.SplitPolygonToDonutsAndPolygons((IPolygon)feature.Shape))
                        {
                            geometries.Add(polygon);
                        }
                    }
                    else if (feature.Shape is IPolyline)
                    {
                        foreach (IPath path in Algorithm.GeometryPaths((IPolyline)feature.Shape))
                        {
                            Polyline pLine = new Polyline();
                            pLine.AddPath(path);
                            geometries.Add(pLine);
                        }
                    }
                    else if (feature.Shape is IMultiPoint)
                    {
                        for (int i = 0; i < ((IMultiPoint)feature.Shape).PointCount; i++)
                        {
                            IPoint p = ((IMultiPoint)feature.Shape)[i];
                            if (p != null)
                            {
                                geometries.Add(p);
                            }
                        }
                    }
                    #endregion

                    if (geometries.Count > 0)
                    {
                        foreach (IGeometry geometry in geometries)
                        {
                            Feature f = new Feature(feature);
                            f.Shape = geometry;
                            if (!tDatabase.Insert(tFc, f))
                            {
                                throw new Exception(tDatabase.lastErrorMsg);
                            }
                        }
                    }
                }
            }

            ReportProgess("Flush Features");
            base.FlushFeatureClass(tFc);

            return(base.ToProcessResult(tFc));
        }
Esempio n. 23
0
        override public List <IActivityData> Process()
        {
            #region Where Clauses
            List <string> whereClauses = new List <string>();
            if (_mergeField == null)
            {
                whereClauses.Add(String.Empty);
            }
            else
            {
                foreach (object val in _values)
                {
                    if (val == null)
                    {
                        continue;
                    }
                    switch (_mergeField.type)
                    {
                    case FieldType.smallinteger:
                    case FieldType.integer:
                    case FieldType.biginteger:
                        whereClauses.Add(_mergeField.name + "=" + val.ToString());
                        break;

                    case FieldType.Float:
                    case FieldType.Double:
                        whereClauses.Add(_mergeField.name + "=" + Convert.ToDouble(val).ToString(_nhi));
                        break;

                    case FieldType.boolean:
                        whereClauses.Add(_mergeField.name + "=" + val.ToString());
                        break;

                    case FieldType.String:
                        whereClauses.Add(_mergeField.name + "='" + val.ToString() + "'");
                        break;

                    default:
                        throw new Exception("Can't merge this fieldtype: " + _mergeField.type.ToString());
                    }
                }
            }
            #endregion

            IDatasetElement sElement = base.SourceDatasetElement;
            IFeatureClass   sFc      = base.SourceFeatureClass;

            TargetDatasetElement tElement = base.TargetDatasetElement;
            IDataset             tDs      = base.TargetDataset;
            //IFeatureDatabase tDatabase = base.TargetFeatureDatabase;

            Fields fields = new Fields();
            if (_mergeField != null)
            {
                fields.Add(_mergeField);
            }
            IFeatureClass    tFc       = base.CreateTargetFeatureclass(sFc, fields);
            IFeatureDatabase tDatabase = FeatureDatabase(tFc);

            Report.featureMax = sFc.CountFeatures;
            Report.featurePos = 0;

            bool isPolygonFc = (sFc.GeometryType == geometryType.Polygon);
            foreach (string whereClause in whereClauses)
            {
                ReportProgess("Query Filter: " + SourceData.FilterClause + (String.IsNullOrEmpty(whereClause) ? " AND " + whereClause : String.Empty));

                Feature mergeFeature   = null;;
                bool    attributeAdded = false;
                using (IFeatureCursor cursor = SourceData.GetFeatures(whereClause))
                {
                    IFeature feature;

                    List <IPolygon> polygons = new List <IPolygon>();
                    while ((feature = cursor.NextFeature) != null)
                    {
                        if (mergeFeature == null)
                        {
                            mergeFeature = new Feature();
                        }

                        Report.featurePos++;
                        if (!CancelTracker.Continue)
                        {
                            break;
                        }

                        if (_mergeField != null && attributeAdded == false)
                        {
                            mergeFeature.Fields.Add(new FieldValue(_mergeField.name, feature[_mergeField.name]));
                            attributeAdded = true;
                        }

                        if (isPolygonFc)
                        {
                            if (feature.Shape != null)
                            {
                                if (!(feature.Shape is IPolygon))
                                {
                                    throw new Exception("Wrong argument type :" + feature.Shape.GeometryType.ToString());
                                }
                                polygons.Add(feature.Shape as IPolygon);
                            }
                        }
                        else
                        {
                            if (mergeFeature.Shape == null)
                            {
                                mergeFeature.Shape = feature.Shape;
                            }
                            else
                            {
                                mergeFeature.Shape = Algorithm.Merge(mergeFeature.Shape, feature.Shape, false);
                            }
                        }
                        ReportProgess();
                    }
                    if (isPolygonFc && mergeFeature != null)
                    {
                        ProgressReporterEvent r = new ProgressReporterEvent(MergePolygonReport);
                        mergeFeature.Shape = Algorithm.FastMergePolygon(polygons, CancelTracker, r);
                    }
                }
                if (mergeFeature != null)
                {
                    if (!tDatabase.Insert(tFc, mergeFeature))
                    {
                        throw new Exception(tDatabase.lastErrorMsg);
                    }
                }
                if (!CancelTracker.Continue)
                {
                    break;
                }
            }

            ReportProgess("Flush Features");
            base.FlushFeatureClass(tFc);

            return(base.ToProcessResult(tFc));
        }
Esempio n. 24
0
        public void Run()
        {
            if (_dataset == null || !(_fdb is IFeatureDatabaseReplication) || _edgeFcs == null)
            {
                return;
            }

            IFeatureDatabaseReplication db = (IFeatureDatabaseReplication)_fdb;

            if (_dataset[_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 = _fdb.DatasetID(_dataset.DatasetName);
                if (datasetId == -1)
                {
                    return;
                }

                NetworkBuilder networkBuilder = new NetworkBuilder(_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 = _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 = _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 = _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 = fc.GetFeatures(filter))
                    {
                        #region Report
                        report.Message    = "Analize Edges: " + fc.Name;
                        report.featureMax = fc.CountFeatures;
                        report.featurePos = 0;
                        if (ReportProgress != null)
                        {
                            ReportProgress(report);
                        }
                        #endregion

                        IFeature feature;
                        while ((feature = 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 = _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 = fc.GetFeatures(filter))
                        {
                            #region Report
                            report.Message    = "Analize Nodes: " + fc.Name;
                            report.featureMax = fc.CountFeatures;
                            report.featurePos = 0;
                            if (ReportProgress != null)
                            {
                                ReportProgress(report);
                            }
                            #endregion

                            IFeature feature;
                            while ((feature = 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));
                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));
                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));

                _fdb.ReplaceFeatureClass(_dataset.DatasetName,
                                         _networkName + "_ComplexEdges",
                                         new GeometryDef(geometryType.Polyline),
                                         fields);
                IDatasetElement element = _dataset[_networkName + "_ComplexEdges"];
                if (element == null || !(element.Class is IFeatureClass))
                {
                    return;
                }
                if (edgeTreeDef != null)
                {
                    _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 = 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);
                            }
                            _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);
                    }
                    _fdb.Insert(edgeFc, features);
                }
                _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));
                        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));

                _fdb.ReplaceFeatureClass(_dataset.DatasetName,
                                         _networkName + "_Nodes",
                                         new GeometryDef(geometryType.Point),
                                         fields);

                element = _dataset[_networkName + "_Nodes"];
                if (element == null || !(element.Class is IFeatureClass))
                {
                    return;
                }
                if (nodeTreeDef != null)
                {
                    _fdb.SetSpatialIndexBounds(_networkName + "_Nodes", "BinaryTree2", nodeTreeDef.Bounds, nodeTreeDef.SplitRatio, nodeTreeDef.MaxPerNode, nodeTreeDef.MaxLevel);
                }
                else if (edgeTreeDef != null)
                {
                    _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 = c.NextFeature) != null)
                {
                    features.Add(f);

                    report.featurePos++;
                    if (features.Count > 0 && features.Count % 1000 == 0)
                    {
                        if (ReportProgress != null)
                        {
                            ReportProgress(report);
                        }
                        _fdb.Insert(nodeFc, features);
                        features.Clear();
                    }
                }
                if (features.Count > 0)
                {
                    if (ReportProgress != null)
                    {
                        ReportProgress(report);
                    }
                    _fdb.Insert(nodeFc, features);
                }
                _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));

                _fdb.ReplaceFeatureClass(_dataset.DatasetName,
                                         _networkName,
                                         new GeometryDef(geometryType.Network),
                                         fields);

                element = _dataset[_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 = 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 = _fdb.GetFeatureClassID(_networkName);
                fields = new Fields();
                fields.Add(new Field("ID", FieldType.integer));
                fields.Add(new Field("Properties", FieldType.binary));
                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));

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

                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");
                    }
                    _fdb.DeleteFeatureClass(_networkName + "_ComplexEdges");
                    _fdb.DeleteFeatureClass(_networkName + "_Nodes");
                    _fdb.DeleteFeatureClass(_networkName);
                }
            }
        }
        public AccessFDBFeatureClassExplorerObject(AccessFDBDatasetExplorerObject parent, string filename, string dsname, IDatasetElement element)
            : base(parent, typeof(FeatureClass))
        {
            if (element == null)
            {
                return;
            }

            _parent   = parent;
            _filename = filename;
            _dsname   = dsname;
            _fcname   = element.Title;

            string typePrefix = String.Empty;
            bool   isLinked   = false;

            if (element.Class is LinkedFeatureClass)
            {
                typePrefix = "Linked ";
                isLinked   = true;
            }

            if (element.Class is IRasterCatalogClass)
            {
                _icon = new AccessFDBRasterIcon();
                _type = typePrefix + "Raster Catalog Layer";
                _rc   = (IRasterClass)element.Class;
            }
            else if (element.Class is IRasterClass)
            {
                _icon = new AccessFDBRasterIcon();
                _type = typePrefix + "Raster Layer";
                _rc   = (IRasterClass)element.Class;
            }
            else if (element.Class is IFeatureClass)
            {
                _fc = (IFeatureClass)element.Class;
                switch (_fc.GeometryType)
                {
                case geometryType.Envelope:
                case geometryType.Polygon:
                    if (isLinked)
                    {
                        _icon = new AccessFDBLinkedPolygonIcon();
                    }
                    else
                    {
                        _icon = new AccessFDBPolygonIcon();
                    }
                    _type = typePrefix + "Polygon Featureclass";
                    break;

                case geometryType.Multipoint:
                case geometryType.Point:
                    if (isLinked)
                    {
                        _icon = new AccessFDBLinkedPointIcon();
                    }
                    else
                    {
                        _icon = new AccessFDBPointIcon();
                    }
                    _type = typePrefix + "Point Featureclass";
                    break;

                case geometryType.Polyline:
                    if (isLinked)
                    {
                        _icon = new AccessFDBLinkedLineIcon();
                    }
                    else
                    {
                        _icon = new AccessFDBLineIcon();
                    }
                    _type = typePrefix + "Polyline Featureclass";
                    break;
                }
            }

            _contextItems    = new ToolStripItem[1];
            _contextItems[0] = new ToolStripMenuItem("Tasks");

            //_contextItems = new ToolStripItem[1];
            //_contextItems[0] = new ToolStripMenuItem("Rebuild Spatial Index...");
            //_contextItems[0].Click += new EventHandler(RebuildSpatialIndex_Click);
            ToolStripMenuItem item = new ToolStripMenuItem("Shrink Spatial Index...");

            item.Click += new EventHandler(ShrinkSpatialIndex_Click);
            ((ToolStripMenuItem)_contextItems[0]).DropDownItems.Add(item);
            item        = new ToolStripMenuItem("Spatial Index Definition...");
            item.Click += new EventHandler(SpatialIndexDef_Click);
            ((ToolStripMenuItem)_contextItems[0]).DropDownItems.Add(item);
            item        = new ToolStripMenuItem("Repair Spatial Index...");
            item.Click += new EventHandler(RepairSpatialIndex_Click);
            ((ToolStripMenuItem)_contextItems[0]).DropDownItems.Add(item);
            ((ToolStripMenuItem)_contextItems[0]).DropDownItems.Add(new ToolStripSeparator());
            item        = new ToolStripMenuItem("Truncate");
            item.Click += new EventHandler(Truncate_Click);
            ((ToolStripMenuItem)_contextItems[0]).DropDownItems.Add(item);
        }
Esempio n. 26
0
        private void 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 = _fdb.DatasetID(_targetDataset.DatasetName);
                if (datasetId == -1)
                {
                    return;
                }

                IClass cls = null;
                try
                {
                    cls = _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 = _targetDataset[_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
                    {
                        _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));

                    _fdb.CreateFeatureClass(_targetDataset.DatasetName, _name,
                                            new GeometryDef(geometryType.Polygon),
                                            fields);
                    element = _targetDataset[_name];
                    if (element == null || !(element.Class is IFeatureClass))
                    {
                        return;
                    }
                    _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 = sourceFc.GetFeatures(filter))
                                    {
                                        if (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 = 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));
                                        map.RefreshMap(DrawPhase.All, _cancelTracker);
                                        if (_gridType == TileGridType.image_png)
                                        {
                                            map.Bitmap.Save(filename + ".png", System.Drawing.Imaging.ImageFormat.Png);
                                        }
                                        else if (_gridType == TileGridType.image_jpg)
                                        {
                                            map.Bitmap.Save(filename + ".jpg", System.Drawing.Imaging.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 (!_fdb.Insert(fc, features))
                                    {
                                        MessageBox.Show(_fdb.lastErrorMsg, "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);
                    }
                    _fdb.Insert(fc, features);
                }
                _fdb.CalculateExtent(fc);
                #endregion

                succeeded = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                if (!succeeded)
                {
                    _fdb.DeleteFeatureClass(_name);
                }
            }
        }
Esempio n. 27
0
        private bool InsertImage(IFeatureUpdater fdb, IFeatureClass rasterFC, FileInfo fi, Dictionary <string, Guid> providers)
        {
            if (!_cancelTracker.Continue)
            {
                _errMsg = "Canceled by user...";
                return(false);
            }

            if (ReportAction != null)
            {
                ReportAction(this, "Insert Image: " + fi.FullName);
            }
            if (ReportProgress != null)
            {
                ReportProgress(this, 1);
            }

            System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Jpeg;
            switch (fi.Extension.ToLower())
            {
            case ".png":
                format = System.Drawing.Imaging.ImageFormat.Png;
                break;

            case ".tif":
            case ".tiff":
                format = System.Drawing.Imaging.ImageFormat.Tiff;
                break;
            }

            #region RasterFileDataset bestimmen
            List <IRasterFileDataset> rFileDatasets = new List <IRasterFileDataset>();
            IRasterFileDataset        rFileDataset  = null;
            IRasterLayer  rasterLayer = null;
            PlugInManager compMan     = new PlugInManager();
            foreach (XmlNode ds in compMan.GetPluginNodes(Plugins.Type.IDataset))
            {
                IRasterFileDataset rds = compMan.CreateInstance(ds) as IRasterFileDataset;
                if (rds == null)
                {
                    continue;
                }

                if (rds.SupportsFormat(fi.Extension) < 0)
                {
                    continue;
                }
                if (providers != null && providers.ContainsKey(fi.Extension.ToLower()))
                {
                    if (!providers[fi.Extension.ToLower()].Equals(PlugInManager.PlugInID(rds)))
                    {
                        continue;
                    }
                }
                rFileDatasets.Add(rds);
            }
            if (rFileDatasets.Count == 0)
            {
                _errMsg = "No Rasterfile Provider for " + fi.Extension;
                return(false);
            }

            // RasterFileDataset nach priorität sortieren
            rFileDatasets.Sort(new RasterFileDatasetComparer(fi.Extension));

            // RasterFileDataset suchen, mit dem sich Bild öffnen läßt
            foreach (IRasterFileDataset rfd in rFileDatasets)
            {
                rfd.AddRasterFile(fi.FullName);

                if (rfd.Elements.Count == 0)
                {
                    //Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster File...");
                    continue;
                }
                IDatasetElement element = rfd.Elements[0];
                if (!(element is IRasterLayer))
                {
                    //Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
                    rFileDataset.Dispose();
                    continue;
                }

                // gefunden...
                rasterLayer  = (IRasterLayer)element;
                rFileDataset = rfd;
                break;
            }
            if (rasterLayer == null || rFileDataset == null)
            {
                Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
                return(false);
            }
            #endregion

            FileInfo fiWorld = null;
            double   cellX   = 1;
            double   cellY   = 1;

            IRasterFile rasterFile = null;
            if (rasterLayer is IRasterFile)
            {
                rasterFile = (IRasterFile)rasterLayer;
            }
            if (rasterLayer.RasterClass != null)
            {
                if (rasterLayer.RasterClass is IRasterFile &&
                    ((IRasterFile)rasterLayer.RasterClass).WorldFile != null)
                {
                    rasterFile = (IRasterFile)rasterLayer.RasterClass;
                }
                else
                {
                    IRasterClass c = (IRasterClass)rasterLayer.RasterClass;
                    cellX = Math.Sqrt(c.dx1 * c.dx1 + c.dx2 * c.dx2);
                    cellY = Math.Sqrt(c.dy1 * c.dy1 + c.dy2 * c.dy2);
                }
            }
            if (rasterFile != null)
            {
                try
                {
                    IRasterWorldFile world = rasterFile.WorldFile;
                    if (world != null)
                    {
                        if (!world.isGeoReferenced)
                        {
                            if (handleNonGeorefAsError)
                            {
                                _errMsg = "Can't add non georeferenced images: " + fi.FullName;
                                return(false);
                            }
                            else
                            {
                                return(true);
                            }
                        }

                        cellX = Math.Sqrt(world.dx_X * world.dx_X + world.dx_Y * world.dx_Y);
                        cellY = Math.Sqrt(world.dy_X * world.dy_X + world.dy_Y * world.dy_Y);

                        fiWorld = new FileInfo(rasterFile.WorldFile.Filename);
                        if (!fiWorld.Exists)
                        {
                            fiWorld = null;
                        }
                    }
                }
                catch
                {
                    fiWorld = null;
                }
            }

            #region Check if already Exits
            //
            // Suchen, ob Image mit gleichen Pfad schon vorhanden ist, wenn ja
            // nur weitermachen, wenn sich das änderungsdatum unterscheidet...
            //

            QueryFilter filter = new QueryFilter();
            filter.AddField("FDB_OID");
            filter.AddField("PATH");
            filter.AddField("LAST_MODIFIED");
            filter.AddField("PATH2");
            filter.AddField("LAST_MODIFIED2");

            string fullName = fi.FullName.Replace(@"\", @"\\");
            if (_fdb is AccessFDB)
            {
                filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fullName + "'";
            }
            else
            {
                filter.WhereClause = "PATH='" + fullName + "'";
            }
            int deleteOID = -1;
            using (IFeatureCursor cursor = rasterFC.GetFeatures(filter))
            {
                IFeature existingFeature = cursor.NextFeature;
                if (existingFeature != null)
                {
                    DateTime dt1 = (DateTime)existingFeature["LAST_MODIFIED"];
                    if (Math.Abs(((TimeSpan)(dt1 - fi.LastWriteTimeUtc)).TotalSeconds) > 1.0)
                    {
                        deleteOID = existingFeature.OID;
                    }
                    else if (fiWorld != null &&
                             existingFeature["PATH2"] != System.DBNull.Value &&
                             existingFeature["PATH2"].ToString() != String.Empty)
                    {
                        DateTime dt2 = (DateTime)existingFeature["LAST_MODIFIED2"];
                        if (existingFeature["PATH2"].ToString().ToLower() != fiWorld.FullName.ToLower() ||
                            Math.Abs(((TimeSpan)(dt2 - fiWorld.LastWriteTimeUtc)).TotalSeconds) > 1.0)
                        {
                            deleteOID = existingFeature.OID;
                        }
                    }

                    if (deleteOID == -1)
                    {
                        Console.Write(".");
                        //Console.WriteLine(fi.FullName + " already exists...");
                        return(true);
                    }
                }
            }
            if (deleteOID != -1)
            {
                if (!fdb.Delete(rasterFC, deleteOID))
                {
                    Console.WriteLine(_errMsg = "Can't delete old record " + fi.FullName + "\n" + fdb.lastErrorMsg);
                    return(false);
                }
            }
            //
            ///////////////////////////////////////////////////////////////////
            //
            #endregion

            Feature feature = new Feature();
            feature.Shape = rasterLayer.RasterClass.Polygon;
            feature.Fields.Add(new FieldValue("PATH", fi.FullName));
            feature.Fields.Add(new FieldValue("LAST_MODIFIED", fi.LastWriteTimeUtc));
            if (fiWorld != null)
            {
                feature.Fields.Add(new FieldValue("PATH2", fiWorld.FullName));
                feature.Fields.Add(new FieldValue("LAST_MODIFIED2", fiWorld.LastWriteTimeUtc));
            }
            else
            {
                feature.Fields.Add(new FieldValue("PATH2", ""));
            }
            feature.Fields.Add(new FieldValue("RF_PROVIDER", PlugInManager.PlugInID(rFileDataset).ToString()));
            feature.Fields.Add(new FieldValue("MANAGED", _managed && (rasterLayer is IBitmap)));
            feature.Fields.Add(new FieldValue("FORMAT", fi.Extension.Replace(".", "")));
            feature.Fields.Add(new FieldValue("CELLX", cellX));
            feature.Fields.Add(new FieldValue("CELLY", cellY));
            feature.Fields.Add(new FieldValue("LEVELS", (_managed) ? Math.Max(_levels, 1) : 0));

            if (!fdb.Insert(rasterFC, feature))
            {
                Console.WriteLine("\nERROR@" + fi.FullName + ": " + fdb.lastErrorMsg);
            }
            else
            {
                if (_managed && (rasterLayer is IBitmap) && (fdb is SqlFDB))
                {
                    QueryFilter qfilter = new QueryFilter();
                    qfilter.SubFields = "FDB_OID";
                    if (_fdb is AccessFDB)
                    {
                        filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fi.FullName + "'";
                    }
                    else
                    {
                        qfilter.WhereClause = "PATH='" + fi.FullName + "'";
                    }
                    IFeatureCursor cursor = ((SqlFDB)fdb).Query(rasterFC, qfilter);
                    if (cursor != null)
                    {
                        IFeature feat = cursor.NextFeature;
                        if (feat != null)
                        {
                            InsertImageDatasetBitmap(feat.OID, rasterLayer, _levels, format);
                        }
                        cursor.Dispose();
                    }
                }

                Console.WriteLine(">" + fi.FullName + " added...");
            }

            rFileDataset.Dispose();
            return(true);
        }
Esempio n. 28
0
        internal void Init(string CapabilitiesString, WFSDataset wfsDataset)
        {
            try
            {
                _themes = new List <IWebServiceTheme>();

                XmlDocument doc = new XmlDocument();
                doc.LoadXml(CapabilitiesString);

                XmlNode CapabilitiesNode = doc.SelectSingleNode("WMT_MS_Capabilities/Capability");
                _getCapabilities          = new GetCapabilities(CapabilitiesNode.SelectSingleNode("Request/GetCapabilities"));
                _getMap                   = new GetMap(CapabilitiesNode.SelectSingleNode("Request/GetMap"));
                _getFeatureInfo           = new GetFeatureInfo(CapabilitiesNode.SelectSingleNode("Request/GetFeatureInfo"));
                _describeLayer            = new DescribeLayer(CapabilitiesNode.SelectSingleNode("Request/DescribeLayer"));
                _getLegendGraphic         = new GetLegendGraphic(CapabilitiesNode.SelectSingleNode("Request/GetLegendGraphic"));
                _getStyles                = new GetStyles(CapabilitiesNode.SelectSingleNode("Request/GetStyles"));
                _exceptions               = new WMSExceptions(CapabilitiesNode.SelectSingleNode("Exception"));
                _userDefinedSymbolization = new UserDefinedSymbolization(CapabilitiesNode.SelectSingleNode("UserDefinedSymbolization"));

                XmlNode service = CapabilitiesNode.SelectSingleNode("Layer");
                XmlNode title   = service.SelectSingleNode("Title");
                if (title != null)
                {
                    _name = title.InnerText;
                }

                _srs         = new SRS(service);
                this.SRSCode = _srs.Srs[_srs.SRSIndex];

                foreach (XmlNode layer in service.SelectNodes("Layer"))
                {
                    string  name = "", Title = "";
                    XmlNode nameNode  = layer.SelectSingleNode("Name");
                    XmlNode titleNode = layer.SelectSingleNode("Title");

                    if (nameNode == null)
                    {
                        continue;
                    }
                    name = Title = nameNode.InnerText;
                    if (titleNode != null)
                    {
                        Title = titleNode.InnerText;
                    }
                    XmlNodeList styles = layer.SelectNodes("Style");

                    WFSFeatureClass wfsFc = null;
                    if (wfsDataset != null)
                    {
                        IDatasetElement wfsElement = wfsDataset[name];
                        if (wfsElement != null && wfsElement.Class is WFSFeatureClass)
                        {
                            wfsFc = wfsElement.Class as WFSFeatureClass;
                        }
                    }

                    if (styles.Count == 0)
                    {
                        IClass wClass = null;
                        if (wfsFc != null)
                        {
                            wClass = wfsFc;
                        }
                        else if (layer.Attributes["queryable"] != null && layer.Attributes["queryable"].Value == "1")
                        {
                            wClass = new WMSQueryableThemeClass(_dataset, name, String.Empty, layer, _getFeatureInfo, _srs, _exceptions);
                        }
                        else
                        {
                            wClass = new WMSThemeClass(_dataset, name, String.Empty, layer);
                        }

                        IWebServiceTheme theme;
                        if (wClass is WFSFeatureClass)
                        {
                            theme = new WebServiceTheme2(
                                wClass, Title, name, true, this);
                        }
                        else
                        {
                            theme = new WebServiceTheme(
                                wClass, Title, name, true, this
                                );
                        }

                        _themes.Add(theme);
                    }
                    else
                    {
                        foreach (XmlNode style in styles)
                        {
                            string  sName = "", sTitle = "";
                            XmlNode sNameNode  = style.SelectSingleNode("Name");
                            XmlNode sTitleNode = style.SelectSingleNode("Title");

                            if (sNameNode == null)
                            {
                                continue;
                            }
                            sName = sTitle = sNameNode.InnerText;
                            if (sTitleNode != null)
                            {
                                sTitle = sTitleNode.InnerText;
                            }

                            IClass wClass = null;
                            if (wfsFc is WFSFeatureClass)
                            {
                                wClass = wfsFc;
                                ((WFSFeatureClass)wClass).Style = sName;
                            }
                            else if (layer.Attributes["queryable"] != null && layer.Attributes["queryable"].Value == "1")
                            {
                                wClass = new WMSQueryableThemeClass(_dataset, name, sName, layer, _getFeatureInfo, _srs, _exceptions);
                            }
                            else
                            {
                                wClass = new WMSThemeClass(_dataset, name, sName, layer);
                            }

                            IWebServiceTheme theme;
                            if (wClass is WFSFeatureClass)
                            {
                                theme = new WebServiceTheme2(
                                    wClass, Title + " (Style=" + sTitle + ")", name, true, this);
                            }
                            else
                            {
                                theme = new WebServiceTheme(
                                    wClass, Title + " (Style=" + sTitle + ")", name, true, this
                                    );
                            }

                            _themes.Add(theme);
                        }
                    }
                }
                doc = null;
            }
            catch (Exception ex)
            {
                string errMsg = ex.Message;
            }
        }
Esempio n. 29
0
            public RelationTreeNode(IMapDocument mapDocument, ITableRelation tableRelation, IDatasetElement element)
            {
                _mapDocument        = mapDocument;
                this.TableRelation  = tableRelation;
                this.DatasetElement = element;

                IDatasetElement target = (tableRelation.LeftTable == element) ? tableRelation.RightTable : tableRelation.LeftTable;

                base.Text = tableRelation.RelationName + " (" + target.Title + ")";

                base.Click += new EventHandler(RelationTreeNode_Click);
            }
Esempio n. 30
0
        static void Main(string[] args)
        {
            string cmd = "fill", jsonFile = (args.Length == 1 && args[0] != "fill" ? args[0] : String.Empty), indexUrl = String.Empty, indexName = String.Empty, category = String.Empty;
            bool   replace = false;

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i] == "fill" && i < args.Length - 1)
                {
                    cmd      = "fill";
                    jsonFile = args[i + 1];
                    i++;
                }
                if (args[i] == "remove-category")
                {
                    cmd = "remove-category";
                }
                if (args[i] == "-s" && i < args.Length - 1)
                {
                    indexUrl = args[i + 1];
                }
                if (args[i] == "-i" && i < args.Length - 1)
                {
                    indexName = args[i + 1];
                }
                if (args[i] == "-c" && i < args.Length - 1)
                {
                    category = args[i + 1];
                }
                if (args[i] == "-r")
                {
                    replace = true;
                }
            }

            if (args.Length == 0)
            {
                Console.WriteLine("Usage: gView.Cmd.ElasticSearch fill|remove-catetory [Options]");
                return;
            }

            if (cmd == "fill" && String.IsNullOrEmpty(jsonFile))
            {
                Console.WriteLine("Usage: gView.Cmd.ElasticSearch fill {json-file}");
                return;
            }
            else if (cmd == "remove-category" && (String.IsNullOrWhiteSpace(indexUrl) || String.IsNullOrWhiteSpace(category)))
            {
                Console.WriteLine("Usage: gView.cmd.ElasticSearch remove-category -s {index-url} -i {index-name} -c {category} [-r]");
                Console.WriteLine("  -r ... raplace german Umlaute:");
                Console.WriteLine("            _ae_, _oe_, _ue_   =>  ä, ö, ü");
                Console.WriteLine("            _Ae_, _Oe_, _Ue_   =>  Ä, Ö, Ü");
                Console.WriteLine("            _sz_               =>  ß");
                return;
            }

            try
            {
                //gView.Framework.system.SystemVariables.CustomApplicationDirectory =
                //    System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);

                Console.WriteLine("Environment");

                Console.WriteLine("Working Directory: " + gView.Framework.system.SystemVariables.StartupDirectory);
                Console.WriteLine("64Bit=" + gView.Framework.system.Wow.Is64BitProcess);

                if (cmd == "fill")
                {
                    #region Fill Index (with Json File)

                    var importConfig = JsonConvert.DeserializeObject <ImportConfig>(File.ReadAllText(jsonFile));

                    var searchContext = new ElasticSearchContext(importConfig.Connection.Url, importConfig.Connection.DefaultIndex);

                    if (importConfig.Connection.DeleteIndex)
                    {
                        searchContext.DeleteIndex();
                    }

                    searchContext.CreateIndex();
                    searchContext.Map <Item>();
                    searchContext.Map <Meta>();

                    ISpatialReference sRefTarget = SpatialReference.FromID("epsg:4326");

                    Console.WriteLine("Target Spatial Reference: " + sRefTarget.Name + " " + String.Join(" ", sRefTarget.Parameters));

                    foreach (var datasetConfig in importConfig.Datasets)
                    {
                        if (datasetConfig.FeatureClasses == null)
                        {
                            continue;
                        }

                        IDataset dataset = new PlugInManager().CreateInstance(datasetConfig.DatasetGuid) as IDataset;
                        if (dataset == null)
                        {
                            throw new ArgumentException("Can't load dataset with guid " + datasetConfig.DatasetGuid.ToString());
                        }

                        dataset.ConnectionString = datasetConfig.ConnectionString;
                        dataset.Open();

                        foreach (var featureClassConfig in datasetConfig.FeatureClasses)
                        {
                            var itemProto = featureClassConfig.IndexItemProto;
                            if (itemProto == null)
                            {
                                continue;
                            }

                            string metaId = Guid.NewGuid().ToString("N").ToLower();
                            category = featureClassConfig.Category;
                            if (!String.IsNullOrWhiteSpace(category))
                            {
                                var meta = new Meta()
                                {
                                    Id         = metaId,
                                    Category   = category,
                                    Descrption = featureClassConfig.Meta?.Descrption,
                                    Sample     = featureClassConfig?.Meta.Sample,
                                    Service    = featureClassConfig?.Meta.Service,
                                    Query      = featureClassConfig?.Meta.Query
                                };
                                searchContext.Index <Meta>(meta);
                            }

                            bool useGeometry = featureClassConfig.UserGeometry;

                            IDatasetElement dsElement = dataset[featureClassConfig.Name];
                            if (dsElement == null)
                            {
                                throw new ArgumentException("Unknown dataset element " + featureClassConfig.Name);
                            }
                            IFeatureClass fc = dsElement.Class as IFeatureClass;
                            if (fc == null)
                            {
                                throw new ArgumentException("Dataobject is not a featureclass " + featureClassConfig.Name);
                            }

                            Console.WriteLine("Index " + fc.Name);
                            Console.WriteLine("=====================================================================");

                            QueryFilter filter = new QueryFilter();
                            filter.SubFields = "*";
                            if (!String.IsNullOrWhiteSpace(featureClassConfig.Filter))
                            {
                                filter.WhereClause = featureClassConfig.Filter;
                                Console.WriteLine("Filter: " + featureClassConfig.Filter);
                            }

                            List <Item> items = new List <Item>();
                            int         count = 0;

                            ISpatialReference sRef = fc.SpatialReference ?? SpatialReference.FromID("epsg:" + featureClassConfig.SRefId);
                            Console.WriteLine("Source Spatial Reference: " + sRef.Name + " " + String.Join(" ", sRef.Parameters));
                            Console.WriteLine("IDField: " + fc.IDFieldName);

                            using (GeometricTransformer transformer = new GeometricTransformer())
                            {
                                if (useGeometry)
                                {
                                    transformer.SetSpatialReferences(sRef, sRefTarget);
                                }

                                IFeatureCursor cursor = (IFeatureCursor)fc.GetFeatures(filter);
                                IFeature       feature;
                                while ((feature = cursor.NextFeature) != null)
                                {
                                    var indexItem = ParseFeature(metaId, category, feature, itemProto, useGeometry, transformer, featureClassConfig);
                                    items.Add(indexItem);
                                    count++;

                                    if (items.Count >= 500)
                                    {
                                        searchContext.IndexMany <Item>(items.ToArray());
                                        items.Clear();

                                        Console.Write(count + "...");
                                    }
                                }

                                if (items.Count > 0)
                                {
                                    searchContext.IndexMany <Item>(items.ToArray());
                                    Console.WriteLine(count + "...finish");
                                }
                            }
                        }
                    }

                    #endregion
                }
                else if (cmd == "remove-category")
                {
                    #region Remove Category

                    RemoveCategory(indexUrl, indexName, replace ? Replace(category) : category);

                    #endregion
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }