tidytransit

https://r-transit.github.io/tidytransit/
Admin
Tidytransit is an R package for analyzing General Transit Feed Specification (GTFS) data, enabling...
Tokens:21,200
Snippets:142
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install tidytransit Package

Source: https://r-transit.github.io/tidytransit/articles/introduction

Provides R code for installing the tidytransit package, including instructions for installing from CRAN and the development version from GitHub. It highlights the dependency on the 'sf' package.

```r
# Once sf is installed, you can install from CRAN with: 
install.packages("tidytransit")

# For the development version from Github:
# install.packages("devtools")
devtools::install_github("r-transit/tidytransit")
```

--------------------------------

### List Available GTFS Tables

Source: https://r-transit.github.io/tidytransit/articles/introduction

Demonstrates how to get a list of all tables read from the GTFS feed by using the `names` function on the GTFS object. This helps in understanding the available data components within the feed.

```r
names(nyc)
```

--------------------------------

### Example: Calculating and visualizing shortest travel times with tidytransit

Source: https://r-transit.github.io/tidytransit/reference/raptor

This example demonstrates how to use the raptor() function to calculate travel times in the NYC subway system. It includes filtering stop times for a specific date and time range, calculating journeys departing from specified stops, incorporating initial walk times, and then determining and visualizing the shortest travel times to all reachable stops. It utilizes data.table for efficient data manipulation.

```r
# Load necessary libraries
# library(tidytransit)
# library(data.table)

# Load GTFS data for NYC subway
nyc_path <- system.file("extdata", "nyc_subway.zip", package = "tidytransit")
nyc <- read_gtfs(nyc_path)

# Define sets of stop IDs (e.g., for Harlem St and 155 St stations)
stop_ids_harlem_st <- c("301", "301N", "301S")
stop_ids_155_st <- c("A11", "A11N", "A11S", "D12", "D12N", "D12S")

# Define initial walk times to these stops (in seconds)
walk_times <- data.frame(stop_id = c(stop_ids_harlem_st, stop_ids_155_st),
                         walk_time = c(rep(600, 3), rep(410, 6)), stringsAsFactors = FALSE)

# Filter stop_times for a specific date and departure time window (7 AM to 9 AM)
stop_times <- filter_stop_times(nyc, "2018-06-26", 7*3600, 9*3600)

# Calculate all journeys departing from Harlem St or 155 St between 7:00 and 7:30 (1800 seconds)
rptr <- raptor(stop_times, nyc$transfers, walk_times$stop_id, time_range = 1800,
               keep = "all")

# Add initial walk times to the calculated travel times
rptr <- merge(rptr, walk_times, by.x = "from_stop_id", by.y = "stop_id")
rptr$travel_time_incl_walk <- rptr$travel_time + rptr$walk_time

# Determine the shortest travel time (including walk time) to each destination stop_id
library(data.table)
sht <- setDT(rptr)[order(travel_time_incl_walk)][, .SD[1], by = "to_stop_id"]

# Visualize the distribution of shortest travel times (excluding walk time)
hist(sht$travel_time, breaks = seq(0,2*60)*60)

```

--------------------------------

### Select and Display Departure Information in R

Source: https://r-transit.github.io/tidytransit/articles/timetable

This R code example selects specific columns from the departures data frame, filters for the first few entries using head(), and then formats them as a kable table for display. It helps in visualizing the structure of the departure data.

```r
departures %>%
  select(arrival_time,
         departure_time,
         trip_headsign,trip_origin,
         route_id) %>%
  head() %>%
  knitr::kable()
```

--------------------------------

### Read GTFS Feed into R

Source: https://r-transit.github.io/tidytransit/articles/introduction

Demonstrates how to read a GTFS feed into an R object using the `read_gtfs` function from the tidytransit package. It shows reading from a local file path (using an example feed within the package) and includes commented-out code for reading from a remote URL.

```r
# nyc <- read_gtfs("http://web.mta.info/developers/data/nyct/subway/google_transit.zip")

local_gtfs_path <- system.file("extdata", 
                               "nyc_subway.zip", 
                               package = "tidytransit")
nyc <- read_gtfs(local_gtfs_path)
```

--------------------------------

### Join Departure and Trip Information - R

Source: https://r-transit.github.io/tidytransit/articles/timetable

Combines departure time information with trip details for a selected stop. It joins the previously identified stop_ids with gtfs$stop_times to get departure times, and then with gtfs$trips to retrieve route, service, headsign, and origin information.

```r
departures <- stop_ids %>%
  inner_join(gtfs$stop_times %>%
               select(trip_id, arrival_time,
                      departure_time, stop_id),
             by = "stop_id")

departures <- departures %>%
  left_join(gtfs$trips %>%
              select(trip_id, route_id,
                     service_id, trip_headsign,
                     trip_origin),
            by = "trip_id")
```

--------------------------------

### Access GTFS Stops Table

Source: https://r-transit.github.io/tidytransit/articles/introduction

Illustrates how to access individual tables within the GTFS feed object. This example specifically shows how to view the first few rows of the 'stops' table using `head(nyc$stops)`, displaying columns like stop ID, name, latitude, and longitude.

```r
head(nyc$stops)
```

--------------------------------

### Display Filtered Departures within Time Range in R

Source: https://r-transit.github.io/tidytransit/articles/timetable

