Convert.java

  1. package org.opentrafficsim.road.network.factory.osm.output;

  3. import java.awt.Color;
  4. import java.rmi.RemoteException;
  5. import java.util.ArrayList;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Locale;
  9. import java.util.Map;
  10. import java.util.Objects;
  11. import java.util.SortedMap;
  12. import java.util.TreeMap;

  14. import javax.naming.NamingException;

  16. import org.djunits.unit.LengthUnit;
  17. import org.djunits.unit.SpeedUnit;
  18. import org.djunits.value.vdouble.scalar.Length;
  19. import org.djunits.value.vdouble.scalar.Speed;
  20. import org.opengis.referencing.FactoryException;
  21. import org.opengis.referencing.operation.TransformException;
  22. import org.opentrafficsim.core.dsol.OTSAnimatorInterface;
  23. import org.opentrafficsim.core.dsol.OTSDEVSSimulatorInterface;
  24. import org.opentrafficsim.core.geometry.OTSGeometryException;
  25. import org.opentrafficsim.core.geometry.OTSLine3D;
  26. import org.opentrafficsim.core.geometry.OTSPoint3D;
  27. import org.opentrafficsim.core.gtu.GTUType;
  28. import org.opentrafficsim.core.network.LinkType;
  29. import org.opentrafficsim.core.network.LongitudinalDirectionality;
  30. import org.opentrafficsim.core.network.NetworkException;
  31. import org.opentrafficsim.core.network.OTSNode;
  32. import org.opentrafficsim.road.network.animation.LaneAnimation;
  33. import org.opentrafficsim.road.network.factory.osm.OSMLink;
  34. import org.opentrafficsim.road.network.factory.osm.OSMNetwork;
  35. import org.opentrafficsim.road.network.factory.osm.OSMNode;
  36. import org.opentrafficsim.road.network.factory.osm.OSMTag;
  37. import org.opentrafficsim.road.network.factory.osm.events.ProgressEvent;
  38. import org.opentrafficsim.road.network.factory.osm.events.ProgressListener;
  39. import org.opentrafficsim.road.network.factory.osm.events.WarningEvent;
  40. import org.opentrafficsim.road.network.factory.osm.events.WarningListener;
  41. import org.opentrafficsim.road.network.lane.CrossSectionLink;
  42. import org.opentrafficsim.road.network.lane.Lane;
  43. import org.opentrafficsim.road.network.lane.LaneType;
  44. import org.opentrafficsim.road.network.lane.SinkSensor;
  45. import org.opentrafficsim.road.network.lane.changing.LaneKeepingPolicy;
  46. import org.opentrafficsim.road.network.lane.changing.OvertakingConditions;

  48. import com.vividsolutions.jts.geom.Coordinate;

  50. /**
  51.  * <p>
  52.  * Copyright (c) 2013-2015 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  53.  * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  54.  * <p>
  55.  * $LastChangedDate: 2015-09-16 19:20:07 +0200 (Wed, 16 Sep 2015) $, @version $Revision: 1405 $, by $Author: averbraeck $,
  56.  * initial version 30.12.2014 <br>
  57.  * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
  58.  * @author <a>Moritz Bergmann</a>
  59.  */
  60. public final class Convert
  61. {

  63.     /**
  64.      * Construct a converter.
  65.      */
  66.     public Convert()
  67.     {
  68.         baseX = Double.NaN;
  69.     }

  71.     /** Meridian of least distortion. */
  72.     private static double baseX = Double.NaN;

  74.     /**
  75.      * @param c Coordinate in WGS84
  76.      * @return Coordinate in Geocentric Cartesian system
  77.      * @throws FactoryException on ???
  78.      * @throws TransformException on problems with the coordinate transformation
  79.      */
  80.     public static Coordinate transform(final Coordinate c) throws FactoryException, TransformException
  81.     {
  82.         // final CoordinateReferenceSystem wgs84 = DefaultGeographicCRS.WGS84;
  83.         // final CoordinateReferenceSystem cartesianCRS = DefaultGeocentricCRS.CARTESIAN;
  84.         // final MathTransform mathTransform;
  85.         // mathTransform = CRS.findMathTransform(wgs84, cartesianCRS, false);
  86.         // double[] srcPt = {c.x, c.y};
  87.         // double[] dstPt = new double[mathTransform.getTargetDimensions()];

  89.         // mathTransform.transform(srcPt, 0, dstPt, 0, 1);
  90.         // System.out.println(String.format(Locale.US, "%fkm, %fkm, %fkm", dstPt[0] / 1000, dstPt[1] / 1000, dstPt[2] /
  91.         // 1000));
  92.         // return new Coordinate(dstPt[1], -dstPt[0]);

  94.         // Simple-minded DIY solution
  95.         double radius = 6371000; // Assume Earth is a perfect sphere
  96.         if (Double.isNaN(baseX))
  97.         {
  98.             baseX = c.x; // Use first coordinate as the reference
  99.         }
  100.         double x = radius * Math.toRadians(c.x - baseX) * Math.cos(Math.toRadians(c.y));
  101.         double y = radius * Math.toRadians(c.y);
  102.         // System.out.println(String.format(Locale.US, "%fkm, %fkm, %fkm", x / 1000, y / 1000, radius / 1000));
  103.         return new Coordinate(x, y);
  104.     }

  106.     /**
  107.      * This method converts an OSM link to an OTS link.
  108.      * @param link OSM Link to be converted
  109.      * @return OTS Link
  110.      * @throws OTSGeometryException on failure
  111.      */
  112.     public CrossSectionLink convertLink(final OSMLink link) throws OTSGeometryException
  113.     {
  114.         if (null == link.getStart().getOtsNode())
  115.         {
  116.             link.getStart().setOtsNode(convertNode(link.getStart()));
  117.         }
  118.         if (null == link.getEnd().getOtsNode())
  119.         {
  120.             link.getEnd().setOtsNode(convertNode(link.getEnd()));
  121.         }
  122.         CrossSectionLink result;
  123.         Coordinate[] coordinates;
  124.         List<OSMNode> nodes = link.getSplineList();
  125.         int coordinateCount = 2 + nodes.size();
  126.         coordinates = new Coordinate[coordinateCount];
  127.         OTSNode start = link.getStart().getOtsNode();
  128.         coordinates[0] = new Coordinate(start.getPoint().x, start.getPoint().y, 0);
  129.         for (int i = 0; i < nodes.size(); i++)
  130.         {
  131.             coordinates[i + 1] = new Coordinate(nodes.get(i).getLongitude(), nodes.get(i).getLatitude());
  132.         }
  133.         OTSNode end = link.getEnd().getOtsNode();
  134.         coordinates[coordinates.length - 1] = new Coordinate(end.getPoint().x, end.getPoint().y, 0);
  135.         OTSLine3D designLine = new OTSLine3D(coordinates);
  136.         // XXX How to figure out whether to keep left, right or keep lane?
  137.         // XXX How to figure out if this is a lane in one or two directions? For now, two is assumed...
  138.         result =
  139.             new CrossSectionLink(link.getId(), start, end, LinkType.ALL, designLine,
  140.                 LongitudinalDirectionality.DIR_BOTH, LaneKeepingPolicy.KEEP_RIGHT);
  141.         return result;
  142.     }

  144.     /**
  145.      * This method converts an OSM node to an OTS node.
  146.      * @param node OSM Node to be converted
  147.      * @return OTS Node
  148.      */
  149.     public OTSNode convertNode(final OSMNode node)
  150.     {
  151.         OSMTag tag = node.getTag("ele");
  152.         if (null != tag)
  153.         {
  154.             try
  155.             {
  156.                 String ele = tag.getValue();
  157.                 Double elevation = 0d;
  158.                 if (ele.matches("[0-9]+(km)|m"))
  159.                 {
  160.                     String[] ele2 = ele.split("(km)|m");
  161.                     ele = ele2[0];
  162.                     if (ele2[1].equals("km"))
  163.                     {
  164.                         elevation = Double.parseDouble(ele) * 1000;
  165.                     }
  166.                     else if (ele2[1].equals("m"))
  167.                     {
  168.                         elevation = Double.parseDouble(ele);
  169.                     }
  170.                     else
  171.                     {
  172.                         throw new NumberFormatException("Cannot parse elevation value\"" + ele + "\"");
  173.                     }
  174.                 }
  175.                 else if (ele.matches("[0-9]+"))
  176.                 {
  177.                     elevation = Double.parseDouble(ele);
  178.                 }
  179.                 Coordinate coordWGS84 = new Coordinate(node.getLongitude(), node.getLatitude(), elevation);
  180.                 try
  181.                 {
  182.                     return new OTSNode(Objects.toString(node.getId()), new OTSPoint3D(transform(coordWGS84)));
  183.                 }
  184.                 catch (FactoryException | TransformException exception)
  185.                 {
  186.                     exception.printStackTrace();
  187.                 }
  188.             }
  189.             catch (NumberFormatException exception)
  190.             {
  191.                 exception.printStackTrace();
  192.             }
  193.         }
  194.         // No elevation specified, or we could not parse it; assume elevation is 0
  195.         Coordinate coordWGS84 = new Coordinate(node.getLongitude(), node.getLatitude(), 0d);
  196.         try
  197.         {
  198.             return new OTSNode(Objects.toString(node.getId()), new OTSPoint3D(Convert.transform(coordWGS84)));
  199.         }
  200.         catch (FactoryException | TransformException exception)
  201.         {
  202.             exception.printStackTrace();
  203.             // FIXME: how does the caller deal with a null result? (Answer: not!)
  204.             return null;
  205.         }
  206.     }

  208.     /**
  209.      * Determine the positions of the various lanes on an OSMLink.
  210.      * @param osmLink - The OSM Link on which the conversion is based.
  211.      * @param warningListener WarningListener; the warning listener that receives warning events
  212.      * @return Map&lt;Double, LaneAttributes&gt;; the lane structure
  213.      * @throws NetworkException on failure
  214.      */
  215.     private static Map<Double, LaneAttributes> makeStructure(final OSMLink osmLink,
  216.         final WarningListener warningListener) throws NetworkException
  217.     {
  218.         SortedMap<Integer, LaneAttributes> structure = new TreeMap<Integer, LaneAttributes>();
  219.         int forwards = osmLink.getForwardLanes();
  220.         int backwards = osmLink.getLanes() - osmLink.getForwardLanes();
  221.         LaneType laneType;
  222.         LaneAttributes laneAttributes;
  223.         for (OSMTag tag : osmLink.getTags())
  224.         {
  225.             if (tag.getKey().equals("waterway"))
  226.             {
  227.                 switch (tag.getValue())
  228.                 {
  229.                     case "river":
  230.                         laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BOAT);
  231.                         break;
  232.                     case "canal":
  233.                         laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BOAT);
  234.                         break;
  235.                     default:
  236.                         laneType = makeLaneType(GTUType.NONE);
  237.                         break;
  238.                 }
  239.                 laneAttributes = new LaneAttributes(laneType, Color.CYAN, LongitudinalDirectionality.DIR_BOTH);
  240.                 structure.put(0, laneAttributes);
  241.             }
  242.         }
  243.         for (OSMTag tag : osmLink.getTags())
  244.         {
  245.             if (tag.getKey().equals("highway")
  246.                 && (tag.getValue().equals("primary") || tag.getValue().equals("secondary")
  247.                     || tag.getValue().equals("tertiary") || tag.getValue().equals("residential")
  248.                     || tag.getValue().equals("trunk") || tag.getValue().equals("motorway")
  249.                     || tag.getValue().equals("service") || tag.getValue().equals("unclassified")
  250.                     || tag.getValue().equals("motorway_link") || tag.getValue().equals("primary_link")
  251.                     || tag.getValue().equals("secondary_link") || tag.getValue().equals("tertiary_link")
  252.                     || tag.getValue().equals("trunk_link") || tag.getValue().equals("road")
  253.                     || tag.getValue().equals("track") || tag.getValue().equals("living_street")))
  254.             {
  255.                 laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.CAR);
  256.                 if (osmLink.getLanes() == 1 && !osmLink.isOneway())
  257.                 {
  258.                     laneAttributes =
  259.                         new LaneAttributes(laneType, Color.LIGHT_GRAY, LongitudinalDirectionality.DIR_BOTH);
  260.                     structure.put(0, laneAttributes);
  261.                 }
  262.                 else
  263.                 {
  264.                     for (int i = 0 - backwards; i < forwards; i++)
  265.                     {
  266.                         if (i < 0)
  267.                         {
  268.                             laneAttributes =
  269.                                 new LaneAttributes(laneType, Color.LIGHT_GRAY, LongitudinalDirectionality.DIR_MINUS);
  270.                             structure.put(i, laneAttributes);
  271.                         }
  272.                         if (i >= 0)
  273.                         {
  274.                             laneAttributes =
  275.                                 new LaneAttributes(laneType, Color.LIGHT_GRAY, LongitudinalDirectionality.DIR_PLUS);
  276.                             structure.put(i, laneAttributes);
  277.                         }
  278.                     }
  279.                 }
  280.             }
  281.             else if (tag.getKey().equals("highway")
  282.                 && (tag.getValue().equals("path") || tag.getValue().equals("steps")))
  283.             {
  284.                 List<GTUType> types = new ArrayList<GTUType>();
  285.                 for (OSMTag t2 : osmLink.getTags())
  286.                 {
  287.                     if (t2.getKey().equals("bicycle"))
  288.                     {
  289.                         types.add(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BIKE);
  290.                     }
  291.                     /*
  292.                      * if (t2.getKey().equals("foot")) {
  293.                      * types.add(org.opentrafficsim.importexport.osm.PredefinedGTUTypes.pedestrian); }
  294.                      */
  295.                 }
  296.                 laneType = makeLaneType(types);
  297.                 types.add(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.PEDESTRIAN);
  298.                 if (!types.isEmpty())
  299.                 {
  300.                     if (osmLink.getLanes() == 1 && !osmLink.isOneway())
  301.                     {
  302.                         laneAttributes = new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_BOTH);
  303.                         structure.put(0, laneAttributes);
  304.                     }
  305.                     else
  306.                     {
  307.                         for (int i = 0 - backwards; i < forwards; i++)
  308.                         {
  309.                             if (i < 0)
  310.                             {
  311.                                 laneAttributes =
  312.                                     new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_MINUS);
  313.                                 structure.put(i, laneAttributes);
  314.                             }
  315.                             if (i >= 0)
  316.                             {
  317.                                 laneAttributes =
  318.                                     new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_PLUS);
  319.                                 structure.put(i, laneAttributes);
  320.                             }
  321.                         }
  322.                     }
  323.                 }
  324.                 types.clear();
  325.             }
  326.         }
  327.         for (OSMTag tag : osmLink.getTags())
  328.         {
  329.             if (tag.getKey().equals("cycleway"))
  330.             {
  331.                 laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BIKE);
  332.                 switch (tag.getValue())
  333.                 {
  334.                     case "lane": // cycleway:lane is directly adjacent to the highway.
  335.                         forwards++;
  336.                         backwards++;
  337.                         laneAttributes =
  338.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_MINUS);
  339.                         structure.put(0 - backwards, laneAttributes);
  340.                         laneAttributes =
  341.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_PLUS);
  342.                         structure.put(forwards - 1, laneAttributes);
  343.                         break;
  344.                     case "track": // cycleway:track is separated by a gap from the highway.
  345.                         forwards++;
  346.                         backwards++;
  347.                         laneAttributes =
  348.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_MINUS);
  349.                         structure.put(0 - backwards, laneAttributes);
  350.                         laneAttributes =
  351.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_PLUS);
  352.                         structure.put(forwards - 1, laneAttributes);
  353.                         break;
  354.                     case "shared_lane": // cycleway:shared_lane is embedded into the highway.
  355.                         List<GTUType> types = new ArrayList<GTUType>();
  356.                         types.add(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BIKE);
  357.                         types.add(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.CAR);
  358.                         laneType = makeLaneType(types);
  359.                         laneAttributes =
  360.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_MINUS);
  361.                         structure.put(0 - backwards, laneAttributes);
  362.                         laneAttributes =
  363.                             new LaneAttributes(laneType, Color.ORANGE, LongitudinalDirectionality.DIR_PLUS);
  364.                         structure.put(forwards - 1, laneAttributes);
  365.                         break;
  366.                     default:
  367.                         break;
  368.                 }
  369.             }
  370.         }
  371.         for (OSMTag tag : osmLink.getTags())
  372.         {
  373.             if (tag.getKey().equals("sidewalk"))
  374.             {
  375.                 laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.PEDESTRIAN);
  376.                 switch (tag.getValue())
  377.                 {
  378.                     case "both":
  379.                         forwards++;
  380.                         backwards++;
  381.                         laneAttributes =
  382.                             new LaneAttributes(laneType, Color.YELLOW, LongitudinalDirectionality.DIR_MINUS);
  383.                         structure.put(0 - backwards, laneAttributes);
  384.                         laneAttributes =
  385.                             new LaneAttributes(laneType, Color.YELLOW, LongitudinalDirectionality.DIR_PLUS);
  386.                         structure.put(forwards - 1, laneAttributes);
  387.                         break;
  388.                     case "left":
  389.                         backwards++;
  390.                         laneAttributes =
  391.                             new LaneAttributes(laneType, Color.YELLOW, LongitudinalDirectionality.DIR_BOTH);
  392.                         structure.put(0 - backwards, laneAttributes);
  393.                         break;
  394.                     case "right":
  395.                         forwards++;
  396.                         laneAttributes =
  397.                             new LaneAttributes(laneType, Color.YELLOW, LongitudinalDirectionality.DIR_BOTH);
  398.                         structure.put(forwards - 1, laneAttributes);
  399.                         break;
  400.                     default:
  401.                         break;
  402.                 }
  403.             }
  404.         }
  405.         for (OSMTag tag : osmLink.getTags())
  406.         {
  407.             if (tag.getKey().equals("highway")
  408.                 && (tag.getValue().equals("cycleway") || tag.getValue().equals("footway")
  409.                     || tag.getValue().equals("pedestrian") || tag.getValue().equals("steps")))
  410.             {
  411.                 if (tag.getValue().equals("footway") || tag.getValue().equals("pedestrian")
  412.                     || tag.getValue().equals("steps"))
  413.                 {
  414.                     laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.PEDESTRIAN);
  415.                     if (osmLink.getLanes() == 1 && !osmLink.isOneway())
  416.                     {
  417.                         laneAttributes = new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_BOTH);
  418.                         structure.put(0, laneAttributes);
  419.                     }
  420.                     else
  421.                     {
  422.                         for (int i = 0 - backwards; i < forwards; i++)
  423.                         {
  424.                             if (i < 0)
  425.                             {
  426.                                 laneAttributes =
  427.                                     new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_MINUS);
  428.                                 structure.put(i, laneAttributes);
  429.                             }
  430.                             if (i >= 0)
  431.                             {
  432.                                 laneAttributes =
  433.                                     new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_PLUS);
  434.                                 structure.put(i, laneAttributes);
  435.                             }
  436.                         }
  437.                     }
  438.                 }
  439.                 if (tag.getValue().equals("cycleway"))
  440.                 {
  441.                     laneType = makeLaneType(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BIKE);
  442.                     if (osmLink.getLanes() == 1 && !osmLink.isOneway())
  443.                     {
  444.                         laneAttributes = new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_BOTH);
  445.                         structure.put(0, laneAttributes);
  446.                     }
  447.                     for (int i = 0 - backwards; i < forwards; i++)
  448.                     {
  449.                         if (i < 0)
  450.                         {
  451.                             laneAttributes =
  452.                                 new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_MINUS);
  453.                             structure.put(i, laneAttributes);
  454.                         }
  455.                         if (i >= 0)
  456.                         {
  457.                             laneAttributes =
  458.                                 new LaneAttributes(laneType, Color.GREEN, LongitudinalDirectionality.DIR_PLUS);
  459.                             structure.put(i, laneAttributes);
  460.                         }
  461.                     }
  462.                 }
  463.             }
  464.         }
  465.         return calculateOffsets(structure, osmLink, forwards, backwards, warningListener);
  466.     }

  468.     /**
  469.      * Calculates the actual offsets of the individual lanes.
  470.      * @param structure - Sorted Map of Lane Positions and Attributes
  471.      * @param osmLink - The osmLink on which the conversion is based.
  472.      * @param forwards - Number of forwards oriented lanes.
  473.      * @param backwards - Number of backwards oriented lanes.
  474.      * @param warningListener WarningListener; the warning listener that receives warning events
  475.      * @return Map containing the lane structure with offsets.
  476.      * @throws NetworkException on failure
  477.      */
  478.     private static Map<Double, LaneAttributes> calculateOffsets(final SortedMap<Integer, LaneAttributes> structure,
  479.         final OSMLink osmLink, final Integer forwards, final Integer backwards, final WarningListener warningListener)
  480.         throws NetworkException
  481.     {
  482.         HashMap<Double, LaneAttributes> structurewithOffset = new HashMap<Double, LaneAttributes>();
  483.         LaneAttributes laneAttributes;
  484.         double currentOffset = 0.0D;
  485.         if (structure.isEmpty())
  486.         {
  487.             warningListener.warning(new WarningEvent(osmLink, "Empty Structure at Link " + osmLink.getId()));
  488.         }
  489.         if (structure.lastKey() >= 0)
  490.         {
  491.             for (int i = 0; i < forwards; i++)
  492.             {
  493.                 laneAttributes = structure.get(i);
  494.                 if (null == laneAttributes)
  495.                 {
  496.                     break;
  497.                 }
  498.                 double useWidth = laneWidth(laneAttributes, osmLink, warningListener);
  499.                 laneAttributes.setWidth(useWidth);
  500.                 structurewithOffset.put(currentOffset, laneAttributes);
  501.                 currentOffset += useWidth;
  502.             }
  503.         }
  504.         if (structure.firstKey() < 0)
  505.         {
  506.             currentOffset = 0.0d;
  507.             for (int i = -1; i >= (0 - backwards); i--)
  508.             {
  509.                 laneAttributes = structure.get(i);
  510.                 if (null == laneAttributes)
  511.                 {
  512.                     break;
  513.                 }
  514.                 LaneAttributes previousLaneAttributes = null;
  515.                 for (int k = i + 1; k <= 0; k++)
  516.                 {
  517.                     previousLaneAttributes = structure.get(k);
  518.                     if (null != previousLaneAttributes)
  519.                     {
  520.                         break;
  521.                     }
  522.                 }
  523.                 if (null == previousLaneAttributes)
  524.                 {
  525.                     throw new NetworkException("reverse lane without main lane?");
  526.                 }
  527.                 double useWidth = laneWidth(laneAttributes, osmLink, warningListener);
  528.                 laneAttributes.setWidth(useWidth);
  529.                 currentOffset -= previousLaneAttributes.getWidth().getSI();
  530.                 structurewithOffset.put(currentOffset, laneAttributes);
  531.             }
  532.         }
  533.         return structurewithOffset;
  534.     }

  536.     /**
  537.      * Figure out a reasonable width for a lane.
  538.      * @param laneAttributes LaneAttributes; the attributes of the lane
  539.      * @param link OSMLink; the link that owns the lane
  540.      * @param warningListener WarningListener; the warning listener that receives warning events
  541.      * @return double; the width (in meters) of the lane
  542.      */
  543.     static double laneWidth(final LaneAttributes laneAttributes, final OSMLink link,
  544.         final WarningListener warningListener)
  545.     {
  546.         Double defaultLaneWidth = 3.05d; // TODO This is the German standard car lane width
  547.         boolean widthOverride = false;
  548.         for (OSMTag tag : link.getTags())
  549.         {
  550.             if (tag.getKey().equals("width"))
  551.             {
  552.                 String w = tag.getValue().replace(",", ".");
  553.                 w = w.replace(" ", "");
  554.                 w = w.replace("m", "");
  555.                 w = w.replace("Meter", "");
  556.                 try
  557.                 {
  558.                     defaultLaneWidth = Double.parseDouble(w) / link.getLanes();
  559.                 }
  560.                 catch (NumberFormatException nfe)
  561.                 {
  562.                     System.err.println("Bad lanewidth: \"" + tag.getValue() + "\"");
  563.                 }
  564.                 widthOverride = true;
  565.             }
  566.         }
  567.         LaneType laneType = laneAttributes.getLaneType();
  568.         if (laneType.isCompatible(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.CAR))
  569.         {
  570.             return defaultLaneWidth;
  571.         }
  572.         else if (laneType.isCompatible(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BIKE))
  573.         {
  574.             return 0.8d; // TODO German default bikepath width
  575.         }
  576.         else if (laneType.isCompatible(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.PEDESTRIAN))
  577.         {
  578.             return 0.95d; // TODO German default footpath width
  579.         }
  580.         else if (laneType.isCompatible(org.opentrafficsim.road.network.factory.osm.PredefinedGTUTypes.BOAT))
  581.         {
  582.             for (OSMTag tag : link.getTags())
  583.             {
  584.                 if (tag.getKey().equals("waterway"))
  585.                 {
  586.                     switch (tag.getValue())
  587.                     {
  588.                         case "riverbank":
  589.                             return 1d;
  590.                         default:
  591.                             return defaultLaneWidth;
  592.                     }
  593.                 }
  594.                 else
  595.                 {
  596.                     return 5d;
  597.                 }
  598.             }
  599.         }
  600.         if (!widthOverride)
  601.         {
  602.             warningListener.warning(new WarningEvent(link, "No width given; using default laneWidth for Link "
  603.                 + link.getId()));
  604.         }
  605.         return defaultLaneWidth;
  606.     }

  608.     /**
  609.      * This method creates lanes out of an OSM link LaneTypes are not yet extensive and can be further increased through Tags
  610.      * provided by OSM. The standard lane width of 3.05 is an estimation based on the European width limitation for vehicles
  611.      * (2.55m) + 25cm each side.
  612.      * @param osmlink Link OSMLink; the OSM link to make lanes for
  613.      * @param simulator OTSDEVSSimulatorInterface; the simulator that will animate the generates lanes (if it happens to be an
  614.      *            instance of OTSAnimatorInterface)
  615.      * @param warningListener WarningListener; the warning listener that will receive warning events
  616.      * @return List&lt;Lane&gt;
  617.      * @throws NetworkException on network inconsistency
  618.      * @throws NamingException on naming problems (in the animator)
  619.      * @throws OTSGeometryException when lane contour or center line cannot be instantiated
  620.      */
  621.     public List<Lane> makeLanes(final OSMLink osmlink, final OTSDEVSSimulatorInterface simulator,
  622.         final WarningListener warningListener) throws NetworkException, NamingException, OTSGeometryException
  623.     {
  624.         CrossSectionLink otslink = convertLink(osmlink);
  625.         List<Lane> lanes = new ArrayList<Lane>();
  626.         Map<Double, LaneAttributes> structure = makeStructure(osmlink, warningListener);

  628.         int laneNum = 0;
  629.         for (Double offset : structure.keySet())
  630.         {
  631.             laneNum++;
  632.             LaneAttributes laneAttributes = structure.get(offset);
  633.             if (laneAttributes == null)
  634.             {
  635.                 break;
  636.             }
  637.             Color color = Color.LIGHT_GRAY;
  638.             LaneType laneType = laneAttributes.getLaneType();
  639.             Length.Rel latPos = new Length.Rel(offset, LengthUnit.METER);
  640.             Map<GTUType, LongitudinalDirectionality> directionality = new HashMap<>();
  641.             directionality.put(GTUType.ALL, laneAttributes.getDirectionality());
  642.             Map<GTUType, Speed> speedLimit = new HashMap<>();
  643.             speedLimit.put(GTUType.ALL, new Speed(100, SpeedUnit.KM_PER_HOUR));
  644.             Lane newLane = null;
  645.             // FIXME the following code assumes right-hand-side driving.
  646.             if (osmlink.hasTag("hasPreceding") && offset >= 0 || osmlink.hasTag("hasFollowing") && offset < 0)
  647.             {
  648.                 color = Color.RED;
  649.                 // FIXME overtaking conditions per country and/or type of road?
  650.                 newLane =
  651.                     new Lane(otslink, "lane." + laneNum, latPos, latPos, laneAttributes.getWidth(),
  652.                         laneAttributes.getWidth(), laneType, directionality, speedLimit,
  653.                         new OvertakingConditions.LeftAndRight());
  654.                 SinkSensor sensor = new SinkSensor(newLane, new Length.Rel(0.25, LengthUnit.METER), simulator);
  655.                 newLane.addSensor(sensor, GTUType.ALL);
  656.             }
  657.             else if (osmlink.hasTag("hasPreceding") && offset < 0 || osmlink.hasTag("hasFollowing") && offset >= 0)
  658.             {
  659.                 color = Color.BLUE;
  660.                 // FIXME overtaking conditions per country and/or type of road?
  661.                 newLane =
  662.                     new Lane(otslink, "lane." + laneNum, latPos, latPos, laneAttributes.getWidth(),
  663.                         laneAttributes.getWidth(), laneType, directionality, speedLimit,
  664.                         new OvertakingConditions.LeftAndRight());
  665.             }
  666.             else
  667.             {
  668.                 color = laneAttributes.getColor();
  669.                 // FIXME overtaking conditions per country and/or type of road?
  670.                 newLane =
  671.                     new Lane(otslink, "lane." + laneNum, latPos, latPos, laneAttributes.getWidth(),
  672.                         laneAttributes.getWidth(), laneType, directionality, speedLimit,
  673.                         new OvertakingConditions.LeftAndRight());
  674.             }
  675.             if (simulator instanceof OTSAnimatorInterface)
  676.             {
  677.                 try
  678.                 {
  679.                     new LaneAnimation(newLane, simulator, color, false);
  680.                 }
  681.                 catch (RemoteException exception)
  682.                 {
  683.                     exception.printStackTrace();
  684.                 }
  685.             }
  686.             lanes.add(newLane);
  687.         }
  688.         return lanes;
  689.     }

  691.     /**
  692.      * This method creates a LaneType which supports all GTUTypes that have been specified in the GTUType List "GTUs".
  693.      * @param gtuTypes List&lt;GTUType&lt;String&gt;&gt;; list of GTUTypes
  694.      * @return LaneType permeable for all of the specific GTUTypes
  695.      */
  696.     public static LaneType makeLaneType(final List<GTUType> gtuTypes)
  697.     {
  698.         StringBuilder name = new StringBuilder();
  699.         for (GTUType gtu : gtuTypes)
  700.         {
  701.             if (name.length() > 0)
  702.             {
  703.                 name.append("|");
  704.             }
  705.             name.append(gtu.getId());
  706.         }
  707.         LaneType result = new LaneType(name.toString());
  708.         for (GTUType gtu : gtuTypes)
  709.         {
  710.             result.addCompatibility(gtu);
  711.         }
  712.         return result;
  713.     }

  715.     /**
  716.      * This method creates a LaneType which supports the specified GTUType.
  717.      * @param gtuType GTUType; the type of GTU that can travel on the new LaneType
  718.      * @return LaneType
  719.      */
  720.     public static LaneType makeLaneType(final GTUType gtuType)
  721.     {
  722.         List<GTUType> gtuTypes = new ArrayList<GTUType>(1);
  723.         gtuTypes.add(gtuType);
  724.         return makeLaneType(gtuTypes);
  725.         // String name = gtuType.getId();
  726.         // LaneType result = new LaneType(name);
  727.         // result.addPermeability(gtuType);
  728.         // return result;
  729.     }

  731.     /**
  732.      * Identify Links that are sources or sinks.
  733.      * @param nodes List of Nodes
  734.      * @param links List of Links
  735.      * @return List of Links which are candidates for becoming sinks/sources.
  736.      */
  737.     private static ArrayList<OSMLink> findBoundaryLinks(final List<OSMNode> nodes, final List<OSMLink> links)
  738.     {
  739.         // TODO: test performance (memory- and time-wise) when the counters are replaced by ArrayList<OSMLink> which
  740.         // would obviate the need to do full searches over all Links to find OSMNodes that are source or sink.
  741.         // Reset the counters (should not be necessary unless this method is called more than once)
  742.         for (OSMNode node : nodes)
  743.         {
  744.             node.linksOriginating = 0;
  745.             node.linksTerminating = 0;
  746.         }
  747.         for (OSMLink link : links)
  748.         {
  749.             link.getStart().linksOriginating++;
  750.             link.getEnd().linksTerminating++;
  751.         }
  752.         ArrayList<OSMNode> foundEndNodes = new ArrayList<OSMNode>();
  753.         for (OSMNode node : nodes)
  754.         {
  755.             if (0 == node.linksOriginating && node.linksTerminating > 0 || 0 == node.linksTerminating
  756.                 && node.linksOriginating > 0)
  757.             {
  758.                 foundEndNodes.add(node);
  759.             }
  760.         }
  761.         ArrayList<OSMLink> result = new ArrayList<OSMLink>();
  762.         for (OSMLink link : links)
  763.         {
  764.             if (foundEndNodes.contains(link.getStart()) || foundEndNodes.contains(link.getEnd()))
  765.             {
  766.                 result.add(link);
  767.             }
  768.         }
  769.         return result;
  770.     }

  772.     /**
  773.      * @param net The OSM network which is to be searched for Sinks and Sources.
  774.      * @param progressListener ProgressListener; the progress listener that will receive progress events
  775.      * @return Network with all possible sinks and sources tagged.
  776.      */
  777.     public static OSMNetwork findSinksandSources(final OSMNetwork net, final ProgressListener progressListener)
  778.     {
  779.         progressListener.progress(new ProgressEvent(net, "Counting number of links at each node"));
  780.         List<OSMNode> nodes = new ArrayList<OSMNode>();
  781.         nodes.addAll(net.getNodes().values());
  782.         ArrayList<OSMLink> foundEndpoints = findBoundaryLinks(nodes, net.getLinks());
  783.         progressListener.progress(new ProgressEvent(net, "Adding tags to non-sinks and non-sources"));
  784.         int progress = 0;
  785.         final int progressReportStep = 5000;
  786.         // As tags are immutable we make ONE for following and ONE for preceding
  787.         final OSMTag hasFollowing = new OSMTag("hasFollowing", "");
  788.         final OSMTag hasPreceding = new OSMTag("hasPreceding", "");
  789.         for (OSMLink l : net.getLinks())
  790.         {
  791.             if (foundEndpoints.contains(l))
  792.             {
  793.                 if (net.hasFollowingLink(l))
  794.                 {
  795.                     l.addTag(hasFollowing);
  796.                 }
  797.                 else if (net.hasPrecedingLink(l))
  798.                 {
  799.                     l.addTag(hasPreceding);
  800.                 }
  801.             }
  802.             if (0 == ++progress % progressReportStep)
  803.             {
  804.                 progressListener.progress(new ProgressEvent(net, String.format(Locale.US,
  805.                     "%d of %d links processed (%.1f%%)", progress, net.getLinks().size(), 100.0 * progress
  806.                         / net.getLinks().size())));
  807.             }
  808.         }
  809.         progressListener.progress(new ProgressEvent(net, "Found " + foundEndpoints.size() + " Sinks and Sources."));
  810.         return net;
  811.     }
  812. }

  814. /**
  815.  * <p>
  816.  * Copyright (c) 2013-2015 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  817.  * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  818.  * <p>
  819.  * $LastChangedDate: 2015-09-16 19:20:07 +0200 (Wed, 16 Sep 2015) $, @version $Revision: 1405 $, by $Author: averbraeck $,
  820.  * initial version ar 3, 2015 <br>
  821.  * @author <a>Moritz Bergmann</a>
  822.  */
  823. class LaneAttributes
  824. {
  825.     /** Type of the lane (immutable). */
  826.     private final LaneType laneType;

  828.     /** Drawing color of the lane (immutable). */
  829.     private final Color color;

  831.     /** LongitudinalDirectionality of the lane (immutable). */
  832.     private final LongitudinalDirectionality directionality;

  834.     /** Width of the lane. */
  835.     private Length.Rel width;

  837.     /**
  838.      * @param lt - LaneType
  839.      * @param c - Color
  840.      * @param d - LongitudinalDIrectionality
  841.      */
  842.     public LaneAttributes(final LaneType lt, final Color c, final LongitudinalDirectionality d)
  843.     {
  844.         if (lt == null)
  845.         {
  846.             this.laneType = Convert.makeLaneType(GTUType.NONE);
  847.         }
  848.         else
  849.         {
  850.             this.laneType = lt;
  851.         }
  852.         this.color = c;
  853.         this.directionality = d;
  854.     }

  856.     /**
  857.      * @param laneType - LaneType
  858.      * @param color - Color
  859.      * @param directionality - LongitudinalDIrectionality
  860.      * @param width - width
  861.      */
  862.     public LaneAttributes(final LaneType laneType, final Color color, final LongitudinalDirectionality directionality,
  863.         final Double width)
  864.     {
  865.         if (laneType == null)
  866.         {
  867.             this.laneType = Convert.makeLaneType(GTUType.NONE);
  868.         }
  869.         else
  870.         {
  871.             this.laneType = laneType;
  872.         }
  873.         this.color = color;
  874.         this.directionality = directionality;
  875.         this.setWidth(width);
  876.     }

  878.     /**
  879.      * @return LaneType
  880.      */
  881.     public LaneType getLaneType()
  882.     {
  883.         return this.laneType;
  884.     }

  886.     /**
  887.      * @return Color
  888.      */
  889.     public Color getColor()
  890.     {
  891.         return this.color;
  892.     }

  894.     /**
  895.      * @return LongitudinalDirectionality
  896.      */
  897.     public LongitudinalDirectionality getDirectionality()
  898.     {
  899.         return this.directionality;
  900.     }

  902.     /**
  903.      * @return width.
  904.      */
  905.     public Length.Rel getWidth()
  906.     {
  907.         return this.width;
  908.     }

  910.     /**
  911.      * @param width set width.
  912.      */
  913.     public void setWidth(final Double width)
  914.     {
  915.         Length.Rel w = new Length.Rel(width, LengthUnit.METER);
  916.         this.width = w;
  917.     }

  919.     /** {@inheritDoc} */
  920.     public String toString()
  921.     {
  922.         return "Lane Attributes: " + this.laneType + "; " + this.color + "; " + this.directionality + "; " + this.width;
  923.     }

  925. }
Created with JaCoCo 0.7.5.201505241946