OSMAttachedSidewalkProcessor.java

  1. package org.heigit.ors.routing.graphhopper.extensions.reader.osmfeatureprocessors;

  3. import com.graphhopper.reader.ReaderWay;

  5. import java.util.HashSet;
  6. import java.util.Set;

  8. public class OSMAttachedSidewalkProcessor {

  10.     public static final String KEY_ORS_SIDEWALK_SIDE = "ors-sidewalk-side";
  11.     public static final String VAL_RIGHT = "right";
  12.     public static final String VAL_LEFT = "left";

  14.     protected enum Side {LEFT, RIGHT, BOTH, NONE}

  16.     public boolean hasSidewalkInfo(ReaderWay way) {
  17.         return identifySidesWhereSidewalkIsPresent(way) != Side.NONE;
  18.     }

  20.     /**
  21.      * Get the keys that represent sidewalk information
  22.      *
  23.      * @param way
  24.      * @return
  25.      */
  26.     protected Set<String> getSidewalkKeys(ReaderWay way) {
  27.         Set<String> sidewalkInfoKeys = new HashSet<>();

  29.         Set<String> keys = way.getTags().keySet();
  30.         for (String k : keys) {
  31.             if (isSidewalkInfoKey(k)) {
  32.                 sidewalkInfoKeys.add(k);
  33.             }
  34.         }

  36.         return sidewalkInfoKeys;
  37.     }

  39.     /**
  40.      * Identify if the specified key could contain sidewalk information
  41.      *
  42.      * @param osmTagKey
  43.      * @return
  44.      */
  45.     private boolean isSidewalkInfoKey(String osmTagKey) {
  46.         return osmTagKey.startsWith("sidewalk:") || osmTagKey.startsWith("footway:");
  47.     }

  49.     /**
  50.      * Add a tag to the way which signifies which side of the road the sidewalk needs to be processed for
  51.      *
  52.      * @param way
  53.      * @param side
  54.      * @return
  55.      */
  56.     public ReaderWay attachSidewalkTag(ReaderWay way, Side side) {
  57.         switch (side) {
  58.             case LEFT:
  59.                 way.setTag(KEY_ORS_SIDEWALK_SIDE, VAL_LEFT);
  60.                 break;
  61.             case RIGHT:
  62.                 way.setTag(KEY_ORS_SIDEWALK_SIDE, VAL_RIGHT);
  63.                 break;
  64.             case BOTH:
  65.                 if (way.hasTag(KEY_ORS_SIDEWALK_SIDE) && way.getTag(KEY_ORS_SIDEWALK_SIDE).equalsIgnoreCase(VAL_LEFT)) {
  66.                     // The left side has been attached previously, so now attach the right side
  67.                     way.setTag(KEY_ORS_SIDEWALK_SIDE, VAL_RIGHT);
  68.                 } else {
  69.                     // start with the left side
  70.                     way.setTag(KEY_ORS_SIDEWALK_SIDE, VAL_LEFT);
  71.                 }
  72.                 break;
  73.             case NONE:
  74.                 if (way.hasTag(KEY_ORS_SIDEWALK_SIDE)) {
  75.                     way.removeTag(KEY_ORS_SIDEWALK_SIDE);
  76.                 }
  77.         }

  79.         return way;
  80.     }

  82.     /**
  83.      * Determine which sidewalk side is to be processed based on the tag that was attached.
  84.      *
  85.      * @param way
  86.      * @return
  87.      */
  88.     public Side getPreparedSide(ReaderWay way) {
  89.         if (way.hasTag(KEY_ORS_SIDEWALK_SIDE)) {
  90.             String preparedSide = way.getTag(KEY_ORS_SIDEWALK_SIDE);
  91.             if (preparedSide.equalsIgnoreCase(VAL_LEFT)) {
  92.                 return Side.LEFT;
  93.             }
  94.             if (preparedSide.equalsIgnoreCase(VAL_RIGHT)) {
  95.                 return Side.RIGHT;
  96.             }
  97.         }

  99.         return Side.NONE;
  100.     }

  102.     /**
  103.      * Identify which side there is a sidealk present on the road based on the tags assigned in OSM
  104.      *
  105.      * @param osmWay
  106.      * @return
  107.      */
  108.     protected Side identifySidesWhereSidewalkIsPresent(ReaderWay osmWay) {
  109.         boolean sidewalkOnLeftSide = false;
  110.         boolean sidewalkOnRightSide = false;
  111.         boolean sidewalkOnBothSides = false;

  113.         if (osmWay.hasTag("sidewalk")) {
  114.             String side = osmWay.getTag("sidewalk");
  115.             switch (side) {
  116.                 case VAL_LEFT -> sidewalkOnLeftSide = true;
  117.                 case VAL_RIGHT -> sidewalkOnRightSide = true;
  118.                 case "both" -> sidewalkOnBothSides = true;
  119.                 default -> {
  120.                 }
  121.             }
  122.         }

  124.         Set<String> sidewalkProperties = getSidewalkKeys(osmWay);

  126.         for (String key : sidewalkProperties) {
  127.             if (key.startsWith("sidewalk:left") || key.startsWith("footway:left")) sidewalkOnLeftSide = true;
  128.             if (key.startsWith("sidewalk:right") || key.startsWith("footway:right")) sidewalkOnRightSide = true;
  129.             if (key.startsWith("sidewalk:both") || key.startsWith("footway:both")) sidewalkOnBothSides = true;
  130.         }

  132.         if (sidewalkOnLeftSide && sidewalkOnRightSide) {
  133.             sidewalkOnBothSides = true;
  134.         }

  136.         if (sidewalkOnBothSides) {
  137.             return Side.BOTH;
  138.         }

  140.         if (sidewalkOnLeftSide) {
  141.             return Side.LEFT;
  142.         }

  144.         if (sidewalkOnRightSide) {
  145.             return Side.RIGHT;
  146.         }

  148.         return Side.NONE;
  149.     }
  150. }
Created with JaCoCo 0.8.10.202304240956