예제 #1
0
        public override FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes)
        {
            var whitelist = new List <string>();

            return(PedestrianProfile.FactorAndSpeed(attributes, new Whitelist()));
        }
예제 #2
0
 /// <summary>
 /// Sets a single value.
 /// </summary>
 public static void SetSingle(this IAttributeCollection attributes, string key, float value)
 {
     attributes.AddOrReplace(key, value.ToInvariantString());
 }
예제 #3
0
 /// <summary>
 /// Returns true if the two edges with the given attributes are identical as far as this profile is concerned.
 /// </summary>
 /// <remarks>
 /// Default implementation compares attributes one-by-one.
 /// </remarks>
 public override sealed bool Equals(IAttributeCollection attributes1, IAttributeCollection attributes2)
 {
     return(attributes1.ContainsSame(attributes2));
 }
예제 #4
0
 /// <summary>
 /// Adds a tag as an attribute.
 /// </summary>
 public static void Add(this IAttributeCollection attributes, Tag tag)
 {
     attributes.AddOrReplace(tag.Key, tag.Value);
 }
        /// <summary>
        /// Get a function to calculate properties for a set given edge attributes.
        /// </summary>
        /// <returns></returns>
        public sealed override EdgeFactor Factor(IAttributeCollection attributes)
        {
            lock (_script)
            {
                // build lua table.
                _attributesTable.Clear();
                if (attributes == null || attributes.Count == 0)
                {
                    return(EdgeFactor.NoFactor);
                }
                foreach (var attribute in attributes)
                {
                    _attributesTable.Set(attribute.Key, DynValue.NewString(attribute.Value));
                }

                // call factor_and_speed function.
                _resultsTable.Clear();
                _script.Call(_script.Globals["factor"], _attributesTable, _resultsTable);

                // get the results.
                if (!_resultsTable.TryGetDouble("forward", out var forwardFactor))
                {
                    forwardFactor = 0;
                }
                if (!_resultsTable.TryGetDouble("backward", out var backwardFactor))
                {
                    backwardFactor = 0;
                }
                if (!_resultsTable.TryGetBool("canstop", out var canstop))
                {
                    canstop = backwardFactor != 0 || forwardFactor != 0;
                }

                // the speeds are supposed to be in m/s.
                if (!_resultsTable.TryGetDouble("forward_speed", out var speedForward))
                { // when forward_speed isn't explicitly filled, the assumption is that factors are in 1/(m/s)
                    speedForward = 0;
                    if (forwardFactor > 0)
                    { // convert to m/s.
                        speedForward = 1.0 / forwardFactor;
                    }
                }
                else
                { // when forward_speed is filled, it's assumed to be in km/h, it needs to be convert to m/s.
                    speedForward /= 3.6;
                }
                if (!_resultsTable.TryGetDouble("backward_speed", out var speedBackward))
                { // when backward_speed isn't explicitly filled, the assumption is that factors are in 1/(m/s)
                    speedBackward = 0;
                    if (backwardFactor > 0)
                    { // convert to m/s.
                        speedBackward = 1.0 / backwardFactor;
                    }
                }
                else
                { // when forward_speed is filled, it's assumed to be in km/h, it needs to be convert to m/s.
                    speedBackward /= 3.6;
                }

                return(new EdgeFactor((uint)(forwardFactor * 100), (uint)(backwardFactor * 100),
                                      (ushort)(speedForward * 100), (ushort)(speedBackward * 100), canstop));
            }
        }
