Geovis Project Assignment, TMU Geography, SA8905, Fall 2025
By: Haneen Banat

Introduction

Traffic collisions are a major urban safety concern in large cities like Toronto, where dense road networks, high population, and multimodal movement create complex interactions between drivers, pedestrians, cyclists, and transit. Traditional 2D maps and tables can represent collision statistics, but they often fail to communicate spatial intensity or the “feel” of risk across neighbourhoods. For this project, I explore how GIS, 3D modeling, and architectural rendering tools can work together to reimagine collision data as a three-dimensional, design-driven geovisualization.

My project, 3D Visualization of Traffic Collision Hotspots in Toronto, transforms Toronto Police Service collision data into an immersive 3D map. The goal is to visualize where collisions are concentrated, how spatial patterns differ across neighbourhoods, and how 3D storytelling techniques can make urban safety data more intuitive and visually compelling for planners, designers, and the public. I use a multi-software workflow that spans ArcGIS Pro, the City of Toronto’s 3D massing data, SketchUp, and Lumion. This project demonstrates how cartographic tools can support modern spatial storytelling, blending urban analytics with design. 

Data Sources

Toronto Police Open Data Portal

Dataset: Traffic Collisions (ASR-T-TBL-001)
Link: https://data.torontopolice.on.ca

This dataset includes over 770,000 collision records across many years. Each record includes: Location, Date, time, collision type, mode invloved and different attributes. Because the full dataset is extremely large and includes COVID-period anomalies, I filtered the dataset to only the year 2022. This produced roughly 50,000-60,000 collision records. For this project, only automobile collisions were used. I downloaded the geodatabase file as a CVS.

The second piece of data that was needed was City of Toronto – Neighbourhood Boundaries: Link: https://open.toronto.ca/dataset/neighbourhoods/

The third piece of data is City of Toronto Planning, 3D Massing Model. Link: https://cot-planning.maps.arcgis.com/apps/webappviewer/index.html?id=161511b3fd7943e39465f3d857389aab

This dataset includes 3D building footprints and massing geometry. I downloaded individual massing tiles in SketchUp format (.skp) for the neighbourhoods with the highest hotspot scores. Because each tile is extremely heavy, I imported them piece by piece.

Software Used:

• ArcGIS Pr: filtering, spatial join, hotspot analysis
• SketchUp: extrusion modeling and colour classification
• Lumion: 3D rendering, lighting, and final visuals

Methodology

This project required a multi-stage workflow spanning GIS analysis, CAD conversion, 3D modeling, and rendering. The workflow is divided into four main stages.

Step 1: Data Cleaning & Hotspot Analysis using ArcGIS Pro

Filtering Collision Data:

The Police dataset originally contained 772,000 records.

1. Applied a filter for OCC_DATE = 2022
2. Removed non-automobile collisions
3. Ensured that only records with valid geometry were included
4. Downloaded as File Geodatabase (shapefile download was corrupt)

After filtering, the dataset was reduced to a manageable 50,000 records

Step 2: Spatial Join (Join collisions to neighbourhoods)

To understand spatial distribution, I joined the collision points to Toronto’s 158 neighbourhood polygons

Tool: Spatial Join

• Target features: Neighbourhoods
  
• Join features: Collisions
  
• Join operation: JOIN_ONE_TO_ONE
  
• Match option: INTERSECT

Step 3: Hotspot Analysis (Optimized Hot Spot Analysis)

Tool: Optimized Hot Spot Analysis
Input: All collision points
This produced a statistically significant hotspot/coldspot map: White = not significant Red = High-risk clusters Blue = Low-risk clusters

Step 4: 3D Map in Sketchup

Importing DWG into SketchUp

To import into SketchUp, the downloaded SketchUp files of Toronto neighborhood boundaries that were downloaded earlier were used in this stage. Each file must be downloaded separately. Identifying each section was done through the labels that were automatically applied.

Applying Colour Classification: To create a visually intuitive gradient:

Very high hotspots: red, Low collisions: blue

Step 5: Rendering & Visualization in Lumion

Importing the SketchUp Model: The extruded model was imported into Lumion for realistic visualization.

Adding Atmospheric Lighting: Because this visualization focuses on highlighting hotspot intensities, I chose a night time scene: which then i reduced sunlight intensity. Added Spotlights added at various heights Colours represented collision intensity: Blue = lower-risk area, Red = high collision zones

Add lighting and change color to to match the collision type

Decrease the Sun intensity to set a night time setting

Camera Movement & Composition: I created multiple camera angles to show: Nighttime lighting reflecting collision intensity, Panoramic views of the 3D collision landscape, Close-ups of high-risk clusters

Step 6: Exporting the Final Renders

Each neighborhood would need to be rendered at the chosen angle and exported. 

Results

1. Downtown and Waterfront

Areas such as St. Lawrence–East Bayfront–Islands, Harbourfront–CityPlace, Fort York–Liberty Village, and West Queen West showed extremely high collision densities

2. Inner Suburban Belt

Neighbourhoods like South Riverdale, Annex, Dufferin Grove, and Trinity-Bellwoods exhibited moderate-to-high collision intensity, correlating with high pedestrian and cyclist activity.

3. Lower-risk Zones

Coldspots appeared mainly in low-density residential neighbourhoods with fewer arterial roads.

3D Advantages

The extruded height and nighttime lighting made it easy to instantly see:

• Which areas had the most collisions
• How intensity changes across neighbourhoods
• Where the city might focus safety interventions

Limitations

• Massing data is extremely large: Importing all of Toronto was impossible due to memory and file size constraints.
  Only selected hotspot tiles were used.