This R code example displays departure information for a specific date, filtered to show only departures between 7:00 AM and 7:10 AM. It arranges the data and uses kable() for formatted output.

```r
departures_180823 %>%
  arrange(departure_time, stop_id, route_short_name) %>%
  select(departure_time, stop_id, route_short_name, trip_headsign) %>%
  filter(departure_time >= hms::hms(hours = 7)) %>%
  filter(departure_time < hms::hms(hours = 7, minutes = 10)) %>%
  knitr::kable()
```

--------------------------------

### Visualize Travel Times on a Map (R)

Source: https://r-transit.github.io/tidytransit/reference/travel_times

Generates a scatter plot displaying the geographical locations of transit stops, with points colored according to their travel time from a starting point. This provides a basic visualization of travel time distribution across the transit network. It requires the 'ggplot2' R package.

```r
library(ggplot2)
ggplot(tts) + geom_point(aes(x=to_stop_lon, y=to_stop_lat, color = travel_time))
```

--------------------------------

### Get Route Geometry in R

Source: https://r-transit.github.io/tidytransit/reference/get_route_geometry

Retrieves all trip shapes for a given route and service from a GTFS object. It takes a tidytransit GTFS object with sf data frames as input and returns an sf dataframe containing linestrings for each trip. Optional arguments allow filtering by route_ids and service_ids.

```R
get_route_geometry(gtfs_sf_obj, route_ids = NULL, service_ids = NULL)

data(gtfs_duke)
gtfs_duke_sf <- gtfs_as_sf(gtfs_duke)
routes_sf <- get_route_geometry(gtfs_duke_sf)
plot(routes_sf[c(1,1350),])
```

--------------------------------

### Calculate Stop Frequency and Headways (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Calculates the frequency of stops and average headways for specified service IDs within a given time range. It takes GTFS data, start and end times, and service IDs as input, returning a data frame summarized by route. This is a foundational step for analyzing transit performance.

```R
am_stop_freq <- get_stop_frequency(gtfs, start_time = 6*3600, end_time = 10*3600, 
                                   service_ids = service_ids, by_route = TRUE)
```

--------------------------------

### Example GTFS Validation in R

Source: https://r-transit.github.io/tidytransit/reference/validate_gtfs

Demonstrates how to use the validate_gtfs function with a sample GTFS object. It shows how to access validation results stored as an attribute and how removing files like 'shapes' or 'stop_times' from the GTFS object can trigger validation warnings.

```r
local_gtfs_path <- system.file("extdata", "nyc_subway.zip", package = "tidytransit")
gtfs <- read_gtfs(local_gtfs_path)
attr(gtfs, "validation_result")

gtfs$shapes <- NULL
validation_result <- validate_gtfs(gtfs)

# should raise a warning
gtfs$stop_times <- NULL
validation_result <- validate_gtfs(gtfs)
```

--------------------------------

### Get Trip Shapes from GTFS Data (R)

Source: https://r-transit.github.io/tidytransit/reference/get_trip_geometry

Retrieves all trip shapes for specified trip IDs from a GTFS object converted to an sf dataframe. It requires the tidytransit package and an sf-formatted GTFS object. The output is an sf dataframe containing linestrings for each requested trip.

```R
get_trip_geometry <- function(gtfs_sf_obj, trip_ids) {
  # Function body would go here
}

data(gtfs_duke)
gtfs_duke <- gtfs_as_sf(gtfs_duke)
trips_sf <- get_trip_geometry(gtfs_duke, c("t_726295_b_19493_tn_41", "t_726295_b_19493_tn_40"))
plot(trips_sf[1,"shape_id"])
```

--------------------------------

### Calculate minimal travel times between transit stops using R

Source: https://r-transit.github.io/tidytransit/reference/raptor

The raptor() function computes the minimum travel time, earliest arrival, or latest arrival time for all reachable stops from a given set of starting stops within a specified time range. It utilizes a modified RAPTOR algorithm and requires prepared stop_times and transfers data from a GTFS feed. The function can optionally include walk times and filter results based on the number of transfers or desired journey type (shortest, earliest, latest).

```r
raptor(
  stop_times,
  transfers,
  stop_ids,
  arrival = FALSE,
  time_range = 3600,
  max_transfers = NULL,
  keep = "all"
)
```

--------------------------------

### Summarize GTFS Feed Object

Source: https://r-transit.github.io/tidytransit/articles/introduction

Shows how to use the `summary` function on a `tidygtfs` object created by `read_gtfs`. The output provides a concise overview of the GTFS feed, including agency, service dates, and counts of routes, trips, and stops.

```r
summary(nyc)
```

--------------------------------

### Get Stop IDs by Name - R

Source: https://r-transit.github.io/tidytransit/articles/timetable

Filters the gtfs$stops data frame to retrieve the stop_id(s) corresponding to a specific stop name, such as 'Times Sq - 42 St'. This is a prerequisite for finding departures from a named location.

```r
stop_ids <- gtfs$stops %>%
  filter(stop_name == "Times Sq - 42 St") %>%
  select(stop_id)
```

--------------------------------

### Download and Read MobilityData CSV in R

Source: https://r-transit.github.io/tidytransit/articles/introduction

This code snippet downloads the MobilityData.org CSV file containing GTFS feed sources and reads it into an R data frame. It utilizes the `read.csv` function for direct download and parsing. No specific dependencies are mentioned beyond base R.

