Will Skora's blog

An Abbreviated Review of Markers and Marker Cluster Accessibility in Web Map Libraries

Sat, 31 Jan 2026 06:25:06 -0500

This post assumes that you have basic familarity with web maps and concepts like zoom level, This post is also not fully complete and can use a couple clarifications in some places as well as some editing and polish.

At my workplace, we’re redesigning a landing page of our Ohio Authors Initiative that highlights the lives of over 300 Ohio authors, each with individual biographies (like this one of Amy Braunschweiger).

The Literary Heritage Map by the Pennsylvania Center for the Book is loved by our Literature librarians and I was asked “could I do something like that?” (well, in the back of my mind, not exactly like that since we don’t have an ESRI license ;)

And yes, I thought a map would be appropriate for this (the first question to ask even before making a map), so we could:

effectively communicate that Ohio Authors are generally spread geographically all over Ohio; with the Cleveland, Columbus, Cinncinnati, dominating as you’d expect; with college towns like Athens, Yellow Springs, Kent, and Oberlin punching up. The southeastern portion of the state had fewer authors.
allow readers to browse authors geographically: without knowing of names of cities/towns in Ohio, browse by region, instead of thinking of and searching by each city (what is currently available)

How should I represent the points on the map?

My initial thought, given the contraints in the existing data set:

There are over 120 unique towns/cities; over 350 authors, all within the State of Ohio
Each Author has 1 town/city associated with it (determined by our librarians, based on the author’s current residence or where they grew up) .