• Temporal variation ignored: This project analyzed only 2022 and not multi-year trends.
• Hotspot analysis generalizes clustering
  While statistically robust, it does not differentiate between collisions caused by traffic volume, infrastructure, or behavioural factors.
• Rendering is interpretive
  Height and colour were designed for visual storytelling rather than strict quantitative precision.
• Limited Interactive: The 3D render isnt interactive unless you have acess to the softwares used, which would either need to be Sketchup or Lumion.

Conclusion

This project demonstrates how collision data can be transformed from static points into an immersive 3D visualization that highlights urban road safety patterns. By integrating ArcGIS analysis with architectural modeling tools like SketchUp and Lumion, I created a geographically accurate, data-driven 3D landscape of Toronto’s collision hotspots.

The final visualization shows where collisions cluster most intensely, provides intuitive spatial cues for understanding road safety risks, and showcases the potential of hybrid cartographic-design workflows. This form of neo-cartography offers a compelling way to communicate urban safety information to planners, designers, policymakers, and the public.

1. Introduction and Objectives
This report documents the methodology and execution of a geospatial analysis aimed at identifying specific segments of the road network with a high potential for dangerous solar glare during critical commute times.
The analysis focuses on the high-risk window for solar glare in the Greater Toronto Area (GTA), typically the winter months (January) around the afternoon commute (4:00 PM EST), when the sun is low on the horizon and positioned in the southwest.
The primary objectives were to:
1. Calculate the average solar position (Azimuth and Elevation) for the defined high-risk period.
2. Determine the orientation (Azimuth) of all road segments in the StreetCentreline layer.
3. Calculate the acute angle between the road and the sun (R_S_ANGLE).
4. Filter the results to identify segments where the road is both highly aligned with the sun and the driver is traveling into the solar direction, marking them as High Glare Hazard Potential.
2. Phase I: ArcPy Scripting for Data Calculation
The first phase involved developing an ArcPy script to calculate the necessary astronomical and geometric values and append them to the input feature class. Due to database constraints (specifically the 10-character field name limit in certain geodatabase formats), field names were abbreviated.
2.1. Script Parameters and Solar Calculation
The script uses the approximate latitude and longitude of Mississauga, ON (43.59, -79.64), and calculates the average solar position for the first week of January 2025 at 4:00 PM EST.
2.2. Final ArcPy Script
The following Python code was executed in the ArcGIS Pro Python environment:
import arcpy
import datetime
import math
import calendar

# — User Inputs (ADJUST THESE VALUES AS NEEDED) —
input_fc = “StreetCentreline”
MISSISSAUGA_LAT = 43.59
MISSISSAUGA_LON = -79.64
TARGET_TIME_HOUR = 16
YEAR = 2025

# — Field Names for Output (MAX 10 CHARACTERS FOR COMPLIANCE) —
ROAD_AZIMUTH_FIELD = “R_AZIMUTH” # Road segment’s direction (Calculated)
SOLAR_AZIMUTH_FIELD = “S_AZIMUTH” # Average Sun direction
SOLAR_ELEVATION_FIELD = “S_ELEV” # Average Sun altitude
ROAD_SOLAR_ANGLE_FIELD = “R_S_ANGLE” # Angle difference (Glare Indicator: 0=Worst Glare)

# — Helper Functions (Solar Geometry and Segment Azimuth) —

def calculate_solar_position(lat, lon, dt_local):
“””Calculates Solar Azimuth and Elevation (Simplified NOAA Standard).”””
TIMEZONE = -5
day_of_year = dt_local.timetuple().tm_yday
gamma = (2 * math.pi / 365) * (day_of_year – 1 + (dt_local.hour – 12) / 24)

eqtime = 229.18 * (0.000075 + 0.001868 * math.cos(gamma) – 0.032077 * math.sin(gamma)
– 0.014615 * math.cos(2 * gamma) – 0.040849 * math.sin(2 * gamma))
decl = math.radians(0.006918 – 0.399912 * math.cos(gamma) + 0.070257 * math.sin(gamma)
– 0.006758 * math.cos(2 * gamma) + 0.000907 * math.sin(2 * gamma)
– 0.002697 * math.cos(3 * gamma) + 0.00148 * math.sin(3 * gamma))

time_offset = eqtime + 4 * lon – 60 * TIMEZONE
tst = dt_local.hour * 60 + dt_local.minute + dt_local.second / 60 + time_offset
ha_deg = (tst / 4) – 180
ha_rad = math.radians(ha_deg)
lat_rad = math.radians(lat)

cos_zenith = (math.sin(lat_rad) * math.sin(decl) +
math.cos(lat_rad) * math.cos(decl) * math.cos(ha_rad))
zenith_rad = math.acos(min(max(cos_zenith, -1.0), 1.0))
solar_elevation = 90 – math.degrees(zenith_rad)

azimuth_num = -math.sin(ha_rad)
azimuth_den = math.tan(decl) * math.cos(lat_rad) – math.sin(lat_rad) * math.cos(ha_rad)

if azimuth_den == 0:
solar_azimuth_deg = 180 if ha_deg > 0 else 0
else:
solar_azimuth_rad = math.atan2(azimuth_num, azimuth_den)
solar_azimuth_deg = math.degrees(solar_azimuth_rad)

solar_azimuth = (solar_azimuth_deg + 360) % 360

return solar_azimuth, solar_elevation


def calculate_segment_azimuth(first_pt, last_pt):
“””Calculates the azimuth/bearing of a line segment.”””
dx = last_pt.X – first_pt.X
dy = last_pt.Y – first_pt.Y
bearing_rad = math.atan2(dx, dy)
bearing_deg = math.degrees(bearing_rad)
azimuth = (bearing_deg + 360) % 360
return azimuth