예제 #6
0
        /// <summary>
        /// Tries to match the given attributes to the given fow/frc and returns a score of the match.
        /// </summary>
        public override float Match(IAttributeCollection attributes, FormOfWay fow, FunctionalRoadClass frc)
        {
            string highway;

            if (!attributes.TryGetValue("highway", out highway))
            { // not even a highway tag!
                return(0);
            }

            // TODO: take into account form of way? Maybe not for OSM-data?
            switch (frc)
            {                              // check there reference values against OSM: http://wiki.openstreetmap.org/wiki/Highway
            case FunctionalRoadClass.Frc0: // main road.
                if (highway == "motorway" || highway == "motorway_link" ||
                    highway == "trunk" || highway == "trunk_link")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc1:     // first class road.
                if (highway == "primary" || highway == "primary_link")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc2:     // second class road.
                if (highway == "secondary" || highway == "secondary_link")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc3:     // third class road.
                if (highway == "tertiary" || highway == "tertiary_link")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc4:
                if (highway == "road" || highway == "road_link" ||
                    highway == "unclassified" || highway == "residential")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc5:
                if (highway == "road" || highway == "road_link" ||
                    highway == "unclassified" || highway == "residential" ||
                    highway == "living_street")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc6:
                if (highway == "road" || highway == "track" ||
                    highway == "unclassified" || highway == "residential" ||
                    highway == "living_street")
                {
                    return(1);
                }
                break;

            case FunctionalRoadClass.Frc7:     // other class road.
                if (highway == "footway" || highway == "bridleway" ||
                    highway == "steps" || highway == "path" ||
                    highway == "living_street")
                {
                    return(1);
                }
                break;
            }

            if (highway != null && highway.Length > 0)
            { // for any other highway return a low match.
                return(0.2f);
            }
            return(0);
        }
예제 #7
0
 public static bool Contains(this IAttributeCollection self, AttributeKind kind)
 {
     return(self.Any(a => a.Kind == kind));
 }
예제 #8
0
 /// <summary>
 /// Returns true if the edge is one way forward, false if backward, null if bidirectional.
 /// </summary>
 public override bool?IsOneWay(IAttributeCollection tags)
 {
     return(null);
 }
예제 #9
0
 /// <summary>
 /// Writes an attributes collection to the given stream and prefixed with it's size.
 /// </summary>
 public static long WriteWithSize(this IAttributeCollection attributes, System.IO.Stream stream)
 {
     return(attributes.SerializeWithSize(stream));
 }
예제 #10
0
 /// <summary>
 /// Gets a the factor for an edge with the given attributes.
 /// </summary>
 public static Factor Factor(this IProfileInstance profileInstance, IAttributeCollection attributes)
 {
     return(profileInstance.FactorAndSpeed(attributes).ToFactor());
 }
예제 #11
0
        /// <summary>
        /// Gets a the factor and speed for an edge with the given attributes.
        /// </summary>
        public static FactorAndSpeed FactorAndSpeed(this IProfileInstance profileInstance, IAttributeCollection attributes)
        {
            var factorAndSpeed = profileInstance.Profile.FactorAndSpeed(attributes);

            if (profileInstance.IsConstrained(factorAndSpeed.Constraints))
            {
                return(Profiles.FactorAndSpeed.NoFactor);
            }
            return(factorAndSpeed);
        }
예제 #12
0
 /// <summary>
 /// Tries to get cached whitelist.
 /// </summary>
 public bool TryGetCached(IAttributeCollection attributes, out Whitelist whitelist, bool filter = true)
 {
     bool[] canTraverse;
     return(this.TryGetCached(attributes, out whitelist, out canTraverse, filter));
 }
예제 #13
0
            public void AddComponent <T>(Action <T, XmlLayoutElement> componentConfig, IAttributeCollection <T> attrs = null) where T : Component
            {
                objectBuildActions.Add((prefabObject, binder) =>
                {
                    if (!prefabObject.gameObject.TryGetComponent <T>(out var component))
                    {
                        component = prefabObject.gameObject.AddComponent <T>();
                    }

                    componentConfig?.Invoke(component, prefabObject);

                    if (attrs.IsEmpty())
                    {
                        return;
                    }

                    foreach (var c in attrs.SerializableConstants)
                    {
                        c.Setter(prefabObject, component);
                    }

                    binder.AddAttributes(prefabObject, component,
                                         attrs.Variables, attrs.NonSerializableConstants);
                });
            }
