Animated map – Page 2 – Master of Spatial Analysis

ArcPro Animation of 1923 Canoe Trip in Algonquin Park

By Sarah Medland

Geovis Course Project @RyersonGeo, SA8905, Fall 2018

Context

While searching the web for historic maps to inspire this project I came across the personal website of Bob and Diane McElroy. Their website includes an extensive personal collection of present and historic records of the natural environment within Ottawa Valley and Algonquin Park. The collection of thoughts and logs on their site consist of those of their ancestors – dating back many decades from now. The following map is a section of the one which was chosen for the purpose of this assignment. It dates back to 1921:

In July of 1923, a group of 4 men led by a guide embarked on a 12-day canoe-trip, creating a log of their route as they traveled. The map log included handwritten details by W. H. McConnell about wildlife, weather, and their experience in the Park.

Purpose:

to animate an artistic rendering of a historic canoeing route which…

– brings to life a historic map by integrating it with modern GIS technology

– reveals information from approx. a hundred years prior about an ever-popular canoeing area

Methods

To begin, the map was download as a JPEG and brought into ArcMap. A DMTI Spatial minor water bodies Shapefile was added. Using this present-day layer, labelled by lake name, it was fairly easy to align this with the lakes from the historic map. Some challenges arose as the map is from 1921 therefore its accuracy is questionable, however, I was able to geo-reference the map fairly well.

Historic Map in ArcMap where it was georeferenced to a present-day water bodies layer

Next, DEM tiles were downloaded from Scholar’s Geoportal. These were converted into a TIN using the raster to TIN tool in ArcMap, and then into TIN nodes using the TIN node tool. This allowed the tiles to be combined into one continuous TIN using the Create TIN tool which could be clipped to the extent of the map surface. Once the elevation surface was made, the map could be given height.

The map surface after it was draped over an elevated TIN surface and atmospheric effects were applied

To visualize the canoe route, a line Shapefile was created over the route drawn on the map. Campsites were also added as a point Shapefile which included a ‘Date’ field in the attribute table. In the ArcGIS Pro Global setting the map was draped over the TIN surface and campsites symbolized in 3D with the dates labelled.

An example of some of the original annotations on the map

Lastly, a animation following the canoe route was created in ArcGIS Pro. The animation was created to guide the viewer along the route of the 1923 trip and included annotations such as those above and historic pictures from the time period.

Results: The following video is the final product:

Visualizing Alaska’s Forest Damage in Twenty Years

Author: Anitha Muraleedharan
Geovis Project Assignment@RyersonGeo,
SA 8905, Fall 2018 (Rinner)

Forest Damage in Alaska

Alaska is a dynamic region and has a long history of changeable climate. Alaska has lost a lot of its forests due to insect infestation, fire, flood, landslides, and windthrow. Aerial surveys are conducted to monitor forest health for the State of Alaska and to identify insect and some disease pest trends. This time series map animation will visualize the forest damage in Kenai Peninsula, Tanana Region and Fort Yukon Region of Alaska during the years 1989 to 2010. This blog will cover the entire processes involved in creating this visualization.

Data