# — Main Script Execution —
arcpy.env.overwriteOutput = True

try:
# 1. Calculate Average Solar Position
start_date = datetime.date(YEAR, 1, 1)
end_date = datetime.date(YEAR, 1, 7)
total_azimuth, total_elevation, day_count = 0, 0, 0
current_date = start_date

while current_date <= end_date:
local_dt = datetime.datetime(current_date.year, current_date.month, current_date.day, TARGET_TIME_HOUR, 0, 0)
az, el = calculate_solar_position(MISSISSAUGA_LAT, MISSISSAUGA_LON, local_dt)
if el > 0:
total_azimuth += az
total_elevation += el
day_count += 1
current_date += datetime.timedelta(days=1)

if day_count == 0:
raise ValueError(“The sun is below the horizon for all calculated dates/times.”)

avg_solar_azimuth = total_azimuth / day_count
avg_solar_elevation = total_elevation / day_count

# 2. Add required fields
for field_name in [ROAD_AZIMUTH_FIELD, SOLAR_AZIMUTH_FIELD, SOLAR_ELEVATION_FIELD, ROAD_SOLAR_ANGLE_FIELD]:
if not arcpy.ListFields(input_fc, field_name):
arcpy.AddField_management(input_fc, field_name, “DOUBLE”)

# 3. Use an UpdateCursor to calculate and populate fields
fields = [“SHAPE@”, ROAD_AZIMUTH_FIELD, SOLAR_AZIMUTH_FIELD, SOLAR_ELEVATION_FIELD, ROAD_SOLAR_ANGLE_FIELD]

with arcpy.da.UpdateCursor(input_fc, fields) as cursor:
for row in cursor:
geometry = row[0]
segment_azimuth = None
if geometry and geometry.partCount > 0 and geometry.getPart(0).count > 1:
segment_azimuth = calculate_segment_azimuth(geometry.firstPoint, geometry.lastPoint)

road_solar_angle = None
if segment_azimuth is not None:
angle_diff = abs(segment_azimuth – avg_solar_azimuth)
road_solar_angle = min(angle_diff, 360 – angle_diff) # Acute angle (0-90)

row[1] = segment_azimuth
row[2] = avg_solar_azimuth
row[3] = avg_solar_elevation
row[4] = road_solar_angle

cursor.updateRow(row)

except arcpy.ExecuteError:
arcpy.AddError(arcpy.GetMessages(2))
except Exception as e:
print(f”An unexpected error occurred: {e}”)
3. Phase II: Classification of True Hazard Potential (Arcade)
Calculating the R_S_ANGLE ($0^\circ$ to $90^\circ$) identifies road segments that are geometrically aligned with the sun. However, it does not distinguish between a driver traveling into the sun (High Hazard) versus traveling away from the sun (No Hazard).
To isolate the segments with a true hazard potential, a new field (HAZARD_DIR) was created and calculated using an Arcade Expression in ArcGIS Pro’s Calculate Field tool.
3.1. Classification Criteria
A segment is classified as having High Hazard Potential (HAZARD_DIR = 1) if both conditions are met:
1. Angle Alignment: The calculated R_S_ANGLE is $15^\circ$ or less (indicating maximum glare).
2. Directional Alignment: The segment’s azimuth (R_AZIMUTH) is oriented within $\pm 90^\circ$ of the sun’s azimuth (S_AZIMUTH), meaning the driver is facing the sun.
3.2. Final Arcade Expression for Field Calculation
The following Arcade script was used to populate the HAZARD_DIR field (Short Integer type):
// HAZARD_DIR Field Calculation (Language: Arcade)

// Define required input fields
var solarAz = $feature.S_AZIMUTH; // Average Sun Azimuth (e.g., 245 degrees)
var roadAz = $feature.R_AZIMUTH; // Road Segment Azimuth (0-360)
var angleDiff = $feature.R_S_ANGLE; // Acute Angle between Road and Sun (0-90)

// 1. Check for High Glare Angle (< 15 degrees)
if (angleDiff <= 15) {

// 2. Check if the road direction is facing INTO the solar direction
// Calculate the acute difference between roadAz and solarAz (0-180 degrees)
var directionDiff = Abs(roadAz – solarAz);
var acuteDirDiff = Min(directionDiff, 360 – directionDiff);

// If the difference is <= 90 degrees, the driver is generally facing the sun
if (acuteDirDiff <= 90) {
return 1; // TRUE: HIGH Glare Hazard Potential
}
}

return 0; // FALSE: NO Glare Hazard Potential (Angle too high or driving away from sun)
4. Results and Mapping of Hazard Potential
The final classification based on the HAZARD_DIR field (where 1 indicates a High Glare Hazard Potential) was used to generate a thematic map of the Mississauga road network. The map isolates the segments that will experience direct, high-intensity sun glare during the 4:00 PM EST winter commute.
4.1. Map Output Description
The map, titled “Solar Glare Hazard Map of City of Mississauga for the First Week of The Year,” clearly differentiates between segments with no glare hazard (yellow) and those with a high solar glare hazard (red).
• Yellow Segments (Street with no Solar Glare Hazard in first week of the year): These represent the vast majority of the network. They include roads running generally north-south (where the sun is primarily hitting the side of the vehicle) or segments where the driver is traveling away from the low sun angle (i.e., eastbound/northeast-bound traffic).
• Red Segments (Street with High Solar Glare Hazard in first week of the year): These are the critical segments for this analysis. They represent roads that are:
1. Oriented in the southwest-to-west direction (similar to the sun’s average azimuth).
2. Where a driver traveling along that segment would be facing directly into the low sun angle.
4.2. Analysis of Identified Hazard Corridors
The high-hazard (red) segments are predominantly clustered along major arterial roads as shown in the following map that follow a strong East-West or Northeast-Southwest orientation.