예제 #14
0
        internal static FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes,
                                                      Whitelist whitelist)
        {
            if (attributes == null || attributes.Count == 0)
            {
                return(Itinero.Profiles.FactorAndSpeed.NoFactor);
            }

            string highway = null;

            if (attributes.TryGetValue("highway", out highway))
            {
                whitelist.Add("highway");
            }
            string foot = null;

            if (attributes.TryGetValue("foot", out foot))
            {
                if (foot == "no" || foot == "0")
                {
                    return(Itinero.Profiles.FactorAndSpeed.NoFactor);
                }
                whitelist.Add("foot");
            }
            string footway;

            if (attributes.TryGetValue("footway", out footway))
            {
                whitelist.Add("footway");
            }
            var   result    = new FactorAndSpeed();
            var   speed     = 0.0f;
            short direction = 0;
            var   canstop   = true;

            if (String.IsNullOrEmpty(highway))
            {
                if (!String.IsNullOrEmpty(foot))
                {
                    highway = "footway";
                }
                else
                {
                    return(Itinero.Profiles.FactorAndSpeed.NoFactor);
                }
            }
            //get default speed profiles
            var highway_speed = SpeedProfiles.ContainsKey(highway) ? (int?)SpeedProfiles[highway] : null;

            if (highway_speed != null)
            {
                speed     = highway_speed.Value;
                direction = 0;
                canstop   = true;
            }
            else
            {
                return(Itinero.Profiles.FactorAndSpeed.NoFactor);
            }

            if (CanAccess(attributes) == false || speed == 0)
            {
                return(Itinero.Profiles.FactorAndSpeed.NoFactor);
            }

            result.SpeedFactor = 1.0f / (speed / 3.6f); // 1/m/s
            result.Value       = result.SpeedFactor;
            result.Direction   = direction;
            if (!canstop)
            {
                result.Direction += 3;
            }
            return(result);
        }
예제 #15
0
 /// <summary>
 /// Returns true if the two given edges are equals as far as this vehicle is concerned.
 /// </summary>
 public virtual bool Equals(IAttributeCollection attributes1, IAttributeCollection attributes2)
 {
     return(attributes1.ContainsSame(attributes2));
 }
예제 #16
0
        /// <summary>
        /// Adds new attributes.
        /// </summary>
        public uint Add(IAttributeCollection tags)
        {
            if (tags == null)
            {
                return(NULL_ATTRIBUTES);
            }
            else if (tags.Count == 0)
            {
                return(EMPTY_ATTRIBUTES);
            }

            if (_isReadonly)
            { // this index is readonly.
                // TODO: make writeable.
                // - set nextId.
                // - create reverse indexes if needed.
                if (_index != null)
                { // this should be an increase-one index.
                    if ((_mode & AttributesIndexMode.IncreaseOne) != AttributesIndexMode.IncreaseOne)
                    {
                        throw new Exception("Invalid combination of data: There is an index but mode isn't increase one.");
                    }

                    _nextId = (uint)_index.Length;
                }

                // build reverse indexes if needed.
                if ((_mode & AttributesIndexMode.ReverseStringIndex) == AttributesIndexMode.ReverseStringIndex ||
                    (_mode & AttributesIndexMode.ReverseStringIndexKeysOnly) == AttributesIndexMode.ReverseStringIndexKeysOnly)
                {
                    _stringReverseIndex = new Reminiscence.Collections.Dictionary <string, int>(
                        new MemoryMapStream(), 1024 * 16);

                    // add existing data.
                    if ((_mode & AttributesIndexMode.ReverseStringIndex) == AttributesIndexMode.ReverseStringIndex)
                    { // build reverse index for all data.
                        foreach (var pair in _stringIndex)
                        {
                            _stringReverseIndex[pair.Value] = (int)pair.Key;
                        }
                    }
                    else
                    { // build reverse index for keys only.
                        foreach (var collectionPair in _collectionIndex)
                        {
                            foreach (var stringId in collectionPair.Value)
                            {
                                _stringReverseIndex[_stringIndex.Get(stringId)] = stringId;
                            }
                        }
                    }
                }

                if ((_mode & AttributesIndexMode.ReverseCollectionIndex) == AttributesIndexMode.ReverseCollectionIndex)
                {
                    _collectionReverseIndex = new Reminiscence.Collections.Dictionary <int[], uint>(new MemoryMapStream(), 1024 * 16, new EqualityComparer());
                    if (_index != null)
                    {
                        for (uint col = 0; col < _nextId; col++)
                        {
                            var pointer = _index[col];
                            _collectionReverseIndex[_collectionIndex.Get(pointer)] = col;
                        }
                    }
                    else
                    {
                        foreach (var pair in _collectionIndex)
                        {
                            _collectionReverseIndex[pair.Value] = (uint)pair.Key;
                        }
                    }
                }

                _isReadonly = false;
            }

            // add new collection.
            var sortedSet = new SortedSet <long>();

            foreach (var tag in tags)
            {
                sortedSet.Add((long)this.AddString(tag.Key, true) +
                              (long)int.MaxValue * (long)this.AddString(tag.Value, false));
            }

            // sort keys.
            var sorted = new int[sortedSet.Count * 2];
            var i      = 0;

            foreach (var pair in sortedSet)
            {
                sorted[i] = (int)(pair % int.MaxValue);
                i++;
                sorted[i] = (int)(pair / int.MaxValue);
                i++;
            }

            // add sorted collection.
            return(this.AddCollection(sorted));
        }
