ExtraInfoProcessor.java

/*  This file is part of Openrouteservice.
 *
 *  Openrouteservice is free software; you can redistribute it and/or modify it under the terms of the
 *  GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1
 *  of the License, or (at your option) any later version.

 *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *  See the GNU Lesser General Public License for more details.

 *  You should have received a copy of the GNU Lesser General Public License along with this library;
 *  if not, see <https://www.gnu.org/licenses/>.
 */
package org.heigit.ors.routing.pathprocessors;

import com.graphhopper.routing.querygraph.EdgeIteratorStateHelper;
import com.graphhopper.routing.util.FlagEncoder;
import com.graphhopper.routing.util.PathProcessor;
import com.graphhopper.routing.weighting.PriorityWeighting;
import com.graphhopper.storage.GraphExtension;
import com.graphhopper.storage.GraphHopperStorage;
import com.graphhopper.util.EdgeIteratorState;
import com.graphhopper.util.PMap;
import com.graphhopper.util.PointList;
import org.apache.log4j.Logger;
import org.heigit.ors.routing.RouteExtraInfo;
import org.heigit.ors.routing.RouteExtraInfoFlag;
import org.heigit.ors.routing.RoutingProfileType;
import org.heigit.ors.routing.graphhopper.extensions.flagencoders.FlagEncoderKeys;
import org.heigit.ors.routing.graphhopper.extensions.reader.borders.CountryBordersPolygon;
import org.heigit.ors.routing.graphhopper.extensions.reader.borders.CountryBordersReader;
import org.heigit.ors.routing.graphhopper.extensions.storages.*;
import org.heigit.ors.routing.graphhopper.extensions.util.PriorityCode;
import org.heigit.ors.routing.parameters.ProfileParameters;
import org.heigit.ors.routing.util.WaySurfaceDescription;
import org.heigit.ors.routing.util.extrainfobuilders.AppendableRouteExtraInfoBuilder;
import org.heigit.ors.routing.util.extrainfobuilders.AppendableSteepnessExtraInfoBuilder;
import org.heigit.ors.routing.util.extrainfobuilders.RouteExtraInfoBuilder;
import org.heigit.ors.routing.util.extrainfobuilders.SteepnessExtraInfoBuilder;
import org.locationtech.jts.geom.Coordinate;

import java.util.ArrayList;
import java.util.List;

import static com.graphhopper.routing.util.EncodingManager.getKey;

public class ExtraInfoProcessor implements PathProcessor {
    private WaySurfaceTypeGraphStorage extWaySurface;
    private WayCategoryGraphStorage extWayCategory;
    private GreenIndexGraphStorage extGreenIndex;
    private NoiseIndexGraphStorage extNoiseIndex;
    private TollwaysGraphStorage extTollways;
    private TrailDifficultyScaleGraphStorage extTrailDifficulty;
    private HillIndexGraphStorage extHillIndex;
    private OsmIdGraphStorage extOsmId;
    private RoadAccessRestrictionsGraphStorage extRoadAccessRestrictions;
    private BordersGraphStorage extCountryTraversalInfo;
    private CsvGraphStorage extCsvData;
    private ShadowIndexGraphStorage extShadowIndex;

    private RouteExtraInfo surfaceInfo;
    private RouteExtraInfoBuilder surfaceInfoBuilder;

    private RouteExtraInfo wayTypeInfo;
    private RouteExtraInfoBuilder wayTypeInfoBuilder;

    private RouteExtraInfo steepnessInfo;
    private SteepnessExtraInfoBuilder steepnessInfoBuilder;

    private RouteExtraInfo waySuitabilityInfo;
    private RouteExtraInfoBuilder waySuitabilityInfoBuilder;

    private RouteExtraInfo wayCategoryInfo;
    private RouteExtraInfoBuilder wayCategoryInfoBuilder;

    private RouteExtraInfo greenInfo;
    private RouteExtraInfoBuilder greenInfoBuilder;

    private RouteExtraInfo noiseInfo;
    private RouteExtraInfoBuilder noiseInfoBuilder;

    private RouteExtraInfo avgSpeedInfo;
    private RouteExtraInfoBuilder avgSpeedInfoBuilder;