For context, each author has their own dedicated ‘page’ and we can assign a city/town with it (In WordPress lingo, we have a custom post type, ohio_author, and there is a custom taxonomy named ohio_author_city. Then in the back end/wp-admin, I would geocode that that city’s name into latitude and longitude coordinates, stores the lat/lon as custom fields, then fetch those custom fields

So, How to display the markers in a map that is accessible for all of our patrons so they could geographically browse the locations of Ohio Authors?

Markers and The Marker Cluster

My initial approach that we could build a map and that marker cluster; having built maps in the past, I knew that markers were keyboard accessible (or I thought!).

Markers are the common name for individual points on a web map and are often interactive for the user, often with a openable pop-up window to display further information.

Marker Clusters are points that aggregate more points when you want to want to represent all points at lower zoom levels to the user without overwhelming the user or cluttering the map.

Marker Clusters are used in the popular web map libraries like Leaflet, google maps, mapbox GL, maplibre, and ESRI although ESRI calls them point clusters.

With a few hundred points in the State of Ohio - I instantly thought of marker clustering as the way to represent all of those markers on the map.

The goal with marker clustering, with adding one marker on the map for each author whose city would be geocoded (to the same, centroid point within that city’s boundaries;

I didn’t want to assign a random point within a city’s boundaries for every author - with a random placement, people may that a particular geographic location (where the singular marker is located) in the city would have meaning to the author.

for example, 3 markers within a small town; one is randomly placed within a lake or river, another may be randomly placed in on a street, the map viewer would think maybe the author (of that marker) was associated with);

and a randomly placed marker that is on eastern edge of one city Y and then a randomly placed marker that is on the western maybe very geographically close even though they were for different places.

Screenshot from 2025-12-02 13-50-11.png

is the hundreds of markers on the map; although these are randomly placed and one for every

My initial approach was to use Google Maps library because our branch location map uses Google maps and we have a lot of existing code behind the scenes, including geocoding, and I’d like to reuse as much as possible.

Before, I fully build out the map, I wantd proof of concepts down and simpler examples and I wanted to make sure the marker clusters are accessible by keyboard.

Web Accessibility

The goal of web accessibility is to generally make all content and functionality to be accessible, usable, by all users; regardless of their motor skills, vision, or hearing. Keyboard accessibility - ensuring that all functionality and content on a web page can be done through only the keyboard (more details) is a key (pun intended) part of making a web site accessible and one that I’ll focus in this article. Making a website or web map accessible involves much more than just keyboard accessibility; I’m focusing just on keyboard accessibility in this post.

For the unaware and those following and wish to test out the keyboard accessibility of a map: Tab is the keyboard shortcut to move between interactive elements* (links, buttons, form fields like search text boxes, dropdown menus, etc); then within those interactive elements, arrow keys are used to further navigate. Tab + shift is used to access the previous interactive element. For accessing the markers within the map, when the keyboard focus (often visually designated by an outline around the element currently focused) is on the larger map, that is when you press the arrow keys, as shown below: (There are many, many exceptions to these keyboard shortcuts).

Robert Linder thoroughly reviewed several map libraries’ basic functionality for accessibility although that didn’t include markers and marker clusters. I hope this blog post provides some useful analysis and recommendations of going forward for marker and marker clusters on web maps.

While most users will use a mouse or their hand to tap and open a marker cluster; we should not assume that all users place the cursor or I cannot assume (no should you as a web developer) that a person will use a mouse to access information.

—— EDIT The Goal with our map, is:

to have markers to show (which places/towns have more authors than others ) on the map, and

Have on each marker, allow the user to open the marker (or markercluster) (through a marker pop-up) to view the list of authors associated with that city.

The thought was to do this was with marker clusters and make 1 marker for each author but on the marker cluster, combine markers and list all of the authors at the lat/lon.

I was imagining something pretty close to:

—– edit

Map Library Marker Cluster Performance

Google Maps:

tl;dr: Frustrating and inconistent for accessing markers and marker clusters by the keyboard

Marker clustering is not included into the default Google Maps JS library so I forked the google maps’ markercluster library and wanted to get some smaller examples. I modified the examples in the examples directory on google maps’ github

(Most of my examples do not include every marker that would be in my map; I only added 20-35 markers as a test)

So, let’s get an accessible (at least for keyboard accessibility) marker cluster example up and running! Follow along in my github fork.

My first initial examples (as code) and then as a page Here, I couldn’t even access any of the single markers by keyboard nor were could they be accessed through any assistive technology like a screen reader (probably because they were made with the Shadow Dom.

I then learned by default, individual markers in google maps do not receive any keyboard focus (cannot be accessed by tab) and that is intentional.

Markers are not tabbable (and do not receive any keyboard focus) by default according to a June 2021 blog post by google employee Chris Shull. According to Chris, markers that do not have a click event (any action that would happen like a pop-up window) attached to the marker are assigned an “img” accessibility role,” meaning that they are skipped over in most assistive technology and cannot be accessed by a keyboard.

Although in my testing, single markers, by default in google maps, are not any assigned any accessibility role; they do not appear in the accessibiliy cannot be accessed even if you’re trying to browse the img (or images with the assigned role (which can be done in the keyboard when using a screen reader); for example, and the my first example; or the official example. On both of those pages, I couldn’t access it in neither NVDA & chrome nor NVDA & firefox.

As a result, someone only using a screen reader, does not know that there are individual markers in the map; only just that there are 2 marker clusters.

I argue the markers (or marker clusters) themselves are informational - information like how many markers are included in the map and each’s marker/point location this should be communicated to all map users by default in a map library. Currently, this is only communicated visually. Strike one.

I needed to add the property “gmpClickable: true” to the AdvancedMarkerElement so individual markers can accessed by the keyboard. and override the default behavior.

In my next code commit from 12/25, the individual markers and marker clusters markers were both now focusable by keyboard in this 2nd working example.

I then needed to figure out how to create the event listener pop-up for each marker so when the marker was opened (By keyboard, tapping on it, or clicking); the information from the pop-up would eventually display there. I found an example in the google maps’ accessible markers doc. I added the pop-up infoWindow for each marker in this commit. In my eventual map, the pop-up window will contain the list of authors associated with that town/place (more on that later)

(Note to anyone who comes across this : If you’re using google’s js-markercluster library and want to share their examples after cloning the repository:

run npm run docs in js-markerclusterer directory that will compile/build your changes that made in the examples folder into the public folder , which you can then upload anywhere on the web * (of course, you have to provide your own google maps API key). This info is missing from the readme and was not obvious to me in the documentation (although I figured out it by deciphering the package.json)

At my next commit, As of Jan 17th commit, but with the markerclustering library, I haven’t figured out. With my working example.

(I’m aware in this commit, even under all conditions, you cannot open the pop-up for the marker clusters, that is because there are multiple markers at the same lat/lon and I restricted the zoom level, leading to my plan)

The Accessibility issues with Google Maps

Keyboard accessibility: madly inconsistent . Some times, I could access (by keyboard) all of the markers and marker clusters; other times, I could only access the marker clusters by keyboard and the individual markers were not accessible. Other times, all but one marker could be accessed. This was across multiple computers and operating systems (Windows 11, Chrome and firefox) and (Firefox 147 and Chrome on Ubuntu 22.04). I couldn’t determine a cause or pattern.

Even if I couldn’t access all of the marker or marker clusters by keyboard, all markers and marker clusters were listed through NVDA and Jaws (screen reader) through as shown in the screenshot below. Although clumisly, someone could move the keyboard focus to the marker cluster BUT they (if I had properly the names of the towns in each marker, instead of a generic hello world). Again, though, someone should be able to access all markers without having to use a screen reader.

(NEED SCREENSHOT)

For marker clusters, assistive technology will say “cluster of X markers” (replace X with the number of markers) - . As I mention earlier, adding the geographic context (even a rough location) of the marker cluster would be invaluable;; stating something like “33 markers around Cleveland, Ohio)” like in this example. For someone , they could know which of the marker clusters to browse to; otherwise, they just see as shown in the screenshot.

something like it could inform someone using NVDA or another screenreader (or anyone who has vision have the vision broadly, knowing, This behavior of stating of providing ‘X clusters of markers” is also common to Leaflet as well. (On the other hand, adding the functionality of the marker detecting that extra bit of geographic knowledge, is not simple, although it’s a worthy challenge).

I had the same inconsistent results with the marker clustering example from Google as shown in the following (Very sped-up) image, so I’m not just alone.

View this gif as a slower webm.

Try yourself with the keyboard (Remember, tab to move across each element, tab + shift to go back)

Positively, when you open a pop-up on a marker, the focus is moved to the marker so you can then close the marker immediately or interact with the marker’s contents (like visiting a link). This is consistently reproduced.

So, where I'm at right now for my project

As of Jan 17th commit, but with the markerclustering library, I haven’t figured out. With my working example.

(I know in this commit, even under all conditions, I cannot open the pop-up for the marker clusters, that is because there are multiple markers at the same lat/lon and restricted the zoom level, leading to my plan)

As I drafted this blog post and encountered that above issue for the I wondered - do i really need to actually cluster the markers ?

My initial proof of concept, I rendered over 300 individual markers, at instead of a - a crucial mistake.

I almost regret that I did spend so much time on the blog post and investigating marker clusters.

I had thought of another approach:

how would it look without the marker clustering ?

Instead, do I not need 1 marker per author? just create one marker per city and style that marker based on the number of authors who are affiliated with that city?

As an alternative: I removed the marker cluster, and have one marker for each city ( commit ) and here’s the this visual example.

Again, this is just my mockup, and hey, i can access each marker at this point by keyboard, I need to access every markers’ contents

But, I need to visually represent how many authors are at each city (that would be helpful, i think on the map)

My current idea/approach is the following:

Ditch the marker clustering, instead:

create a foreach loop, For each author that comes through (which has properties like, the author’s name, the associated city (as a text field) and the lat/lon pair:

see if there already a marker created for that lat/lng pair:
- If no marker for that lat/lng pair,
  - create a marker at tha lat/lng, create a pop-up window with the city/place name, and create a list and insert a link to the author’s biography <li> author nameassociated with that lat/lon pair</li>
- If a marker already exists at lat/lng pair,
  - find that marker, modify the pop-up-windows contents, and add the <li> author nameassociated with that lat/lon pair</li>
  - increase the numerical value of a variable (authorCount) that I had made within the foreach loop
  - increase the marker’s width based on the AuthorCount and then increase the marker’s width/and or changes the marker’s color based on that AuthorCount)

This would then end up with something like (of course with the marker modified):

rateyourmusic, a cataloging service of music (like letterboxed for music), displays a map of artists whose albums you’ve reviewed (a live link to the map requires you to be registered and logged into their website) and this is pretty darn closer to what I’m imagining although there’ll be (credit to Luke Everhart for suggesting to me rateyourmusic as inspiration)

Other Web map libraries:

(I had briefly experimented with these but I am not including each commit, this article was gitting long and you’ll mapbox and maplibre’s initial results weren’t great. )

Mapbox GL and Maplibre

Mapbox and Maplibre, a fork of Mapbox, have 2 approaches to render point geometry as ‘markers’: neither are great for keyboard accessibility and don’t follow .

One approach, if you add the points as a map layer:

When the points are added as a map layer, Mapbox and Maplibre.GL’s markers and marker clusters are NOT keyboard accessible. Regardless whether or not you attach an event or pop-up to the points; you cannot access them with a keyboard.

Mapbox’s cluster example rendering earthquakes(data from a 3 week period in 2015-16) and Maplibre’s nearly-identical Marker Clusters example are 2 examples where your points (the geometry) are added as a map layer and

Only the single elment as a canvas

Below is the Maplibre’s marker clusters example using Jaws 2022,

In Jaws (and other assistive technology), only the toggle, light/dark mode, a search input (for the entire maplibre website), clear the search input, nd the map’s controls ; only map attribute is directly associated with the map; the rest are a part of the larger web page.

This violating one of the most basic tenets of accessibility ; not making the map’s markers accessible by keyboard.

Ironically, when you click on an individual marker using a mouse (or tapping), the keyboard focus is moved to the marker with the pop up windows, allowing a user to immediately close the pop-up (which isn’t done in Leaflet).

By inspecting the DOM, you’ll notice that the map is rendered in the canvas element Increased speed of , he advantage of is increased speed and some consistent styling

Although canvas is a part of the DOM Tree; canvas accessibility, is well, still has ways to go. Kanaru Sato wrote an informative piece in 2024 about the state of accessibility in Canvas.

MDN recommends to not use canvas for accessible elements(although that is probably too strong of a recommendation).

Other Approach in mapbox/maplibre, rendering points as a Marker (API Doc).

Rendering points as markers results in some better accessibility experiences:

Now, just rendering points as markers will not immediately create a more accessible experience in Mapbox or Maplibre.

Rendering points as markers adds them to the DOM, as individual markers ; what are they ?

If you don't add any pop-ups or event interaction; individual markers are by default assigned an aria role of image , which does not make them interactive by keyboard; but but if you are someone using assistive technology like a screen reader. However, the but just state 'map marker'; which - to my ability - cannot be customized. Instead (MORE LATER in the information - like the marker's location, should be attainable If you don't attach an event to the marker like a pop-up, you will not be able to they will not be accessible by a keyboard like in Mapbox's default markers example. If you attach an event (like a pop-up to the markers), the markers usually* become accessible to the keyboard. In this dynamic markers example from mapbox done in react, markers are attached to the DOM. but the markers are assigned role of `img` which removes the keyboard interactivity but using other In this map, the arrow keys are used to navigate the area displayed on the map. () Marker Clusters in Mapbox (GL) can be rendered within the DOM but they are again assigned an ARIA of image; which results in them not being accessible by the keyboard. so if you ; https://docs.mapbox.com/mapbox-gl-js/example/cluster-html/ (OK RESUME HERE!!! ) AND YES, there's a tradeoff - https://dev.to/mapbox/how-lemontree-improved-map-performance-with-a-small-refactor-2272 of going with markers; markers will only make Single markers can be exposed to the DOM; if you follow this Mapbox Tutorial (More information this github ticket). The clusters are there for But if you add your data as a marker AND offer additional interaction (like a pop-up), the marker will be added (assigned a `role=button` ) as shown in this attach a pop-up to a marker maplibre example the lack of marker accessibility is mentioned in https://github.com/mapbox/mapbox-gl-js/issues/11763 and it was recently resolved in Maplibre (there is the other library, ) Accessing by keyboard was very recently implemented (in January 2026) in MapLibre, v. 5.9.x, in this PR request by https://github.com/maplibre/maplibre-gl-js/pull/6517 by Corado Burcus. https://github.com/maplibre/maplibre-gl-js/issues/356 But, Mal Wood-Santoro's a11y-map-gl plugin for MapLibre for is really promising; I've yet to experiemnt with it.

Leaflet:

Leaflet will be my next option that I'll thoroughly try if Google Maps doesn't work out. This Leaflet Map from the little free library utilizes marker clusters, can be toggled through the keyboard but they cannot be opened by the keyboard. Leaflet's 2.0 release is pretty soon as of this writing and it's a complete re-write. Marker Clustering is a plugin that has to be added. built into there has been extensive Work by https://kristjanesperanto.github.io/Leaflet.markercluster/example/marker-clustering-accessibility.html where the marker clustering and are accessible by keyboard! Although, there are other marker related issues like the https://github.com/Leaflet/Leaflet/issues/2199#issuecomment-443891218 https://github.com/Leaflet/Leaflet/issues/8115 Within Leaflet, there is the ability to customize the To customize the aria-label that's passed along and https://kristjanesperanto.github.io/Leaflet.markercluster/example/marker-clustering-accessibility.html . This means, when you , ! I'd love to test this more but this looks very promising!

Spidering, an alternative to Marker Clustering:

Spidering is another method that i had thought of as well and tested very early in map-making process but the google maps' spidering library is no longer maintained and fails basic keyboard accessibility - lead to keyboard traps (being unable to exit the spider marker using only the keyboard). I could fork it (and some updates have been proposed ) and rewriting but my time is limited. I'd probably rather use Leaflet than spend the time updating a google maps library. Secondly, I don't think spidering would be as aesthetically clear for the user either.

Summary

Maps traditionally have been a visual medium and implemented as such. (hot take:) But we have to turn that assumption on its head and remember what are maps' purpose are also abou communicating spatial information to its users. Most online web maps still focus on visually communicating that information (understandibly so) and to use the mouse for interactions. Map Libraries: - include a rough location of the marker or marker cluster in its aria-label. - consistent marker tabbing on google maps. - When keep marker focus on the marker when the marker opens There's a lot of improvement for making maps with markers and marker clusters more accessible, some of which you can do if you're making web maps yourself: - Use leaflet if you're , their support is the most promising. - include an input searchbox where a user could enter a text term of the geographic area that they want to search, which is then geocoded and moves the keyboard focus marker as a supplement to have to tab and move through what could be tens of marker clusters. (this should be doable) Long term: I think there's a more re-imagining of what the accessible web map will be. I hope that this post moved the ball a little forward and I found Audiom although is promising although its source isn't publicly available (but based on and requires you to contact them.

Archiving Your Past Web Map Projects

Sun, 23 Nov 2025 06:25:06 -0500

This post was largely drafted in May 2020 but the practice and point still remains. I’m making more of an effort to share my past work. I have quite a few posts that I’ve left in draft for whatever reason.

James Fee’s tweet (now since deleted in 2025 when I’m publishing this) along with Mapbox’s recent announcement of deprecating loading maps made in Mapbox Studio classic, reminded me that the ‘life span’ of online web maps are relatively short, sometimes 2-3 years. How do you view or remember them when software breaks, the hosting bill is no longer paid, your employer decides to just cancel the project, or the company hosting it goes out of business?

I didn’t to lose the work that I’ve done over the years; I wanted to be able to save and view them later so here’s what I’ve been doing.

Decide and prioritize what you want to save Obvious needs to be said, but you can’t save everything. One of my largest misconceptions of public libraries before I started working at one is that they archive and save so much everything: they save and preserve a lot less than you think. Libraries decided what ou. (particularly if it Deciding what to save and document is part of their process. With online maps, you won’t be able to save every view, every map interaction , every zoom level.

1a. For online maps that may be large and you can’t capture the entire area: what geographic areas hold personal sentimental value to you? were unique or noteworthy? Any geographic areas on the map or map interactions that really showed off your work and effort ?

For Raster Maps (before vector tiles were widely used), the-ultimate-tile-stitcher, a python script made by Stamen, that enables you to download each of the png raster tiles and then stitches them together as one very large png image.

the-ultimate-tile-stitcher worked excellent to fetch several maps I made in Mapbox Studio Classic. These maps didn’t have any interaction, markers, pop-ups, on them; these were base maps; the-ultimate-tile-stitcher works best on base maps. the-ultimate-tile-stitcher only works on raster tiles (X/Y/PNG) which is what mapbox was getting rid of in 2020 (2025 edit: that long ago ?!).

If your map is a vector map (or is web-gl like Mapzen’s Tangram maps): Make a screen recording while viewing the map and map interactions; zooming in and out at multiple zoom levels, and whatever you want to capture. Making the screen recording while you view your map works across any mapping library and software that you use.
don’t forget to add a couple sentences about the project; include the project docs and your build setup. you may forget a few years from now ;)

Will's 2024 Proposed City of Cleveland Ward Boundaries

Wed, 30 Oct 2024 13:33:06 -0400

Long time no talk. (Note: this post will be further edited for grammar and clarity)

Currently, Cleveland has 17 members of Cleveland City Council, councilmen, that each represent a designated geographic area known as a ward.

Because of City Rules and city’s declining population, the ward boundaries are being redrawn in a relatively opaque process.

Before the proposed boundaries are released, I wanted to try drawing my own, so here is how I did that, and what I learned in the process.

Why redraw the boundaries?

The City Charter requires the number of councilmen to depend on the city’s population taken during the Census every 10 years.

The guidelines are specified in Chapter 5 of the City’s Charter sections 25 and 25.1, both of which state:

“The wards so formed shall be as nearly equal in population as may be fair and equitable, composed of contiguous and compact territory, and bounded by natural boundaries or street lines” Section 25.1, which deals specifically with the reapportionment, redrawing of the ward boundaries, omits be fair and equitable portion.

A May 2024 Press Release from Cleveland City Council mentions census tracks (sic) , reviews and compiling and analyzing GIS data” but there are no other public mention of criteria that are used. The city did hold public meetings in October.

They are being redrawn for the 2025 election. The 2020 Census results on a city-wide level were released in August 2021, only three months before the last city election; which was not enough time to make new ward boundaries for that election. That said, I wonder why the city waited until 2024 to redraw the ward boundaries.

My goals for making my own proposed boundaries:

I found the existing ward boundaries last made in 2013 to not be very compact nor bounded by natural boundaries.
I wondered how difficult it could be to make a new boundaries that had be more cohesive to align with neighborhood boundaries.
Learn more about the process.

How I did it:

Dave’s Redistricting is free software to create redistricting maps in the USA and was extremely useful for my drawing of the new ward boundaries. As you create a map with in Dave Redisricting, the population for each political subdivison is automatically calculates the population.

(insert the screenshot displaying the interface, where you quickly view the population of each current section; draw an area by particular census tracks or census blocks.

With that in mind, I hadn’t looked at the existing boundaries before drawing new boundaries and I started from a blank canvas; I did not modify the existing ward boundaries.

I don’t know if there’s any rule prohibiting their use to draw the ward boundaries but I used census blocks to give more me flexibility. Then I drew.

For boundaries: where possible, I used freeways (just south of the Opportunity Corridor I-71, the innerbelt, i-90), natural features like Doan Brook, the gap between east 67th and Marion Motley Park which formally was Kingsbury Run and the Sidaway Bridge , the lowlying area (where the zoo and Big Creek are located) and changes in landuse, railways. I didn’t realize until finishing it that my proposed boundaries for Slife and Kazy were extremely similar to their existing wards; population in that area changed very little between 2010 and 2020.

What I learned from this:

The councilpeople whose wards will be eliminted will likely fall onto councilpeople whose wards are towards the center of the city. This is because ward boundaries ; so you have more flexibility in the center

More importantly, the populations of each ward are extremely similar: I made a couple drafts of the map and compared it to the 2013 ward boundaries. I noticed the each ward’s population in the 2013/2014 ward boundaries were extremely close to each other. Each ward’s population in the 2013 map ranged from 22,240 (Ward 4) to 24,509 (ward 13); all wards’ populations were within 5% of 23,342 which is the average of (2010 Census for the city of Clevelandwas 396,815; divided by 17 (wards). (Ward population data is from NeoCando at CWRU)

Thus, I need to go back to the drawing board.

Now knowing that Cleveland City Council would likely only pass (into law) a set of ward boundaries whose ward populations were within 5% of the average population of a ward, I made another version of the map, what you see here. The city of Cleveland’s population according to the 2020 Census was 372,624. Divide that by 15 wards, averages to 24,841 and if we want all wards to be within 5% of that average, each ward’s population must fall between roughly 23,600 and 26,000.

As noted by Nick Castele in this Signal Cleveland piece, the majority of the city’s population loss between the 2010 and 2020 Census was on the East side, ( The City Planning Department has several maps highlighting the population change in Statistical Planning Areas (SPA) like 6,000 less people in the Glenville SPA). Because each ward’s population needs to be very similar (in this case between 23,600 and 26,000) you’ll need to cover more land compared to the previous ward boundaries to reach the desired ward’s population, consequently leading to larger boundaries and on the East side and create the perception on the East Side that will lose representation.

View my proposed Ward Boundaries for 2024 on a map

Newspaper articles on my wall

Fri, 13 Nov 2020 15:25:06 -0500

(This has been sitting in my drafts folder for months; I need to just post!)

As a teenager in the early/mid 2000s, I cut out my favorite articles from print publications (Plain Dealer - the daily newspaper in Cleveland, or the Free Times, the Scene (the local alt. weeklies), or the New York Times - I had a subscription when I was home from college); I would then glue them onto poster board and then hang them up on my bedroom wall using sticky tack or push pins.

I don’t know where I got the idea for this; I don’t claim to be the original.

While cleaning, I found some of these and decided to document them before I threw them out.

(As a part of my effort to document my life on my blog instead of just on twitter, I’ve posted this here.)

Recently

Wed, 16 Oct 2019 19:25:06 -0400

(Reminder to myself, this was originally drafted in April and to use this more often to share small snippets of information..)

I second guess myself if I don’t do enough to remove our president (if it’s not clear, generally, I do NOT support his policies). I try to let my actions speak for myself but I wonder whether its enough; I know that those who are privildged (and also often have power (financial, influence)) to not have to deal with the ramifactions are generally quickly turned off and that the effect of my sharing it on social media is probably minimal. I keep that in mind by trying to act locally.

While in college 10-15 years ago (damn, it has been that long) I realized that the fate of our country for most of its residents wasn’t going to be as good as it once was; and unfortunately that’s been the case. Financially, my partner and I are a little bit better off than my parents were thanks to education, priviledge, and a bit of luck (especially with our health); but there’s more precarity in our future than in the past due to our current administration and with the increasing costs of health care.

I’ve been more intentional in backing up my photos, documents, and videos on a using a combination of rclone and backblaze b2.

There’s a really sharp learning curve (knowing the basics of bash, cron, unix are a requirement for these tools) but the value is really good (per GB); the customization and automation are great.

While looking at past photos, I realized that I haven’t taken that many photos of myself or friends actually.

I’ve pared down even more of what I’ve shared on social media.
I was cognisant of this before (this isn’t the result of anything in particular and I don’t think there’s anything out there that I’d deeply regret) but more so of even less trust that my information may be used against me (denial of health care coverage)

I’ve been contributing to OpenStreetmap for nearly 9 years. It’s how I fell in love with maps; gave me multiple career options, opportunities to work in Haiti and Sengal, forge friendships and acquatinences across the world that continue today, I’ve given a couple dozen presentations or some aspect of it. I wouldn’t be where I am today without it. It has changed my routine; encourages me to be much more observant of how the environment is built, notice the little businesses with signage that would otherwise be forgotten and fade in the landscape.

It’s my biggest hobby (and relatively affordable too ;)), probably 3-4 hours a week.

I’ve lost a little luster for it over the past year or so. I still edit nearly every day, but the quantity of edits and my overall involvement has decreased.

I second guess more often while I’m editing: how often is this data in a way that’s positive for the world? I had thought about this many times before but this just wears on me more.
Will there be more usage of it besides just routing for private ride-sharing companies or real estate analysis?

The local transit authority began to use OSM on their route maps; so that’s actually a great positive.

In OSM, there’s less focus on how users can extract or use its data to make simple maps without having to know HTML or geojson or perform some basic spatial queries (e.g. where are coffee shops or child care facilities that are within 1 mile of me?). The OpenStreetMap community focuses more on how to get data into OSM but not enough on how to get the data out of it (unless you have very )

After spending about 8 years across different continents and areas; you see some of the weaknesses of the tagging system; (to be fair, I think any crowd-sourced system would have probably had these issues).

Looking back, I’m a bit surprised that editing hasn’t taken off like it has for wikipedia; the killer app for openstreetmap (to drive individuals or companies) to contribute for use never came and I think that window of opportunity - for OSM to become the defacto standard in America has passed.

There was a period, I think in the late 00s and perhaps early 2010s when OpenStreetMap and its crowdsource model - manaully drawing features through drawing of aerial imagery and gps traces was the most efficient; and google maps didn’t quite have its strong market share.

Since then, open data sets from municipalities have become more plentiful, machine learning for drawing features have greatly improved. Google uses the crowdsourced data from all of the captchas we fill out to identify addresses and features that they’ve collected from their Street View vehicles.

For a bit, I thought MapBox may have been that company whose products would incentivize people to contribute to OSM and increase its usage of OSM to unforeseen levels of use but it looks like they’ve focused a bit more gathering data through sensors and focusing on automobile navigation.

I sometimes wonder if another entity in a few years will usurp OpenStreetMap as a widely-used defacto source of crowdsourced, global geographic data. OSM largely hasn’t tackled the representation of 3D features; still represents more features as lines instead of areas (no doubt, representing everything as an area would be a lot of work for mappers at this point).

There’s a lot more to share; I also need to make this process of updating this and then uploading it to the website a little easier.

I’m also over markdown, the language that this is written; I’d rather go to just pure html and css again.

Digitizing Cleveland's Historic Annexations

Tue, 05 Mar 2019 18:25:06 -0500

I created a digitized dataset of Cleveland’s historical land annexations and it didn’t exist before. Thanks to this data set, I was able to make this time-lapse map displaying the growth of Cleveland’s historic annexations and additional research can more easily be done.

More below on what I learned, why I did it, what else can be done with this new data set.

If you just want the data set, download the annexation boundaries at https://github.com/skorasaurus/cleboundaries

Why I did this:

As a part of my day job as a web developer at the local library, I met with Marty, the City of Cleveland Archivist, about an unrelated issue with the Cleveland Public Library website. He graciously gave me a tour of the City Archives across from the Justice Center in Downtown Cleveland. He had large copy (2 x 3 foot) of an annexation map from 1968 on the wall and often referenced it for city employees. I’ve been a fan of maps and he mentioned in passing that since that map’s publishing, there have been additional annexations but no map has been made since then*** and no one had the time or resources to do it.

(Just in early 2019, I found an annexation map on made in wikipedia made around 2010 by Paul J Meissner but I haven’t been able to contact him or obtain it in a higher resolution. Additionally, that map appears to use Google which goes against Google’s Terms and Conditions and is not on very firm ground to be legally shared.

Aloud to Marty, “I could make you a newer print map with those annexations”, I offered to make one (I’m still working on it).

To make a new print map, you would need the annexation boundaries data set first.

That data set didn’t exist, until now.

Answering historical questions that couldn't be answered before:

Creating this data set by creating the digital boundaries doesn’t solve any civic technology problems by itself; but like other open data sets, it can, with additional effort, be used in with other data sets to answer questions like:

How much of Cleveland's population growth in the 19th and 20th century can be attributed by annexating other places?
Did Cleveland's population grow at the same proportion in the 20th century as its size?
Did proposed or implemented annexations had any influence on development patterns or migration patterns for residents in the 19th and 20th century?

I’m also casually interested in how past city decisions influence our present day. How would Cleveland and Northeast Ohio would be different if certain areas were never annexed or annexed at a later date (or certain places that were once considered for annexation, like East Cleveland and Lakewood, were annexed).

In the process of creating these boundaries, a scholar had contacted the Cleveland Public Library with a research question seeking the historical Cleveland boundaries (!) (I found out through my day job) and I was able to provide him with some of my data.

These boundaries can also be used as the basis for a new printed map of Cleveland annexations.

A look at historic open data

Through my years in open data advocacy and mapmaking, I hadn’t known much about available past, open accessible historic geospatial data. Historic geo data generally wasn’t included in municipal open data portals.

Before this project, I hadn’t known of any historical annexation boundaries to exist but Karl Phillips has been doing prolific work on digitizing historic annexation boundaries and had been putting his annexation boundaries up on mapstory (a neat site in its own right) although you won’t find them there right now; mapstory redesigned their site and deleted some of the existing work. Karl told me he’s planning on reuploading them to mapstory. Reach out to him at Phillips AT MapStory dot org.

In addition, this project may be used to get myself and others more attention to the question of who should store historic geospatial data (and how).

I suggest that the overlooked the public library may be appropropriate:

I discuss in an earlier post why public libraries can be great places to host and curate civic data (domain expertise of subjects, community understanding/trust as a place to get knowledge in a way that doesn’t feel as stuffy or intimidating as an academic library would, and a 3rd party source [generally] outside of direct municipal government control).

Although Mapstory likely had good reasoning why they deleted previously uploaded data sets and had good intentions in the first place, it’s an example of caution to rely on 3rd party sources for historic information. In case where others like entities like mapstory may temporarily data that was behind the map (although I’m sure they had good intentions and reasoning why they had to delete the data sets). (I did contact them about 2 weeks ago asking to learn more but did not receive a response.)

I’ve talked with some co-workers on how that our data set can be something that we can be the steward at the library; we haven’t stored any geospatial data just yet, and to my knowledge, no or very few public libraries do yet (Maybe I’m running in the wrong circles; I’d like to know where).

That means we have to set up the resources to host it and and our current digital system doesn’t store geographic data and I’d also have to figure out how other binary data sources should be stored. This is not an insignificant question. Something I’m looking forward to figuring out and hear you opinions.

Many public libraries may not have the infrastructure or technical knowledge to do this; so maybe this is something that occurs in collaboration across multiple libraries, ala DPLA.

The geographic data set is currently available as Shapefiles and geojson at my github repository of Cleveland Boundaries, cleboundaries where the metadata and additional notes are also located to understand the data.

The data set as of this writing is not yet complete. There are several annexations from the 2nd half of the 20th century that need to be added, especially around the Cleveland International Airport.

I’d like to have a consistent way of determining annexations’ “start dates”. Should it be when the annexation was passed in legislation or when it was effective ‘on the street’? When acknowledged/recorded by the state or county? As I far as I know, all of these dates vary.

How did I do this?

The process of georectification isn’t easy, so I think there’s some value in writing this out. I’ll breifly outline how I created these polygons.

Maps that are images (not ‘web maps’ like google maps) or paper maps scanned into a computer cannot be overlaid a web map with georectification.

When you first scan a paper map into a computer, there’s no information within the image that tells the computer “this portion of the image” is in Cleveland, Ohio (or any another particular place).

Very broadly, this absence of context is similar to when you scan a paper document, you cannot immediately select the text on it. You can visually see with your eyes what the words say; but computer software only knows that there are black and white shapes there; computer software does not known those shapes also represent characters of a language.

(These are completely different processes but very abstractly, the same process. )

Transforming the image of a map (in this case, the annexation map from 1968) and aligning to specific locations by a coordinate system is known as georectification (this a term very often interchanged with ‘georeferencing’; the terms are confusing (ESRI’s definition of georectification)

Lincoln Mullen does a great job of explaining the overall process of georectification.

When I first started the project, I planned to create the geographic shapes by first georectiying what I dubbed the 1968 map, a hand-drawn map by the City Engineering and Construction Dept. that is the most recently published version of a map with the boundaries. Then, I would create the shapes by tracing over the georectified map.

I first tried georeferencing the 1968 map on mapwarper.net; a great free, open-source tool (although he deserves some $ for this, but I digress); and used OpenStreetMap as the reference map.

After making over 20 reference points with the 1968 map in mapwarper.net, I found that many places in the 1968 georeferenced map it still didn’t match up well with my reference map; In many places, I was getting only about 30-40 meter accuracy.

As shown in the image below, the black lines representing streets from the 1968 map; with aerial imagery from state of Ohio imagery (circa 2015) as the referenced map.

I came to the conclusion that the 1968 map wasn’t drawn very consistently. It was hand-drawn somewhat poorly and that I could not merely trace over the georeferenced 1968 map. I couldn’t rely primarily rely on that. At this point, I also began relying primarily on TIGER and the state of Ohio’s aerial imagery, to eliminate any copyright restrictions (which would have occurred if I would continue using OpenStreetMap) on my data set.

Instead, I had to use the 1968 map and the Volkmann map as sort of a guide: Look at a particular polygon in the 1968 map and volkmann map by identifying them on one of the maps(thinking my mind, “oh, western border of this polygon is a house-worth’s east of east 156th”, then open up the TIGER/State of Ohio imagery and draw it in the same location.

So, on and off, over a few months on idle Saturdays, I drew the polygons. At one point, I stopped because I wasn’t sure which dates to use in the source data as ‘actual date of when annexations were implemented’ and that discouraged me for a few months.

Not until a few months in the process, I realized that I could also use the historic plat maps from Sanborn and Hopkins some which are digitally available (but not georeferenced) from the Cleveland Public Library’s Digital Map Collection and The Library of Congress.

The Sanborn and Hopkins maps represent property-level maps of historic Cleveland from the early 20th century and late 19th century. They also include the municipal boundaries on the map.

Below is an image 4, from vol 4 of the 1896 Sanborn, courtesy of the Library of Congress

The Hopkins and Saborns provided a tremendous amount of detail that was not available in the 1968 or Volkmann maps and I began using them as my primary references.

Going forward as I refine the maps the great detail of the Sanborn and Hopkins maps along with manual verification of the original City Council legislation (the actual true authority) will likely be the best to determine the accuracy and details of the boundaries.

Random snippets

Fri, 08 Feb 2019 18:25:06 -0500

http://www.chicagomag.com/city-life/June-2018/How-the-Obsidian-Collection-Is-Bringing-Black-Newspapers-to-Google/

While this is exciting to see that this material is finally shared; that its production is being done within a single company is troublesome.

The noise that is made when in a RTA bus releases its would be a great sample.

It’s remarkable how much people generally stay on the same streets in their daily lives. How often do you even driven or rode a bicycle through parts of town that you aren’t apart of your normal routine? Have you even ever been through Madison Ave in Cleveland, Noble Rd. in East Cleveland, Broadview Road in Old Brooklyn, or Willoughby, or Larchmere Boulevard?

When I add roads in OpenStreetMap, gave an additional incentive to visit a place that I hadn’t visited before and made me realize how so often people just take the same routes, the quickest to get from point a to B (with reason, it saves time, wear and tear on cars, and lowers pollution).

Recently, November 2018

Sun, 18 Nov 2018 18:25:06 -0500

A small portion of my life in recent months.

Recently:

What I’ve been thinking, asking myself about, or wondering:

How do you conduct an accessibility audit for a website?

How do I delegate and ask others for help without abdicating my responsibilities and without unfairly foisting something on them? Is the level of assistance that you are asking for at which you differ based on the context (a personal friend, a co-worker, someone that you’re in a volunteer organization with, of the relationship)?

Not taking for granted how many people your parents had a positive impact on in their lives. Dad died about 3 weeks ago. I was genuinely touched by the number of people who came to the wake and told our family how he had a positive impact on them.

Reconciling that I’m not learning some programming concepts as quickly as I had hoped and occasionally feeling that my feelings of imposter syndrome are valid? Prioritizing what to learn. Depending on the task at hand at work, it varies; a smattering of CSS, HTML, PHP, javascript, and SQL (and in that order). (There’s a lot more code - like our wordpress theme - that I haven’t made public just yet). Heck, I’m still using all ES5; should I go over to setting up the whole babel ecosystem (and frankly learn it, to be honest) (looking at the fetch library to retrieve JSON, so I’m considering it).

Watching:

The leaves falling

Kim’s Convenience

Listening:

The Flys - Got You (Where I Want You). (youtube video) The night before my wedding, one of my best friends, since grade school and I were catching up on our lives at a local bar. For context, Old Brooklyn isn’t really sexy or trendy. It’s not surburban like Applebee’s either. I was genuinely suprised that

Hearing that song in the background instantly brought me back to my adolescence. I’ve enjoyed the song but I couldn’t name the song or artist until then (thanks soundhound for identifying it). Finally identifying one of a song’s artist and title after not knowing for years is one of my favorite feelings. I’ve kept a playlist of these songs (spotify). Some of these songs are just ones where the title is not apparent in the lyrics, but I like more than others.

Serial, season 3; based in Cleveland.

Reading:

Metafilter. I’ve been a daily reader, although it’s not the same as before. Maybe its just my life experiences where what people write doesn’t seem so novel; also the rampant distrust of most institutions.

The Accessibility Interpretation Problem by Glenda Sims and Wilco Fiers. The best piece that I’ve read on web accessibility. How the guidelines for web accessibility are very subjective and subject to intepretations; despite the initial impressions that it’s straight-forward and binary; there’s no “This site is accessible” badge or designation.

Un Lun Dun by China Miéville

Writing:

A web-standards guide for the library Although I write most of the code, the content and editing is done by co-workers and when I arrived, our practices of code and were either non-existent or unwritten. Writing this out and determining how something like this should be written has been a fair amount of time and experimentation.

Georeferencing the past

Tue, 10 Apr 2018 07:25:06 -0400

I’ve been learning about georeferencing (what is georeferencing) maps for an upcoming project at work to display a print map (24 x 36 inch) where the library provided services circa 1912.

My secondary goal for georefencing these maps is to provide a web map layer for users to browse historic Cleveland at a high resolution detail (i.e. at zoom level 19-20).

Before I started this, my knowledge on georeferencing wasn’t much and I didn’t know what I’d use as the base map for my project - one that would provide viewers a sense of streets, intersections, and lack of sprawl in 1912…

Here’s what I learned and what I’m still trying to figure out:

The sources of paper maps:

CPL has Sanborn maps. Produced every few years in the early 20th century, Sanborns richly detail addresses, landuse, streets, rivers, buildings, and often times, property owners, of the entire city. Sometimes the buildings usage was also noted. In addition to their utility, they are relatively asthetically pleasing. They’re also available at an extremely fine scale, a scale of 200 feet per inch.

These maps were published as a bounded book of ‘plats’/’plates’ - pages - each roughly 15 by 10 inches of an arbitrary geographic area.

CPL also have “Hopkins Maps”, made by a different company, but same physical layout and map design.

Fortunately, CPL has unbounded a few editions, digital scanned them, and uploaded them into in our digital map collection

For the city of Cleveland’s 1881 Hopkins maps, there are 40 pages; each image with borders containing extraneous information (page number, map key) and on several pages, contained areas that are also displayed on another plat.

Although the LOC will eventually be uploading historic Sanborn maps of the entire country, they have barely started the state of Ohio save for good ole’ (Monroeville).

As shown in the above image, there’s extraneous information (the map scale, the north arrow, the plate number) on each page that would need to be removed or clipped out if I wanted to present them as one congruious map. The image in Cleveland Public Library’s digital gallery

If I wanted to create a contigous map, I had a fair amount of work ahead of me:

and I didn’t even know what order I should do these steps?!

So, how do I do this?!

I had multiple questions when I first started:

Do I stitch the plat(e)s together first and then georeference them? Or do I georeference first?

What tools do I use stitch them together? (stitch - creating them as if they appeared as one contiguous image)

How much accuracy should I get from them? Is 5 meter accuracy (from a reference layer) realistic? What if the original map had distortions in it in the first place?*

Would I be able to get results as accurate as than this GIF below? (Prospect Ave didn’t exist there at the old time, this is to primarily illustrate Carnegie Ave)

(after all, I wanted to create a nice digital map layer)

(In Cleveland, OSM is pretty well aligned (usually within 5 meters) with State of Ohio aerial imagery licensed in the public domain and that is pretty darn accurate [http://ogrip.oit.ohio.gov/ProjectsInitiatives/StatewideImagery.aspx]) So, I has a good reference layer.

I spent an hour or so exploring our scanned maps to determine if there were any that, together would provide enough coverage of the city of Cleveland. Some of their metadata and descriptions our digital collections were misleading; this item has the title of Plat Book of Cuyahoga County, Ohio Complete in One Volume (Hopkins, 1914) but if you carefully read the title page of this book and view a couple adjacent pages of it, you learn that it’s just 1 of 4 volumes that are needed to have complete coverage of Cuyahoga County. Unfortunately, we didn’t even have all 4 volumes of the 1914 Hopkins available; so I couldn’t use that as a resource.

I finally found a map collection that had coverage of the entire city of Cleveland: a Hopkins book of Cleveland from 1881.

So, I started out using the public mapwarper which is really neat.

I experimented by:

Uploading each image page to mapwarper.net (for now, just manually)

Applying the “mask” that would remove the extraneous areas I didn’t need to reference

georeferencing (rectifying) them

I learned that it doesn’t matter whether you georeference or apply the mask first to a map on mapwarper;

This recommendation maybe different if you’re attempting to use the mosaic feature on there.

Lou Klepner reported that Plate Spline is most effective rectifying method on mapwarper; I haven’t noticed definitively one better than the other. For the resampling method, I used cubic spline and didn’t find any noticeable speed delay compared to the nearest neighbor.

I then downloaded the geotiffs from mapwarper - now georeferenced that have the geographic projection stored within them - so they can be displayed over other modern maps.

Now I can open the geotiffs in QGIS as raster layers. They matched up pretty well although not perfect (ADD screenshot) and I printed a portion out in QGIS’ print composer. And… You couldn’t read the street names on the printed copy. I learned that these image were scanned and uploaded as 72ppi and don’t print well. Oops. Our library didn’t save the original loseless digital scans (they had since corrected this practice several years ago for other scanned maps).

So, more searching to see if we had another map set of the complete coverage of the city of Cleveland. Yes, we did! volumes one and two of the 1912 Hopkins of Cleveland.

72 PPI images are publicly available but we had 600PPI of these in private digital storage.

I asked Stephen Titchenal of railsandtrails.com - an underrated resource for rail maps of the 20th century; he’s digitized dozens of maps. He admitted he hadn’t stitched together any map as large as I was proposing but recommended photoshop and Panavue image assembler a since abandonwared windows stitcher but he hadn’t stitched together anything as large as I was proposing. Welp. Most of his maps were 300ppi and suitable.

Guides by Mauricio Giraldo Arteaga, formerly of NYPL, National Library of Scotland, and Lincoln Mullen are great introductions to the basics of georeferencing with mapwarper but they all assume that you’re only georeferencing one image at a time and not stitching them together.

So, now: My task, I ask for readers:

Given my constraints: computing power on my work and personal computers (Thinkpad T450s, HP Z240 both with ubuntu) each no more than 16gb of ram); would I be able to work on 1 giant image of all of the items stitched together? I tried gimp on ubuntu (to be fair it was a 600 PPI) and it was nearly unusable on a single image…

It wouldn’t be realistic to upload about 3gb of images to mapwarper.net…

So, readers, I’d love to hear your suggestions and thoughts.

I ask a few questions on how to proceed:

Given my two goals (a slippy web map and a print map of 24x36inch) would 300PPI be ok for both?

In which order should I complete the tasks of cropping/masking the plates, georeferencing the plates, and stitching them together to appear as one image?

After I georeference them, should CPL provide both georeferenced and non-georefenced items in our digial collection?

Tentatively, I think I’ll batch convert (with imagemagick) the images to 300PPI; then crop 1-2 plates of them in gimp (if it’s feasible from a memory standpoint), then try to georeference them in qgis.

For sharing georeferenced, I can see both sides whether to add the georeferenced ones because georeferencing is never perfect; it’s always a work in progress.

I’d appreciate your advice for my next steps and what you’ve learned if you’ve done something similar (email is skorasaurus at gmail, the left bar has my social media contacts). I’ll share what I’ve learned later.

Tools on map-making at Data Days CLE

Sun, 08 Apr 2018 22:25:06 -0400

I gave a workshop/presentation on tools for map-making at Data Days CLE on Friday. One of my favorite moments was the city employee who asked me about alternatives to ARCGIS/ESRI and specifically being able to offer read access to geodatabases to other departments of data without using ESRI (hope I remember that correctly).

My slides are at http://skorasaur.us/ddc18 and below is a long list of resources, most of which I mentioned in my talk. This list is also available in my github repository for this - https://github.com/skorasaurus/ddc18

This list is by no means, comprehensive, but a starting point for tools for map-making, primarily focusing on web maps (maps that are viewable online) outside of the ESRI ecosystem.

mapschool - As brief as it is, it’s an extremely useful overview of modern maps and some theory. I don’t know of any other document on maps that is as short yet as informative.

mapmaking suites (SAAS, software as a service):

carto

mapbox

shinyapps - R-based

Quicker and simpler web map templates:

All of these simpler web map templates require a relatively minimal amount of data (not a very rigid rule, but I’d say less than a couple hundred points/features and that you don’t have a lot of properties on them). If you have more than this, you’ll need to upload them to one of the above services.

mapzap - less styling options but easier to use

mapstarter - also has print options

leaflet + and google sheets

umap - If you want a map to share with others with some custom icons quickly and aren’t picky about the basemap; can embed as well.

data manipulation/gis in browser:

As above, these may not work (or will work very slowly) if you’re using files that have hundreds of features or are above, say 10mb, in size.

geojson.io - quickly edit and save to numerous formats; works on files < 10mb

mapshaper - relatively simple yet powerful, also has command-line based tool

dropchop - do some common GIS operations within the browser

turf.js - do some common GIS operations within the browser (javascript)

utilities for printing web maps:

portmap -

staticmapmaker.com - limited options; but usable

LA Times’ Web Map Maker

Petroff’s Print Maps

https://www.mapbox.com/help/static-api-playground/

geocoding:

smartstreets Not free; but does a relatively great job and has relatively easy to use interface; good if you’re on a timecrunch and/or limited skills.

Meta (a list of other lists):

robin’s list

awesome-spatial - great list of all types of spatial tools, many of these require knowledge in a particular programming language, comfortability with command line.

awesome-geojson - great utilities for working with geoJSON.

color-tools - all resources on colors

dataviz-tools’ list - thorough list, somewhat out of date

theory:

maptime - An informal association of meetup groups that teach geospatial concepts and maps. They have accessible tutorials. I co-organized Cleveland’s maptime from 2012-2014ish.

mapmakers-cheatsheet

Advanced:

csvkit - python library and command line to manipulate CSV files

qgis - geospatial analysis, map-making, and so much more; comparable to ArcGIS.

cheat-sheet for fiona and rasterio - Cheatsheet for using python libraries of fiona, rasterio, manipulating geospatial data.

miller - command-line based; very powerful and advanced; specifically for parsing CSV files.

GDAL cheatsheet - GDAL is a geospatial library at the core of many geospatial applications; data conversion; reprojection; analysis, and more. Cheatsheet for using some of its command-line based tools.

d3 - extremely powerful javascript library for dataviz and maps

observable HQ - a sandbox for experimenting with javascript and D3

Sites/Articles mentioned in talk:

Most famous set in every US state

when it shouldn’t be a map

data sources: Guide to Cleveland Data sources - A list of places to get available open civic data for the Cleveland area

If you want to start with the command line: https://github.com/jlevy/the-art-of-command-line

Highly recommended Books: Interactive Data Visualization for the Web: An Introduction to Designing with D3 (2nd Edition) - Scott Murray - clearly written with examples; good not just for D3 as a refresher or extremely concise overview of html, css, and javascript.

GIS Cartography - Gretchen Peterson Great design influence for making print and web-maps.

cat photo by Walid Mahfoudh