The spatial data of the forest damage survey conducted during the period from 1989 to 2010 by the Alaska Department of Natural Resources are readily available for download from AK State Geo-Spatial Data Clearinghouse (http://www.asgdc.state.ak.us/?#2952). The shapefiles are available individually for each year from 1989 to 2010 except for years from 2000 to 2007. These data were used for preparing this Time Series map animation.

Preparing Data for Animation in QGIS

QGIS 3.2.3 64bit was used to prepare the data for animated map visualization of Alaska’s forest damage. QGIS is a free and open-source cross-platform desktop geographic information system (GIS) application that supports viewing, editing, visualization and analysis of geospatial data. Since the data were available only as individual files, the first step in preparing the data was to merge this data together into one shapefile. For this task, I used the Merge Vector Layers Tool in QGIS which merged all the individual shapefiles into a single shapefile.

Steps to Merge multiple vector layers into one

Step1: Add all the vector layers, intended to be merged, into QGIS
Step2: Go to Vector →Data Management Tools → Merge Vector Layers in the menu
Step3: Click input layers button and select all the layers needed to be merged
Step4: Click Merged Layer button to give a name for the merged output layer
Step4: Click Run in Background button to create the merged layer and add it to QGIS

Fig. 1 Merge Vector Layer Tool in QGIS

The next task was to format the timestamp column to fit the QGIS Time Manager plugin tool that will be used to create the animated map visualization. The timestamp column for this data was “SURVEY_YR” which was in four-digit format. The QGIS Time Manager Plugin requires that the timestamp data be in YYYY-MM-DD format. For this, a new field was created with name “Damage_Yr” and type string and used the Field Calculator tool in Processing Toolbox of QGIS.

Fig. 2 Field Calculator Tool in QGIS

In the Field Calculator tool, the expression “tostring(SURVEY_YR) + ‘-01-01’ ” was used to concatenate data in the field “SURVEY_YR” and the “-01-01” together to make the timestamp in YYYY-MM-DD format and copy the data to the new field “Damage_Yr”.

Fig. 3 Attribute table showing the Damge_Yr in YYYY-MM-DD format after update.

Visualizing the Time Series

The Time Manager plugin was downloaded and installed in QGIS. The forest damage data was then added as a layer in QGIS. The Google Terrain map was added as the base map for this time series animation. The following steps were performed to add the Google Terrain map to QGIS.

Step1: Add a new connection to XYZ Tiles in QGIS and give it a name, say “Google Terrain”
Step2: Use https://mt1.google.com/vt/lyrs=t&x={x}&y={y}&z={z} as the URL.
Step3. Click Ok and then double-click the created layer to add the “Google Terrain” as the layer.

After the data was added, it was time to apply symbology to the polygon data showing the forest damage in QGIS. The layer was styled using the attribute “Damage_Yr” and categorized with sequential symbology. Once the data was styled, the Time Manager plugin needed to be configured to visualize the time series animation.

In the Time Manager Settings window, the Forest damage layer which needs to be animated was added using the “Add layer” button. The Damage_Yr column was chosen for the Start and End time and “Accumulate features” option was selected to show the features accumulated on the map as the year changes during the animation. 500 milliseconds duration was set in the animation options to show each year for that many seconds in the animation before showing the next year. To display each year as a label in the map during the animation, time format was set as “%Y” and the font, font size, and text color were also set.

Fig. 4 Time manager settings window

Fig. 5 Time display options.

The time frame in the Time manager dock was set as years since the forest damage in each year will be animated and displayed. The time frame size for the animation was set as 1 since we have data for each year from 1989 to 2010. The animation can be played by clicking the play button and QGIS will show the forest damage of Alaska in each year from 1989 to 2010 on the map window for 500 milliseconds each.

Fig. 6 Time Manager dock showing settings for the animation in QGIS

Converting the Time Series into Video

The Time Manager allows exporting the animation to a video. However, there is no option to add a legend onto the rendered maps in the animation in QGIS. Therefore, the maps were exported as .PNG image files. The map frames were exported first with the full extent of the map and subsequently, two more times with map zoomed to areas Tanana and Fort Yukon respectively for showing different areas in one animation. The legend along with title and data source labels were then added for each exported map frame using photoshop.

Finally, VirtualDub software was used to convert the .PNG files to video for each series of maps. VirtualDub is a free and open-source video capture and video processing utility for Microsoft Windows written by Avery Lee. The generated .PNG files were then renamed in ascending order sequence in the format “frameXXX.png” where XXX is the frame number. For example, frame000, frame001 and so on. This is required for VirtualDub to detect the files as a sequence of images and then combine it to a video. The steps followed to create the animated video is as given below.

Step1: Open VirtualDub software
Step2: Go to File → Open video file option in the menu and navigate to the images folder
Step3: Click the first image in the map image series and VirtualDub will automatically add all the other images that are in sequence
Step5: Go to Video → Frame rate and set fps as 0.5 to show each frame for 500 milliseconds in the video
Step6: Preview the video and save it using File → Save as AVI option in the menu

Fig. 7 Combining the png files in VirtualDub software

Results

<span style="width: 0px;overflow: hidden;line-height: 0" class="mce_SELRES_start"></span>
Watch the visualization on YouTube

North American Impact Events throughout History – A Map Animation

By: Nicole Slattery. Geovis Project Assignment @RyersonGeo, SA8905, Fall 2018

For my Geovisualization assignment, I wanted to create an animated map of impact crater events in North America throughout history. I decided to use ArcGIS Pro in order to do this because of the nature of the data. The Earth Impact Database maintained by the Planetary and Space Science Centre (PSSC) in New Brunswick, has achieved the 190 confirmed impact craters from around the world. The impacts have occurred anywhere from 1850 million years ago to 600 000 years ago. Usually, when creating an animated map throughout time, the map software requires a date. The impacts did not occur within the span of the Gregorian calendar used today; therefore, this software cannot map this data. However, ArcGIS Pro includes a tool “Animate through a range” which allows for this data to be animated sequentially without a date.

2D Map of Impact Craters in North America

In order to utilize ArcGIS Pro’s animation through a range tool, the data points of impact craters were geocoded and added to a new map. The points were displayed by proportional symbols of their diameter on the earth in km. Therefore, the map displays the distribution of impact craters across North America by their diameter. The locations were symbolized as well, in a gradient colours brown to black, in order for the points to appear to have depth. The 2D map can be viewed above. The basemap of the map was added from the basemap gallery under the Map tab in ArcGIS Pro. The World Imagery basemap was selected; this layer presents high resolution satellite and aerial imagery of the world. Another interesting feature of ArcGIS Pro is that any 2D map can be converted to a 3D scene for data visualization. Under the View tab, the Convert button was selected. Within this drop-down menu, the option To a Global Scene was selected. This converted the map into a 3D globe.

Converting the 2D map into a Global Scene

Under Properties of the scene layer impact points, the range setting was enabled for the “Age” attribute of the layer. The age attribute describes when the impact occurred in MYA (millions of years ago). The range was set between 1850 and 0 MYA, as this is the full range of the data in the layer. A range slider was added to the side of the scene. By dragging the slider, the points animatedly appear and disappear depending on their ages.

Enabling Range on the “Age” Attribute of the Impacts

Range Slider (display at 1315 MYA)

In order to start an animation, the Add button was selected in the View tab. This created and opened an Animation tab within ArcGIS Pro. In order to start the video, the Range of visible data was selected as 1850-1850. This way only the oldest impact crater is displayed. The scene was zoomed out for the first shot of the animation. By setting the Append Time to 5 seconds and selecting Append, the first clip of animation was created. This clip was 5 seconds. In order to display the progression of impacts occurring, the slider was dragged closer throughout time. By increasing Append time to 15 seconds and selecting Append, the animation clip was created. The animation clip is range aware therefore it will progress through the range slider up to where the slider was dragged throughout this append time. This process was repeated until the whole range was animated.

Range set at 1850-1850 in order to start animation

After the range of ages of the impacts was animated, a camera path was animated in order to create an interesting visual. By zooming and changing the view of the map and using the append animation clip, a visualization of the satellite imagery of the impact craters was created. For example, the Sudbury crater was zoomed in upon and animated. Then, a paragraph of facts about the Sudbury crater was overlaid using the Overlay option in the Animation Tab. As well, a scale was overlaid using the same tool. This was done for three other craters and was added to the animation video.

Finally, the animation was exported as a MP4 file in order to easily share the file.

The Final Video seen above was uploaded to YouTube.

Map Animation of Toronto’s Watermain Breaks (2015)

Audrey Weidenfelder
Geovis Project Assignment @RyersonGeo, SA8905, Fall 2016
mymap

For my geo-viz project, I wanted to create a map animation. I decided to use CARTO, a web mapping application.

CARTO

CARTO is an open source web application software built on PostGIS and PostgreSQL open source spatial databases. Users can manage data, run spatial analysis and design custom maps. Within CARTO, there is an interface where SQL can be used to manipulate data, and a CartoCSS editor (a cartography language) to symbolize data.

CARTO has a tool called Torque that allows you to ‘bring your data to life’. It’s good for mapping large data sets that have a time and/or date reference. CARTO is well documented, and they offer guides and tutorials to assist users in their web mapping projects. You can sign up for a free account here. The free account is limited to 250Mb of storage after which charges apply.

The Process: Connect to data, create new data set, add new column, symbolize

To create a map animation, simply connect to your data set either by dragging and dropping or browsing to your file. If you don’t have data, you can search CARTO’s data library. I had a file that I downloaded from the Toronto Open Data Catalogue. I wanted to test CARTO’s claim that it can ‘bring large data sets to life’. The file contained over 35,000 records of the city’s watermain breaks from 1990 to 2015. I brought it into CARTO through the file browser, and in about 40 seconds all 35,000 point locations appeared in the map viewer. From here, I explored the data, experimented with all the different visualization tools, and practised with CartoCSS to symbolize the data.

I decided to animate the 1,353 watermain breaks for 2015. I had to filter the data set using a SQL statement to create a new data set containing only the 2015 breaks. It’s easy to do using SQL. You select from your table and column:

Select * from Breaks where Break_Year = 2015

CARTO asks if you wish to create a new data set from your selection – select ‘Yes’. A new data set is created. It will transfer your selected data into a new table along with the attributes associated with the selection. You can keep the default table name or change the name of your table. I re-named the table to ‘Watermain Breaks 2015’

From here, I wanted to organize the data by the seasons: Spring, Summer, Winter and Fall. This required creating a new column, selecting data according to the months and days of the season, entering the selected data into the column, and reassigning it a new name.

In data view, select ‘Add Column’ from the table designer, give it a name and a data type. In this case I called it ‘Season’ and selected ‘String’ as the data type for text. The next step was to update the column ‘Season’ based on values from the ‘Break_Date’ column that contained the dates of all breaks. This was accomplished through the SQL Query editor, as so:

Update Watermain_Breaks _2015 set Season = ‘Spring’
where Break_Date >= ‘2015-03-21’ and Break_Date <= ‘2015-06-20’

The value of ‘Spring’ replaced the selected date range in the new column. This was repeated for summer, fall and winter, substituting the appropriate date range for each season.

I then switched to the Category Wizard to symbolize this map layer. Here you select the column you wish to symbolize. I wasn’t pleased with the CARTO default symbolization, and there are were few options to choose from, so I used the CartoCSS editor to modify:

/** category visualization */
#breaks {
Marker-fill-opacity: 0.9;
Marker-placement: point;
Marker-type: ellipse;
Marker-width: 8;
Marker-allow-overlap: true;
}