• Major Corridors: A highly concentrated linear feature of red segments is visible running across the northern/central part of the city, strongly suggesting a major East-West highway or arterial road where the vast majority of segments are oriented to the west. This confirms that these major commuter corridors are the highest-risk areas for this specific time and season.
• Localized Hazards: Several smaller, isolated red segments are scattered throughout the map. These likely represent the East-West portions of minor residential streets or short segments of angled intersections where the road azimuth briefly aligns with the sun.
• Mitigation Focus: The results provide specific, actionable intelligence. Instead of deploying wide-scale mitigation efforts, the city can focus on the delineated red corridors for strategies such as:
o Targeted message boards warning drivers during the specific 3:30 PM–5:00 PM time window in January.
o Evaluating tree planting or physical barriers only along these identified segments to block the low western sun.
5. Conclusion and Next Steps
The integration of solar geometry (Python/ArcPy) and directional filtering (Arcade) successfully generated a definitive dataset of high-risk road segments. The final map, generated based on the HAZARD_DIR field, clearly highlights specific routes that pose a safety risk to westbound or southwest-bound drivers during the target time window.
Future steps for this analysis include:
• Expanding the calculation to include the morning commute period (e.g., 7:00 AM EST) when the sun is low in the East/Southeast.
• Integrating the analysis with collision data to validate the modeled hazard areas.
• Developing mitigation strategies, such as targeted placement of tree cover or glare-reducing signage, based on the identified high-hazard segments.

By Aria Brown

Geovis Project Assignment | TMU Geography | SA8905 | Fall 2025

Hello everyone! Welcome to my geovis blog post :)

Introduction & Context

As someone who has an immense passion for geography, I have come across many opportunities where I can implement such a passion in relation to my other interests. Although geography is paramount in my interests, I am also quite an avid history buff. Thus, I wanted to see if I could capture both my passions and merge them into one project.

Contentedly, I was able to produce a project that combines 3 very important and personal aspects that provide insight into myself and my interests; my passion for geography and history, as well as my appreciation for the City of Toronto, where myself and my family’s roots in Canada first began. Therefore, I decided that I wanted to visualize the history of this great city, taking viewers through time to show how Toronto was able to get to what it is today by utilizing the free-to-use new gen. website Canva with its animation and interactive features.

Therefore, I present to you Unifying the “Megacity,” A Historical Interactive Animation of the Amalgamation of Toronto. My project takes us back to 1834 when the City of Toronto was first created and progressively follows a timeline to bring viewers to the present.

Data & Rationale

Recently, incorporating animation into the world of GIS has been a quite popular trend that many individuals, organizations, and companies have decided to implement in their work. However, animation tools may be hard to come by and most would require a fee upon usage. Therefore, I knew I wanted to see if I could implement a way that GIS could be visualized using an easy-to-use tool that supports interactive features and animation. For those that may be aware, ArcGIS Pro itself does feature an animation tool that uses a timeline (key frames) that the software then compiles and presents in a rather static animation. 

So you might be wondering, why not just use ArcGISPro? ArcGISPro animation and interactive features I found to be quite limiting. Users are limited to key frames to present their animation and may not include extensive interactive features that can be played with or toggled on. I wanted to create a fun interactive animation that was almost seamless and easy to follow without being tied to the constraining ArcGISPro capabilities, and without the fees that other animation tools and softwares may require. Also, Canva is widely used by many to create presentations, reports, etc, and I thought why not showcase how this website that many know and love is capable of so much more.

Tools Used:

Canva- Free Graphic Design Tool

ArcGIS Pro- Desktop GIS Software

Data Used:

City of Toronto Historical Annexation Boundaries (1834-1967)- University of Toronto Dataverse

City of Toronto Community Council Boundaries- Toronto Open Data Portal

Municipal Boundaries as of 1996- Government of Canada

Methodology

Step 1: Upload Data into ArcGISPro and Examine the Data and its Attributes
First, I created a new map project in ArcGIS Pro and uploaded my data. I then right clicked my layers in the ‘Contents’ pane and selected ‘Attributes,’ here you can investigate your data and look for key information such as time frames or date fields. With this particular dataset, the attributes table featured key fields such as the Name of the annexed community (Name) and the year it was annexed (DtAnxd).

Step 2: Separate the Data into Key Time Frames

In order to ensure that my animation was concise, I separated the data into key time frames instead of showing the progression of city boundaries one-by-one, as there are a total of 51 records. I then laid out a framework as to how I was going to group my data using Microsoft Excel and grouped the data by their decades or significant time frames. I exported the attributes table to Excel using the ‘Table to Excel’ geoprocessing tool. I colour-coded my excel document to keep my records organized and so I could easily visualize the beginning and end of each time frame.

Step 3: Use the ‘Export Features’ Tool to Export Selected Attributes

Once my data and time frames were organized, I selected the date-specific polygons using the ‘Select By Attributes’ tool and ran the expression:

Where YrAnxd (text field that has just the year of annexation) includes the value(s) 1883, 1884 (years)

After running this tool for each time frame, I exported the selected attributes by selecting the layer on the Contents pane, right-clicking and selecting Data→Export Features, where I exported selected features based on the time frame. Each time frame was exported into separate shape-files, and the picture below shows the export of the 1883-1884 time frame into a shape-file entitled ‘1883_1884” which was the titling format I maintained for each shape-file.

Step 4: Customize the Map and Layout

After exporting each time frame into separate shape-files, I edited the look of my map by changing the basemap to depict a more historical-looking one that I felt fit the theme of my project and symbolized the boundary lines, scale bar, and north arrow to match the theme as well. I made sure to bookmark the location of the map in order to ensure each time frame would have a seamless transition without any movement from the map itself. 