    private RouteExtraInfo tollwaysInfo;
    private RouteExtraInfoBuilder tollwaysInfoBuilder;
    private TollwayExtractor tollwayExtractor;

    private RouteExtraInfo trailDifficultyInfo;
    private RouteExtraInfoBuilder trailDifficultyInfoBuilder;

    private RouteExtraInfo osmIdInfo;
    private RouteExtraInfoBuilder osmIdInfoBuilder;

    private RouteExtraInfo roadAccessRestrictionsInfo;
    private RouteExtraInfoBuilder roadAccessRestrictionsInfoBuilder;

    private RouteExtraInfo countryTraversalInfo;
    private RouteExtraInfoBuilder countryTraversalInfoBuilder;

    private RouteExtraInfo csvInfo;
    private RouteExtraInfoBuilder csvInfoBuilder;
    int csvColumn = 0;

    private RouteExtraInfo shadowInfo;
    private RouteExtraInfoBuilder shadowInfoBuilder;

    private List<Integer> warningExtensions;

    private int profileType = RoutingProfileType.UNKNOWN;
    private final FlagEncoder encoder;
    private final boolean encoderWithPriority;
    private final byte[] buffer;
    private static final Logger LOGGER = Logger.getLogger(ExtraInfoProcessor.class.getName());

    private String skippedExtraInfo = "";

    private CountryBordersReader countryBordersReader;

    ExtraInfoProcessor(PMap opts, GraphHopperStorage graphHopperStorage, FlagEncoder enc, CountryBordersReader cbReader) throws Exception {
        this(opts, graphHopperStorage, enc);
        this.countryBordersReader = cbReader;
    }