#breaks[season=”Fall”] {
Marker-fill: #FF9900;
Marker-line-color: #FF9900
}

#breaks[season=”Spring”] {
Marker-fill: #229A00;
Marker-line-color: #229A00;
}

And so on …

To make the map layer interactive, I used the Infowindow designer in map view. Here you can create pop-up windows based on a column in the table. Options are available for a hover window or a clickable window.

Adding Layers

To add more interest to the map, I added the City of Toronto Neighbourhood boundaries so that the number of breaks per neighbourhood could be viewed. I downloaded the shapefile from Toronto Open Data, connected the data set to my map and added it as a second layer. I added info pop-ups, and changed the default symbolization with CartoCSS editor:

/** simple visualization */ #neighbourhoods_wgs84{
Polygon-fill: #FF6600;
Polygon-opacity: 0;
Line-color: #000000;
Line-width: 0.5;
Line-opacity: 1;
}

Animation

CARTO only allows animation on one map layer, and it does not permit info windows. You also cannot copy a layer. As such, I added a new layer by connecting to the watermain breaks data table, and then used the Torque Cat Wizard to animate the layer.

Animation is based on the column that contains either a date or time. I selected the Break_Date column, and used CartoCSS editor to set the number of frames, duration of the animation, data aggregation to cumulative so that the points remained on the map, and then symbolized the data points to match the original watermain breaks layer. A legend was then added to this layer.