```r
mbd_url = "https://storage.googleapis.com/storage/v1/b/mdb-csv/o/sources.csv?alt=media"
MobilityData.csv = read.csv(mbd_url)
```

--------------------------------

### Visualize Bounding Boxes on Interactive Map with Leaflet

Source: https://r-transit.github.io/tidytransit/articles/introduction

This R code snippet uses the `leaflet` package to create an interactive map displaying bounding box polygons. It initializes a leaflet map with a CartoDB Positron base tile layer and then adds the `MobilityData_sf` spatial data as polygons. The polygons are styled with a weight of 2 and reduced fill opacity, with labels showing the truncated provider names.

```r
library(leaflet)
leaflet() %>%
  addProviderTiles(provider = providers$CartoDB.Positron) %>%
  addPolygons(data = MobilityData_sf, weight = 2,
              fillOpacity = 0.1, label = substr(MobilityData_sf$provider, 0, 60))
```

--------------------------------

### Summarize GTFS Service Patterns

Source: https://r-transit.github.io/tidytransit/articles/frequency

This R code summarizes various aspects of GTFS service patterns, including the number of trips, distinct routes, total daily distance per service pattern in kilometers, average route distance per service pattern, and the number of stops. It joins data from trips, service patterns, shape lengths, and stop times, then groups by service pattern ID for aggregation. The output is a summary table of service pattern statistics.

```r
service_pattern_summary <- gtfs$trips %>%
  left_join(gtfs$.$servicepatterns, by="service_id") %>%
  left_join(shape_lengths, by="shape_id") %>%
  left_join(gtfs$stop_times, by="trip_id") %>%
  group_by(servicepattern_id) %>%
  summarise(
    trips = n(),
    routes = n_distinct(route_id),
    total_distance_per_day_km = sum(as.numeric(length), na.rm=TRUE)/1e3,
    route_avg_distance_km = (sum(as.numeric(length), na.rm=TRUE)/1e3)/(trips*routes),
    stops=(n_distinct(stop_id)/2))
```

--------------------------------

### Import GTFS Data (URL) - R

Source: https://r-transit.github.io/tidytransit/articles/frequency

Imports GTFS schedule data directly from a URL. This function uses `read_gtfs` from the tidytransit package to fetch and parse the data. It requires a valid URL pointing to a GTFS zip file. Note that some feeds may be large or incomplete.

```r
# gtfs <- read_gtfs("http://web.mta.info/developers/data/nyct/subway/google_transit.zip")
```

--------------------------------

### Plot All Departures with Route Colors (R)

Source: https://r-transit.github.io/tidytransit/articles/timetable

Generates a scatter plot of all departures from a specified location, differentiating routes by color. It first extracts and formats route colors from the GTFS feed and then uses ggplot2 to visualize departures, with custom time axis labels and legend positioning. Dependencies include dplyr and scales packages.

```r
route_colors <- gtfs$routes %>% select(route_id, route_short_name, route_color)
route_colors$route_color[which(route_colors$route_color == "")] <- "454545"
route_colors <- setNames(paste0("#", route_colors$route_color), route_colors$route_short_name)

ggplot(departures_180823) + theme_bw() +
  geom_point(aes(y=trip_headsign, x=departure_time, color = route_short_name), size = 0.2) +
  scale_x_time(breaks = seq(0, max(as.numeric(departures$departure_time)), 3600), 
               labels = scales::time_format("%H:%M")) +
  theme(axis.text.x = element_text(angle = 90, hjust = 1)) +
  theme(legend.position = "bottom") +
  scale_color_manual(values = route_colors) +
  labs(title = "Departures from Times Square on 08/23/18")
```

--------------------------------

### Get Route Geometries with TidyTransit

Source: https://r-transit.github.io/tidytransit/articles/frequency

Retrieves the geometric shapes (routes) for specified service IDs from a GTFS object. This function, `get_route_geometry`, requires the GTFS object to contain shape data as simple feature data frames. The output is a simple features data frame containing route geometries.

```r
# get_route_geometry needs a gtfs object that includes shapes as simple feature data frames
routes_sf <- get_route_geometry(gtfs, service_ids = service_ids)
```

--------------------------------

### Print Service Pattern Summary Table

Source: https://r-transit.github.io/tidytransit/articles/frequency

This R code uses the `knitr::kable()` function to display the `service_pattern_summary` data frame in a formatted table. This is useful for visually inspecting the aggregated service pattern statistics. The input is the `service_pattern_summary` data frame, and the output is a rendered table.

```r
knitr::kable(service_pattern_summary)
```

--------------------------------

### View GTFS Dates and Services in R

Source: https://r-transit.github.io/tidytransit/articles/timetable

This R code snippet displays the first few rows of the 'dates_services' data frame from the GTFS object. This data frame maps dates to service IDs, crucial for filtering transit services by day.

```r
head(gtfs$.$dates_services)
```

--------------------------------

### Read GTFS Feed Directly into R

Source: https://r-transit.github.io/tidytransit/articles/introduction

This code snippet demonstrates how to download and read a GTFS (General Transit Feed Specification) feed directly into R using the `read_gtfs` function. It first filters a MobilityData feedlist to find a specific provider and then extracts the direct download URL before passing it to the reading function. This is useful for accessing real-time or updated transit data.

```r
gtfs_path_goldengate <- MobilityData_feedlist %>%
  filter(provider == "Golden Gate Transit") %>%
  pull(urls.direct_download)

gtfs_goldengate = read_gtfs(gtfs_path_goldengate)
```

