Пример #1
0
station_labels = npz['station_labels']
matrix         = npz['matrix'].astype(np.int32)

station_idx = dict( zip(station_labels, range(len(station_labels))) )

origins = list(station_labels)
destinations = origins[:] # copy 1 level

random.shuffle(origins)
random.shuffle(destinations)

pairs = zip(origins, destinations)
errors = []

for o, d in pairs : 
    og = gtfsdb.stop(o[4:])
    dg = gtfsdb.stop(d[4:])
    #print 'Origin (mds, gtfs)'
    #print o, og
    #print 'Destination (mds, gtfs)'
    #print d, dg
    print 'from %s to %s (%f, %f) -> (%f, %f)' % (og[1], dg[1], og[2], og[3], dg[2], dg[3])

    tm = matrix[station_idx[o], station_idx[d]] / 60.
    
    from_str = '%f,%f' % (og[2], og[3])
    to_str   = '%f,%f' % (dg[2], dg[3])
    conn = httplib.HTTPConnection('developer.trimet.org')
    conn.request("GET", URL_FORMAT % (from_str, to_str, TRIP_DATE, TRIP_TIME) )
    r1 = conn.getresponse()
    #print r1.status, r1.reason
Пример #2
0
class MakeMatrixThread(QtCore.QThread):
    def __init__(self, parent=None):
        QtCore.QThread.__init__(self, parent)
        self.exiting = False

    def makeMatrix(self, gtfsdb, gdb):
        self.gtfsdb = str(gtfsdb)
        self.gdb = str(gdb)
        self.start()

    def run(self):
        self.gtfsdb = GTFSDatabase(self.gtfsdb)
        self.gdb = GraphDatabase(self.gdb)
        # Calculate an origin-destination matrix for the graph's stations
        print "Loading Graphserver DB..."
        self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Loading SQLite Graphserver graph..."))
        g = self.gdb.incarnate()

        # Set up distance-preserving projection system
        # Make a grid over the study area and save its geographic coordinates
        MARGIN = 8000  # meters beyond all stations, diagonally
        min_lon, min_lat, max_lon, max_lat = self.gtfsdb.extent()
        geod = pyproj.Geod(ellps="WGS84")
        min_lon, min_lat, arc_dist = geod.fwd(min_lon, min_lat, 180 + 45, MARGIN)
        max_lon, max_lat, arc_dist = geod.fwd(max_lon, max_lat, 45, MARGIN)
        proj = pyproj.Proj(proj="sinu", ellps="WGS84")
        min_x, min_y = proj(min_lon, min_lat)
        proj = pyproj.Proj(
            proj="sinu", ellps="WGS84", lon_0=min_lon, y_0=-min_y
        )  # why doesn't m parameter work for scaling by 100?
        grid_dim = array(proj(max_lon, max_lat), dtype=int32) / 100
        max_x, max_y = grid_dim
        print "\nMaking grid with dimesions: ", max_x, max_y
        self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Making %i by %i grid..." % (max_x, max_y)))
        # later, use reshape/flat to switch between 1d and 2d array representation
        grid_latlon = empty((max_x, max_y, 2), dtype=float32)
        for y in range(0, max_y):
            self.emit(QtCore.SIGNAL("progress(int, int)"), y, max_y)
            for x in range(0, max_x):
                # inverse project meters to lat/lon
                grid_latlon[x, y] = proj(x * 100, y * 100, inverse=True)

        station_vertices = [v for v in g.vertices if v.label[0:4] == "sta-"]
        station_labels = [v.label for v in station_vertices]
        n_stations = len(station_vertices)
        print "Finding station coordinates..."
        self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Projecting station coordinates..."))
        station_coords = empty((n_stations, 2), dtype=float32)
        for i, label in enumerate(station_labels):
            stop_id, stop_name, lat, lon = self.gtfsdb.stop(label[4:])
            station_coords[i] = proj(lon, lat)
            if i % 20 == 0:
                self.emit(QtCore.SIGNAL("progress(int, int)"), i, n_stations)
        station_coords /= 100

        # ELIMINATE STATIONS WITH SAME INTEGRAL COORDINATES
        # self.emit( QtCore.SIGNAL( 'say(QString)' ), QtCore.QString( 'Eliminating equivalent stations...'  ) )
        # while len(station_coords) > 0 :
        #    coord =
        #    mask = station_coords != station_coords[i]
        #    station_coords = station_coords[mask]
        # newer version follows
        # self.emit( QtCore.SIGNAL( 'say(QString)' ), QtCore.QString( 'Eliminating equivalent stations...' ) )
        # station_labels = np.array(station_labels)
        # station_coords_new = []
        # station_labels_new = []
        # while len(station_coords) > 0 :
        #    coord = np.round(station_coords[0])
        #    minIdx = np.argmin(np.sum(np.abs(station_coords - coord), axis=1))
        #    station_labels_new.append(station_labels[minIdx])
        #    station_coords_new.append(station_coords[minIdx])
        #    mask = np.any(np.round(station_coords) != coord, axis=1)
        #    #print mask
        #    #print len(station_coords)
        #    #print coord
        #    #print station_coords[np.logical_not(mask)]
        #    station_coords = station_coords[mask][:]
        #    station_labels = station_labels[mask][:]
        #    self.emit( QtCore.SIGNAL( 'progress(int, int)' ), n_stations - len(station_coords_new), n_stations )
        #
        # station_labels = station_labels_new
        # station_coords = station_coords_new
        # station_vertices = [g.get_vertex(slabel) for slabel in station_labels_new]
        # n_stations = len(station_labels)
        # print len(station_labels), len(station_coords), len(station_vertices)

        print "Making OD matrix..."
        os.environ["TZ"] = "US/Pacific"
        time.tzset()
        t0s = "Tue Mar 09 08:00:00 2010"
        t0t = time.strptime(t0s)
        d0s = time.strftime("%a %b %d %Y", t0t)
        t0 = int(time.mktime(t0t))
        print "search date: ", d0s
        print "search time: ", time.ctime(t0), t0

        wo = WalkOptions()
        wo.max_walk = 20000
        wo.walking_overage = 0.1
        wo.walking_speed = 1  # trimet uses 0.03 miles / 1 minute
        wo.transfer_penalty = 60 * 10
        wo.walking_reluctance = 2
        wo.max_transfers = 40
        wo.transfer_slack = 60 * 4

        matrix = zeros(
            (n_stations, n_stations), dtype=float
        )  # dtype could be uint16 except that there are inf's ---- why?
        colortable = [QtGui.QColor(i, i, i).rgb() for i in range(256)]
        colortable[254] = QtGui.QColor(050, 128, 050).rgb()
        colortable[255] = QtGui.QColor(255, 050, 050).rgb()
        matrixImage = QtGui.QImage(max_x, max_y, QtGui.QImage.Format_Indexed8)
        matrixImage.fill(0)
        matrixImage.setColorTable(colortable)
        for origin_idx in range(n_stations):
            sys.stdout.write("\rProcessing %i / %i ..." % (origin_idx, n_stations))
            sys.stdout.flush()
            self.emit(
                QtCore.SIGNAL("say(QString)"),
                QtCore.QString("Making OD matrix (station %i/%i)..." % (origin_idx, n_stations)),
            )
            self.emit(QtCore.SIGNAL("progress(int, int)"), origin_idx, n_stations)

            origin_label = station_labels[origin_idx]
            # g.spt_in_place(origin_label, None, State(1, t0), wo)
            spt = g.shortest_path_tree(origin_label, None, State(1, t0), wo)
            for dest_idx in range(n_stations):
                dest_label = station_labels[dest_idx]
                dest_vertex = spt.get_vertex(dest_label)
                # first board time should be subtracted here
                # if dest_vertex.payload is None :
                if dest_vertex is None:
                    print "Unreachable vertex. Set to infinity.", dest_idx, dest_label
                    delta_t = inf
                else:
                    # delta_t = dest_vertex.best_state.time - t0
                    bs = dest_vertex.best_state
                    delta_t = bs.time - t0 - bs.initial_wait
                if delta_t < 0:
                    print "Negative trip time; set to 0."
                    delta_t = 0

                matrix[origin_idx, dest_idx] = delta_t

                # sys.stdout.write( '%i %i\n' % (delta_t, dest_vertex.payload.initial_wait) )
                # sys.stdout.flush()
                # time.sleep(0.5)

                if dest_idx == origin_idx - 1:
                    color = 254
                elif dest_idx == origin_idx:
                    color = 255
                else:
                    color = 253 - delta_t * 3 / 60
                    if color < 0:
                        color = 0
                coord = station_coords[dest_idx]
                x = coord[0]
                y = coord[1]
                if color >= 254:
                    for x2 in range(x - 1, x + 2):
                        for y2 in range(y - 1, y + 2):
                            matrixImage.setPixel(x2, y2, color)
                else:
                    matrixImage.setPixel(x, y, color)

            self.emit(QtCore.SIGNAL("display(QImage)"), matrixImage)
            spt.destroy()
            # time.sleep(1)

        print x * y, "points, done."

        self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Saving as gzipped numpy ndarrays..."))

        savez(
            "od_matrix.npz",
            station_labels=station_labels,
            station_coords=station_coords,
            grid_dim=grid_dim,
            grid_latlon=grid_latlon,
            matrix=matrix,
        )
