CommonBikeFlagEncoder.java

  1. /*
  2.  *  Licensed to GraphHopper GmbH under one or more contributor
  3.  *  license agreements. See the NOTICE file distributed with this work for
  4.  *  additional information regarding copyright ownership.
  5.  *
  6.  *  GraphHopper GmbH licenses this file to you under the Apache License,
  7.  *  Version 2.0 (the "License"); you may not use this file except in
  8.  *  compliance with the License. You may obtain a copy of the License at
  9.  *
  10.  *       http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  *  Unless required by applicable law or agreed to in writing, software
  13.  *  distributed under the License is distributed on an "AS IS" BASIS,
  14.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  *  See the License for the specific language governing permissions and
  16.  *  limitations under the License.
  17.  */
  18. package org.heigit.ors.routing.graphhopper.extensions.flagencoders.bike;

  20. import com.graphhopper.reader.ReaderWay;
  21. import com.graphhopper.routing.ev.*;
  22. import com.graphhopper.routing.util.BikeCommonFlagEncoder;
  23. import com.graphhopper.routing.util.EncodingManager;
  24. import com.graphhopper.routing.util.TransportationMode;
  25. import com.graphhopper.routing.weighting.PriorityWeighting;
  26. import com.graphhopper.storage.ConditionalEdges;
  27. import com.graphhopper.storage.IntsRef;
  28. import com.graphhopper.util.Helper;
  29. import com.graphhopper.util.PMap;
  30. import com.graphhopper.util.Translation;
  31. import org.apache.log4j.Logger;
  32. import org.heigit.ors.routing.graphhopper.extensions.util.PriorityCode;

  34. import java.io.File;
  35. import java.io.FileWriter;
  36. import java.util.*;

  38. import static com.graphhopper.routing.ev.RouteNetwork.*;
  39. import static com.graphhopper.routing.util.EncodingManager.getKey;
  40. import static org.heigit.ors.routing.graphhopper.extensions.util.PriorityCode.*;

  42. /**
  43.  * Defines bit layout of bicycles (not motorcycles) for speed, access and relations (network).
  44.  * <p>
  45.  *
  46.  * @author Peter Karich
  47.  * @author Nop
  48.  * @author ratrun
  49.  */
  50. public abstract class CommonBikeFlagEncoder extends BikeCommonFlagEncoder {
  51.     /**
  52.      * Reports whether this edge is unpaved.
  53.      */
  54.     protected static final int PUSHING_SECTION_SPEED = 4;
  55.     public static final String KEY_BICYCLE = "bicycle";
  56.     public static final String KEY_DESIGNATED = "designated";
  57.     public static final String KEY_OFFICIAL = "official";
  58.     public static final String KEY_UNPAVED = "unpaved";
  59.     public static final String KEY_LIVING_STREET = "living_street";
  60.     public static final String KEY_SERVICE = "service";
  61.     public static final String KEY_STEPS = "steps";
  62.     public static final String KEY_CYCLEWAY = "cycleway";
  63.     public static final String KEY_TRACK = "track";
  64.     public static final String KEY_MOTORWAY = "motorway";
  65.     public static final String KEY_MOTORWAY_LINK = "motorway_link";
  66.     public static final String KEY_HIGHWAY = "highway";
  67.     public static final String KEY_ROUTE = "route";
  68.     public static final String KEY_RAILWAY = "railway";
  69.     public static final String KEY_BICYCLE_ROAD = "bicycle_road";
  70.     public static final String KEY_JUNCTION = "junction";
  71.     public static final String KEY_SEGREGATED = "segregated";
  72.     public static final String KEY_ONEWAY_BICYCLE = "oneway:bicycle";
  73.     public static final String KEY_BRIDLEWAY = "bridleway";

  75.     // Pushing section highways are parts where you need to get off your bike and push it (German: Schiebestrecke)
  76.     protected final HashSet<String> pushingSectionsHighways = new HashSet<>();
  77.     protected final HashSet<String> oppositeLanes = new HashSet<>();
  78.     protected final Set<String> preferHighwayTags = new HashSet<>();
  79.     protected final Set<String> avoidHighwayTags = new HashSet<>();
  80.     protected final Set<String> unpavedSurfaceTags = new HashSet<>();
  81.     private final Map<String, SpeedValue> trackTypeSpeeds = new HashMap<>();
  82.     private final Map<String, SpeedValue> surfaceSpeeds = new HashMap<>();
  83.     private final Set<String> roadValues = new HashSet<>();
  84.     private final Map<String, SpeedValue> highwaySpeeds = new HashMap<>();
  85.     // convert network tag of bicycle routes into a way route code
  86.     DecimalEncodedValue priorityWayEncoder;
  87.     BooleanEncodedValue unpavedEncoder;
  88.     private IntEncodedValue wayTypeEncoder;
  89.     // Car speed limit which switches the preference from UNCHANGED to AVOID_IF_POSSIBLE
  90.     private int avoidSpeedLimit;
  91.     EnumEncodedValue<RouteNetwork> bikeRouteEnc;
  92.     Map<RouteNetwork, Integer> routeMap = new HashMap<>();
  93.     protected boolean conditionalAccess = false;
  94.     // This is the specific bicycle class
  95.     private String classBicycleKey;

  97.     private BooleanEncodedValue conditionalAccessEncoder;

  99.     private static final boolean DEBUG_OUTPUT = false;
  100.     FileWriter logWriter;

  102.     // MARQ24 MOD START
  103.     // MARQ24 ADDON in the case of the RoadBike Encoder we want to skip some
  104.     // conditions...
  105.     private final boolean isRoadBikeEncoder = this instanceof RoadBikeFlagEncoder; // TODO: design: parent class should not need to know of child
  106.     protected static final Logger LOGGER = Logger.getLogger(CommonBikeFlagEncoder.class.getName());
  107.     // MARQ24 MOD END

  109.     // MARQ24 MOD START
  110.     protected CommonBikeFlagEncoder(int speedBits, double speedFactor, int maxTurnCosts) {
  111.         this(speedBits, speedFactor, maxTurnCosts, false);
  112.     }
  113.     // MARQ24 MOD END

  115.     protected void setProperties(PMap properties) {
  116.         blockFords(properties.getBool("block_fords", true));
  117.         conditionalAccess = properties.getBool(ConditionalEdges.ACCESS, false);
  118.     }

  120.     // MARQ24 MOD START
  121.     protected CommonBikeFlagEncoder(int speedBits, double speedFactor, int maxTurnCosts, boolean considerElevation) {
  122.         // MARQ24 MOD END
  123.         super(speedBits, speedFactor, maxTurnCosts);
  124.         // strict set, usually vehicle and agricultural/forestry are ignored by cyclists
  125.         restrictions.addAll(Arrays.asList(KEY_BICYCLE, "vehicle", "access"));
  126.         restrictedValues.add("private");
  127.         restrictedValues.add("no");
  128.         restrictedValues.add("restricted");
  129.         restrictedValues.add("military");
  130.         restrictedValues.add("emergency");

  132.         intendedValues.add("yes");
  133.         intendedValues.add(KEY_DESIGNATED);
  134.         intendedValues.add(KEY_OFFICIAL);
  135.         intendedValues.add("permissive");

  137.         oppositeLanes.add("opposite");
  138.         oppositeLanes.add("opposite_lane");
  139.         oppositeLanes.add("opposite_track");

  141.         passByDefaultBarriers.add("gate");
  142.         passByDefaultBarriers.add("swing_gate");

  144.         blockByDefaultBarriers.add("stile");
  145.         blockByDefaultBarriers.add("turnstile");

  147.         unpavedSurfaceTags.add(KEY_UNPAVED);
  148.         unpavedSurfaceTags.add("gravel");
  149.         unpavedSurfaceTags.add("ground");
  150.         unpavedSurfaceTags.add("dirt");
  151.         unpavedSurfaceTags.add("grass");
  152.         unpavedSurfaceTags.add("compacted");
  153.         unpavedSurfaceTags.add("earth");
  154.         unpavedSurfaceTags.add("fine_gravel");
  155.         unpavedSurfaceTags.add("grass_paver");
  156.         unpavedSurfaceTags.add("ice");
  157.         unpavedSurfaceTags.add("mud");
  158.         unpavedSurfaceTags.add("salt");
  159.         unpavedSurfaceTags.add("sand");
  160.         unpavedSurfaceTags.add("wood");

  162.         roadValues.add(KEY_LIVING_STREET);
  163.         roadValues.add("road");
  164.         roadValues.add(KEY_SERVICE);
  165.         roadValues.add("unclassified");
  166.         roadValues.add("residential");
  167.         roadValues.add("trunk");
  168.         roadValues.add("trunk_link");
  169.         roadValues.add("primary");
  170.         roadValues.add("primary_link");
  171.         roadValues.add("secondary");
  172.         roadValues.add("secondary_link");
  173.         roadValues.add("tertiary");
  174.         roadValues.add("tertiary_link");

  176.         maxPossibleSpeed = 30;

  178.         // MARQ24 MOD START
  179.         // we have to check, WHAT this really does - since when 'enabled' we get 'cracy' detours like this one
  180.         // http://localhost:3035/directions?n1=51.563406&n2=8.713585&n3=16&a=51.566454,8.705764,51.559224,8.707244&b=1a&c=0&g1=-1&g2=0&h2=3&k1=en-US&k2=km
  181.         if (considerElevation) {
  182.             maxPossibleSpeed = (int) getDownhillMaxSpeed();
  183.         }
  184.         // MARQ24 MOD END

  186.         setTrackTypeSpeed("grade1", 18); // paved
  187.         setTrackTypeSpeed("grade2", 12); // now unpaved ...
  188.         setTrackTypeSpeed("grade3", 8);
  189.         setTrackTypeSpeed("grade4", 6);
  190.         setTrackTypeSpeed("grade5", 4); // like sand/grass

  192.         setSurfaceSpeed("paved", 18);
  193.         setSurfaceSpeed("asphalt", 18);
  194.         setSurfaceSpeed("cobblestone", 8);
  195.         setSurfaceSpeed("cobblestone:flattened", 10);
  196.         setSurfaceSpeed("sett", 10);
  197.         setSurfaceSpeed("concrete", 18);
  198.         setSurfaceSpeed("concrete:lanes", 16);
  199.         setSurfaceSpeed("concrete:plates", 16);
  200.         setSurfaceSpeed("paving_stones", 12);
  201.         setSurfaceSpeed("paving_stones:30", 12);
  202.         setSurfaceSpeed(KEY_UNPAVED, 14);
  203.         setSurfaceSpeed("compacted", 16);
  204.         setSurfaceSpeed("dirt", 10);
  205.         setSurfaceSpeed("earth", 12);
  206.         setSurfaceSpeed("fine_gravel", 18);
  207.         setSurfaceSpeed("grass", 8);
  208.         setSurfaceSpeed("grass_paver", 8);
  209.         setSurfaceSpeed("gravel", 12);
  210.         setSurfaceSpeed("ground", 12);
  211.         setSurfaceSpeed("ice", PUSHING_SECTION_SPEED / 2);
  212.         setSurfaceSpeed("metal", 10);
  213.         setSurfaceSpeed("mud", 10);
  214.         setSurfaceSpeed("pebblestone", 16);
  215.         setSurfaceSpeed("salt", 6);
  216.         setSurfaceSpeed("sand", 6);
  217.         setSurfaceSpeed("wood", 6);

  219.         setHighwaySpeed(KEY_LIVING_STREET, 6);
  220.         setHighwaySpeed(KEY_STEPS, PUSHING_SECTION_SPEED / 2);

  222.         final int CYCLEWAY_SPEED = 18;  // Make sure cycleway and path use same speed value, see #634
  223.         setHighwaySpeed(KEY_CYCLEWAY, CYCLEWAY_SPEED);
  224.         setHighwaySpeed("path", 10);
  225.         setHighwaySpeed("footway", 6);
  226.         setHighwaySpeed("pedestrian", 6);
  227.         setHighwaySpeed(KEY_TRACK, 12);
  228.         setHighwaySpeed(KEY_SERVICE, 14);
  229.         setHighwaySpeed("residential", 18);
  230.         // no other highway applies:
  231.         setHighwaySpeed("unclassified", 16);
  232.         // unknown road:
  233.         setHighwaySpeed("road", 12);

  235.         setHighwaySpeed("trunk", 18);
  236.         setHighwaySpeed("trunk_link", 18);
  237.         setHighwaySpeed("primary", 18);
  238.         setHighwaySpeed("primary_link", 18);
  239.         setHighwaySpeed("secondary", 18);
  240.         setHighwaySpeed("secondary_link", 18);
  241.         setHighwaySpeed("tertiary", 18);
  242.         setHighwaySpeed("tertiary_link", 18);

  244.         // special case see tests and #191
  245.         setHighwaySpeed(KEY_MOTORWAY, 18);
  246.         setHighwaySpeed(KEY_MOTORWAY_LINK, 18);
  247.         avoidHighwayTags.add(KEY_MOTORWAY);
  248.         avoidHighwayTags.add(KEY_MOTORWAY_LINK);

  250.         // bridleways are allowed to ride over in some cases
  251.         setHighwaySpeed(KEY_BRIDLEWAY, 6);
  252.         avoidHighwayTags.add(KEY_BRIDLEWAY);

  254.         routeMap.put(INTERNATIONAL, BEST.getValue());
  255.         routeMap.put(NATIONAL, BEST.getValue());
  256.         routeMap.put(REGIONAL, VERY_NICE.getValue());
  257.         routeMap.put(LOCAL, PREFER.getValue());
  258.         routeMap.put(DEPRECATED, REACH_DEST.getValue());
  259.         routeMap.put(MTB, UNCHANGED.getValue());
  260.         routeMap.put(FERRY, AVOID_IF_POSSIBLE.getValue());

  262.         setAvoidSpeedLimit(71);

  264.         if (DEBUG_OUTPUT) {
  265.             try {
  266.                 File file = new File("CommonBikeFlagEncoder.log");
  267.                 logWriter = new FileWriter(file);
  268.             } catch (Exception ex) {
  269.                 LOGGER.warn("Failed to write log file.");
  270.             }
  271.         }
  272.     }

  274.     @Override
  275.     public TransportationMode getTransportationMode() {
  276.         return TransportationMode.BIKE;
  277.     }

  279.     @Override
  280.     public void createEncodedValues(List<EncodedValue> registerNewEncodedValue, String prefix, int index) {
  281.         super.createEncodedValues(registerNewEncodedValue, prefix, index);
  282.         registerNewEncodedValue.add(avgSpeedEnc = new UnsignedDecimalEncodedValue(getKey(prefix, "average_speed"), speedBits, speedFactor, false));
  283.         unpavedEncoder = new SimpleBooleanEncodedValue(getKey(prefix, "paved"), false);
  284.         registerNewEncodedValue.add(unpavedEncoder);
  285.         wayTypeEncoder = new UnsignedIntEncodedValue(getKey(prefix, "waytype"), 2, false);
  286.         registerNewEncodedValue.add(wayTypeEncoder);
  287.         priorityWayEncoder = new UnsignedDecimalEncodedValue(getKey(prefix, "priority"), 4, PriorityCode.getFactor(1), false);
  288.         registerNewEncodedValue.add(priorityWayEncoder);
  289.         if (conditionalAccess) {
  290.             conditionalAccessEncoder = new SimpleBooleanEncodedValue(EncodingManager.getKey(prefix, ConditionalEdges.ACCESS), true);
  291.             registerNewEncodedValue.add(conditionalAccessEncoder);
  292.         }
  293.         bikeRouteEnc = getEnumEncodedValue(RouteNetwork.key("bike"), RouteNetwork.class);
  294.     }

  296.     @Override
  297.     public EncodingManager.Access getAccess(ReaderWay way) {
  298.         String highwayValue = way.getTag(KEY_HIGHWAY);
  299.         if (highwayValue == null) {
  300.             EncodingManager.Access acceptPotentially = EncodingManager.Access.CAN_SKIP;

  302.             if (way.hasTag(KEY_ROUTE, ferries)) {
  303.                 // if bike is NOT explicitly tagged allow bike but only if foot is not specified
  304.                 String bikeTag = way.getTag(KEY_BICYCLE);
  305.                 if (bikeTag == null && !way.hasTag("foot") || "yes".equals(bikeTag)) {
  306.                     acceptPotentially = EncodingManager.Access.FERRY;
  307.                 }
  308.             }

  310.             // special case not for all acceptedRailways, only platform
  311.             if (way.hasTag(KEY_RAILWAY, "platform")) {
  312.                 acceptPotentially = EncodingManager.Access.WAY;
  313.             }

  315.             if (way.hasTag("man_made", "pier")) {
  316.                 acceptPotentially = EncodingManager.Access.WAY;
  317.             }

  319.             if (!acceptPotentially.canSkip()) {
  320.                 if (way.hasTag(restrictions, restrictedValues))
  321.                     acceptPotentially = isRestrictedWayConditionallyPermitted(way, acceptPotentially);
  322.                 return acceptPotentially;
  323.             }

  325.             return EncodingManager.Access.CAN_SKIP;
  326.         }

  328.         if (!highwaySpeeds.containsKey(highwayValue)) {
  329.             return EncodingManager.Access.CAN_SKIP;
  330.         }

  332.         String sacScale = way.getTag("sac_scale");
  333.         if (sacScale != null) {
  334.             if ((way.hasTag(KEY_HIGHWAY, KEY_CYCLEWAY)) && (way.hasTag("sac_scale", "hiking"))) {
  335.                 return EncodingManager.Access.WAY;
  336.             }
  337.             if (!isSacScaleAllowed(sacScale)) {
  338.                 return EncodingManager.Access.CAN_SKIP;
  339.             }
  340.         }

  342.         // use the way if it is tagged for bikes
  343.         if (way.hasTag(KEY_BICYCLE, intendedValues)
  344.                 || way.hasTag(KEY_BICYCLE, "dismount")
  345.                 || way.hasTag(KEY_HIGHWAY, KEY_CYCLEWAY)
  346.                 // MARQ24 MOD START
  347.                 // Runge: http://www.openstreetmap.org/way/1700503
  348.                 || way.hasTag(KEY_BICYCLE_ROAD, "yes")
  349.             // MARQ24 MOD END
  350.         ) {
  351.             return isPermittedWayConditionallyRestricted(way);
  352.         }

  354.         // accept only if explicitly tagged for bike usage
  355.         if (KEY_MOTORWAY.equals(highwayValue) || KEY_MOTORWAY_LINK.equals(highwayValue) || KEY_BRIDLEWAY.equals(highwayValue)) {
  356.             return EncodingManager.Access.CAN_SKIP;
  357.         }

  359.         if (way.hasTag("motorroad", "yes")) {
  360.             return EncodingManager.Access.CAN_SKIP;
  361.         }

  363.         // do not use fords with normal bikes, flagged fords are in included above
  364.         if (isBlockFords() && (way.hasTag(KEY_HIGHWAY, "ford") || way.hasTag("ford"))) {
  365.             return EncodingManager.Access.CAN_SKIP;
  366.         }

  368.         // check access restrictions
  369.         if (way.hasTag(restrictions, restrictedValues))
  370.             return isRestrictedWayConditionallyPermitted(way);

  372.         return isPermittedWayConditionallyRestricted(way);
  373.     }

  375.     boolean isSacScaleAllowed(String sacScale) {
  376.         // other scales are nearly impossible by an ordinary bike, see http://wiki.openstreetmap.org/wiki/Key:sac_scale
  377.         return "hiking".equals(sacScale);
  378.     }

  380.     /**
  381.      * Apply maxspeed: In contrast to the implementation of the AbstractFlagEncoder, we assume that
  382.      * we can reach the maxspeed for bicycles in case that the road type speed is higher and not
  383.      * just only 90%.
  384.      * <p>
  385.      *
  386.      * @param way   needed to retrieve tags
  387.      * @param speed speed guessed e.g. from the road type or other tags
  388.      * @return The assumed average speed.
  389.      */
  390.     @Override
  391.     protected double applyMaxSpeed(ReaderWay way, double speed) {
  392.         double maxSpeed = getMaxSpeed(way);
  393.         if (isValidSpeed(maxSpeed) && maxSpeed < speed) {
  394.             return maxSpeed;
  395.         }
  396.         return speed;
  397.     }

  399.     @Override
  400.     public IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, EncodingManager.Access access) {
  401.         if (access.canSkip()) {
  402.             return edgeFlags;
  403.         }

  405.         Integer priorityFromRelationInt = routeMap.get(bikeRouteEnc.getEnum(false, edgeFlags));
  406.         int priorityFromRelation = priorityFromRelationInt == null ? 0 : priorityFromRelationInt;

  408.         double wayTypeSpeed = getSpeed(way);
  409.         if (!access.isFerry()) {
  410.             wayTypeSpeed = applyMaxSpeed(way, wayTypeSpeed);
  411.             handleSpeed(edgeFlags, way, wayTypeSpeed);
  412.             handleBikeRelated(edgeFlags, way, priorityFromRelation > UNCHANGED.getValue());
  413.             if (access.isConditional() && conditionalAccessEncoder != null)
  414.                 conditionalAccessEncoder.setBool(false, edgeFlags, true);
  415.             boolean isRoundabout = way.hasTag(KEY_JUNCTION, "roundabout") || way.hasTag(KEY_JUNCTION, "circular");
  416.             if (isRoundabout) {
  417.                 roundaboutEnc.setBool(false, edgeFlags, true);
  418.             }
  419.         } else {
  420.             double ferrySpeed = ferrySpeedCalc.getSpeed(way);
  421.             handleSpeed(edgeFlags, way, ferrySpeed);
  422.         }

  424.         int priority = handlePriority(way, wayTypeSpeed, priorityFromRelation);
  425.         if (DEBUG_OUTPUT) {
  426.             try {
  427.                 logWriter.write("WayID %d RelationPrio %d FinalPrio %d %n".formatted(way.getId(), priorityFromRelation, priority));
  428.                 logWriter.flush();
  429.             } catch (Exception ex) {
  430.                 LOGGER.warn("Failed to write log file.");
  431.             }
  432.         }
  433.         priorityWayEncoder.setDecimal(false, edgeFlags, PriorityCode.getFactor(priority));
  434.         return edgeFlags;
  435.     }

  437.     int getSpeed(ReaderWay way) {
  438.         int speed = Integer.MIN_VALUE;
  439.         String highwayTag = way.getTag(KEY_HIGHWAY);
  440.         SpeedValue highwaySpeed = highwaySpeeds.get(highwayTag);

  442.         boolean isPushingWay = isPushingSection(way);
  443.         boolean isCyclewayLikeWay = false;
  444.         boolean isSteps = way.hasTag(KEY_HIGHWAY, KEY_STEPS);

  446.         // Under certain conditions we need to increase the speed of pushing sections to the speed of a "highway=cycleway"
  447.         // MARQ24 - so if this is a pushing section (like path, track or footway) BUT have additional bicycle attributes
  448.         // then we treat this way as it was tagged as "cycleway"...
  449.         if (isPushingWay &&
  450.                 (
  451.                         (way.hasTag("foot", "yes") && way.hasTag(KEY_SEGREGATED, "yes"))
  452.                                 || way.hasTag(KEY_BICYCLE, "yes")
  453.                                 || way.hasTag(KEY_BICYCLE, KEY_DESIGNATED)
  454.                                 || way.hasTag(KEY_BICYCLE, KEY_OFFICIAL)
  455.                 )
  456.                 && !isSteps
  457.         ) {
  458.             isCyclewayLikeWay = true;
  459.             highwaySpeed = getHighwaySpeed(KEY_CYCLEWAY);
  460.         }

  462.         String s = way.getTag("surface");
  463.         if (!Helper.isEmpty(s)) {
  464.             SpeedValue surfaceSpeed = surfaceSpeeds.get(s);
  465.             if (surfaceSpeed != null && (!isPushingWay || isCyclewayLikeWay)) {
  466.                 // ok if no specific highway speed is set we will use the surface speed...
  467.                 if (highwaySpeed == null) {
  468.                     speed = surfaceSpeed.speed;
  469.                 } else {
  470.                     speed = calcHighwaySpeedBasedOnSurface(highwaySpeed, surfaceSpeed);
  471.                 }
  472.             }
  473.         } else {
  474.             // no SURFACE TAG present...
  475.             String tt = way.getTag("tracktype");
  476.             if (!Helper.isEmpty(tt)) {
  477.                 SpeedValue tracktypeSpeed = trackTypeSpeeds.get(tt);
  478.                 if (tracktypeSpeed != null && (!isPushingWay || isCyclewayLikeWay)) {
  479.                     if (highwaySpeed == null) {
  480.                         speed = tracktypeSpeed.speed;
  481.                     } else {
  482.                         speed = calcHighwaySpeedBasedOnSurface(highwaySpeed, tracktypeSpeed);
  483.                     }
  484.                 }
  485.             }
  486.         }

  488.         // if the speed have not been set yet...
  489.         if (speed == Integer.MIN_VALUE) {
  490.             if (highwaySpeed != null) {
  491.                 if (!way.hasTag(KEY_SERVICE)) {
  492.                     speed = highwaySpeed.speed;
  493.                 } else {
  494.                     // MARQ24: with other words any 'service' tagged ways will be
  495.                     // considered as min "living street" speed (or slower)...
  496.                     speed = Math.min(highwaySpeeds.get(KEY_LIVING_STREET).speed, highwaySpeed.speed);
  497.                 }
  498.             } else {
  499.                 speed = PUSHING_SECTION_SPEED;
  500.             }
  501.         }

  503.         // MARQ24 MOD START
  504.         if (speed <= PUSHING_SECTION_SPEED) {
  505.             if (!isSteps) {
  506.                 // MARQ24 if we are still on pushing section speed, then we at least double the speed in the case
  507.                 // that the way is 'segregated' (but of course we sill ignore steps)...
  508.                 // MARQ24 MOD END
  509.                 // Increase speed in case of segregated
  510.                 if (way.hasTag(KEY_SEGREGATED, "yes")) {
  511.                     speed = PUSHING_SECTION_SPEED * 2;
  512.                 }
  513.                 // MARQ24 MOD START
  514.             } else {
  515.                 // MARQ24: make sure that steps will always get a very slow speed...
  516.                 speed = PUSHING_SECTION_SPEED / 2;
  517.             }
  518.         }
  519.         // MARQ24 MOD END

  521.         return speed;
  522.     }

  524.     /*
  525.     The order of speed arguments MAKE a difference !!! When highway & surface SpeedValue have the UpdateType=BOTH
  526.     then the return value will be always the speed of the last speed argument (surface.speed)!!!
  527.     */
  528.     public int calcHighwaySpeedBasedOnSurface(SpeedValue highway, SpeedValue surface) {
  529.         if (highway.speed.equals(surface.speed)) {
  530.             return highway.speed;
  531.         } else if (highway.speed > surface.speed) {
  532.             // highway = 18 (residential)
  533.             // surface = 4 (gravel)
  534.             switch (highway.type) {
  535.                 case UPGRADE_ONLY:
  536.                     return highway.speed;

  538.                 case DOWNGRADE_ONLY:
  539.                 case BOTH:
  540.                 default:
  541.                     return switch (surface.type) {
  542.                         case UPGRADE_ONLY -> highway.speed;
  543.                         case DOWNGRADE_ONLY, BOTH -> surface.speed;
  544.                         default -> surface.speed;
  545.                     };
  546.             }
  547.         } else {
  548.             // highway = 8 (cycleway)
  549.             // surface = 18 (asphalt)
  550.             switch (highway.type) {
  551.                 case DOWNGRADE_ONLY:
  552.                     return highway.speed;
  553.                 case UPGRADE_ONLY:
  554.                 case BOTH:
  555.                 default:
  556.                     return switch (surface.type) {
  557.                         case DOWNGRADE_ONLY -> highway.speed;
  558.                         case UPGRADE_ONLY, BOTH -> surface.speed;
  559.                         default -> surface.speed;
  560.                     };
  561.             }
  562.         }
  563.     }

  565.     String getWayName(int pavementType, int wayType, Translation tr) {
  566.         String pavementName = "";
  567.         if (pavementType == 1)
  568.             pavementName = tr.tr(KEY_UNPAVED);

  570.         String wayTypeName = switch (wayType) {
  571.             case 0 -> "";
  572.             case 1 -> tr.tr("off_bike");
  573.             case 2 -> tr.tr(KEY_CYCLEWAY);
  574.             case 3 -> tr.tr("small_way");
  575.             default -> "";
  576.         };

  578.         if (pavementName.isEmpty()) {
  579.             if (wayType == 0 || wayType == 3)
  580.                 return "";
  581.             return wayTypeName;
  582.         } else if (wayTypeName.isEmpty())
  583.             return pavementName;
  584.         else
  585.             return wayTypeName + ", " + pavementName;
  586.     }

  588.     /**
  589.      * In this method we prefer cycleways or roads with designated bike access and avoid big roads
  590.      * or roads with trams or pedestrian.
  591.      * <p>
  592.      *
  593.      * @return new priority based on priorityFromRelation and on the tags in ReaderWay.
  594.      */
  595.     protected int handlePriority(ReaderWay way, double wayTypeSpeed, int priorityFromRelation) {
  596.         TreeMap<Double, Integer> weightToPrioMap = new TreeMap<>();
  597.         if (priorityFromRelation == 0)
  598.             weightToPrioMap.put(0d, UNCHANGED.getValue());
  599.         else
  600.             weightToPrioMap.put(110d, priorityFromRelation);

  602.         collect(way, wayTypeSpeed, weightToPrioMap);

  604.         // pick priority with biggest order value
  605.         return weightToPrioMap.lastEntry().getValue();
  606.     }

  608.     // Conversion of class value to priority. See http://wiki.openstreetmap.org/wiki/Class:bicycle
  609.     private PriorityCode convertClassValueToPriority(String tagvalue) {
  610.         int classvalue;
  611.         try {
  612.             classvalue = Integer.parseInt(tagvalue);
  613.         } catch (NumberFormatException e) {
  614.             return UNCHANGED;
  615.         }

  617.         return switch (classvalue) {
  618.             case 3 -> BEST;
  619.             case 2 -> VERY_NICE;
  620.             case 1 -> PREFER;
  621.             case 0 -> UNCHANGED;
  622.             case -1 -> AVOID_IF_POSSIBLE;
  623.             case -2 -> REACH_DEST;
  624.             case -3 -> AVOID_AT_ALL_COSTS;
  625.             default -> UNCHANGED;
  626.         };
  627.     }

  629.     /**
  630.      * @param weightToPrioMap associate a weight with every priority. This sorted map allows
  631.      *                        subclasses to 'insert' more important priorities as well as overwrite determined priorities.
  632.      */
  633.     void collect(ReaderWay way, double wayTypeSpeed, TreeMap<Double, Integer> weightToPrioMap) {
  634.         String service = way.getTag(KEY_SERVICE);
  635.         String highway = way.getTag(KEY_HIGHWAY);
  636.         // MARQ24 MOD START
  637.         if (!isRoadBikeEncoder) {
  638.             // MARQ24 MOD END
  639.             // MARQ24 MOD START
  640.             if (way.hasTag(KEY_BICYCLE, KEY_DESIGNATED) || way.hasTag(KEY_BICYCLE, KEY_OFFICIAL) || way.hasTag(KEY_BICYCLE_ROAD, "yes")) {
  641.                 // MARQ24 MOD END
  642.                 if ("path".equals(highway)) {
  643.                     weightToPrioMap.put(100d, VERY_NICE.getValue());
  644.                 } else {
  645.                     weightToPrioMap.put(100d, PREFER.getValue());
  646.                 }
  647.             }
  648.             if (KEY_CYCLEWAY.equals(highway)) {
  649.                 if (way.hasTag("foot", intendedValues) && !way.hasTag(KEY_SEGREGATED, "yes")) {
  650.                     weightToPrioMap.put(100d, PREFER.getValue());
  651.                 } else {
  652.                     weightToPrioMap.put(100d, VERY_NICE.getValue());
  653.                 }
  654.             }
  655.             // MARQ24 MOD START
  656.         }
  657.         // MARQ24 MOD END

  659.         double maxSpeed = getMaxSpeed(way);
  660.         if (preferHighwayTags.contains(highway) || this.isValidSpeed(maxSpeed) && maxSpeed <= 30) {
  661.             if (!this.isValidSpeed(maxSpeed) || maxSpeed < avoidSpeedLimit) {
  662.                 weightToPrioMap.put(40d, PREFER.getValue());
  663.                 if (way.hasTag("tunnel", intendedValues)) {
  664.                     weightToPrioMap.put(40d, UNCHANGED.getValue());
  665.                 }
  666.             }
  667.         } else if (avoidHighwayTags.contains(highway) || maxSpeed >= avoidSpeedLimit && !KEY_TRACK.equals(highway)) {
  668.             weightToPrioMap.put(50d, REACH_DEST.getValue());
  669.             if (way.hasTag("tunnel", intendedValues)) {
  670.                 weightToPrioMap.put(50d, AVOID_AT_ALL_COSTS.getValue());
  671.             }
  672.         }

  674.         if (pushingSectionsHighways.contains(highway)
  675.                 || "parking_aisle".equals(service)) {
  676.             int pushingSectionPrio = AVOID_IF_POSSIBLE.getValue();
  677.             // MARQ24 MOD START
  678.             if (!isRoadBikeEncoder) {
  679.                 // MARQ24 MOD END
  680.                 if (way.hasTag(KEY_BICYCLE, "use_sidepath") || way.hasTag(KEY_BICYCLE, "yes") || way.hasTag(KEY_BICYCLE, "permissive")) {
  681.                     pushingSectionPrio = PREFER.getValue();
  682.                 }
  683.                 if (way.hasTag(KEY_BICYCLE, KEY_DESIGNATED) || way.hasTag(KEY_BICYCLE, KEY_OFFICIAL)) {
  684.                     pushingSectionPrio = VERY_NICE.getValue();
  685.                 }
  686.                 // MARQ24 MOD START
  687.             }
  688.             // MARQ24 MOD END

  690.             if (way.hasTag("foot", "yes")) {
  691.                 pushingSectionPrio = Math.max(pushingSectionPrio - 1, WORST.getValue());
  692.                 if (!isRoadBikeEncoder && way.hasTag(KEY_SEGREGATED, "yes")) {
  693.                     pushingSectionPrio = Math.min(pushingSectionPrio + 1, BEST.getValue());
  694.                 }
  695.             }
  696.             weightToPrioMap.put(100d, pushingSectionPrio);
  697.         }

  699.         if (way.hasTag(KEY_RAILWAY, "tram")) {
  700.             weightToPrioMap.put(50d, AVOID_AT_ALL_COSTS.getValue());
  701.         }

  703.         String classBicycleValue = way.getTag(classBicycleKey);
  704.         if (classBicycleValue != null) {
  705.             // We assume that humans are better in classifying preferences compared to our algorithm above -> weight = 100
  706.             weightToPrioMap.put(100d, convertClassValueToPriority(classBicycleValue).getValue());
  707.         } else {
  708.             String classBicycle = way.getTag("class:bicycle");
  709.             if (classBicycle != null) {
  710.                 weightToPrioMap.put(100d, convertClassValueToPriority(classBicycle).getValue());
  711.             }
  712.         }

  714.         // Increase the priority for scenic routes or in case that maxspeed limits our average speed as compensation. See #630
  715.         if ((way.hasTag("scenic", "yes") || (maxSpeed > 0 && maxSpeed < wayTypeSpeed)) && weightToPrioMap.lastEntry().getValue() < BEST.getValue()) {
  716.             // Increase the prio by one step
  717.             weightToPrioMap.put(110d, weightToPrioMap.lastEntry().getValue() + 1);
  718.         }
  719.     }

  721.     /**
  722.      * Handle surface and wayType encoding
  723.      */
  724.     void handleBikeRelated(IntsRef edgeFlags, ReaderWay way, boolean partOfCycleRelation) {
  725.         String surfaceTag = way.getTag("surface");
  726.         String highway = way.getTag(KEY_HIGHWAY);
  727.         String trackType = way.getTag("tracktype");

  729.         // Populate unpavedBit
  730.         if (KEY_TRACK.equals(highway) && (!"grade1".equals(trackType))
  731.                 || "path".equals(highway) && surfaceTag == null
  732.                 || unpavedSurfaceTags.contains(surfaceTag)) {
  733.             unpavedEncoder.setBool(false, edgeFlags, true);
  734.         }

  736.         WayType wayType;
  737.         if (roadValues.contains(highway)) {
  738.             wayType = WayType.ROAD;
  739.         } else {
  740.             wayType = WayType.OTHER_SMALL_WAY;
  741.         }

  743.         boolean isPushingSection = isPushingSection(way);
  744.         if (isPushingSection || KEY_STEPS.equals(highway)) {
  745.             wayType = WayType.PUSHING_SECTION;
  746.         } else {
  747.             // boost "none identified" partOfCycleRelation
  748.             if (!isRoadBikeEncoder && partOfCycleRelation) {
  749.                 wayType = WayType.CYCLEWAY;
  750.             }

  752.             if (way.hasTag(KEY_BICYCLE, intendedValues) || KEY_CYCLEWAY.equals(highway)) {
  753.                 wayType = WayType.CYCLEWAY;
  754.             }
  755.         }
  756.         wayTypeEncoder.setInt(false, edgeFlags, wayType.getValue());
  757.     }

  759.     boolean isPushingSection(ReaderWay way) {
  760.         // MARQ24 MOD START
  761.         return way.hasTag(KEY_HIGHWAY, pushingSectionsHighways) || way.hasTag(KEY_RAILWAY, "platform") || way.hasTag(KEY_BICYCLE, "dismount") || way.hasTag(KEY_ROUTE, ferries); // Runge
  762.         // MARQ24 MOD END
  763.     }

  765.     protected void handleSpeed(IntsRef edgeFlags, ReaderWay way, double speed) {
  766.         String bicycleForwardTag = "bicycle:forward";
  767.         avgSpeedEnc.setDecimal(false, edgeFlags, speed);
  768.         // handle oneways
  769.         boolean isOneway = way.hasTag("oneway", oneways)
  770.                 || way.hasTag(KEY_ONEWAY_BICYCLE, oneways)
  771.                 || way.hasTag("vehicle:backward")
  772.                 || way.hasTag("vehicle:forward")
  773.                 || way.hasTag(bicycleForwardTag, "yes")
  774.                 || way.hasTag(bicycleForwardTag, "no");
  775.         //MARQ24 MOD START
  776.         if (!way.hasTag(KEY_BICYCLE_ROAD, "yes") && (isOneway || way.hasTag(KEY_JUNCTION, "roundabout"))
  777.                 //MARQ24 MOD END
  778.                 && !way.hasTag(KEY_ONEWAY_BICYCLE, "no")
  779.                 && !way.hasTag("bicycle:backward")
  780.                 && !way.hasTag(KEY_CYCLEWAY, oppositeLanes)
  781.                 && !way.hasTag("cycleway:left", oppositeLanes)
  782.                 && !way.hasTag("cycleway:right", oppositeLanes)) {
  783.             boolean isBackward = way.hasTag("oneway", "-1")
  784.                     || way.hasTag(KEY_ONEWAY_BICYCLE, "-1")
  785.                     || way.hasTag("vehicle:forward", "no")
  786.                     || way.hasTag(bicycleForwardTag, "no");
  787.             accessEnc.setBool(isBackward, edgeFlags, true);
  788.         } else {
  789.             accessEnc.setBool(false, edgeFlags, true);
  790.             accessEnc.setBool(true, edgeFlags, true);
  791.         }
  792.     }

  794.     protected void setHighwaySpeed(String highway, int speed) {
  795.         highwaySpeeds.put(highway, new SpeedValue(speed));
  796.     }

  798.     protected void setHighwaySpeed(String highway, SpeedValue speed) {
  799.         highwaySpeeds.put(highway, speed);
  800.     }

  802.     SpeedValue getHighwaySpeed(String key) {
  803.         return highwaySpeeds.get(key);
  804.     }

  806.     protected void setTrackTypeSpeed(String tracktype, int speed) {
  807.         trackTypeSpeeds.put(tracktype, new SpeedValue(speed));
  808.     }

  810.     protected void setTrackTypeSpeed(String tracktype, SpeedValue speed) {
  811.         trackTypeSpeeds.put(tracktype, speed);
  812.     }

  814.     protected void setSurfaceSpeed(String surface, int speed) {
  815.         surfaceSpeeds.put(surface, new SpeedValue(speed));
  816.     }

  818.     protected void setSurfaceSpeed(String surface, SpeedValue speed) {
  819.         surfaceSpeeds.put(surface, speed);
  820.     }

  822.     SpeedValue getSurfaceSpeed(String key) {
  823.         return surfaceSpeeds.get(key);
  824.     }

  826.     void addPushingSection(String highway) {
  827.         pushingSectionsHighways.add(highway);
  828.     }

  830.     @Override
  831.     public boolean supports(Class<?> feature) {
  832.         if (super.supports(feature)) {
  833.             return true;
  834.         }
  835.         return PriorityWeighting.class.isAssignableFrom(feature);
  836.     }

  838.     public void setAvoidSpeedLimit(int limit) {
  839.         avoidSpeedLimit = limit;
  840.     }

  842.     protected void setSpecificClassBicycle(String subkey) {
  843.         classBicycleKey = "class:bicycle:" + subkey;
  844.     }

  846.     private enum WayType {
  847.         ROAD(0),
  848.         PUSHING_SECTION(1),
  849.         CYCLEWAY(2),
  850.         OTHER_SMALL_WAY(3);

  852.         private final int value;

  854.         WayType(int value) {
  855.             this.value = value;
  856.         }

  858.         public int getValue() {
  859.             return value;
  860.         }
  861.     }

  863.     protected enum UpdateType {
  864.         UPGRADE_ONLY,
  865.         DOWNGRADE_ONLY,
  866.         BOTH
  867.     }

  869.     protected static class SpeedValue {
  870.         private final Integer speed;
  871.         private UpdateType type = UpdateType.BOTH;

  873.         private SpeedValue(Integer speed) {
  874.             this.speed = speed;
  875.         }

  877.         protected SpeedValue(Integer speed, UpdateType type) {
  878.             this.speed = speed;
  879.             this.type = type;
  880.         }

  882.         public String toString() {
  883.             return switch (type) {
  884.                 case BOTH -> speed + " [BOTH]";
  885.                 case UPGRADE_ONLY -> speed + " [UP]";
  886.                 case DOWNGRADE_ONLY -> speed + " [DOWN]";
  887.             };
  888.         }
  889.     }

  891.     // MARQ24 MOD START
  892.     protected abstract double getDownhillMaxSpeed();
  893.     // MARQ24 MOD END

  895.     @Override
  896.     public int hashCode() {
  897.         return ("CommonBikeFlagEnc" + this).hashCode();
  898.     }

  900.     @Override
  901.     public boolean equals(Object obj) {
  902.         if (obj == null)
  903.             return false;
  904.         if (getClass() != obj.getClass())
  905.             return false;
  906.         CommonBikeFlagEncoder cast = (CommonBikeFlagEncoder) obj;
  907.         return toString().equals(cast.toString());
  908.     }

  910.     public abstract double getMeanSpeed();
  911. }
Created with JaCoCo 0.8.10.202304240956