--------------------------------

### Read GTFS Data - R

Source: https://r-transit.github.io/tidytransit/articles/timetable

Reads GTFS (General Transit Feed Specification) data into an R environment using the read_gtfs function from the tidytransit package. It can read data from a local zip file or a remote URL. Dependencies include the tidytransit package.

```r
local_gtfs_path <- system.file("extdata", "nyc_subway.zip", package = "tidytransit")
gtfs <- read_gtfs(local_gtfs_path)
# gtfs <- read_gtfs("http://web.mta.info/developers/data/nyct/subway/google_transit.zip")
```

--------------------------------

### Map Route Lines with Transparent Borders (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code renders a map of the buffered route lines using `ggplot2`. It sets the fill color to a semi-transparent red and makes the borders of the route lines transparent. The `theme_bw()` function applies a black and white theme to the plot. This visualization helps to show the density of routes.

```r
routes_sf_buffer %>%
  ggplot() + 
  geom_sf(colour = alpha("white", 0), fill = alpha("red",0.2)) + 
  theme_bw()

```

--------------------------------

### Map Routes and Stops by Departure Frequency (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code combines visualizations of route line density and stop departure frequency on a single map using `ggplot2`. It plots semi-transparent red route buffers and points for stops, with point size representing total departures. It uses `theme_bw()` and hides the legend for clarity. This provides a comprehensive view of transit service intensity.

```r
ggplot() + 
  geom_sf(data = routes_sf_buffer, 
          colour = alpha("white",0), fill = alpha("red",0.3)) + 
  geom_sf(data = am_stop_name_departures, 
          aes(size = total_departures), shape=1) + 
  labs(size = "Departures (Hundreds)") + 
  theme_bw() + 
  theme(legend.position="none") + 
  ggtitle("NYC MTA - Relative Departures by Route and Stop (AM)")

```

--------------------------------

### Import GTFS Data (Local Path) - R

Source: https://r-transit.github.io/tidytransit/articles/frequency

Reads GTFS schedule data from a local zip file path. It utilizes the `read_gtfs` function from the tidytransit package. The input is a file path to a GTFS zip archive, and the output is a GTFS object suitable for further analysis.

```r
local_gtfs_path <- system.file("extdata", "nyc_subway.zip", package = "tidytransit")
gtfs <- read_gtfs(local_gtfs_path)
```

--------------------------------

### Generate and Print Service Pattern Names Table

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Applies the `suggest_servicepattern_name` function to all service patterns in the GTFS data and prints a tibble containing service pattern IDs and their automatically generated names. This utilizes `dplyr` for grouping and summarization.

```r
servicepattern_names = gtfs$.$dates_servicepatterns %>%
  group_by(servicepattern_id) %>%
  summarise(
    servicepattern_name = suggest_serviceservicepattern_name(date, calendar)
  )

print(servicepattern_names)
```

--------------------------------

### Buffer Route Lines by Departure Frequency (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code snippet creates a buffer around route lines, with the buffer distance scaled by the total number of departures. This is used to visually represent the frequency of service along each route on a map. It requires the `sf` package for spatial operations.

```r
routes_sf_buffer <- st_buffer(routes_sf,
                              dist = routes_sf$total_departures/1e6)

```

--------------------------------

### Summarize Headway Statistics (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Calculates and displays summary statistics (minimum, 1st quartile, median, mean, 3rd quartile, maximum) for the average headways of a specific route. This provides a concise overview of the headway distribution along the route.

```R
summary(one_line_stops$mean_headway)
```

--------------------------------

### Plot Service Patterns as Calendar using R

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Visualizes GTFS service patterns on a calendar-like plot. It processes dates from the GTFS feed, calculates weekdays and week numbers, and uses ggplot2 to create a heatmap for each service pattern. Dependencies include the lubridate and dplyr packages.

```r
dates = gtfs$.$dates_servicepatterns
dates$wday <- lubridate::wday(dates$date, label = TRUE, abbr = TRUE, week_start = 7)
dates$week_nr <- lubridate::week(dates$date)

dates <- dates %>% group_by(week_nr) %>%
  summarise(week_first_date = min(date)) %>%
  right_join(dates, by = "week_nr")

week_labels = dates %>% select(week_nr, week_first_date) %>% unique()

ggplot(dates) + theme_bw() +
  geom_tile(aes(x = wday, y = week_nr), color = "#747474") +
  scale_x_discrete(drop = F) +
  scale_y_continuous(trans = "reverse", labels = week_labels$week_first_date, breaks = week_labels$week_nr) +
  theme(legend.position = "bottom", axis.text.x = element_text(angle = 90, hjust = 1)) +
  labs(x = NULL, y = "Date of Sundays") +
  facet_wrap(~servicepattern_id, nrow = 1)
```

--------------------------------

### Create Bounding Box Polygon using sf

Source: https://r-transit.github.io/tidytransit/articles/introduction

This R code defines a function `bbox_polygon` that creates a simple feature polygon representing a bounding box from minimum and maximum longitude and latitude coordinates. It utilizes the `sf` package for spatial operations and assigns the WGS 84 coordinate reference system (EPSG:4326). The subsequent code block then applies this function to a feedlist, filtering for valid coordinates and creating spatial data for visualization.