    ExtraInfoProcessor(PMap opts, GraphHopperStorage graphHopperStorage, FlagEncoder enc) throws Exception {
        encoder = enc;
        encoderWithPriority = encoder.supports(PriorityWeighting.class);
        List<String> skippedExtras = new ArrayList<>();

        try {
            PMap params = opts;
            if (params == null) {
                params = new PMap();
            }

            int extraInfo = params.getInt("routing_extra_info", 0);
            profileType = params.getInt("routing_profile_type", 0);
            ProfileParameters profileParameters = params.getObject("routing_profile_params", new ProfileParameters());
            boolean suppressWarnings = params.getBool("routing_suppress_warnings", false);

            warningExtensions = new ArrayList<>();

            if (!suppressWarnings)
                applyWarningExtensions(graphHopperStorage);

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.WAY_CATEGORY)) {
                extWayCategory = GraphStorageUtils.getGraphExtension(graphHopperStorage, WayCategoryGraphStorage.class);
                if (extWayCategory != null) {
                    wayCategoryInfo = new RouteExtraInfo("waycategory");
                    wayCategoryInfoBuilder = new AppendableRouteExtraInfoBuilder(wayCategoryInfo);
                } else {
                    skippedExtras.add("waycategory");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.SURFACE) || includeExtraInfo(extraInfo, RouteExtraInfoFlag.WAY_TYPE)) {
                extWaySurface = GraphStorageUtils.getGraphExtension(graphHopperStorage, WaySurfaceTypeGraphStorage.class);
                if (extWaySurface != null) {
                    if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.SURFACE)) {
                        surfaceInfo = new RouteExtraInfo("surface");
                        surfaceInfoBuilder = new AppendableRouteExtraInfoBuilder(surfaceInfo);
                    }
                    if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.WAY_TYPE)) {
                        wayTypeInfo = new RouteExtraInfo("waytypes");
                        wayTypeInfoBuilder = new AppendableRouteExtraInfoBuilder(wayTypeInfo);
                    }
                } else {
                    skippedExtras.add("surface/waytypes");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.STEEPNESS)) {
                if ("true".equals(graphHopperStorage.getProperties().get("elevation"))) {
                    steepnessInfo = new RouteExtraInfo("steepness");
                    steepnessInfoBuilder = new AppendableSteepnessExtraInfoBuilder(steepnessInfo);
                } else {
                    skippedExtras.add("steepness");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.SUITABILITY)) {
                waySuitabilityInfo = new RouteExtraInfo("suitability");
                waySuitabilityInfoBuilder = new AppendableRouteExtraInfoBuilder(waySuitabilityInfo);
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.AVG_SPEED)) {
                avgSpeedInfo = new RouteExtraInfo("avgspeed");
                avgSpeedInfo.setFactor(10);
                avgSpeedInfoBuilder = new AppendableRouteExtraInfoBuilder(avgSpeedInfo);
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.TOLLWAYS)) {
                extTollways = GraphStorageUtils.getGraphExtension(graphHopperStorage, TollwaysGraphStorage.class);
                if (extTollways != null) {
                    tollwaysInfo = new RouteExtraInfo("tollways", extTollways);
                    tollwaysInfoBuilder = new AppendableRouteExtraInfoBuilder(tollwaysInfo);
                    tollwayExtractor = new TollwayExtractor(extTollways, profileType, profileParameters);
                } else {
                    skippedExtras.add("tollways");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.TRAIL_DIFFICULTY)) {
                extTrailDifficulty = GraphStorageUtils.getGraphExtension(graphHopperStorage, TrailDifficultyScaleGraphStorage.class);
                extHillIndex = GraphStorageUtils.getGraphExtension(graphHopperStorage, HillIndexGraphStorage.class);

                trailDifficultyInfo = new RouteExtraInfo("traildifficulty");
                trailDifficultyInfoBuilder = new AppendableRouteExtraInfoBuilder(trailDifficultyInfo);
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.GREEN)) {
                extGreenIndex = GraphStorageUtils.getGraphExtension(graphHopperStorage, GreenIndexGraphStorage.class);
                if (extGreenIndex != null) {
                    greenInfo = new RouteExtraInfo("green");
                    greenInfoBuilder = new AppendableRouteExtraInfoBuilder(greenInfo);
                } else {
                    skippedExtras.add("green");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.NOISE)) {
                extNoiseIndex = GraphStorageUtils.getGraphExtension(graphHopperStorage, NoiseIndexGraphStorage.class);
                if (extNoiseIndex != null) {
                    noiseInfo = new RouteExtraInfo("noise");
                    noiseInfoBuilder = new AppendableRouteExtraInfoBuilder(noiseInfo);
                } else {
                    skippedExtras.add("noise");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.SHADOW)) {
                extShadowIndex = GraphStorageUtils.getGraphExtension(graphHopperStorage, ShadowIndexGraphStorage.class);
                if (extShadowIndex != null) {
                    shadowInfo = new RouteExtraInfo("shadow");
                    shadowInfoBuilder = new AppendableRouteExtraInfoBuilder(shadowInfo);
                } else {
                    skippedExtras.add("shadow");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.OSM_ID)) {
                extOsmId = GraphStorageUtils.getGraphExtension(graphHopperStorage, OsmIdGraphStorage.class);
                if (extOsmId != null) {
                    osmIdInfo = new RouteExtraInfo("osmId");
                    osmIdInfoBuilder = new AppendableRouteExtraInfoBuilder(osmIdInfo);
                } else {
                    skippedExtras.add("osmid");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.ROAD_ACCESS_RESTRICTIONS)) {
                extRoadAccessRestrictions = GraphStorageUtils.getGraphExtension(graphHopperStorage, RoadAccessRestrictionsGraphStorage.class);
                if (extRoadAccessRestrictions != null) {
                    roadAccessRestrictionsInfo = new RouteExtraInfo("roadaccessrestrictions", extRoadAccessRestrictions);
                    roadAccessRestrictionsInfoBuilder = new AppendableRouteExtraInfoBuilder(roadAccessRestrictionsInfo);
                } else {
                    skippedExtras.add("roadaccessrestrictions");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.COUNTRY_INFO)) {
                extCountryTraversalInfo = GraphStorageUtils.getGraphExtension(graphHopperStorage, BordersGraphStorage.class);
                if (extCountryTraversalInfo != null) {
                    countryTraversalInfo = new RouteExtraInfo("countryinfo", extCountryTraversalInfo);
                    countryTraversalInfoBuilder = new AppendableRouteExtraInfoBuilder(countryTraversalInfo);
                } else {
                    skippedExtras.add("countryinfo");
                }
            }

            if (includeExtraInfo(extraInfo, RouteExtraInfoFlag.CSV)) {
                extCsvData = GraphStorageUtils.getGraphExtension(graphHopperStorage, CsvGraphStorage.class);
                if (extCsvData != null) {
                    csvInfo = new RouteExtraInfo("csv");
                    csvInfoBuilder = new AppendableRouteExtraInfoBuilder(csvInfo);
                    csvColumn = extCsvData.columnIndex(params.getString("weighting_#csv#column", ""));
                } else {
                    skippedExtras.add("csv");
                }
            }
        } catch (Exception ex) {
            LOGGER.error(ex);
        }
        if (!skippedExtras.isEmpty()) {
            skippedExtraInfo = String.join(", ", skippedExtras);
        }
        buffer = new byte[4];
    }

    /**
     * Loop through the GraphExtensions of the storage and store in the warningExtensions object those that implement
     * the WarningGraphExtension interface and are set to be used for generating warnings.
     *
     * @param graphHopperStorage the storage containing the warnings
     */
    private void applyWarningExtensions(GraphHopperStorage graphHopperStorage) {
        GraphExtension[] extensions = graphHopperStorage.getExtensions().getExtensions();
        for (GraphExtension ge : extensions) {
            if (ge instanceof WarningGraphExtension extension && extension.isUsedForWarning()) {
                warningExtensions.add(RouteExtraInfoFlag.getFromString(extension.getName()));
            }
        }
    }

    /**
     * Check if the extra info should be included in the generation or not by looking at the encoded extras value and
     * the list of warning extras.
     *
     * @param encodedExtras The encoded value stating which extras were passed explicitly
     * @param infoFlag      The id of the extra info whose inclusion needs to be decided
     */
    private boolean includeExtraInfo(int encodedExtras, int infoFlag) {
        return RouteExtraInfoFlag.isSet(encodedExtras, infoFlag) || warningExtensions.contains(infoFlag);
    }

    public List<RouteExtraInfo> getExtras() {
        List<RouteExtraInfo> extras = new ArrayList<>();
        if (surfaceInfo != null) {
            surfaceInfoBuilder.finish();
            extras.add(surfaceInfo);
        }
        if (wayTypeInfo != null) {
            wayTypeInfoBuilder.finish();
            extras.add(wayTypeInfo);
        }
        if (steepnessInfo != null) {
            steepnessInfoBuilder.finish();
            extras.add(steepnessInfo);
        }
        if (waySuitabilityInfo != null) {
            waySuitabilityInfoBuilder.finish();
            extras.add(waySuitabilityInfo);
        }
        if (wayCategoryInfo != null) {
            wayCategoryInfoBuilder.finish();
            extras.add(wayCategoryInfo);
        }
        if (avgSpeedInfo != null) {
            avgSpeedInfoBuilder.finish();
            extras.add(avgSpeedInfo);
        }
        if (greenInfo != null) {
            greenInfoBuilder.finish();
            extras.add(greenInfo);
        }
        if (noiseInfo != null) {
            noiseInfoBuilder.finish();
            extras.add(noiseInfo);
        }
        if (tollwaysInfo != null) {
            tollwaysInfoBuilder.finish();
            extras.add(tollwaysInfo);
        }
        if (trailDifficultyInfo != null) {
            trailDifficultyInfoBuilder.finish();
            extras.add(trailDifficultyInfo);
        }
        if (osmIdInfo != null) {
            osmIdInfoBuilder.finish();
            extras.add(osmIdInfo);
        }
        if (roadAccessRestrictionsInfo != null) {
            roadAccessRestrictionsInfoBuilder.finish();
            extras.add(roadAccessRestrictionsInfo);
        }
        if (countryTraversalInfo != null) {
            countryTraversalInfoBuilder.finish();
            extras.add(countryTraversalInfo);
        }
        if (csvInfo != null) {
            csvInfoBuilder.finish();
            extras.add(csvInfo);
        }
        if (shadowInfo != null) {
            shadowInfoBuilder.finish();
            extras.add(shadowInfo);
        }
        return extras;
    }

    public void appendData(ExtraInfoProcessor more) {
        if (surfaceInfo != null)
            ((AppendableRouteExtraInfoBuilder) surfaceInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.surfaceInfoBuilder);
        if (wayTypeInfo != null)
            ((AppendableRouteExtraInfoBuilder) wayTypeInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.wayTypeInfoBuilder);
        if (steepnessInfo != null)
            ((AppendableSteepnessExtraInfoBuilder) steepnessInfoBuilder).append((AppendableSteepnessExtraInfoBuilder) more.steepnessInfoBuilder);
        if (waySuitabilityInfo != null)
            ((AppendableRouteExtraInfoBuilder) waySuitabilityInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.waySuitabilityInfoBuilder);
        if (wayCategoryInfo != null)
            ((AppendableRouteExtraInfoBuilder) wayCategoryInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.wayCategoryInfoBuilder);
        if (avgSpeedInfo != null) //TODO remove this? avgSpeed is not extra info, but regular routing attribute
            ((AppendableRouteExtraInfoBuilder) avgSpeedInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.avgSpeedInfoBuilder);
        if (greenInfo != null)
            ((AppendableRouteExtraInfoBuilder) greenInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.greenInfoBuilder);
        if (noiseInfo != null)
            ((AppendableRouteExtraInfoBuilder) noiseInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.noiseInfoBuilder);
        if (tollwaysInfo != null)
            ((AppendableRouteExtraInfoBuilder) tollwaysInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.tollwaysInfoBuilder);
        if (trailDifficultyInfo != null)
            ((AppendableRouteExtraInfoBuilder) trailDifficultyInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.trailDifficultyInfoBuilder);
        if (osmIdInfo != null)
            ((AppendableRouteExtraInfoBuilder) osmIdInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.osmIdInfoBuilder);
        if (roadAccessRestrictionsInfo != null)
            ((AppendableRouteExtraInfoBuilder) roadAccessRestrictionsInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.roadAccessRestrictionsInfoBuilder);
        if (countryTraversalInfoBuilder != null)
            ((AppendableRouteExtraInfoBuilder) countryTraversalInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.countryTraversalInfoBuilder);
        if (csvInfo != null)
            ((AppendableRouteExtraInfoBuilder) csvInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.csvInfoBuilder);
        if (shadowInfo != null)
            ((AppendableRouteExtraInfoBuilder) shadowInfoBuilder).append((AppendableRouteExtraInfoBuilder) more.shadowInfoBuilder);
    }

    @Override
    public void processPathEdge(EdgeIteratorState edge, PointList geom) {
        double dist = edge.getDistance();

        // TODO Add extra info for crossed countries
        if (extCountryTraversalInfo != null && countryBordersReader != null) {
            short country1 = extCountryTraversalInfo.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), BordersGraphStorage.Property.START);
            short country2 = extCountryTraversalInfo.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), BordersGraphStorage.Property.END);
            // This check will correct the countries of an edge if the starting coordinate of the route lies in a different country than the start of the edge.
            if (country1 != country2 && geom.size() > 0) {
                Coordinate coordinate = new Coordinate();
                coordinate.x = geom.getLon(0);
                coordinate.y = geom.getLat(0);
                CountryBordersPolygon[] countries = countryBordersReader.getCountry(coordinate);
                if (countries.length >= 1) {
                    country1 = Short.parseShort(countryBordersReader.getId(countryBordersReader.getCountry(coordinate)[0].getName()));
                }
            }
            if (countryTraversalInfoBuilder != null && country1 != 0) {
                countryTraversalInfoBuilder.addSegment(country1, country1, geom, dist);
            }
        }

        if (extWaySurface != null && wayTypeInfo != null || surfaceInfo != null) {
            WaySurfaceDescription wsd = extWaySurface.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);

            if (surfaceInfoBuilder != null)
                surfaceInfoBuilder.addSegment(wsd.getSurfaceType().value(), wsd.getSurfaceType().value(), geom, dist);

            if (wayTypeInfo != null)
                wayTypeInfoBuilder.addSegment(wsd.getWayType(), wsd.getWayType(), geom, dist);
        }

        if (wayCategoryInfoBuilder != null) {
            int value = extWayCategory.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);
            wayCategoryInfoBuilder.addSegment(value, value, geom, dist);
        }

        if (trailDifficultyInfoBuilder != null) {
            int value = 0;
            if (RoutingProfileType.isCycling(profileType)) {
                boolean uphill = false;
                if (extHillIndex != null) {
                    boolean revert = edge.getBaseNode() > edge.getAdjNode();
                    int hillIndex = extHillIndex.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), revert, buffer);
                    if (hillIndex > 0)
                        uphill = true;
                }
                value = extTrailDifficulty.getMtbScale(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer, uphill);
            } else if (RoutingProfileType.isWalking(profileType))
                value = extTrailDifficulty.getHikingScale(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);

            trailDifficultyInfoBuilder.addSegment(value, value, geom, dist);
        }

        if (avgSpeedInfoBuilder != null) {
            double speed = encoder.getAverageSpeedEnc().getDecimal(false, edge.getFlags());
            avgSpeedInfoBuilder.addSegment(speed, (int) Math.round(speed * avgSpeedInfo.getFactor()), geom, dist);
        }

        if (tollwaysInfoBuilder != null) {
            int value = tollwayExtractor.getValue(EdgeIteratorStateHelper.getOriginalEdge(edge));
            tollwaysInfoBuilder.addSegment(value, value, geom, dist);
        }

        if (waySuitabilityInfoBuilder != null) {
            double priority;
            int priorityIndex;
            if (encoderWithPriority) {
                priority = edge.get(encoder.getDecimalEncodedValue(getKey(encoder, FlagEncoderKeys.PRIORITY_KEY)));
                priorityIndex = (int) Math.round(3 + priority * PriorityCode.BEST.getValue()); // normalize values between 3 and 10
            } else {
                priority = encoder.getAverageSpeedEnc().getDecimal(false, edge.getFlags()) / encoder.getMaxSpeed();
                if (priority < 0.3)
                    priority = 0.3;
                priorityIndex = (int) Math.round(priority * 10);
            }
            waySuitabilityInfoBuilder.addSegment(priority, priorityIndex, geom, dist);
        }

        if (greenInfoBuilder != null) {
            int value = extGreenIndex.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);
            // This number is how many levels client can display in the stats bar
            // FIXME should be changed when the specific bar legend for green routing is finished
            int minClientVal = 3;
            int maxClientVal = 10;
            int clientVal = minClientVal + value * (maxClientVal - minClientVal + 1) / 64;
            greenInfoBuilder.addSegment(value, clientVal, geom, dist);
        }

        if (noiseInfoBuilder != null) {
            int noiseLevel = extNoiseIndex.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);
            // convert the noise level (from 0 to 3) to the values (from 7 to 10) for the client
            if (noiseLevel > 3)
                noiseLevel = 3;

            int clientNoiseLevel = noiseLevel + 7;
            noiseInfoBuilder.addSegment(noiseLevel, clientNoiseLevel, geom, dist);
        }

        if (osmIdInfoBuilder != null) {
            long osmId = extOsmId.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge));

            osmIdInfoBuilder.addSegment((double) osmId, osmId, geom, dist);
        }

        if (roadAccessRestrictionsInfoBuilder != null) {
            int value = extRoadAccessRestrictions.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);
            roadAccessRestrictionsInfoBuilder.addSegment(value, value, geom, dist);
        }

        if (csvInfoBuilder != null) {
            int value = extCsvData.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), csvColumn, buffer);
            csvInfoBuilder.addSegment(value, value, geom, dist);
        }

        if (shadowInfoBuilder != null) {
            int shadowLevel = extShadowIndex.getEdgeValue(EdgeIteratorStateHelper.getOriginalEdge(edge), buffer);
            shadowInfoBuilder.addSegment(shadowLevel, shadowLevel, geom, dist);
        }
    }

    @Override
    public PointList processPoints(PointList points) {
        PointList result = points;

		if (steepnessInfoBuilder != null) {
			// compute steepness information only after elevation data is smoothed.
			steepnessInfoBuilder.addPoints(result);
		}

        return result;
    }

    public String getSkippedExtraInfo() {
        return skippedExtraInfo;
    }
}