C# OsmSharp类代码示例

 /// <summary>
 /// Converts the given OsmSharp feature collection into a list of NTS feature collection.
 /// </summary>
 /// <param name="featureCollection"></param>
 /// <returns></returns>
 public static List<Feature> Convert(OsmSharp.Geo.Features.FeatureCollection featureCollection)
 {
     var features = new List<Feature>(featureCollection.Count);
     foreach (var feature in featureCollection)
     {
         features.Add(OsmSharpToNTSFeatureConvertor.Convert(feature));
     }
     return features;
 }

 /// <summary>
 /// Converts boundary type into an osm object.
 /// </summary>
 /// <param name="boundary"></param>
 /// <returns></returns>
 private static IEnumerable<LineairRing> ConvertBoundary(OsmSharp.IO.Xml.Kml.v2_1.boundaryType[] boundary)
 {
     List<LineairRing> rings = new List<LineairRing>();
     foreach (OsmSharp.IO.Xml.Kml.v2_1.boundaryType geo in boundary)
     {
         rings.Add(KmlFeatureStreamSource.ConvertLinearRing(geo.LinearRing).Geometry as LineairRing);
     }
     return rings;
 }

        /// <summary>
        /// Creates a new polygon filter.
        /// </summary>
        public OsmStreamFilterPoly(OsmSharp.Geo.Geometries.LineairRing poly)
            : base()
        {
            if (poly == null) { throw new ArgumentNullException("poly"); }

            _poly = poly;
            _box = new GeoCoordinateBox(poly.Coordinates);

            this.Meta.Add("poly", OsmSharp.Geo.Streams.GeoJson.GeoJsonConverter.ToGeoJson(_poly));
        }

 /// <summary>
 /// Generates an immidiate turn.
 /// </summary>
 /// <param name="instruction"></param>
 /// <param name="firstStreetCountTo"></param>
 /// <param name="firstStreetTo"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreetTo"></param>
 /// <param name="secondDirection"></param>
 /// <returns></returns>
 public Instruction GenerateImmidiateTurn(Instruction instruction, 
     int firstStreetCountTo, 
     List<KeyValuePair<string, string>> firstStreetTo, 
     OsmSharp.Tools.Math.Geo.Meta.RelativeDirection firstDirection, 
     List<KeyValuePair<string, string>> secondStreetTo, 
     RelativeDirection secondDirection)
 {
     instruction.Text = string.Format("GenerateImmidiateTurn:{0}_{1}_{2}_{3}",
                                      firstStreetCountTo, firstDirection,
                                      firstDirection.ToString(),
                                      secondDirection.ToString());
     return instruction;
 }

        /// <summary>
        /// Converts a polygon.
        /// </summary>
        /// <param name="polygon"></param>
        /// <returns></returns>
        private static Polygon ConvertPolygon(OsmSharp.Xml.Kml.v2_0_response.Polygon polygon)
        {
            LineairRing inner = KmlGeoStreamSource.ConvertLinearRing(polygon.innerBoundaryIs.LinearRing);
            LineairRing outer = KmlGeoStreamSource.ConvertLinearRing(polygon.outerBoundaryIs.LinearRing);

            return new Polygon(outer, new LineairRing[] { inner });
        }

        /// <summary>
        /// Converts a point into an oms object.
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        private static Point ConvertPoint(OsmSharp.Xml.Kml.v2_1.PointType point)
        {
            // convert the coordiantes.
            IList<GeoCoordinate> coordinates = KmlGeoStreamSource.ConvertCoordinates(point.coordinates);

            // create the point.
            Point pointGeometry = new Point(coordinates[0]);
            pointGeometry.Attributes = new SimpleGeometryAttributeCollection();
            if (point.targetId != null) { pointGeometry.Attributes.Add("targetId", point.targetId); }
            pointGeometry.Attributes.Add("altitude", point.altitudeMode);
            if (point.extrude) { pointGeometry.Attributes.Add("extrude", point.extrude); }
            if (point.id != null) { pointGeometry.Attributes.Add("id", point.id); }

            return pointGeometry;
        }

 /// <summary>
 /// Converts a multipolygon into osm objects.
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <returns></returns>
 private static MultiPolygon ConvertMultiPolygon(OsmSharp.Xml.Kml.v2_0_response.MultiPolygon multiPolygon)
 {
     return new MultiPolygon(new Polygon[] { KmlGeoStreamSource.ConvertPolygon(multiPolygon.Polygon) });
 }

 /// <summary>
 /// Converts a multipoint to osm objects.
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <returns></returns>
 private static MultiPoint ConvertMultiPoint(OsmSharp.Xml.Kml.v2_0_response.MultiPoint multiPoint)
 {
     return new MultiPoint(new Point[] { KmlGeoStreamSource.ConvertPoint(multiPoint.Point) });
 }

 /// <summary>
 /// Converts a multilinestring to osm objects.
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <returns></returns>
 private static MultiLineString ConvertMultiLineString(OsmSharp.Xml.Kml.v2_0_response.MultiLineString multiLineString)
 {
     return new MultiLineString(new LineString[] { KmlGeoStreamSource.ConvertLineString(multiLineString.LineString) });
 }

        /// <summary>
        /// Converts a line string into an osm object.
        /// </summary>
        /// <param name="lineString"></param>
        /// <returns></returns>
        private static LineString ConvertLineString(OsmSharp.Xml.Kml.v2_1.LineStringType lineString)
        {
            // convert the coordinates.
            IList<GeoCoordinate> coordinates = KmlGeoStreamSource.ConvertCoordinates(lineString.coordinates);

            // create the ring.
            LineString lineStringGeometry = new LineString(coordinates);
            lineStringGeometry.Attributes = new SimpleGeometryAttributeCollection();
            lineStringGeometry.Attributes.Add("id", lineString.id);

            return lineStringGeometry;
        }

        /// <summary>
        /// Converts a lineairring into an osm object.
        /// </summary>
        /// <param name="linearRing"></param>
        /// <returns></returns>
        private static LineairRing ConvertLinearRing(OsmSharp.Xml.Kml.v2_0_response.LinearRing linearRing)
        {
            // convert the coordinates.
            IList<GeoCoordinate> coordinates = KmlGeoStreamSource.ConvertCoordinates(linearRing.coordinates);

            // create the ring.
            LineairRing ring = new LineairRing(coordinates);
            ring.Attributes = new SimpleGeometryAttributeCollection();
            ring.Attributes.Add("id", linearRing.id);

            return ring;
        }

        /// <summary>
        /// Converts a PBF way into an OsmSharp-way.
        /// </summary>
        /// <param name="block"></param>
        /// <param name="way"></param>
        /// <returns></returns>
        internal OsmSharp.Osm.Way ConvertWay(PrimitiveBlock block, OsmSharp.Osm.PBF.Way way)
        {
            var simpleWay = new OsmSharp.Osm.Way();
            simpleWay.Id = way.id;
            simpleWay.Nodes = new List<long>(way.refs.Count);
            long node_id = 0;
            for (int node_idx = 0; node_idx < way.refs.Count; node_idx++)
            {
                node_id = node_id + way.refs[node_idx];
                simpleWay.Nodes.Add(node_id);
            }
            simpleWay.Tags = new TagsCollection(way.keys.Count);
            if (way.keys.Count > 0)
            {
                for (int tag_idx = 0; tag_idx < way.keys.Count; tag_idx++)
                {
                    string key = Encoding.UTF8.GetString(block.stringtable.s[(int)way.keys[tag_idx]]);
                    string value = Encoding.UTF8.GetString(block.stringtable.s[(int)way.vals[tag_idx]]);

                    simpleWay.Tags.Add(new Tag(key, value));
                }
            }
            if (way.info != null)
            { // add the metadata if any.
                simpleWay.ChangeSetId = way.info.changeset;
                simpleWay.TimeStamp = Utilities.FromUnixTime((long)way.info.timestamp *
                    (long)block.date_granularity);
                simpleWay.UserId = way.info.uid;
                simpleWay.UserName = Encoding.UTF8.GetString(block.stringtable.s[way.info.user_sid]);
                simpleWay.Version = (ulong)way.info.version;
            }
            simpleWay.Visible = true;

            return simpleWay;
        }

        /// <summary>
        /// Converts a PBF way into an OsmSharp-relation.
        /// </summary>
        /// <param name="block"></param>
        /// <param name="relation"></param>
        /// <returns></returns>
        internal OsmSharp.Osm.Relation ConvertRelation(PrimitiveBlock block, OsmSharp.Osm.PBF.Relation relation)
        {
            var simpleRelation = new OsmSharp.Osm.Relation();
            simpleRelation.Id = relation.id;
            if (relation.types.Count > 0)
            {
                simpleRelation.Members = new List<OsmSharp.Osm.RelationMember>();
                long member_id = 0;
                for (int member_idx = 0; member_idx < relation.types.Count; member_idx++)
                {
                    member_id = member_id + relation.memids[member_idx];
                    string role = Encoding.UTF8.GetString(
                        block.stringtable.s[relation.roles_sid[member_idx]]);
                    var member = new OsmSharp.Osm.RelationMember();
                    member.MemberId = member_id;
                    member.MemberRole = role;
                    switch (relation.types[member_idx])
                    {
                        case Relation.MemberType.NODE:
                            member.MemberType = OsmSharp.Osm.OsmGeoType.Node;
                            break;
                        case Relation.MemberType.WAY:
                            member.MemberType = OsmSharp.Osm.OsmGeoType.Way;
                            break;
                        case Relation.MemberType.RELATION:
                            member.MemberType = OsmSharp.Osm.OsmGeoType.Relation;
                            break;
                    }

                    simpleRelation.Members.Add(member);
                }
            }
            simpleRelation.Tags = new TagsCollection(relation.keys.Count);
            if (relation.keys.Count > 0)
            {
                for (int tag_idx = 0; tag_idx < relation.keys.Count; tag_idx++)
                {
                    string key = Encoding.UTF8.GetString(block.stringtable.s[(int)relation.keys[tag_idx]]);
                    string value = Encoding.UTF8.GetString(block.stringtable.s[(int)relation.vals[tag_idx]]);

                    simpleRelation.Tags.Add(new Tag(key, value));
                }
            }
            if (relation.info != null)
            { // read metadata if any.
                simpleRelation.ChangeSetId = relation.info.changeset;
                simpleRelation.TimeStamp = Utilities.FromUnixTime((long)relation.info.timestamp *
                    (long)block.date_granularity);
                simpleRelation.UserId = relation.info.uid;
                simpleRelation.UserName = Encoding.UTF8.GetString(block.stringtable.s[relation.info.user_sid]);
                simpleRelation.Version = (ulong)relation.info.version;
            }
            simpleRelation.Visible = true;

            return simpleRelation;
        }

 /// <summary>
 /// Called when the map was first initialized.
 /// </summary>
 /// <param name="mapView">Map view.</param>
 /// <param name="newZoom">New zoom.</param>
 /// <param name="newTilt">New tilt.</param>
 /// <param name="newCenter">New center.</param>
 private void _mapView_MapInitialized(OsmSharp.UI.IMapView mapView, float newZoom, OsmSharp.Units.Angle.Degree newTilt, GeoCoordinate newCenter)
 {
     // make sure the center marker stays in place from now on.
     _centerMarker.MoveWithMap = false;
 }

        /// <summary>
        /// Solves the problem using a GA.
        /// </summary>
        /// <param name="problem"></param>
        /// <returns></returns>
        protected override IRoute DoSolve(OsmSharp.Tools.Math.TSP.Problems.IProblem problem)
        {
            //int population_size = 10;
            //if (problem.Size < 100)
            //{
            //    population_size = System.Math.Max(problem.Size * 3, 10);
            //    if (problem.Size < 10)
            //    {
            //        population_size = 1;
            //    }
            //}
            //if (problem.Size < 1000)
            //{
            //    population_size = problem.Size / 4;
            //}

            // create the settings.
            SolverSettings settings = new SolverSettings(
                _stagnation_count,
                _population,
                1000000000,
                _eltism,
                _cross,
                _mutation);

            //List<IMutationOperation<List<int>, GeneticProblem, Fitness>> mutators = new List<IMutationOperation<int,GeneticProblem,Fitness>>();
            ////mutators.Add(new DefaultMutationOperation());
            ////mutators.Add(new BestPlacementMutationOperation());
            //mutators.Add(new BestDetailedPlacementMutationOperation());
            //List<double> probabilities = new List<double>();
            //probabilities.Add(1);
            ////probabilities.Add(0.5);
            ////probabilities.Add(0.3);

            //CombinedMutation<List<int>, GeneticProblem, Fitness> mutation = new CombinedMutation<int,GeneticProblem,Fitness>(
            //    StaticRandomGenerator.Get(),
            //    mutators,
            //    probabilities);

            ////SequentialContructiveCrossoverOperator cross_over = new SequentialContructiveCrossoverOperator();
            //BestDetailedPlacementCrossOverOperation cross_over = new BestDetailedPlacementCrossOverOperation();
            ////BestPlacementCrossOverOperation cross_over = new BestPlacementCrossOverOperation();
            ////EdgeRecombinationCrossOverOperation cross_over = new EdgeRecombinationCrossOverOperation();

            //BestPlacementGenerationOperation generation = new BestPlacementGenerationOperation();
            ////RandomGenerationOperation generation = new RandomGenerationOperation();
            ISelector<List<int>, GeneticProblem, Fitness> selector = new RandomSelector<List<int>, GeneticProblem, Fitness>();
            //ISelector<List<int>, GeneticProblem, Fitness> selector = new TournamentBasedSelector<List<int>, GeneticProblem, Fitness>(75, 0.01);
            solver =
                new Solver<List<int>, GeneticProblem, Fitness>(
                    new GeneticProblem(problem),
                    settings,
                    selector,
                    _mutation_operation,
                    _cross_over_operation,
                    _generation_operation,
                    new FitnessCalculator(),
                    true, false);

            solver.NewFittest += new Solver<List<int>, GeneticProblem, Fitness>.NewFittestDelegate(solver_NewFittest);
            solver.NewGeneration += new Solver<List<int>, GeneticProblem, Fitness>.NewGenerationDelegate(solver_NewGeneration);
            List<int> result = new List<int>(solver.Start(null).Genomes);
            result.Insert(0, 0);
            return new SimpleAsymmetricRoute(result, true);
        }