예제 #17
0
        /// <summary>
        /// Tries to extract fow/frc from the given attributes.
        /// </summary>
        public override bool Extract(IAttributeCollection tags, out FunctionalRoadClass frc, out FormOfWay fow)
        {
            frc = FunctionalRoadClass.Frc7;
            fow = FormOfWay.Undefined;
            string highway;

            if (tags.TryGetValue("highway", out highway))
            {
                switch (highway)
                { // check there reference values against OSM: http://wiki.openstreetmap.org/wiki/Highway
                case "motorway":
                case "trunk":
                    frc = FunctionalRoadClass.Frc0;
                    break;

                case "primary":
                case "primary_link":
                    frc = FunctionalRoadClass.Frc1;
                    break;

                case "secondary":
                case "secondary_link":
                    frc = FunctionalRoadClass.Frc2;
                    break;

                case "tertiary":
                case "tertiary_link":
                    frc = FunctionalRoadClass.Frc3;
                    break;

                case "road":
                case "road_link":
                case "unclassified":
                case "residential":
                    frc = FunctionalRoadClass.Frc4;
                    break;

                case "living_street":
                    frc = FunctionalRoadClass.Frc5;
                    break;

                default:
                    frc = FunctionalRoadClass.Frc7;
                    break;
                }
                switch (highway)
                { // check there reference values against OSM: http://wiki.openstreetmap.org/wiki/Highway
                case "motorway":
                case "trunk":
                    fow = FormOfWay.Motorway;
                    break;

                case "primary":
                case "primary_link":
                    fow = FormOfWay.MultipleCarriageWay;
                    break;

                case "secondary":
                case "secondary_link":
                case "tertiary":
                case "tertiary_link":
                    fow = FormOfWay.SingleCarriageWay;
                    break;

                default:
                    fow = FormOfWay.SingleCarriageWay;
                    break;
                }
                return(true); // should never fail on a highway tag.
            }
            return(false);
        }
예제 #18
0
 /// <summary>
 /// Returns true if the given attribute collection represents a shortcut and returns the name.
 /// </summary>
 public static bool IsShortcut(this IAttributeCollection attributes, out string name)
 {
     return(attributes.TryGetValue(ShortcutExtensions.SHORTCUT_KEY, out name));
 }