```r
# create a bounding box polygon from min/max corner coordinates
suppressPackageStartupMessages(library(sf))
bbox_polygon = function(lon_min, lon_max, lat_min, lat_max) {
  corner_coords = matrix(
    c(lon_min, lat_min,
      lon_min, lat_max,
      lon_max, lat_max,
      lon_max, lat_min,
      lon_min, lat_min),
    ncol = 2, byrow = TRUE
  )
  polyg = st_polygon(list(corner_coords))
  return(st_sfc(polyg, crs = 4326))
}

# create bounding box polygon (only for reasonable values)
MobilityData_sf = MobilityData_feedlist %>%
  filter(!is.na(location.bounding_box.minimum_longitude)) %>%
  filter(location.bounding_box.minimum_latitude > -89) %>%
  group_by(mdb_source_id) %>%
  mutate(geometry = bbox_polygon(location.bounding_box.minimum_longitude,
                                 location.bounding_box.maximum_longitude,
                                 location.bounding_box.minimum_latitude,
                                 location.bounding_box.maximum_latitude)) %>%
  ungroup() %>%
  st_as_sf()
```

--------------------------------

### Create Calendar Data with Weekdays and Holidays

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Generates a calendar tibble containing dates, weekdays, and holidays. It first extracts unique dates from the `dates_services` data frame and then calculates the corresponding weekday for each date. Finally, it joins a predefined holidays tibble to add holiday information.

```r
holidays = tribble(~date, ~holiday,
  ymd("2018-07-04"), "Independence Day",
  ymd("2018-09-03"), "Labor Day")

calendar = tibble(date = unique(gtfs$.$dates_services$date)) %>%
  mutate(
    weekday = (function(date) {
      c("Sunday", "Monday", "Tuesday", 
        "Wednesday", "Thursday", "Friday", 
        "Saturday")[as.POSIXlt(date)$wday + 1]
    })(date)
  )

calendar <- calendar %>% left_join(holidays, by = "date")
head(calendar)
```

--------------------------------

### Plot Routes by Median Headways

Source: https://r-transit.github.io/tidytransit/articles/frequency

Visualizes transit routes on a map, colored by their median headways during the morning period. Routes with median headways less than 10 minutes are filtered and displayed. The plot uses `ggplot2` and `sf` for spatial data handling and transformation to a suitable Coordinate Reference System (CRS 26919). Route IDs are added as labels.

```r
# convert to an appropriate coordinate reference system
routes_sf_crs <- sf::st_transform(routes_sf, 26919) 
routes_sf_crs %>%
  filter(median_headways < 10*60) %>%
  ggplot() + 
  geom_sf(aes(colour=as.factor(median_headways))) + 
  labs(color = "Headways") + 
  geom_sf_text(aes(label=route_id)) + 
  theme_bw()
```

--------------------------------

### Write tidygtfs object to zip file (R)

Source: https://r-transit.github.io/tidytransit/reference/write_gtfs

Writes a tidygtfs object to a zip file. This function can optionally write the feed to a directory instead of a zip file. It uses `gtfsio::export_gtfs()` internally and does not export auxiliary tables. The output is the input gtfs_obj invisibly. Accepts a tidygtfs object, a path for the zip file or directory, an optional compression level (1-9), and a boolean to specify output as a directory.

```R
write_gtfs(gtfs_obj, zipfile, compression_level = 9, as_dir = FALSE)
```

```R
if (FALSE) { # \dontrun{
local_gtfs_path <- system.file("extdata", "nyc_subway.zip", package = "tidytransit")
gtfs <- read_gtfs(local_gtfs_path)

gtfs <- filter_feed_by_date(gtfs, "2018-06-30")

write_gtfs(gtfs, "feed_filtered.zip")
} # }
```

--------------------------------

### Create trip_origin Column - R

Source: https://r-transit.github.io/tidytransit/articles/timetable

Generates a 'trip_origin' column in the gtfs$trips data frame. This is achieved by identifying the first stop of each trip and joining its name. Requires gtfs object with stop_times and stops data frames.

```r
# get the id of the first stop in the trip's stop sequence
first_stop_id <- gtfs$stop_times %>%
  group_by(trip_id) %>%
  summarise(stop_id = stop_id[which.min(stop_sequence)])

# join with the stops table to get the stop_name
first_stop_names <- left_join(first_stop_id, gtfs$stops, by="stop_id")

# rename the first stop_name as trip_origin
trip_origins <- first_stop_names %>% select(trip_id, trip_origin = stop_name)

# join the trip origins back onto the trips
gtfs$trips <- left_join(gtfs$trips, trip_origins, by = "trip_id")
```

--------------------------------

### GTFS Feed Summary - R

Source: https://r-transit.github.io/tidytransit/reference/summary

Provides a summary of a GTFS feed loaded as a tidygtfs object. This S3 method is designed for the generic R `summary` function and takes a tidygtfs object as input. It is primarily used for inspecting the contents and structure of the GTFS data.

```R
summary(object, ...)
```

--------------------------------

### Count Trips per Service ID and Route

Source: https://r-transit.github.io/tidytransit/articles/frequency

This R code analyzes the `trips` table from the GTFS data. It filters trips based on a provided vector of `service_ids`, then groups the results by `service_id` and `route_id` to count the number of trips for each combination. The `head()` function displays the first few results. The output is a table showing trip counts for each service ID and route.