Пример #3
0
r = np.load('results/pdx-5d-1000i/result.npy')

station_idx = dict( zip(station_labels, range(len(station_labels))) )

origins = list(zip(station_labels, np.round(station_coords).astype(np.int32)))
destinations = origins[:] # copy 1 level

random.shuffle(origins)
random.shuffle(destinations)

pairs = zip(origins, destinations)
errors = []

for o, d in pairs : 
    og = gtfsdb.stop(o[0][4:])
    dg = gtfsdb.stop(d[0][4:])
    #print 'Origin (mds, gtfs)'
    #print o, og
    #print 'Destination (mds, gtfs)'
    #print d, dg
    print 'from %s to %s (%f, %f) -> (%f, %f)' % (og[1], dg[1], og[2], og[3], dg[2], dg[3])

    p1 = r[ o[1][0], o[1][1] ]
    p2 = r[ d[1][0], d[1][1] ]
    vec = p1 - p2
    tmds = np.sqrt(np.sum(vec ** 2)) / 60
    
    tmat = matrix[ station_idx[ o[0] ], station_idx[ d[0] ] ] / 60.

    llo = (og[2], og[3])
Пример #4
0
pairs = zip(origins, destinations)[:SAMPLE_SIZE]

wo = WalkOptions() 
wo.max_walk = 2000 
wo.walking_overage = 0.0
wo.walking_speed = 1.0 # trimet uses 0.03 miles / 1 minute - but it uses straight line distance as well
wo.transfer_penalty = 60 * 10
wo.walking_reluctance = 1.5
wo.max_transfers = 5
wo.transfer_slack = 60 * 4

residuals  = []
magnitudes = []
normalize = 0
for o, d in pairs : 
    og = gtfsdb.stop(o)
    dg = gtfsdb.stop(d)
    #print 'Origin (mds, gtfs)'
    #print o, og
    #print 'Destination (mds, gtfs)'
    #print d, dg
    print 'from %s to %s (%f, %f) -> (%f, %f)' % (og[0], dg[0], og[2], og[3], dg[2], dg[3])

    #replace
    spt = g.shortest_path_tree( 'sta-' + o, 'sta-' + d, State(1, t0), wo )
    try:
        vp = spt.get_vertex( 'sta-' + d ).best_state
    except:
        print 'Graphserver search failed.'
        continue