CARTO has the option to add elements such as title, text boxes and images. I added a title and a text box containing some facts about the city’s watermain breaks and pipe distribution.

The map animation can be viewed here . Zoom in, pan around, find your neighbourhood, move the date slider, and select from the visible layers.

Note: CARTO does not function well in Microsoft Edge

Displaying Brooklyn’s Urban Layers by Mapping Over 200 Years of Buildings

Renad Kerdasi
Geovis Course Assignment
SA8905, Fall 2015 (Rinner)

Growth in Brooklyn
Located at the far western end of Long Island, Brooklyn is the most populous of New York City’s five boroughs. The borough began to expand between the 1830s and 1860s in downtown Brooklyn. The borough continued to expand outwards as a result of a massive European immigration, the completion of the Brooklyn Bridge connecting to Manhattan, and the expansion of industry. By mid 1900s, most of Brooklyn was already built up as population increased rapidly.

Data
The data in the time series map are from PLUTO, which is a NYC open data site created by NYC Department of City Planning and released in 2015. The data contain information about each building located in the boroughs, including the year the construction of the building was completed (in numeric 4 digits format) and the building footprints. The building years range from 1800 to 2015, there are some missing dates in the dataset as well as some inaccuracy in the recorded dates. The data are available in Shapefile and Windows Comma Separated format, found on NYC Planning website: http://www.nyc.gov/html/dcp/html/bytes/dwn_pluto_mappluto.shtml