```r
gtfs$trips %>%
  filter(service_id %in% service_ids) %>%
  group_by(service_id, route_id) %>%
  summarise(count = n()) %>%
  head() %>%
  knitr::kable()
```

--------------------------------

### Display Headway Data Summary (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Displays the first few rows of the calculated stop frequency data frame, showing stop IDs, route IDs, service IDs, number of departures, and average headway. This helps in quickly inspecting the results of the get_stop_frequency function.

```R
knitr::kable(head(am_stop_freq))
```

--------------------------------

### Add Days in Service to Service Pattern Summary

Source: https://r-transit.github.io/tidytransit/articles/frequency

This R code adds the number of days each service pattern is in operation to the existing service pattern summary. It groups the dates associated with service patterns and counts the number of distinct days. The result is then joined with the `service_pattern_summary` data frame. The output is an updated summary including 'days_in_service'.

```r
service_pattern_summary <- gtfs$.$dates_servicepatterns %>%
  group_by(servicepattern_id) %>%
  summarise(days_in_service = n()) %>%
  left_join(service_pattern_summary, by="servicepattern_id")
```

--------------------------------

### Calculate Morning Route Frequency with TidyTransit

Source: https://r-transit.github.io/tidytransit/articles/frequency

Calculates the frequency of transit service for each route during the morning period (6 AM to 10 AM). It utilizes the `get_route_frequency` function from the TidyTransit package, taking a GTFS object and specified service IDs as input. The output is a table summarizing frequency data, which can be previewed with `head()` and `kable()`.

```r
am_route_freq <- get_route_frequency(gtfs, service_ids = service_ids, 
                                     start_time = 6*3600, end_time = 10*3600) 
head(am_route_freq) %>%
  knitr::kable()
```

--------------------------------

### Display Top Stops by Departure Frequency (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code filters and selects the top stops based on their departure frequency and mean headway. It joins stop information with departure frequency data, filters for stops with more than 50 departures, selects relevant columns, sorts by departures, and displays the top 6 using `knitr::kable()` for formatted output. It assumes `gtfs$stops` and `am_stop_freq` are available.

```r
gtfs$stops %>%
  inner_join(am_stop_freq, by = "stop_id") %>%
  filter(n_departures > 50) %>%
  select(stop_id, stop_name, n_departures, mean_headway) %>%
  arrange(n_departures) %>%
  head() %>%
  knitr::kable()

```

--------------------------------

### Join Stop Data for Mapping (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Joins the calculated headway data for a specific route with the GTFS stops data to prepare it for spatial visualization. This ensures that geographic information is available for plotting stop locations.

```R
one_line_stops_sf <- gtfs$stops %>%
  right_join(one_line_stops, by="stop_id")
```

--------------------------------

### Display Head of Dates and Service Patterns Data

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Displays the initial rows of the `dates_servicepatterns` data frame. This data frame links specific dates to their corresponding `servicepattern_id`s, providing a way to identify which service patterns are active on any given date.

```r
head(gtfs$.$dates_servicepatterns)
```

--------------------------------

### Plot Route Headways on Map (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Visualizes the calculated average headways for a specific route on a map using ggplot2's geom_sf. The color of the points represents the mean headway in minutes, allowing for a visual assessment of headway distribution across the route.

```R
one_line_stops_sf %>%
  ggplot() %>%
  geom_sf(aes(color = mean_headway_minutes)) %>%
  theme_bw()
```

--------------------------------

### Calculate Total Departures by Stop Name (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code calculates the total number of departures for each stop name by joining GTFS stop data with departure frequency data, grouping by `stop_name`, summing departures, and filtering for stops with more than 100 total departures. This prepares data for mapping stop departure counts.

```r
am_stop_name_departures <- left_join(gtfs$stops, am_stop_freq, by="stop_id")

am_stop_name_departures <- am_stop_name_departures %>%
  group_by(stop_name) %>%
  transmute(total_departures = sum(n_departures, na.rm=TRUE))

am_stop_name_departures <- am_stop_name_departures %>%
  filter(total_departures > 100)

```

--------------------------------

### Display Top/Bottom Headway Stops (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Arranges the filtered route data by headway in descending order and selects relevant columns (stop name, number of departures, mean headway) to display the stops with the highest and lowest average headways. This helps identify variations in service speed along a route.

```R
one_line_stops %>%
  arrange(desc(mean_headway)) %>%
  select(stop_name, n_departures, mean_headway) %>%
  head() %>%
  knitr::kable()
```

```R
one_line_stops %>%
  arrange(desc(mean_headway)) %>%
  select(stop_name, n_departures, mean_headway) %>%
  tail() %>%
  knitr::kable()
```

--------------------------------

### Suggest Service Pattern Names Function

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Defines an R function `suggest_servicepattern_name` to programmatically generate readable names for service patterns based on their associated dates and calendar information. This function uses heuristics to identify patterns like 'Every day', 'Weekdays', 'Weekends', single days, or combinations thereof, and can include holidays. It depends on the `dplyr` package for data manipulation.