In order to show a progression of Toronto’s boundaries that gradually increased over time, I made sure to toggle on the shape-files of the previous years to showcase this. For example, for the 1883-1884 time frame, I kept the previous 1834 shape-file to show this boundary progression.

Step 5: Export Maps

I then exported each map to a PNG file by selecting the Share tab and selecting Export Layout.

Step 6: Upload to Canva

Each map was uploaded to Canva using the ‘Uploads’ tool on the left menu bar to a presentation-style template 

Step 7: Use Presentation Template to Layout Maps and Customize

I customized each slide of my presentation by adding my maps, borders, images and icons.

Step 8: Enable Various Animation Tools Between Slides and Text

To create a rather seamless transition between time frames, I selected the ‘Dissolve’ animation tool by hovering my mouse over the space between each slide and selecting the ‘Add Transition’ option. Here, Canva presents a variety of different animation transitions to choose from, however I selected ‘Dissolve’ as I felt it was the most seamless transition due to its fading animation type. I also used different animation types for the display of different text components within the slides.

Step 9: Add Selectable Icons

I also wanted to make my animation more interactive and came up with the idea of allowing viewers to see a historic map of Toronto at the particular time frame that the slide was presenting. I got this idea by seeing the use of historic maps being used as basemaps to showcase the evolution of the city and its boundaries. I then found historical maps from the City of Toronto’s Historical Maps and Atlases website and saved them. I then uploaded them to Canva, duplicated my slide with a blank map and added the historic map to it. I then georeferenced the historic maps by lining up the borders between them and my map. I temporarily made the historic maps a bit transparent so I could line up the borders accurately.

I added a ‘plus’ icon from Canva on the slide I wanted and configured the icon so that if it was selected, viewers would be able to see the historic map of Toronto at around the same time. This was done by selecting the plus icon and selecting the ellipsis and navigating to ‘Add Link.’ Then, I selected the particular slide I wanted in the ‘Enter a link or Search’ section. This configured the plus icon to allow viewers to select it, prompting Canva to present the map with the historic imagery overlaid on top. An additional selectable icon (back button) was created on the historic map slides to allow users to go back to the original slide they were viewing.

Results

Link to Canva Presentation:

https://www.canva.com/design/DAG4ck_PXLQ/S60h1kAtqPjzCwqFgmYAVA/edit?utm_content=DAG4ck_PXLQ&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton

Presentation:

After the completion of the previous steps, the final product features an animated and interactive presentation of maps! The final product now has:

• Select capabilities
• Animated transitions between slides and text
• Selectable pop up icons to present new information (historic map imagery)
• Zoom in and out capabilities

I hope you may be inspired by this and try to make your own interactive animation

Thank you!

References

City of Toronto. (2018). Toronto Community Council Boundaries Options Paper. City of Toronto. https://www.toronto.ca/legdocs/mmis/2018/ex/bgrd/backgroundfile-116256.pdf

City of Toronto. (2025). Community Council Area Profiles. City of Toronto. https://www.toronto.ca/city-government/data-research-maps/neighbourhoods-communities/community-council-area-profiles/

City of Toronto. (2025). Historical Maps and Atlases. City of Toronto. https://www.toronto.ca/city-government/accountability-operations-customer-service/access-city-information-or-records/city-of-toronto-archives/whats-online/maps/historical-maps-and-atlases/

Government of Canada. (2005). Municipal boundaries as of 1996. Government of Canada. https://open.canada.ca/data/en/dataset/a3e19e02-36f0-4244-87ab-8f029c6846e2

Fortin, M. (2023). City of Toronto Historical Annexation Boundaries (1834 – 1967). University of Toronto. https://borealisdata.ca/dataset.xhtml?persistentId=doi:10.5683/SP3/XN2NRW
MacNamara, J. (2005). Toronto Chronology. Ontario Genealogical Society.https://web.archive.org/web/20070929044646/http://www.torontofamilyhistory.org/chronology.html

SA8905 – Cartography and Geovisualization
Geovisualization Project Assignment

By: Nishaan Grewal

I am sure that many of us have experienced or have heard about the ever-growing issue, which is auto theft. This project, utilizing PowerBI, will not only help analyze but also provide a visualization of Toronto auto theft patterns (2020-2024). Using the spatial insights together with the business intelligence tools provided by PowerBI, it has allowed me to compare trends across the years, and overall create an interactive dashboard that is usable by users.

You may be asking why not just use ArcGIS and PowerBI, but as informative and advanced the mapping is on ArcGIS it still lacks the story telling and understanding for the everyday user. I believe GIS should be used to help educate and inform individuals in a user-friendly and easy-to-access manner. Using Power BI for the first time myself, I can truly say it has helped me understand how GIS can be used in many other ways, rather than in my comfort zone, which is just using ArcGIS Pro. My goal was to create an easy-to-follow to follow dashboard that allows the user to explore Toronto’s neighbourhood-level auto theft trends in an intuitive and meaningful way, without being confused.

So let’s get started and give an overview of the project. Please remember if your TorontoMU account does not work for PowerBI, you must obtain licencing from the TMU. I had to get help from the TMU help desk.

Datasets:

STEP 1: Add and Clean Data

I started by importing the CSV file of the Auto Theft dataset into PowerBI.

Click: Home → Get Data → Text/CSV → Transform Data

With that, I cleaned the data as I was only interested in the Auto Theft crime from the years 2020 to 2024. I manually just removed unnecessary columns (e.g, other crime types). I also verified column types (Year = whole number, Neighbourhood = text)

With the cleaning done, my dataset looked a bit like this.