예제 #19
0
 public static bool IsEmpty <T>(this IAttributeCollection <T> c) =>
 c == null || c.SerializableConstants.Length == 0 && c.NonSerializableConstants.Length == 0 && c.Variables.Length == 0;
예제 #20
0
 /// <summary>
 /// Calculates a factor and speed.
 /// </summary>
 public override FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes, Whitelist whitelist)
 {
     return(_getFactorAndSpeed(attributes));
 }
예제 #21
0
        /// <summary>
        /// Creates a new router database.
        /// </summary>
        private RouterDb(Guid guid, RoutingNetwork network, AttributesIndex profiles, AttributesIndex meta, IAttributeCollection dbMeta,
                         Profiles.Vehicle[] supportedVehicles)
        {
            _guid         = guid;
            _network      = network;
            _edgeProfiles = profiles;
            _meta         = meta;
            _dbMeta       = dbMeta;

            _supportedVehicles = new Dictionary <string, Vehicle>();
            _supportedProfiles = new Dictionary <string, Profile>();
            foreach (var vehicle in supportedVehicles)
            {
                _supportedVehicles[vehicle.Name.ToLowerInvariant()] = vehicle;
                foreach (var profile in vehicle.GetProfiles())
                {
                    _supportedProfiles[profile.FullName.ToLowerInvariant()] = profile;
                }
            }
            _contracted     = new Dictionary <string, ContractedDb>();
            _restrictionDbs = new Dictionary <string, RestrictionsDb>();
            _shortcutsDbs   = new Dictionary <string, ShortcutsDb>();
        }
예제 #22
0
 public override bool AddToWhiteList(IAttributeCollection attributes, Whitelist whitelist)
 {
     return(PedestrianProfile.FactorAndSpeed(attributes, whitelist).SpeedFactor > 0);
 }
예제 #23
0
 /// <summary>
 /// Pushes the attributes through this profiles and adds used keys in the given whitelist.
 /// </summary>
 public override FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes, Whitelist whiteList)
 {
     throw new NotImplementedException("Not used and unavailable with dynamic vehicles.");
 }
예제 #24
0
 public override FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes, Whitelist whitelist)
 {
     throw new NotImplementedException();
 }
예제 #25
0
 /// <summary>
 /// Adds a new attribute.
 /// </summary>
 public static void AddOrReplace(this IAttributeCollection attributes, Attribute attribute)
 {
     attributes.AddOrReplace(attribute.Key, attribute.Value);
 }
예제 #26
0
 /// <summary>
 /// Adds a number of keys to the given whitelist when they are relevant for this vehicle.
 /// </summary>
 /// <returns>True if the edge with the given attributes is usefull for this vehicle.</returns>
 public virtual bool AddToWhiteList(IAttributeCollection attributes, Whitelist whitelist)
 {
     return(this.FactorAndSpeed(attributes, whitelist).Value > 0);
 }
