Data structure, standard creators, Nicaragua networks

README.md

@@ -18,12 +18,20 @@ caches on disk for efficient re-use. Then the data is combined with another
 source of schedule (time) information in order to create a GTFS file using the
 transitfeed library.
 
-**Attention:** The source code is currently very specific to Florianópolis Buses
-and Costa Rica Urban Train, but it can be extended to make it work for your use
-case. In the config file any transit network can be specified for download from
-OpenStreetMap. And by extending the creator classes in code, different
-approaches for time information handling can be easily implemented. You can help
-with pull requests to improve this script.
+For every new city a new [configuration file](https://github.com/grote/osm2gtfs/wiki/Configuration)
+needs to be created. Additionally, schedule information should be provided. By-default the schedule information is expected to be provided in a  [certain format](https://github.com/grote/osm2gtfs/wiki/Schedule). However other formats are supported through extending the code. For any city and schedule format the script can be easily extended, see the
+[developer documentation](https://github.com/grote/osm2gtfs/wiki/Development)
+for more information.
+
+Included cities
+-----------------
+
+* [Florianópolis, Brazil](./osm2gtfs/creators/fenix/fenix.json)
+* [Suburban trains in Costa Rica](./osm2gtfs/creators/incofer/incofer.json)
+* [Accra, Ghana](./osm2gtfs/creators/accra/accra.json)
+* [Managua, Ciudad Sandino](./osm2gtfs/creators/managua/managua.json) and [Estelí](./osm2gtfs/creators/esteli/esteli.json) in Nicaragua
+
+*Soon, also in your city*
 
 Install
 ------------

osm2gtfs/core/cache.py

@@ -50,7 +50,7 @@ def write_file(name, content):
         if not os.path.isdir('data'):
             os.mkdir('data')
         with open(os.path.join('data', name), 'wb') as f:
-            f.write(content.read())
+            f.write(content)
 
     @staticmethod
     def read_file(name):

osm2gtfs/core/configuration.py

@@ -51,7 +51,7 @@ def get_schedule_source(self, refresh=False):
 
         else:
             source_file = self.data['schedule_source']
-            cached_file = 'schedule-source-' + self.data['selector']
+            cached_file = self.data['selector'] + '-schedule'
 
             # Preferably return cached data about schedule
             if refresh is False:
@@ -81,11 +81,12 @@ def get_schedule_source(self, refresh=False):
                     sys.stderr.write(
                         "Error: Couldn't find schedule_source file.\n")
                     sys.exit(0)
-                schedule_source = schedule_source_file
+                schedule_source = schedule_source_file.read()
 
-        # Cache data
-        Cache.write_file(cached_file, schedule_source)
         self._schedule_source = schedule_source
+
+        # Cache data
+        Cache.write_file(cached_file, self._schedule_source)
         return self._schedule_source
 
     def _load_config(self, args):

osm2gtfs/core/elements.py

@@ -0,0 +1,186 @@
+# coding=utf-8
+
+import sys
+import attr
+
+
+@attr.s
+class Element(object):
+    """The basic data element.
+    Contains the common attributes all other data classes share.
+
+    """
+    osm_id = attr.ib()
+    osm_type = attr.ib()
+    osm_url = attr.ib()
+
+    tags = attr.ib()
+    name = attr.ib()
+
+
+@attr.s
+class Line(Element):
+    """A general public transport service Line.
+
+    It's a container of meta information and different Itinerary objects for
+    variants of the same service line.
+
+    In OpenStreetMap this is usually represented as "route_master" relation.
+    In GTFS this is usually represented as "route".
+
+    """
+    route_id = attr.ib()
+
+    route_type = attr.ib(default=None)
+    route_desc = attr.ib(default=None)
+    route_color = attr.ib(default="#FFFFFF")
+    route_text_color = attr.ib(default="#000000")
+
+    # Related route variants
+    _itineraries = attr.ib(default=attr.Factory(list))
+
+    def __attrs_post_init__(self):
+        '''
+        Populates the object with information obtained from the tags
+        '''
+        # pylint: disable=unsupported-membership-test,unsubscriptable-object
+        if 'colour' in self.tags:
+            self.route_color = self.tags['colour']
+
+        # pylint: disable=unsupported-membership-test,unsubscriptable-object
+        if 'route_master' in self.tags:
+            self.route_type = self.tags['route_master'].capitalize()
+        else:
+            sys.stderr.write(
+                "Warning: Route master relation without a route_master tag:\n")
+            sys.stderr.write(" " + self.osm_url + "\n")
+
+            # Try to guess the type differently
+            if 'route' in self.tags:
+                self.route_type = self.tags['route'].capitalize()
+            else:
+                self.route_type = "Bus"
+
+    def add_itinerary(self, itinerary):
+
+        if self.route_id != itinerary.route_id:
+            raise ValueError('Itinerary route ID (' +
+                             itinerary.route_id +
+                             ') does not match Line route ID (' +
+                             self.route_id + ')')
+        # pylint: disable=no-member
+        self._itineraries.append(itinerary)
+
+    def get_itineraries(self):
+        return self._itineraries
+
+
+@attr.s
+class Itinerary(Element):
+    """A public transport service itinerary.
+
+    It's a representation of a possible variant of a line, grouped together by
+    a Line object.
+
+    In OpenStreetMap this is usually represented as "route" relation.
+    In GTFS this is not exlicitly presented but used as base to create "trips"
+
+    """
+    route_id = attr.ib()
+    shape = attr.ib()
+
+    line = attr.ib(default=None)
+    fr = attr.ib(default=None)
+    to = attr.ib(default=None)
+    duration = attr.ib(default=None)
+
+    # All stop objects of itinerary
+    stops = attr.ib(default=attr.Factory(list))
+
+    def __attrs_post_init__(self):
+        '''
+        Populates the object with information obtained from the tags
+        '''
+        # pylint: disable=unsupported-membership-test,unsubscriptable-object
+        if 'from' in self.tags:
+            self.fr = self.tags['from']
+
+        # pylint: disable=unsupported-membership-test,unsubscriptable-object
+        if 'to' in self.tags:
+            self.to = self.tags['to']
+
+    def get_stops(self):
+        return self.stops
+
+
+@attr.s
+class Station(Element):
+    """A public transport stop of the type station.
+
+    It's a representation of a possible group of stops.
+
+    In OpenStreetMap this is usually represented as "stop_area" relation.
+    In GTFS it is handled as a stop with a location_type=1. Regular Stops with
+    location_type=0 might specify a station as parent_station.
+
+    """
+    lat = attr.ib()
+    lon = attr.ib()
+
+    stop_id = attr.ib(default="")
+    location_type = attr.ib(default=1)
+
+    # Stops forming part of this Station
+    _members = attr.ib(default=attr.Factory(list))
+
+    def set_members(self, members):
+        self._members = members
+
+    def get_members(self):
+        return self._members
+
+    def get_stop_id(self):
+        return self.stop_id
+
+    def set_stop_id(self, stop_id):
+        self.stop_id = stop_id
+
+
+@attr.s
+class Stop(Element):
+    """A public transport stop.
+
+    In OpenStreetMap this is usually represented as an object of the role
+    "plattform" in the route.
+
+    """
+    lat = attr.ib()
+    lon = attr.ib()
+
+    stop_id = attr.ib("")
+    location_type = attr.ib(default=0)
+
+    # The id of the Station this Stop might be part of.
+    _parent_station = attr.ib(default=None)
+
+    def set_parent_station(self, identifier, override=False):
+        """
+        Set the parent_station_id on the first time;
+        Second attempts throw a warning
+        """
+        if self._parent_station is None or override is True:
+            self._parent_station = identifier
+        else:
+            sys.stderr.write("Warning: Stop is part of two stop areas:\n")
+            sys.stderr.write(
+                "https://osm.org/" + self.osm_type + "/" + str(
+                    self.osm_id) + "\n")
+
+    def get_parent_station(self):
+        return self._parent_station
+
+    def get_stop_id(self):
+        return self.stop_id
+
+    def set_stop_id(self, stop_id):
+        self.stop_id = stop_id

osm2gtfs/core/helper.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+
+import sys
+from math import cos, sin, atan2, sqrt, radians, degrees
+
+
+class Helper(object):
+    """The Helper class contains useful static functions
+
+    """
+
+    @staticmethod
+    def print_shape_for_leaflet(shape):
+        print "var shape = [",
+        i = 0
+        for node in shape:
+            print "new L.LatLng(" + str(node["lat"]) + ", " + str(node["lon"]) + ")",
+            if i != len(shape) - 1:
+                print ",",
+            i += 1
+        print "];"
+        i = 0
+        for node in shape:
+            print "L.marker([" + str(node["lat"]) + ", " + str(node["lon"]) + "]).addTo(map)"
+            print "    .bindPopup(\"" + str(i) + "\").openPopup();"
+            i += 1
+
+    @staticmethod
+    def get_center_of_nodes(nodes):
+        """Helper function to get center coordinates of a group of nodes
+
+        """
+        x = 0
+        y = 0
+        z = 0
+
+        if len(nodes) < 1:
+            sys.stderr.write("Cannot find the center of zero nodes\n")
+        for node in nodes:
+            lat = radians(float(node.lat))
+            lon = radians(float(node.lon))
+
+            x += cos(lat) * cos(lon)
+            y += cos(lat) * sin(lon)
+            z += sin(lat)
+
+        x = float(x / len(nodes))
+        y = float(y / len(nodes))
+        z = float(z / len(nodes))
+
+        center_lat = degrees(atan2(z, sqrt(x * x + y * y)))
+        center_lon = degrees(atan2(y, x))
+
+        return center_lat, center_lon
+
+    @staticmethod
+    def interpolate_stop_times(trip):
+        """
+        Interpolate stop_times, because Navitia does not handle this itself
+        """
+        try:
+            for secs, stop_time, is_timepoint in trip.GetTimeInterpolatedStops():
+                if not is_timepoint:
+                    stop_time.arrival_secs = secs
+                    stop_time.departure_secs = secs
+                    trip.ReplaceStopTimeObject(stop_time)
+        except ValueError as e:
+            print(e)