Esempio n. 1
0
        async public Task <IFeatureCursor> NetworkPathEdges(Dijkstra.Nodes nodes, string fields)
        {
            if (_nfc == null)
            {
                return(null);
            }

            //StringBuilder sb = new StringBuilder();
            //sb.Append("FDB_OID in (");
            //foreach (Dijkstra.Node node in nodes)
            //{
            //    //if (node.Dist > maxDistance)
            //    //    continue;
            //    if (sb.Length > 12)
            //        sb.Append(",");
            //    sb.Append(node.EId);
            //}
            //sb.Append(")");

            //QueryFilter filter = new QueryFilter();
            //filter.AddField("FDB_OID");
            //filter.AddField("FDB_SHAPE");
            //if (!String.IsNullOrEmpty(fields))
            //{
            //    foreach (string field in fields.Split(','))
            //        filter.AddField(field);
            //}
            //filter.WhereClause = sb.ToString();
            RowIDFilter filter = new RowIDFilter(String.Empty);

            foreach (Dijkstra.Node node in nodes)
            {
                filter.IDs.Add(node.EId);
            }
            if (!String.IsNullOrEmpty(fields))
            {
                foreach (string field in fields.Split(','))
                {
                    filter.AddField(field);
                }
            }

            return(await _nfc.GetEdgeFeatures(filter));
        }
Esempio n. 2
0
        async public Task <IFeature> GetEdgeFeature(int eid)
        {
            RowIDFilter filter = new RowIDFilter(String.Empty);

            filter.IDs.Add(eid);
            filter.AddField("*");

            IFeatureCursor cursor = await GetEdgeFeatures(filter);

            if (cursor == null)
            {
                return(null);
            }

            IFeature feature = await cursor.NextFeature();

            cursor.Dispose();

            if (feature != null && feature.FindField("FCID") != null && feature.FindField("OID") != null &&
                _edgeFcs.ContainsKey((int)feature["FCID"]))
            {
                IGraphEdge edge = _pageManager.GetEdge(eid);
                try
                {
                    if (edge != null && edge.FcId == -1) // Complex Edge
                    {
                        filter = new RowIDFilter("FDB_OID");
                        filter.IDs.Add((int)feature["OID"]);
                        filter.AddField("*");
                        IFeatureClass fc = _edgeFcs[(int)feature["FCID"]];
                        using (IFeatureCursor c = await fc.GetFeatures(filter))
                        {
                            return(await c.NextFeature());
                        }
                    }
                }
                catch { }
            }
            return(feature);
        }
Esempio n. 3
0
        public IFeature GetEdgeFeature(int eid)
        {
            RowIDFilter filter = new RowIDFilter(String.Empty);

            filter.IDs.Add(eid);
            filter.AddField("*");

            IFeature feature = null;

            using (IFeatureCursor cursor = GetEdgeFeatures(filter))
            {
                feature = cursor.NextFeature;
            }

            if (feature != null && feature.FindField("FCID") != null && feature.FindField("OID") != null &&
                _edgeFcs.ContainsKey(Convert.ToInt32(feature["FCID"])))
            {
                IGraphEdge edge = _pageManager.GetEdge(eid);
                try
                {
                    if (edge != null && edge.FcId == -1) // Complex Edge
                    {
                        filter = new RowIDFilter("FDB_OID");
                        filter.IDs.Add(Convert.ToInt32(feature["OID"]));
                        filter.AddField("*");
                        IFeatureClass fc = _edgeFcs[Convert.ToInt32(feature["FCID"])];
                        using (IFeatureCursor c = fc.GetFeatures(filter))
                        {
                            return(c.NextFeature);
                        }
                    }
                }
                catch { }
            }

            return(feature);
        }
Esempio n. 4
0
        public IFeatureCursor GetEdgeFeatures(IQueryFilter filter)
        {
            if (_edgeFcs.Count == 0)
            {
                return(null);
            }

            if (filter is SpatialFilter)
            {
                List <IFeatureClass> edgeFcs = new List <IFeatureClass>();
                if (_edgeFcs != null)
                {
                    foreach (IFeatureClass fc in _edgeFcs.Values)
                    {
                        edgeFcs.Add(fc);
                    }
                }
                return(new NetworkFeatureCursor(_fdb, _name, edgeFcs, null, filter));
            }

            if (filter is RowIDFilter)
            {
                RowIDFilter idFilter = (RowIDFilter)filter;

                Dictionary <int, QueryFilter> rfilters = new Dictionary <int, QueryFilter>();
                Dictionary <int, Dictionary <int, List <FieldValue> > > additionalFields = new Dictionary <int, Dictionary <int, List <FieldValue> > >();
                foreach (int eid in idFilter.IDs)
                {
                    IGraphEdge edge = _pageManager.GetEdge(eid);
                    if (edge == null || _edgeFcs.ContainsKey(edge.FcId) == false)
                    {
                        continue;
                    }

                    if (!rfilters.ContainsKey(edge.FcId))
                    {
                        string idFieldName    = "FDB_OID";
                        string shapeFieldName = "FDB_SHAPE";

                        IFeatureClass fc = edge.FcId >= 0 ? _fdb.GetFeatureclass(edge.FcId) : null;
                        if (fc != null)
                        {
                            idFieldName    = fc.IDFieldName;
                            shapeFieldName = fc.ShapeFieldName;
                        }

                        RowIDFilter rfilter = new RowIDFilter(edge.FcId >= 0 ? idFieldName : "EID");
                        rfilter.fieldPostfix = rfilter.fieldPrefix = "\"";
                        rfilters.Add(edge.FcId, rfilter);
                        additionalFields.Add(edge.FcId, new Dictionary <int, List <FieldValue> >());

                        rfilter.IgnoreUndefinedFields = true;
                        rfilters[edge.FcId].AddField(shapeFieldName);
                        if (filter.SubFields.IndexOf("*") != -1 || fc == null)
                        {
                            rfilters[edge.FcId].AddField("*");
                        }
                        else
                        {
                            foreach (string field in filter.SubFields.Split(' '))
                            {
                                if (field == shapeFieldName)
                                {
                                    continue;
                                }
                                if (fc.Fields.FindField(field) != null)
                                {
                                    rfilter.AddField(fc.Fields.FindField(field).name);
                                }
                            }
                        }
                    }

                    ((RowIDFilter)rfilters[edge.FcId]).IDs.Add(edge.FcId >= 0 ? edge.Oid : edge.Eid);
                    additionalFields[edge.FcId].Add(edge.FcId >= 0 ? edge.Oid : edge.Eid, new List <FieldValue>()
                    {
                        new FieldValue("_eid", edge.Eid)
                    });
                }
                if (rfilters.ContainsKey(-1))
                {
                    RowIDFilter complexEdgeFilter = (RowIDFilter)rfilters[-1];
                    QueryFilter ceFilter          = new QueryFilter(complexEdgeFilter);
                    ceFilter.WhereClause = complexEdgeFilter.RowIDWhereClause;
                    rfilters[-1]         = ceFilter;
                }
                return(new CursorCollection <int>(_edgeFcs, rfilters, additionalFields));
            }

            return(null);
        }