(Keep in mind, this cleaned dataset is 790 rows of data)

STEP 2: Add Map

As mentioned earlier, although there is a ArcGIS feature on PowerBI, I wanted to only use features that PowerBI offers, eliminating the need for furthur licensing (for everyday users). So for this project, I used Shape Map, which is under the Visualizations pane.

With that added to the Format panel, I had to expand the Map settings, turn on Custom map, and upload the Neighbourhoods Boundary (JSON file).

With that you will see a neighbourhood boundary of Toronto

After Dragging the Neighbourhoods and AutoTheftCount columns from the cleaned dataset (in the Data pane) and dragging them to the Location and Colour saturation as follows:

You get a map choropleth map like the following:

Feel free to choose a colour scheme of your liking and make sure to add your title.

STEP 3: Add Interactive Year Slicer

As a map is now present, it is time for us to make the interactive feature of the dashboard. I did this by adding a Slicer (Year Slicer), and adding the Year column from the dataset. The slicer can be located in the Visualization panel.

After playing around with the format settings, I had finalized a Slicer that allows a user to click a year (2020 – 2024), which changes the map appearance with the Auto Theft counts within that specific year.

Step 4: Create Measures for KPIs

With the slicer working, it was now time to create the KPIs to provide viewers with key indicators that not only updated with the click of a button, but also gave insightful and readable information. This allowed the viewer to understand the map with better context.

I did this by creating new measures (Go to the top ribbon → Modeling → New measure). As the formula bar popped up, I wrote some code that helped analyze different insights.

The insight measures created were:

1. Total Auto Thefts

2. Neighbourhood With Most Auto Theft

3. Neighbourhood With Least Auto Theft

4. Highest Auto Theft in Neighbourhood

5. Lowest Auto Theft in Neighbourhood

6. Change in Auto Theft Based on Previous Year (%)

With the help of ChatGPT, I was able to validate my code.

Step 5: Turn Every Measure into a KPI Card

Now that the measures were all made, it is time for the easier step, which is to add KPI Cards.

In the Visualization pane, there is a feature called “Card”; make sure you use the dynamic version as seen below.

With 6 Cards now on the Dashboard, I then dragged each measurement into each card from the Data pane.

This is what was created from steps 1 to 5.

Step 6: Add Graphs

With graphs missing, I had decided to add a Line Chart that showed “Total Auto Thefts in Years”, and a Stacked Bar Chart that showed “Top 5 Neighbourhoods With Most Total Auto Theft”.

These graphs can be added by using the same Visualization Panel.

LINE CHART:

Make sure to drag the data to the respective X and Y axes.

STACKED BAR CHART:

Make sure to drag the data to the respective X and Y axes, and make sure to add a filter that takes only the top 5 neighbourhoods instead of all neighbourhoods.

After this step was done, I had a rough dashboard, which, although it wasn’t aesthetically finished, it now at least had an interactive map that changed based on a viewer’s click on a selected year, which also updated the KPIs and graphs data.

Step 7: Make it Finalized

After playing around with each feature’s formatting (to change colour and look), I had now developed a finished product that I was very pleased with.

This is now an interactive dashboard that displays information on the Auto Theft trends in Toronto based on the years 2020 to 2024.

By Matthew Cygan

GeoVis Project Assignment, TMU Geography, SA8905, Fall 2025

Introduction: Gone But Never Forgotten

Five days ago, on November 14, 2025, Ontario’s automated speed enforcement program ended¹. At midnight, all 150 of Toronto’s speed cameras stopped issuing tickets, closing a controversial five-year chapter in the city’s traffic safety infrastructure. Between January and August 2025 alone, these cameras issued 550,997 tickets and collected over $30 million². Since July 2020, they generated millions in revenue while reducing speeding in school zones by 45%³.

This memorial blog will aim to preserve the good memories. The result is a digital memorial: a 3D interactive web map documenting 198 speed camera locations across Toronto’s 25 wards, built with Mapbox GL JS and custom JavaScript. This map highlights geographic and temporal features along with the volume of tickets issued to drivers!

Users can scroll to zoom and hold Ctrl/Cmd and drag to rotate and tilt for 3D view

Preview

Context: The Automated Speed Camera Program and Its Ban

The automated speed enforcement program began in July 2020 after the provincial government enabled municipalities to deploy cameras⁴. By November 2022, Toronto had issued 560,000 tickets and collected $34 million⁵. The city expanded from 75 to 150 cameras in March 2025, using data-driven placement to target areas with speeding and collision histories⁷.

Despite some data indicating effectiveness (45% reduction in school zone speeding³, 87% reduction in vehicles exceeding limits by 20+ km/h⁹), Premier Doug Ford announced a provincial ban in September 2025, calling the cameras a “cash grab”⁸. The ban took effect November 14, 2025¹.

Consequences:

• Potential layoff of 1,000 Toronto workers¹⁰
• Loss of $30+ million in annual revenue¹⁰
• Removal of all active 150 cameras and infrastructure
• Provincial funding of $42 million deemed insufficient by city leaders¹⁰

Data Sources and Data Management

The project combines datasets from the City of Toronto’s Open Data Portal¹¹:

• Speed Camera Locations (GeoJSON)
• Monthly Charge Data (July 2020 to November 2025)

The Data Management Problem:

The biggest challenge was joining the location and charge datasets by my only linking variable: address. Unfortunately, both had a plethora of inconsistencies in address formats:

• Random double spaces: “Kipling Ave.” vs “Kipling Ave.”
• Period inconsistencies: “St.” vs “St”
• Abbreviation differences: “W” vs “West”, “Dr” vs “Drive”
• Directional contradictions: Same location described as “south of X” in one dataset, “north of Y” in another