```r
suggest_servicepattern_name = function(dates, calendar) {
  servicepattern_calendar = tibble(date = dates) %>% left_join(calendar, by = "date")
  
  # all normal dates without holidays
  calendar_normal = servicepattern_calendar %>% filter(is.na(holiday))
  
  # create a frequency table for all calendar dates without holidays
  weekday_freq = sort(table(calendar_normal$weekday), decreasing = TRUE)
  n_weekdays = length(weekday_freq)
  
  # all holidays that are not covered by normal weekdays anyways
  calendar_holidays <- servicepattern_calendar %>% filter(!is.na(holiday)) %>% filter(!(weekday %in% names(weekday_freq)))

  if(n_weekdays == 7) {
    pattern_name = "Every day"
  }
  # Single day service
  else if(n_weekdays == 1) {
    wd = names(weekday_freq)[1]
    # while paste0(weekday, "s") is easier, this solution can be used for other languages
    pattern_name = c("Sunday"  = "Sundays", 
        "Monday"    = "Mondays", 
        "Tuesday"   = "Tuesdays", 
        "Wednesday" = "Wednesdays",
        "Thursday"  = "Thursdays",  
        "Friday"    = "Fridays",  
        "Saturday"  = "Saturdays")[wd]
  }
  # Weekday Service
  else if(n_weekdays == 5 && 
      length(intersect(names(weekday_freq), 
        c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday"))) == 5) {
    pattern_name = "Weekdays"
  }
  # Weekend
  else if(n_weekdays == 2 && 
      length(intersect(names(weekday_freq), c("Saturday", "Sunday"))) == 2) {
    pattern_name = "Weekends"
  }
  # Multiple weekdays that appear regularly
  else if(n_weekdays >= 2 && (max(weekday_freq) - min(weekday_freq)) <= 1) {
    wd = names(weekday_freq)
    ordered_wd = wd[order(match(wd, c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")))]
    pattern_name = paste(ordered_wd, collapse = ", ")
  } 
  # default
  else {
    pattern_name = paste(weekday_freq, names(weekday_freq), sep = "x ", collapse = ", ")
  }
  
  # add holidays
  if(nrow(calendar_holidays) > 0) {
    pattern_name <- paste0(pattern_name, " and ", paste(calendar_holidays$holiday, collapse = ", "))
  }
  
  pattern_name <- paste0(pattern_name, " (", min(dates), " - ", max(dates), ")") 

  return(pattern_name)
}
```

--------------------------------

### Filter and Enhance Route Headway Data (R)

Source: https://r-transit.github.io/tidytransit/articles/frequency

Filters the stop frequency data for a specific route (e.g., '1' train) and direction, then joins it with the GTFS stops data to include stop names. It also calculates headways in minutes for easier interpretation. This allows for detailed analysis of a single route's performance.

```R
one_line_stops <- am_stop_freq %>%
    filter(route_id == "1" & direction_id == 0) %>%
    left_join(gtfs$stops, by ="stop_id") %>%
    mutate(mean_headway_minutes = mean_headway/60)
```

--------------------------------

### Display Head of Service Patterns Data

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Shows the first few rows of the `servicepatterns` data frame within the GTFS object. This data frame maps each `service_id` to a unique `servicepattern_id`, which represents a set of dates when a particular service operates.

```r
head(gtfs$.$servicepatterns)
```

--------------------------------

### Plot Number of Trips per Day as Calendar Heatmap using R

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Generates a calendar heatmap showing the number of trips per day. It joins trip data with service pattern information, aggregates trip counts by date, and then formats the dates to create a monthly calendar view using ggplot2. Requires dplyr and lubridate.

```r
trips_servicepattern = left_join(select(gtfs$trips, trip_id, service_id), gtfs$.$servicepatterns, by = "service_id")
trip_dates = left_join(gtfs$.$dates_servicepatterns, trips_servicepattern, by = "servicepattern_id", relationship = "many-to-many")

trip_dates_count = trip_dates %>%
  group_by(date) %>%
  summarise(count = dplyr::n())

trip_dates_count <- trip_dates_count %>%
  mutate(weekday = lubridate::wday(date, label = TRUE, abbr = TRUE, week_start = 7),
         day_of_month = lubridate::day(date),
         first_day_of_month = lubridate::wday(date - day_of_month, week_start = 7),
         week_of_month = ceiling((day_of_month - as.numeric(weekday) - first_day_of_month) / 7),
         month = lubridate::month(date, label = TRUE, abbr = FALSE))

ggplot(trip_dates_count, aes(x = weekday, y = -week_of_month)) + 
  theme_bw() +
  facet_wrap(~month, ncol = 3) +
  geom_tile(aes(fill = count, colour = "grey50")) +
  geom_text(aes(label = day_of_month), size = 3, colour = "grey20") +
  scale_fill_gradient(low = "cornsilk1", high = "DarkOrange", na.value="white") +
  scale_color_manual(guide = "none", values = "grey50") +
  theme(axis.text.y = element_blank(), axis.ticks.y = element_blank()) +
  theme(panel.grid = element_blank()) +
  labs(x = NULL, y = NULL, fill = "# trips") +
  coord_fixed()
```

--------------------------------

### Set Service Patterns for GTFS Data

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Applies the `set_servicepattern` function to the GTFS object. This function calculates and assigns a `servicepattern_id` to each `service_id`, helping to group similar service patterns based on the dates they operate. The updated GTFS object is then returned.

```r
gtfs <- set_servicepattern(gtfs)
```

--------------------------------

### Add Route Short Name to Departures in R

Source: https://r-transit.github.io/tidytransit/articles/timetable

This snippet demonstrates how to join the departures data frame with the routes data frame from GTFS to add the 'route_short_name' column. It uses dplyr's left_join for this operation.