The Making of the Time Series
To present the structural episodes of Brooklyn’s built environment, QGIS 2.10 was utilized with the Time Manager plugin. QGIS is an open source GIS application that provides data visualization, editing, and analysis through functions and plugins (https://www.qgis.org/en/site/about/). The Time Manager plugin animates vector features based on a time attribute (https://plugins.qgis.org/plugins/timemanager/). This tool was effective in presenting a time series of Brooklyn’s building construction dates.

To create the time series, the PLUTO SHP was downloaded and prepared by removing any unnecessary fields. The columns of interest are: FID, Shape, and YearBuilt. Because we are interested in the time column, the formatting must fit with QGIS Time Manager. QGIS Time Manager requires timestamps to be in YYYY-MM-DD format whereas the building dates in the PLUTO SHP are in a four-digit format. Therefore, the date in the dataset must be modified to fit the Time Manager format before it can be brought into QGIS.

In QGIS, Time Manager plugin must be installed first. The SHP can then be added into QGIS as well as other Shapefiles needed: roads, highways, state boundaries, etc. Note: to use Time Manager, the data must be in SHP format.

Once the data are added, the polygons (i.e. buildings) are styled based on age. This will be effective in distinguishing the oldest buildings from the newest. In QGIS, there are a large number of options available to apply different types of symbology to the data. The layer is styled based on the attribute Year Built, since the time series will show urban layers using building dates. Also, Graduated is chosen because features in the layer should not be styled the same way. The other data file, such as roads, highways, and state boundaries, are styled as well.

Once all the data are added and styled, it can be oriented and applied to the Time Manager plugin. To truly see the urban layers, the map is zoomed on the upper portion of Brooklyn. In Time Manager settings, the layer with building dates is added and the Start Time is the Year Built field, which includes the timestamp data. To get features to be configured permanently on the map, in the End Time option “No End Time” is selected. For animation options, each time frame will be shown for 100 milliseconds, and timestamp (i.e. built year) will be displayed on the map.

In the Time Manager dock, the time frame is changed to years since the animation will be showing the year the construction of the building was completed. The size of the time frame will be 5 years. With these settings, each frame will display 5 years of data every 100 millisecond. Playing the video will display the animation inside QGIS, and one can see the time scrolling from 1800-2015 in the dock.

Time Manager also enables you to export the animation to an image series using the “Export Video” button. Actual video export is not implemented in Time Manager. To play the animation outside of QGIS, various software applications can be used on the resulting image series to create a video file.

In addition, QGIS only allows users to insert a legend and title in the Composer Manager window. Currently, it is not possible to get the legend rendered in the main map window. One approach to generate a video with a legend is to create a dummy legend and add the image containing the legend into the PNGs that Time Manager produces. A dummy legend and a title for Brooklyn’s urban layers was created outside of QGIS, and added to each PNG.

Finally, to create a time-lapse and compile the images together, Microsoft Movie Maker was utilized. Other software applications can be used, including mancoder and avidemux.

Results

Link: https://youtu.be/52TnYAVxN3s

Working with WMS-T layers and Time Manager in QGIS

By: Lauren Blumberger
Geovis Course Assignment, SA8905, Fall 2015 (Dr. Rinner)

Are you ever troubled by the amount of large files that you need to download and store on your computer? If so, a Web Map Service (WMS) may be useful as it delivers georeferenced map images over the internet that are generated by a map server. All you need is an internet connection to be able to access maps from a remote server and load them into your GIS. A request is made, and the response is one or more map images (returned as PNG, JPEG etc.). While WMS services are commonly used for retrieving base maps, they also provide a quick and easy way to work with data that has already been symbolized and styled by the author. Many WMS servers also have time support, WMS-T, which enables users to define a temporal subset for the rendering of layers that are properly configured with a time dimension.

In this post, I explore how to work with WMS-T retrieved maps in QGIS and how to animate them using Anita Graser’s Time Manager plugin (http://anitagraser.com/projects/time-manager/ and https://plugins.qgis.org/plugins/timemanager/). Anita Graser’s Blog includes a guest post by Karolina Alexiou on using Time Manager for WMS-T layers. I will describe the process, as well as discuss the limitations.

The first step is to find the service layers that you want to work with. This is not always the easiest task as you must use the GetCapabilities URL to access the maps, which in some cases doesn’t reveal the image until the connection is made from QGIS to the server. Thus, there might be some trial and error in terms of retrieving the maps you are looking for.

The map I use for this demonstration is made available by the Fire Information Resource Management System (FIRMS), who offer fire-based map images. The WMS-T allows access to FIRMS Active Fire Hotspots for a specific day. The GetCapabilities URL is provided on the website:

https://firms.modaps.eosdis.nasa.gov/wms-t/?SERVICE=WMS&VERSION=1.1.1&REQUEST=GETCAPABILITIES

Navigate to Add WMS/WMTS Layer in QGIS and click on new. Add the above URL and name the connection FIRMS. Make sure to enable the Ignore GetMap/GetTile URI reported in capabilities, as this will redirect you to the WMS instead of the WMS-T. When you click connect, multiple layers will appear. Load the MODIS_Hotspots layer to the canvas.*

Now that you have connected to the server you can overlay this image with other layers accessed through servers or available locally. Download any country boundary shapefile and load it to the canvas. Now you can change the style of this new layer and adjust the transparency to make sure that you can see the MODIS image underneath.

The next step involves the TimeManager plugin, which provides some support for stepping through this spatial temporal data.** Once you have installed the plugin, click on settings and add raster layer. The WMS-T standard uses many different time formats and the plugin requires you to know this format for inputting the start and end times. Therefore, you must examine the XML document with the web service description and find the section that defines the format of the time dimension. For this example, add the MODIS layer and input start time as 2005-11-16 and end time as 2015-11-16. Set the time step to months and press play. Now you will see that TimeManager renders each month interval by querying the FIRMS WMS-T.

Since WMS-T is a live service that will automatically update on the map, there are significant delays when working with these layers. Querying the web service and waiting for response takes time, and thus, the interactive mode using TimeManager does not result in a visually pleasing animation. TimeManager includes an option to export all the frames, which you can then move into another software to create a smooth animation.

The resulting animation shows the MODIS Active Fire Hotspots globally for the past ten years. The visualization works best if you maximize the video to full screen view.

Overall, working with WMS-T servers can be tricky. As there are many different time formats that can be used, it is quite a complex task to support them all in a GIS. Also, while you want to be connected to the server to be able to access live, current data, this connection slows down the rendering process and creates choppy animations. This being said, exporting the frames to create an animation provides a nice result and a fast way to visualize current data. As FIRMS constantly provides access to active fire data with the MODIS satellite, through reconnecting to the WMS-T and adjusting the time I can update the animation to 3 hours ago.

*The MODIS satellite detects both flaming and smoldering fires ~1000m²

**Note that FIRMS WMS-T only supports one date per request and date ranges are not allowed. To make Time Manager send the correct request, the source code file wmstlayer.py must be adjusted. If Time Manager is installed, the file can be found in the user folder on your computer. Replace lines 59 to 63 with:

self.layer.dataProvider().setDataSourceUri(self.IGNORE_PREFIX + \
self.originalUri + self.addUrlMark() + “TIME={}” \
.format(
time_util.datetime_to_str(startTime, self.timeFormat)))

This ensures that Time Manager only sends a point in time. A time range will return a black image for this WMS-T.

Special thanks to Dr. Eric Vaz and Anita Graser for their help.

Animating Toronto Parking Enforcement with heatmap.js

by Justin Pierre – Geovis course project for SA8905, Fall 2015 (Dr. Rinner)

Heatmap.js is a project developed by Patrick Wied to create heatmaps online using JSON data and javascript. It’s lightweight, free to use and comes with tons of great customization options.

For my geovisualization project for SA8905 I created an animated heat map of parking tickets issued in Toronto during the 24 hour period of May 1st 2014. Parking ticket data is supplied on the Toronto Open Data Portal.

Thursday May 1st, 2014 was one of the busiest days of the year for parking tickets. There were 9,559 issued in 24 hours. 6am was the safest time with only 25 tickets issued and 9am was the busiest with 1,451.

To create the heatmap I geocoded the Toronto parking ticket data using the city of Toronto street data with address ranges. About 10% of the records had to be manually geocoded to intersections, which was a time consuming process! Once I had the locations, it was simple to create a JSON object for each hour in excel, like this:

var h=[ {
 max: 100000,
 data: [
{lat: 43.667229, lng: -79.382666, count: 1},
{lat: 43.728744, lng: -79.30461, count: 1},
{lat: 43.778933, lng: -79.418283, count: 1},
{lat: 43.647378, lng: -79.418484, count: 1},

etc…

h is an array where each element is a JSON object containing the lats and lngs of each traffic ticket. The count is required for the heatmapping function and is always 1, unless you’re this driver:

Using heatmap.js is super straightforward. Initialize your web map in leaflet or openlayers (I used leaflet), configure some simple parameters:

var cfg = {
 "radius": .008,           //set for interpolation radius
 "maxOpacity": .8,         //set to .8 to show the basedata
 "scaleRadius": true,      //recalibrate radius for zoom
 "useLocalExtrema": true,  //reset data maximum based on view
 latField: 'lat',          //where is latitude referenced 
 lngField: 'lng',          //where is longitude referenced
 valueField: 'count'       //where is the numerical field
 };

Attach that to your heatmap object and point it at your datasource like so:

heatmapLayer = new HeatmapOverlay(cfg);
map.addLayer(heatmapLayer);
i=0;
heatmapLayer.setData(h[i]);

Remember that h[] is the array where the ticket data is stored and so h[0] is the first hour of data, midnight to 1am. This will create a static heatmap like this:

Now comes the part where we cycle through the hours of data with a setInterval() function:

setInterval(function(){ 
 i+=1;
 if (i>23) i=0;
 $( ".heatmap-canvas" ).fadeOut( "slow", function() 
   {heatmapLayer.setData(h[i]);
   heatmapLayer._draw();
   $( "#hour").html(i);
 });
 $( ".heatmap-canvas" ).fadeIn( "slow", function() {
 });
}, 2000);

Every 2,000 milliseconds (2 seconds) the page will fade out the heatmap layer, switch the data for the next hour and fade it back in. If the cycle has reached the end of the day it resets. The $( “#hour”).html(i) bit refers to changing the hour printed on the webpage itself.

You can check out the finished project at http://justinpierre.ca/tools/heatmap/ and be sure to let me know what you think at https://twitter.com/jpierre001.

The Cooling Effect of the 1991 Eruption of Mount Pinatubo, Philippines

By Clarisse Reyna

Geovis Course Assignment, SA8905, Fall 2015 (Rinner)

This is a time series map showing interpolated temperature change. Mount Pinatubo is located in the island of Luzon, Philippines. It erupted in 1991, which marked the second largest volcanic eruption in the 20th century. This caused a cooling effect as it released significant amounts of volcanic gases, aerosols and ash that increases albedo. This means that there is an increase in solar radiation being reflected, which decreases the amount of solar radiation reaching the troposphere and the surface. Since there is less solar radiation at the troposphere and the surface, it causes a temperature decrease. This is exactly what took place when Mount Pinatubo erupted in 1991. After the eruption, there was an observed surface cooling that took place in the Northern Hemisphere of around 0.5 to 0.6 degrees Celsius (Self et al. 1999).

In this time series map, interpolated temperatures in the Philippines from 1988 to 1995 is presented. What you should be able to see is that as time passes after the eruption (1991), there is a significant increase in blue areas which indicate lower temperatures. Originally, the years included would have been from 1985 to 1995. However, there are unusually low temperatures in 1987. In fact, the lowest ever recorded temperature in Manila was on February 4, 1987, with a temperature of 15.1 degrees Celsius. As you can see in the picture below, 1987 has large blue areas, indicating low temperatures. This may cause confusion when viewing the final time series visualization, so it was omitted from the final geovisualization project.

The purpose of including temperatures before the eruption in 1991 is so that the viewer is able to see temperature trends before the cooling occurred. This allows viewers to compare temperature trends before the eruption to temperature trends after the eruption. The years included went up to 1995 because this was the last average temperature where it shows decreasing temperatures from 1991 in most of the cities.

The temperature data in this time series geovisualization were taken from a website called Weather Spark. The data taken from this source was yearly temperature averages from 1988 to 1995 in the Philippine cities of Aparri, Batangas, Bohol, Catarman, Coron, Manila, Davao, Lapu Lapu, Pasig, El Nido, Legazpi, and Pagudpud. Temperature data for the city of Boracay was not available so the province of Malay was used in place of it. Another province used was Bulacan. These areas are very spread apart in the Philippines. Therefore this gives a more accurate representation of temperature patterns during interpolation since the data points are spread apart and covers each part of the country. Lastly, the Philippine boundary shapefile was taken from a website called PhilGIS.

The technology used for this time series visualization was Time Slider, which is available in ArcMap (in versions ArcGIS 10.0 and up). For each year, the data taken from Weather Spark for each city or province was interpolated using the Inverse Distance Weighted method. Therefore, a raster was created for every year. Since there are eight years that are being included in this visualization, eight rasters were created. After creating an interpolation raster for each year, a raster catalog was created, and each of these rasters were added onto the raster catalog. After the rasters were added, time was enabled on the raster catalog layer.

When time is enabled on a layer, ArcMap allows you to use the Time Slider tool to create the time series visualization. This time slider tool allows you to preview what the time series visualization will look like. You can then export the time series visualization to an .avi file by clicking on the icon circled in red in the picture below.

References

Country Boundary. (2013). In PhilGIS. Retrieved from http://philgis.org/freegisdata.htm

Historical Weather. In WeatherSpark Beta. Retrieved from https://weatherspark.com/

Self, S., Zhao, J., Holasek, R., Torres, R., & King, A. (1999). The Atmospheric Impact of the 1991 Mount Pinatubo Eruption. U.S. Geological Survey.

TTC Subway Stations and LRT Expansion Animated 1954-2021

An animated look at TTC’s subways and LRT expansion by when they first opened. Includes 2017’s Finch West subway expansion and 2021’s Eglinton LRT expansion.

By Khakan Zulfiquar – Geovis Course Assignment, SA8905, Fall 2015 (Rinner)

As a course assignment, we were required to develop a professional-quality geographic visualization product that uses novel mapping technology to present a topic of our interest. I chose to create an animated-interactive map using CartoDB to visualize the construction of Toronto Transit Commission (TTC) stations from years 1954 to 2021. The interactive map can be found at https://zzzkhakan.cartodb.com/.

Project Idea

This idea was inspired by Simon Rogers who animated the London’s Rail System. It was interesting to see an animated map slowly draw together a footprint of an entire infrastructure system. A number of (non-interactive) animations of Toronto’s subway system development were collected by Spacing magazine in 2007 and can be viewed at http://spacing.ca/toronto/2007/09/21/ttc-subway-growth-animation-contest/.

A feature within CartoDB called “torque” was used to create the envisioned map. Torque is ideal for mapping large number of points over time. Torque has been famously used in media for mapping tweets as pings.

Execution

As a beginner to CartoDB, I had to go through tutorials and online courses to get familiar with the interface. As I became comfortable with CartoDB and its features, I recalled an example I had seen in the CartoDB gallery. It was Simon Roger’s London Rail System map. I knew exactly the kind of data I would need to make a similar map for TTC stations. There was an instant halt as the data was not readily available. Using Wikipedia, ttc.ca, and OpenStreetMap I was able to compile the data I required. The data was uploaded into CartoDB and the following map was created.

Tutorial / How-to-Use

For the heading numbers above, please find the associated instructions below.

Title and Subtitle – Speaks for itself.
Toronto Subway/ LRT Map [full resolution]- A Map of Toronto’s Subway and future LRT produced by the TTC. This map is the most common visual representation of TTC’s subways and LRT. The map’s color scheme was mimicked to help viewers, especially those familiar with TTC, make the transition to the animated map smoothly.
Timeline – The timeline is in a continuous-loop. You can press pause to stop the animation and resume to start the animation again. You can also control the speed of the animation by sliding the play-bar back-and-forth.
Hover Window – As you hover over the stations, a window will pop up automatically with the name of the station. No clicks required. The names will only appear if the “ttc_station” layer is switched on (more on this in step 7).
Info Window – If you would like further information on a certain station, simply click on the station and you will be presented with the station’s name, line #, grade (above, at, or underground), platform type, and etc. The info window will only appear if the “ttc_station” layer is switched on (more on this in step 7).
Legend – as the name implies…
Layer Switch – a tool to turn on or off the layers being used in this map. The map was created with the intent to be both animated and interactive. The animated bit is the stations being plotted and the interactive part was for the user to find further information about the station. However, the animated bit is both intrusive and resource-heavy. Because of this, an option is being included to turn layers on-or-off as required. Be sure to try out the combinations.
MAIN SHOW – the main map area has a beautiful CartoDB Dark Matter basemap with all of the TTC stations plotted. Feel free to zoom in and out.

Enjoy viewing and exploring.