예제 #27
0
        /// <summary>
        /// Extracts nwb/fow.
        /// </summary>
        public override bool Extract(IAttributeCollection attributes, out FunctionalRoadClass frc, out FormOfWay fow)
        {
            fow = FormOfWay.Undefined;
            frc = FunctionalRoadClass.Frc7;
            string baansubsrt = string.Empty, wegbeerder = string.Empty, wegnummer = string.Empty, rijrichting = string.Empty, dvkletter_ = string.Empty;

            if (!attributes.TryGetValue(BAANSUBSRT, out baansubsrt) &
                !attributes.TryGetValue(WEGBEHSRT, out wegbeerder) &
                !attributes.TryGetValue(WEGNUMMER, out wegnummer) &
                !attributes.TryGetValue(HECTOLTTR, out dvkletter_) &
                !attributes.TryGetValue(RIJRICHTNG, out rijrichting))
            { // not even a BAANSUBSRT tag!
                // defaults: FRC5, OTHER.
                fow = FormOfWay.Other;
                frc = FunctionalRoadClass.Frc5;
                return(true);
            }

            // make sure everything is lowercase.
            char?dvkletter = null;  // assume dkv letter is the suffix used for exits etc. see: http://www.wegenwiki.nl/Hectometerpaal#Suffix

            if (!string.IsNullOrWhiteSpace(wegbeerder))
            {
                wegbeerder = wegbeerder.ToLowerInvariant();
            }
            if (!string.IsNullOrWhiteSpace(baansubsrt))
            {
                baansubsrt = baansubsrt.ToLowerInvariant();
            }
            if (!string.IsNullOrWhiteSpace(wegnummer))
            {
                wegnummer = wegnummer.ToLowerInvariant(); if (!string.IsNullOrEmpty(dvkletter_))
                {
                    dvkletter = dvkletter_[0];
                }
            }
            if (!string.IsNullOrWhiteSpace(rijrichting))
            {
                rijrichting = rijrichting.ToLowerInvariant();
            }

            fow = FormOfWay.Other;
            frc = FunctionalRoadClass.Frc5;
            if (wegbeerder == "r")
            {
                if (baansubsrt == "hr")
                {
                    fow = FormOfWay.Motorway;
                    frc = FunctionalRoadClass.Frc0;
                }
                else if (baansubsrt == "nrb" ||
                         baansubsrt == "mrb")
                {
                    fow = FormOfWay.Roundabout;
                    frc = FunctionalRoadClass.Frc0;
                }
                else if (baansubsrt == "pst")
                {
                    if (dvkletter.HasValue)
                    {
                        fow = FormOfWay.SlipRoad;
                        if (dvkletter == 'a' ||
                            dvkletter == 'b' ||
                            dvkletter == 'c' ||
                            dvkletter == 'd')
                        { // r  pst (a|b|c|d)
                            frc = FunctionalRoadClass.Frc3;
                        }
                        else
                        { // r  pst !(a|b|c|d)
                            frc = FunctionalRoadClass.Frc0;
                        }
                    }
                    else if (!string.IsNullOrWhiteSpace(rijrichting))
                    { // r  pst !(a|b|c|d)
                        fow = FormOfWay.SlipRoad;
                        frc = FunctionalRoadClass.Frc0;
                    }
                }
                else if (baansubsrt == "opr" ||
                         baansubsrt == "afr")
                {
                    frc = FunctionalRoadClass.Frc3;
                    fow = FormOfWay.SlipRoad;
                }
                else if (baansubsrt.StartsWith("vb"))
                {
                    if (!string.IsNullOrWhiteSpace(rijrichting))
                    {
                        fow = FormOfWay.SlipRoad;
                        frc = FunctionalRoadClass.Frc0;
                    }
                }
            }
            else if (wegbeerder == "p")
            {
                if (baansubsrt == "hr")
                {
                    frc = FunctionalRoadClass.Frc3;
                    fow = FormOfWay.MultipleCarriageWay;
                    if (string.IsNullOrWhiteSpace(rijrichting))
                    {
                        frc = FunctionalRoadClass.Frc2;
                        fow = FormOfWay.SingleCarriageWay;
                    }
                }
                else if (baansubsrt == "nrb" ||
                         baansubsrt == "mrb")
                {
                    frc = FunctionalRoadClass.Frc3;
                    fow = FormOfWay.Roundabout;
                }
                else if (baansubsrt == "opr" ||
                         baansubsrt == "afr")
                {
                    frc = FunctionalRoadClass.Frc3;
                    fow = FormOfWay.SlipRoad;
                }
                else if (baansubsrt == "pst" ||
                         baansubsrt.StartsWith("vb"))
                {
                    frc = FunctionalRoadClass.Frc3;
                    fow = FormOfWay.SlipRoad;
                }
            }
            return(true);
        }
예제 #28
0
 /// <summary>
 /// Calculates a factor and speed and adds a keys to the given whitelist that are relevant.
 /// </summary>
 /// <returns>True if the edge with the given attributes is usefull for this vehicle.</returns>
 public abstract FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes, Whitelist whitelist);