```r
departures <- departures %>%
  left_join(gtfs$routes %>%
              select(route_id, 
                     route_short_name),
            by = "route_id")
```

--------------------------------

### Retrieve GTFS Feed Validation Results

Source: https://r-transit.github.io/tidytransit/articles/introduction

Explains how to access the validation results of a GTFS feed after it has been read using `read_gtfs`. The validation information is stored as an attribute named `validation_result` and can be retrieved using `attr()` and then inspected with `head()`.

```r
validation_result <- attr(nyc, "validation_result")
head(validation_result)
```

--------------------------------

### Convert GTFS to Simple Features and Calculate Shape Lengths

Source: https://r-transit.github.io/tidytransit/articles/frequency

This code converts GTFS transit data into a simple features (SF) object for spatial analysis. It then calculates the length of each shape (route path) and stores it. The output is a data frame containing shape IDs and their corresponding lengths, excluding the geometry.

```r
gtfs <- gtfs_as_sf(gtfs)
gtfs$shapes$length <- st_length(gtfs$shapes)

shape_lengths <- gtfs$shapes %>%
  as.data.frame() %>%
  select(shape_id, length, -geometry)
```

--------------------------------

### Plot Date vs. Service Pattern by Weekday

Source: https://r-transit.github.io/tidytransit/articles/servicepatterns

Generates a scatter plot visualizing the relationship between dates and service pattern IDs, colored by the weekday. This plot aids in identifying trends and exceptions in service scheduling. Requires the `ggplot2` and `dplyr` packages.

```r
date_servicepattern_table <- gtfs$.$dates_servicepatterns %>% left_join(calendar, by = "date")

ggplot(date_servicepattern_table) + theme_bw() + 
  geom_point(aes(x = date, y = servicepattern_id, color = weekday), size = 1) + 
  scale_x_date(breaks = scales::date_breaks("1 month")) + theme(legend.position = "bottom")
```

--------------------------------

### Convert GTFS stops and shapes to Simple Features (sf)

Source: https://r-transit.github.io/tidytransit/reference/gtfs_as_sf

The `gtfs_as_sf` function converts GTFS stops to POINT sf data frames and shapes to LINESTRING sf data frames. It takes a `tidygtfs` object as input and can optionally skip shape conversion or transform coordinates to a specified CRS. The function replaces the stops and shapes tables within the `gtfs_obj` with their sf representations.

```r
gtfs_as_sf(gtfs_obj, skip_shapes = FALSE, crs = NULL, quiet = TRUE)
```

--------------------------------

### Plot GTFS stops and trips with tidytransit

Source: https://r-transit.github.io/tidytransit/reference/plot

This R code demonstrates how to plot General Transit Feed Specification (GTFS) stops and trips using the tidytransit package. It requires a tidygtfs object, typically created by the read_gtfs() function. The plot function visualizes the spatial distribution of stops and the routes associated with trips.

```r
local_gtfs_path <- system.file("extdata",
                              "nyc_subway.zip",
                              package = "tidytransit")
nyc <- read_gtfs(local_gtfs_path)
plot(nyc)
```

--------------------------------

### Join Route Geometry with Frequency Data

Source: https://r-transit.github.io/tidytransit/articles/frequency

Merges the route geometry data frame (`routes_sf`) with the calculated route frequency data frame (`am_route_freq`). This join is performed using an inner join on the `route_id` column, ensuring that only routes present in both datasets are retained. This step prepares the data for spatial analysis and plotting.

```r
routes_sf <- routes_sf %>%
  inner_join(am_route_freq, by = "route_id")
```

--------------------------------

### Plot Filtered Departures by Stop ID and Time (R)

Source: https://r-transit.github.io/tidytransit/articles/timetable

Creates a plot showing departures for specific stop IDs within a given time range (7 to 8 AM). This plot uses faceting to separate departures by stop ID, allowing for clearer comparison. It filters the data using dplyr and hms packages before plotting with ggplot2. Dependencies include dplyr, hms, and scales packages.

```r
departures_180823_sub_7to8 <- departures_180823 %>%
  filter(stop_id %in% c("127N", "127S")) %>%
  filter(departure_time >= hms::hms(hours = 7) & departure_time <= hms::hms(hours = 8))

ggplot(departures_180823_sub_7to8) + 
  theme_bw() +
  geom_point(aes(y=trip_headsign, x=departure_time, color = route_short_name), size = 1) +
  scale_x_time(breaks = seq(7*3600, 9*3600, 300), labels = scales::time_format("%H:%M")) +
  scale_y_discrete(drop = FALSE) +
  theme(axis.text.x = element_text(angle = 90, hjust = 1)) +
  theme(legend.position = "bottom") +
  labs(title = "Departures from Times Square on 08/23/18") +
  facet_wrap(~stop_id, ncol = 1)
```

--------------------------------

### Filter GTFS Feeds from MobilityData CSV in R

Source: https://r-transit.github.io/tidytransit/articles/introduction

This R code snippet processes the MobilityData CSV to isolate entries specifically for GTFS static feeds. It uses the `dplyr` package's `as_tibble` and `filter` functions to clean and select relevant data. The output is a tibble containing only GTFS data, which can then be inspected using `str()`.

```r
MobilityData_feedlist = MobilityData.csv %>%
  as_tibble() %>%
  filter(data_type == "gtfs")

str(MobilityData_feedlist)
```
Tokens:
Raw