The final dataset contains 198 documented locations, though some have incomplete enforcement data.

This experience showed me that real-world public datasets are messy. Data cleaning is often the most time-consuming part of any GIS project.

Building the Memorial Map

Step 1: GeoJSON Structure

All Speed Camera XY coordinates were exported to GeoJSON format to make the locations readable by JavaScript:

Step 2: Custom Basemap

I designed a custom basemap in Mapbox Studio that displayed a visually appealing and cartographically sound map:

• Grayscale base colors creating a neutral and smooth background
• Blue roads for road infrastructure clarity and visual harmony
• Minimal labels with clean typography creating a modern aesthetic

Step 3: Adding 3D Terrain

Late in development, I added Mapbox’s 3D terrain feature using the Terrain-DEM v1 tileset¹². This transformed the user experience:

• Users can hold Ctrl/Cmd and drag to rotate and tilt the view
• 3D visualization reveals how cameras are positioned in space and provides more real world context

Step 4: Bringing the Interactive Map to Life

Getting the interactive web map functional required three main files working together: the GeoJSON data, the HTML file, and the CSS styling.

The toronto_speed_cameras.geojson file, as seen in the image in Step 1, contains the coordinates and details for all 198 camera locations. Each camera is a Point feature with properties like ward, location name, site code, and enforcement dates. The JavaScript reads this file to position markers and populate the interactive popups.

The index.html file is the backbone. It sets up the page structure, loads the Mapbox GL JS library, and links everything together. JavaScript embedded in the HTML initializes the map and handles the interactive features.

The style.css file handles visual styling including map default extent and placement, marker appearance including hover effects and drop shadows, and responsive design for different screen sizes.

All three parts need each other. Without the HTML, there’s no web canvas. Without the GeoJSON, there are no locations to display. Without CSS, everything looks unpolished. Making sure each was properly linked and loaded was essential to creating a functional, interactive, and professional-looking final product.

Step 5: Interactive Markers

Using JavaScript, I implemented custom markers with the official speed camera icon:

Step 6: Deployment

I deployed the final map to Netlify’s free hosting service, making it publicly accessible at toronto-speed-camera-locations.netlify.app. Netlify’s continuous deployment means any updates automatically publish.

Technical Challenges and Solutions

Building the interactive map involved several practical technical challenges that shaped the final design. The raw dataset required rigorous cleaning and restructuring as mentioned earlier which lead to a large problem cleaning and thus a few locations could not be obtained.

Additionally, browsers block pages from loading local files for security reasons, meaning the map wouldn’t work when opened directly from the file system; it had to be run through a live server and eventually deployed online to load the GeoJSON data correctly.

The popups also displayed incorrectly at first. Text would overflow outside the popup container, which required removing conflicting styles and adding proper wrapping and layout rules. Although these limitations introduced roadblocks, the final result is a smooth, fully functioning interactive 3D map.

References

¹ CP24. (November 14, 2025). “Speed enforcement camera ban is now in effect in Ontario.” YouTube. https://www.youtube.com/watch?v=zvDqLrSjoos

² The Globe and Mail. (October 2, 2025). “Speed cameras work, but do generate revenue. Is the solution investing more?” https://www.theglobeandmail.com/drive/culture/article-speed-cameras-work-but-do-generate-revenue-is-the-solution-investing/

³ Toronto Metropolitan University & The Hospital for Sick Children. (July 24, 2025). “Automated cameras cut speeding by 45 per cent in Toronto school zones, study finds.” https://www.torontomu.ca/news-events/news/2025/07/cameras-cut-speeding-by-45-per-cent-in-toronto-school-zones/

⁴ CBC News. (November 29, 2022). “Toronto drivers paying $34M in fines thanks to speed cameras.” https://www.cbc.ca/news/canada/toronto/toronto-speed-cameras-millions-in-fines-1.6668443

⁵ CBC News. (November 29, 2022). “Toronto drivers paying $34M in fines thanks to speed cameras.” https://www.cbc.ca/news/canada/toronto/toronto-speed-cameras-millions-in-fines-1.6668443

⁶ CityNews Toronto. (March 13, 2025). “Toronto doubling the number of speed cameras on city streets.” https://toronto.citynews.ca/2025/03/13/toronto-doubling-the-amount-of-speed-cameras-on-city-streets/

⁷ Narcity. (April 15, 2025). “Toronto just got 75 new speed cameras and they’re already active in ‘problematic’ areas.” https://www.narcity.com/toronto/toronto-new-speed-cameras-2025

⁸ Ontario Ministry of Transportation. (September 24, 2025). “Ontario Protecting Taxpayers by Banning Municipal Speed Cameras.” https://news.ontario.ca/en/release/1006534/

⁹ Toronto Metropolitan University. (July 2025). “Study on Automated Speed Enforcement Effectiveness.” (Referenced in multiple sources as demonstrating 87% reduction in vehicles exceeding speed limit by 20+ km/h)

¹⁰ ST Lawyers. (November 14, 2025). “Toronto Layoffs After Speed Camera Ban: Severance Pay for 1,000 Workers.” https://stlawyers.ca/blog-news/toronto-layoffs-speed-camera-ban-severance/

¹¹ City of Toronto. (2025). “Automated Speed Enforcement & Open Data Portal.” https://www.toronto.ca/services-payments/streets-parking-transportation/road-safety/vision-zero/safety-initiatives/automated-speed-enforcement/

¹² Mapbox. (2025). “Add 3D terrain to a map.” Mapbox GL JS Documentation. https://docs.mapbox.com/mapbox-gl-js/example/add-terrain/