예제 #29
0
        /// <summary>
        /// Get a function to calculate properties for a set given edge attributes.
        /// </summary>
        /// <returns></returns>
        public sealed override FactorAndSpeed FactorAndSpeed(IAttributeCollection attributes)
        {
            lock (_script)
            {
                // build lua table.
                _attributesTable.Clear();
                if (attributes == null || attributes.Count == 0)
                {
                    return(Profiles.FactorAndSpeed.NoFactor);
                }
                foreach (var attribute in attributes)
                {
                    _attributesTable.Set(attribute.Key, DynValue.NewString(attribute.Value));
                }

                // call factor_and_speed function.
                _resultsTable.Clear();
                _script.Call(_function, _attributesTable, _resultsTable);

                // get the results.
                var   result = new FactorAndSpeed();
                float val;
                if (!_resultsTable.TryGetFloat("speed", out val))
                {
                    val = 0;
                }
                if (val == 0)
                {
                    return(Profiles.FactorAndSpeed.NoFactor);
                }
                result.SpeedFactor = 1.0f / (val / 3.6f); // 1/m/s
                if (_metric == ProfileMetric.TimeInSeconds)
                {                                         // use 1/speed as factor.
                    result.Value = result.SpeedFactor;
                }
                else if (_metric == ProfileMetric.DistanceInMeters)
                { // use 1 as factor.
                    result.Value = 1;
                }
                else
                { // use a custom factor.
                    if (!_resultsTable.TryGetFloat("factor", out val))
                    {
                        val = 0;
                    }
                    result.Value = val;
                }
                if (!_resultsTable.TryGetFloat("direction", out val))
                {
                    val = 0;
                }
                result.Direction = (short)val;
                bool boolVal;
                if (!_resultsTable.TryGetBool("canstop", out boolVal))
                { // default stopping everywhere.
                    boolVal = true;
                }
                if (!boolVal)
                {
                    result.Direction += 3;
                }

                return(result);
            }
        }
예제 #30
0
        /// <summary>
        /// Splits the given tags into a normalized version, profile tags, and the rest in metatags.
        /// </summary>
        public static bool Normalize(IAttributeCollection tags, IAttributeCollection profileTags, VehicleCache vehicleCache)
        {
            if (tags == null || profileTags == null || vehicleCache == null)
            {
                return(false);
            }

            var normalizedTags = new HashSet <string>(new string[] { "highway", "maxspeed", "oneway", "oneway:bicycle",
                                                                     "cycleway", "junction", "access" });

            foreach (var vehicle in vehicleCache.Vehicles)
            {
                foreach (var vehicleType in vehicle.VehicleTypes)
                {
                    normalizedTags.Add(vehicleType);
                }
            }

            string highway;

            if (!tags.TryGetValue("highway", out highway))
            { // there is no highway tag, don't continue the search.
                return(false);
            }

            // add the highway tag.
            profileTags.AddOrReplace("highway", highway);

            // normalize maxspeed tags.
            tags.NormalizeMaxspeed(profileTags);

            // normalize oneway tags.
            tags.NormalizeOneway(profileTags);
            tags.NormalizeOnewayBicycle(profileTags);

            // normalize cyclceway.
            tags.NormalizeCycleway(profileTags);

            // normalize junction=roundabout tag.
            tags.NormalizeJunction(profileTags);

            // normalize access tags.
            foreach (var vehicle in vehicleCache.Vehicles)
            {
                tags.NormalizeAccess(vehicleCache, vehicle, highway, profileTags);
            }

            // add whitelisted tags but only when they haven't been considered for normalization.
            foreach (var vehicle in vehicleCache.Vehicles)
            {
                foreach (var key in vehicle.ProfileWhiteList)
                {
                    var value = string.Empty;
                    if (tags.TryGetValue(key, out value))
                    {
                        if (!normalizedTags.Contains(key))
                        {
                            profileTags.AddOrReplace(key, value);
                        }
                    }
                }
            }

            return(true);
        }