Esempio n. 1
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. 2
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. 3
0
        static private string ParseFeatureField(IFeature feature, string pattern)
        {
            if (pattern == null || !pattern.Contains("{"))
            {
                return(pattern);
            }

            string[] parameters = GetKeyParameters(pattern);
            foreach (string parameter in parameters)
            {
                var fieldValue = feature.FindField(parameter);
                if (fieldValue == null)
                {
                    continue;
                }

                string val = fieldValue.Value != null?fieldValue.Value.ToString() : String.Empty;

                pattern = pattern.Replace("{" + parameter + "}", val);
            }

            return(pattern);
        }
Esempio n. 4
0
        static private Item ParseFeature(string metaId, string category, IFeature feature, Item proto, bool useGeometry, GeometricTransformer transformer, ImportConfig.FeatureClassDefinition featureClassDef)
        {
            var replace = featureClassDef.Replacements;

            var result = new Item();

            string oid = feature.OID.ToString();

            if (feature.OID <= 0 && !String.IsNullOrWhiteSpace(featureClassDef.ObjectOidField))
            {
                var idFieldValue = feature.FindField(featureClassDef.ObjectOidField);
                if (idFieldValue != null)
                {
                    oid = idFieldValue.Value?.ToString();
                }
            }

            result.Id            = metaId + "." + oid;
            result.SuggestedText = ParseFeatureField(feature, proto.SuggestedText);
            result.SubText       = ParseFeatureField(feature, proto.SubText);
            result.ThumbnailUrl  = ParseFeatureField(feature, proto.ThumbnailUrl);
            result.Category      = category;

            if (replace != null)
            {
                foreach (var r in replace)
                {
                    result.SuggestedText = result.SuggestedText?.Replace(r.From, r.To);
                    result.SubText       = result.SubText?.Replace(r.From, r.To);
                }
            }

            if (useGeometry == true && feature.Shape != null)
            {
                IGeometry shape = feature.Shape;

                if (shape is IPoint)
                {
                    IPoint point = (IPoint)transformer.Transform2D(feature.Shape);
                    result.Geo = new Nest.GeoLocation(point.Y, point.X);
                }
                else if (shape is IPolyline)
                {
                    IEnvelope env = shape.Envelope;
                    if (env != null)
                    {
                        IPoint point = Algorithm.PolylinePoint((IPolyline)shape, ((IPolyline)shape).Length / 2.0);

                        if (point != null)
                        {
                            point      = (IPoint)transformer.Transform2D(point);
                            result.Geo = new Nest.GeoLocation(point.Y, point.X);
                        }

                        result.BBox = GetBBox(env, transformer);
                    }
                }
                else if (shape is IPolygon)
                {
                    IEnvelope env = shape.Envelope;
                    if (env != null)
                    {
                        var points = Algorithm.OrderPoints(Algorithm.PolygonLabelPoints((IPolygon)shape), env.Center);
                        if (points != null && points.PointCount > 0)
                        {
                            IPoint point = (IPoint)transformer.Transform2D(points[0]);
                            result.Geo = new Nest.GeoLocation(point.Y, point.X);
                        }

                        result.BBox = GetBBox(env, transformer);
                    }
                }
            }

            return(result);
        }
Esempio n. 5
0
        static private Dictionary <string, object> ParseFeature(string metaId, string category, IFeature feature, Item proto, bool useGeometry, IGeometricTransformer transformer, ImportConfig.FeatureClassDefinition featureClassDef)
        {
            var replace = featureClassDef.Replacements;

            var result = new Dictionary <string, object>();

            string oid = feature.OID.ToString();

            if (feature.OID <= 0 && !String.IsNullOrWhiteSpace(featureClassDef.ObjectOidField))
            {
                var idFieldValue = feature.FindField(featureClassDef.ObjectOidField);
                if (idFieldValue != null)
                {
                    oid = idFieldValue.Value?.ToString();
                }
            }

            result["id"]             = metaId + "." + oid;
            result["suggested_text"] = ParseFeatureField(feature, proto.SuggestedText);
            result["subtext"]        = ParseFeatureField(feature, proto.SubText);
            result["thumbnail_url"]  = ParseFeatureField(feature, proto.ThumbnailUrl);
            result["category"]       = category;

            if (replace != null)
            {
                foreach (var r in replace)
                {
                    result["suggested_text"] = result["suggested_text"]?.ToString().Replace(r.From, r.To);
                    result["subtext"]        = result["subtext"]?.ToString().Replace(r.From, r.To);
                }
            }

            if (useGeometry == true && feature.Shape != null)
            {
                IGeometry shape = feature.Shape;

                if (shape is IPoint)
                {
                    IPoint point = (IPoint)transformer.Transform2D(feature.Shape);
                    //result["longitude"] = point.X;
                    //result["latitude"] = point.Y;
                    result["geo"] = new LuceneServerNET.Core.Models.Spatial.GeoPoint()
                    {
                        Longidute = point.X,
                        Latitude  = point.Y
                    };
                }
                else if (shape is IPolyline)
                {
                    IEnvelope env = shape.Envelope;
                    if (env != null)
                    {
                        IPoint point = Algorithm.PolylinePoint((IPolyline)shape, ((IPolyline)shape).Length / 2.0);

                        if (point != null)
                        {
                            point = (IPoint)transformer.Transform2D(point);
                            //result["longitude"] = point.X;
                            //result["latitude"] = point.Y;
                            result["geo"] = new LuceneServerNET.Core.Models.Spatial.GeoPoint()
                            {
                                Longidute = point.X,
                                Latitude  = point.Y
                            };
                        }

                        result["bbox"] = GetBBox(env, transformer);
                    }
                }
                else if (shape is IPolygon)
                {
                    IEnvelope env = shape.Envelope;
                    if (env != null)
                    {
                        var points = Algorithm.OrderPoints(Algorithm.PolygonLabelPoints((IPolygon)shape), env.Center);
                        if (points != null && points.PointCount > 0)
                        {
                            IPoint point = (IPoint)transformer.Transform2D(points[0]);
                            //result["longitude"] = point.X;
                            //result["latitude"] = point.Y;
                            result["geo"] = new LuceneServerNET.Core.Models.Spatial.GeoPoint()
                            {
                                Longidute = point.X,
                                Latitude  = point.Y
                            };
                        }

                        result["bbox"] = GetBBox(env, transformer);
                    }
                }
            }

            return(result);
        }