¹³ Halliday, L. (April 15, 2019). “Mapbox – Interactive maps in React.” YouTube. https://youtu.be/JJatzkPcmoI?si=HMYAtzRkYQ-nbR4y

You’ve heard about blockchain and Bitcoin about a million times by now, and may even own some, but did you know that many governments around the world are actually planning to intertwine blockchain technology in a different way, by combining it with their own countries official currency?

Governments plan to do this by implementing what’s known as a “Central Bank Digital Currency”, or CBDC for short. This solution allows governments to utilize the benefits of blockchain technology, without inhibiting the “risk” of decentralization. In fact, countries like Nigeria have already fully launched a fully operational CBDC for their citizens to use. Check out the maps I created below by clicking on the image, and try to spot some other countries that fully launched a CBDC! (Hint: Think islands!)

In case maps are not opening from image, try this link: https://torontomu.maps.arcgis.com/apps/instant/compare/index.html?appid=42c8571764d344949f7d80bd62e0be6b

CBDCs are important because they bring the benefits of blockchain technologies, such as transaction traceability (which can reduce fraud, scams, and other financial crimes), reduced friction, and improved transaction speeds with the benefit (or disadvantage, depending on who you ask) of a centralized government authority to monitor the network, meaning blockchain efficiency but without anonymous wallets. During Bitcoin’s inception, some early adopters called for the replacement of the US dollar with Bitcoin instead, making bold predictions that the world would transition to a decentralized financial system. Unfortunately for them, some governments around the world have banned Bitcoin by law.

What is interesting however, is that despite some countries being pro-CBDC, they may be-anti Bitcoin and crypto. For example; China, who outright banned the dealing and trading of Bitcoin by financial institutions, yet piloted the “eCNY” CBDC. (Try finding some other interesting patterns like this in the maps!) Some countries like the USA have researched a CBDC, but have the “CBDC Anti-Surveillance State Act” in place, preventing the Federal Reserve from issuing a CBDC. (Notes like this can be observed for a few countries in my maps, either under the field “CBDC Notes” or “Bitcoin Notes”).

I wanted to highlight some of these patterns, by creating a global map of Bitcoin legality across different countries, with a second displayable layer which includes CBDC development statuses across different countries. On top of that, I also found that existing Bitcoin legality maps online tend to be static, and do not allow for the convenient viewing of smaller countries, despite having relevant Bitcoin legality data, or CBDC development status data. It is worth mentioning that atlanticcouncil.org has already created an interactive “CBDC Tracker” map, however it does not contain any data regarding Bitcoin, preventing the instant viewing of a countries views on both topics (which my maps allow for by clicking on a country!).

Initially, I planned to create a different map, with layers not just displaying Bitcoin legal status across different countries, but also the legal status of altcoins and stablecoins. However, many countries do not have laws regarding altcoins and stablecoins (many don’t even have laws on Bitcoin, as seen in the grey areas of my map), so I decided to switch my projects trajectory a bit to instead focus on Bitcoin and CBDCs, as there clearly is a lot of data on CBDCs, and it is an even newer and more novel concept compared to traditional decentralized cryptocurrencies.

Map Creation Process:

The creation of my maps took a few steps. Firstly, I had to gather data. This proved relatively simple, as there was a convenient Wikipedia article (I know, I know, but its data was referenced!) that already listed Bitcoin legality across countries that had laws regarding it. I grouped legality into three categories: 1) Permitted By Law, 2) Partially Restricted by Law, and 3) Prohibited by Law. The next step, was to find a shapefile that contained the world’s countries. This was found on ArcGIS Hub, and was as follows:

I noticed it could not be edited, so I had to save it as a new feature layer in ArcGIS Online in order to do the necessary joins.

Next, creation of the .CSV file for joining. First, I copied the “Countries” column from the countries shapefile, then pasted it into a new .CSV. The rest was pretty simple, but tedious, as I manually went back and forth inputting the Bitcoin legality data for each country that contained it. This was done by inputting a 0 for prohibited, a 1 for permitted, and a 2 for partially restricted. I then used an IF statement to create the text column with “Permitted by Law”, “Prohibited by Law” and “Partially Restricted by Law”.

Next, I had to find data on CBDC development statuses around the world, and conveniently enough, atlanticcouncil.org has already created an interactive map that does just this, as mentioned earlier. I did however, find their map’s use of colours to be quite confusing (why is “launched” in pink!?). To add the data, I manually looked at each countries CBDC status, and included it into my .CSV into a new column. I also combined “Inactive” and “Cancelled” into the same category as “Inactive or Cancelled” to reduce the number of legend items, and for simplistic reading. Lastly, notes columns were added for any countries that may include, well, notable details regarding their CBDC status or Bitcoin legality status. In the end, my .CSV looked something like this:

Once the data was ready, it was time to map! I simply joined the countries shapefile to my data file, once for the “Bitcoin_Legal_Status” and once for the “CBDC_Development_Status”.

The resulting map layers were created:

Global Bitcoin Legal Status.

Global Central Bank Digital Currency Development Status.

Next, I had to publish each layer as individual web maps. This would allow me to get to my next step of creating the web app.

ArcGIS Online allows for the creation of web apps, known as “Instant Apps”. I created a “Compare” app, allowing for the side by side comparison of multiple web maps. I simply selected my maps, toggled a few settings, and my app was ready to go!

The world is changing fast, I think these maps highlight interesting dichotomies in some government’s views on blockchain technologies, the difference may simply just be if they can track who’s spending their CBDC’s and on what, as tracking anonymous Bitcoin transactions can be challenging. Invasion of privacy and government overreach or public safety and the future of finance? What do you think?

This blog post and map application was created for the SA8905 course at Toronto Metropolitan University taught by Dr. Claus Rinner.