Notes

GIS is a software tool to analyse and visualise geographical information, it’s not a discipline.
Geospatial analysis turns data into information that we can make decisions on.
Geospatial data is data stored in a special database that can be thought of as a simplified model of the real world.
What is a data-frame?
- A data structure organised as a table where data is organised in rows and columns. Each column typically stores data of a single data type. You can think of it as a spreadsheet or a database table. It can be manipulated via operations like filtering or grouping data.
Types of geospatial data
- Vector
  - Stores data that are discrete in nature (you can count the total number of data that is representable)
  - The SVG of geospatial data
  - Data primitives (simple features)
    - Points
      - Coordinate
      - Examples
        
        Landmarks
    - Polyline (line + polygon)
      - Series of coordinates known as vertices (though like other data types they might also contain additional metadata such as road names)
      - Examples
        
        Roads
    - Polygon
      - Consists of three or more line segments, and the starting and end coordinates must be the same, but how they are stored is almost the same as how vertices are stored in a polyline.
      - Buildings
- Raster (simple features)
  - Stores data that are continuous in nature (data that does not have a clear cut off point)
  - The JPEG of geospatial data
  - Elevation
  - The area of interest is divided into cells (which are essentially pixels on the screen). A grid typically only stores a single attribute of the area of interest, and each grid is responsible for a certain real world area size (such as 10x10 metres). The data stored in each grid is fixed. For instance, a grid can store a single 32 bit floating point value.
Coordinate system
- Coordinates stored in different coordinate systems will have wildly different values relative to each other.
- Types
  - Geographical coordinate systems
    - Uses a three dimensional system to encode data
      - Latitude
        
        Vertical line
        
        0 degrees at the equator, +90 degrees in the north pole and -90 degrees in the south pole
      - Longitude
        
        Horizontal line
        
        0 degrees at Greenwich
        
        0 to +180 degrees (east)
        
        0 to -180 degrees (west)
      - Datum
        
        Defines the shape and the size of the earth as the equator or Greenwich while being used as a reference for the coordinate system does not define how much it varies as you stray further away from it.
        
        Examples
        
        WGS84
        
        Defines the earth as an ellipsoid
    - Not suitable for distance measurement as it takes the curvature of the earth into account which makes it more challenging to calculate. A single degree of difference can lead to different distances depending on the coordinates of the start and end points.
  - Projected coordinate system
    - Examples
      - SVY21 (Singapore) (EPSG code: 3414)
    - Provides consistent area measurements.
    - Important to convert from GCS to PCS before conducting analysis.
    - Large countries might use multiple PCS.
    - Each country or state might have their own PCS to minimise distortions from projecting a spherical surface into a plane, to create an accurate representation of an area.
    - Make sure to convert to this form before doing any analysis.
Simple features
- There are about 17 of them, 3 of them having been mentioned above.
- Most software typically only use a subset of them.
- Types
  - Point
    - Point(30, 10)
  - Multi point
    - MultiPoint([Point(10, 40), Point(40, 30), Point(20, 20), Point(30, 10)])
  - Line string
    - LineString([Point(30, 10), Point(10, 30), Point(40, 40)])
  - Polygon
    - Polygon([Point(30, 10), Point(40, 40), Point(20, 40), Point(10, 20), Point(30, 10)])
    - Polygon([[Point(35, 10), Point(45, 45), Point(15, 40), Point(10, 20), Point(35, 10)], [Point(20, 30), Point(35, 35), Point(30, 20), Point(20, 30)]])
  - MultiX
    - “Multi” versions of the above primitives but have them be elements of an array.
- To work with simple features, you can use the sf package from R which is part of the tidyverse collection.
- Simple features are represented via “simple features geometry (SFG)”, and they and geospatial data can be represented with “simple features objects (SFO)” which represent a collection of SFG as a data-frame object. The non-spatial data (metadata) are stored in a separate column separate from the SFG column. The data type of that SFG column is known as “simple features collection (SFC)”.
- SFO is an object, you can get the class by passing in a variable to the class function.
- In the environments tab, “obs” stands for observations which is basically the number of rows. “Variables” represent the number of columns.
- The data types you will be working with for each column would be:
  - int
  - chr
    - Basically a string.
  - Date
  - num
    - A superclass of int and double. R will automatically cast it to its child classes if needed, but this is basically a generic number class.
  - sfc_MULTIPOLYGON
sf functions
- sf also provides functions that help you in doing data manipulation and analysis of spatial data.
- st_read: import a file or database into a SFO (more flexible but slower)
  - read_sf: import a file or database into a SFO (less flexible but more optimised)
  - Shapefiles can contain many layers, such as elevation that shows different data on the same geography. Each layer can have multiple attributes.
  - Supported file formats
    - Shapefile
      - A misnomer as it is basically a collection of files (hence a single shp file is not enough). File extensions include: dbf, prj, shp, xml, and shx.
      - dsn stands for destination.
        
        sf_mpsz = st_read(dsn = "data/geospatial", layer = "MP14_SUBZONE") st_write(st_poly, "data/my_poly.shp")
        
        Typically you don’t have to specify the layer since it usually only has one.
        
        Exporting to KML:
        
        st_write(mpsz, "data/geospatial/MP14_SUBZONE_WEB_PL.kml", delete_dsn = TRUE)
    - MapInfo TAB
    - KML (Google)
```
sf_preschool = st_read("data/geospatial/pre-schools-location-kml.kml")
```
      You need to provide the file extension if it is not a Shapefile.
      
      KML is typically less tidier than Shapefiles in terms of non-geographical metadata, hence we typically only use it to merge with Shapefiles using st_intersect.
```
<center><table><tr><th colspan='2' align='center'><em>Attributes</…
```
      You’ll have to manually parse and extract the data.
    - GML
    - GeoJSON (popular in web)
    - TopoJSON (popular in web)
- st_write: export a file from a SFO to a file or database
  - write_sf: export a file from a SFO to a file or database (less flexible but more optimised)
- st_as_sf: convert existing data structures into a SFO
- st_as_text: convert a SFO into “well-known text” (WKT) (it is the to_string() of SFO and represents the SFO data structure in a textual format)
- st_as_binary: converts a SFO into a binary format
- st_transform: Convert a SFO into another SFO with a different coordinate reference system via an EPSG code. For example, it can convert GCS data to PCS.
  - A coordinate reference system is a system that specifies the datum (among other attributes) of the coordinate system. It can be represented as a numerical code known as the EPSG code.
- st_intersects: whether two geometries touch or overlap each other
  - Note that many sf functions may sound similar to each other but perform totally different tasks. For instance, st_intersects checks whether each geometry in each SFO intersects with each other while st_intersection will create new geometry that shows the areas of intersection.
  - Many other functions in this category work the same way, and they all typically return a sparse list.
  - Sparse lists
    - A sparse list is a way of efficiently representing the relationship of a geometry in one set with respect to another geometry in another set without using a full matrix.
    - Using st_intersects:
```
# Example sparse list
result <- list(
  c(2, 3),
  integer(0),
  c(1, 4)
)
```
      - result[[1]] (First Geometry in A):
        
        The first element c(2, 3) means that the first geometry in A intersects with the 2nd and 3rd geometries in B.
      - result[[2]] (Second Geometry in A):
        
        The second element integer(0) (an empty integer vector) means that the second geometry in A does not intersect with any geometry in B.
      - result[[3]] (Third Geometry in A):
        
        The third element c(1, 4) means that the third geometry in A intersects with the 1st and 4th geometries in B.
      - Note that sparse lists do not include symmetric pairs, e.g., (2, 4 and (4, 2) are repeated.
- Functions that return a logical matrix indicating whether each geometry pair meets the logical operation
  - st_disjoint: equivalent to performing a NOT boolean operation on the result of st_intersects
  - st_touches: touch
  - st_crosses: cross
  - st_within: within
  - st_contains: overlap
  - st_overlaps: overlaps
  - st_covers: cover
  - st_covered_by: covered by
  - st_equals: equals
  - st_equals_exact: equals, with some fuzz
    - Returns a sparse (default) or dense logical matrix.
- Geometry generating logical operators:
  - st_union: union of several geometries
  - st_intersection: intersection of pairs of geometries
  - st_difference: difference between pairs of geometries
    - If st_difference(A, B), take A and subtract any areas of overlap by B.
  - st_sym_difference: symmetric difference (XOR)
    - Equivalent to st_union(st_difference(A, B), st_difference(B, A)).
- Other miscellaneous functions:
  - st_area calculates the area of the geometries of the SFO given to it as a parameter and outputs a data-frame column.
    - For example, to calculate the area of each geometry, you can do:
```
sfo$Area <- sfo %>% st_area()
```
  - sum is an aggregation function that takes in a data-frame column and returns a number.
- Higher level operations
  - aggregate
  - summarise
  - st_interpolate_aw: area-weighted interpolation of attributes from one set of geometries to another
    - Area-weighted interpolation is a spatial analysis technique used to estimate or transfer values from one set of spatial units (e.g., polygons) to another set of spatial units that may overlap or have different boundaries. For instance, you might have census tracts for population and want to map out the population of each district. The census tract does not match the district. Hence, you will want to use this function to transfer population data over.
    - You need to specify the source and target geometries, each of which are SFOs, but the target geometry does not need to have any attributes. You also need to specify whether the interpolation is done extensively or intensively.
    - In extensive interpolation, you need to sum the contributions from each source polygon based on the proportion of its area that overlaps with the target polygon. For example, if you have a source polygon with a population of 1000 people and it overlaps by 50% with a target polygon, the area-weighted interpolation would allocate 500 people to the target polygon.
    - Intensive attributes are those that are independent of the size or extent of the spatial unit they are associated with. These attributes describe a characteristic that does not change when you change the size of the area. An example of an intensive attribute is population density. For example, if one source polygon has a population density of 200 people per square kilometer and overlaps by 50% with a target polygon, and another source polygon has a density of 100 people per square kilometer and overlaps by 50%, the resulting population density in the target polygon would be the weighted average of these densities.
  - st_join: performs spatial joins between two SFOs
    - A spatial join merges attributes from one SFO to another.
    - The output SFO will retain the geometries of the first input SFO.
    - Think of the second input SFO as an overlay for the first SFO.
      
      Illustration of st_join
      
      Observe that st_join does not do any interpolation or any mathematical operations. It also does not include any points in b. Any repeating data from the merge is included in the final output as an additional row.
      pacman::p_load(sf) a = st_sf(a = 1:3, geom = st_sfc(st_point(c(1,1)), st_point(c(2,2)), st_point(c(3,3)))) b = st_sf(a = 11:15, geom = st_sfc(st_point(c(10,10)), st_point(c(2,2)), st_point(c(2,2)), st_point(c(3,3)), st_point(c(12,12)))) st_join(a, b)
      
      Simple feature collection with 4 features and 2 fields Geometry type: POINT Dimension: XY Bounding box: xmin: 1 ymin: 1 xmax: 3 ymax: 3 CRS: NA a.x a.y geom 1 1 NA POINT (1 1) 2 2 12 POINT (2 2) 2.1 2 13 POINT (2 2) 3 3 14 POINT (3 3)
- Manipulating geometries (spatial data wrangling) (generates new data out of existing data) (the output SFC does not contain any input data)
  - st_line_merge: merges lines
  - st_segmentize: adds points to straight lines
  - st_voronoi: creates voronoi tesselation
  - st_centroid: gives centroid of geometry
    - Outputs a SFC containing points corresponding to the centre of each geometry.
  - st_convex_hull: creates convex hull of set of points
  - st_triangulate: triangulates sets of points (not constrained)
  - st_polygonize: creates polygon from lines that form a closed ring
  - st_simplify: simplifies lines by removing vertices
  - st_split: split a polygon given line boundary
  - st_buffer: compute a buffer around this geometry/each geometry
    - Takes an SFO as input.
    - Creates a region that expands outwards from each geometry by a given distance, creating a buffer zone.
    - For points, it creates a circular buffer. For lines, it creates a buffer along the entire length of the line, creating a polygon that surrounds the line. For polygons, it expands the polygon by a given distance, keeping it’s shape, resulting in a scaled up version of the original polygon.
    - Returns a SFC containing only the buffer.
    - Uses the unit of measurement specified by the PCS, e.g., SVY21 (Singapore) uses metres as the unit of measurement.
    - nQuadSegs determine the smoothness of the circular arcs that make up the buffer. The more the number of quad segments the smoother the curve. It’s typically sufficient to leave this as the default.
  - st_make_valid: tries to make an invalid geometry valid (requires lwgeom)
  - st_boundary: returns the boundary of a geometry
- Convenience functions
  - st_zm: sets or removes z and/or m geometry
  - st_coordinates: retrieves coordinates in a matrix or data frame
  - st_geometry: sets, or retrieves SFC from an SFO
    - Returns the SFC.
  - st_is: checks whether a geometry is of a particular type
Other functions
- glimpse: part of the dplyr package
  - Used to analyse any R object, but especially useful for tidyverse data types.
- head: returns the first few specified rows of a data frame
- st_crs: getting the coordinate system of a SFO
- st_set_crs: set the CRS of a SFO
  - When to use st_transform vs. st_set_crs?
    - Use st_set_crs when the data lack a CRS or has an incorrect CRS and you want to correct it. It does not change the underlying geometry data in any way, and only changes the representation of it. st_transform assumes that the previous SFO has a valid CRS value. Use st_crs to check the CRS value if you are unsure.
- plot: plot data using ggplot2
- summary: function that comes with base R that summarises all sorts of data including data-frames. When applied to a data-frame, it gives a statistical summary of each column, including the mean, median, etc. However, you typically apply it to a column of a data-frame.
- top_n: function that comes with dplyr which is used to get the top n values of a column in a data-frame given the attribute name. For example, top_n(df, 3, score) gets top 3 items with the highest score. Negate 3 to get the lowest scores. Note that score is an identifier, not a string or a variable.
- lengths: used to get the length of each element of the input. “Length” has a pretty arbitrary meaning, so let’s break it down.
  - Data frame: It will be treated as a list of columns, so the output will be the number of items for each column. It does not get affected by the presence of NA values, it will count them regardless.
- st_join: joins two data-frames together
  - The difference between this and st_join is that the latter is only designed to be used with spatial data while this works with any data-frame.
```
mpsz_pop2020 <- left_join(mpsz, popdata2020,
                          by = c("SUBZONE_N" = "SZ"))
```
- write_rds: save an R object to a file
  - Similar to pickle in Python.
You can use the indexing operator to get a particular row of a data frame given the column name.
buffer_cycling$AREA <- st_area(buffer_cycling) is equivalent to buffer_cycling["AREA"] = st_area(buffer_cycling) in other languages.
Backticks are used to allow identifiers which are typically invalid (contain spaces) to be column names, functions, or variables.
%>% is the piping operator in R, which allows you to compose function chains without nesting functions within each other. It essentially passes the output of the expression on its left-hand side as the first argument to the function on its right-hand side. sum(round(abs(c(-1.5, 2.3, -3.8, 4.2)))) is functionally equivalent to:
```
c(-1.5, 2.3, -3.8, 4.2) %>%
  abs() %>%
  round() %>%
  sum()
```
Learn more from ggplot2 examples.
- plot should be treated as a multi-tool that should be able to plot all sorts of data types.
Use the “environment” tab in RStudio to visualise your data-frames.
Choropleth maps
- Used to represent geographical areas.
- Using lines to segment off areas and colours to shade areas depending on its attribute value.
- Types
  - Classified
    - Segments values into range intervals. The intervals are also known as bins.
    - It does not have to be numerical values, it could be categorical too (political parties).
    - How many colours to use?
      - Try to stay within 8 colours.
      - The generality of the data (the more general it is, the less colour shades you need).
    - Classification methods (tmap supports all of them)
      - Quantile
        
        The number of districts for each value range is kept the same.
      - Equal interval
        
        The range between each segment is the same.
        
        Avoid this when the data is highly skewed.
      - Jenk’s method
        
        A combination of quartile and equal interval methods.
      - Standard deviation
        
        Only useful if your data follows a normal distribution.
        
        Instead of mapping based on actual values, you map based on their z-scores.
  - Unclassified
    - There are no fixed segmentation for colours. Instead colour values are continous and there is only one interval from the smallest value to the largest value.
- What colours to use?
  - Use ColorBrewer which is an application to help choose your colour scheme based on your data.
  - Colour schemes used:
    - Nominal
      - Categorical data
    - Sequential
      - Either all positive or negative numbers.
    - Diverging
      - Use when the data does not fit the above scenarios.
- Both types of choropleth maps require you to state the minimum and maximum value and how the colours vary across the spectrum in the legend.
- Using tmap:
  - tmap is a thematic mapping package for R.
  - Includes an R implementation of ColorBrewer.
  - It is compatible with the sf package.
  - Under tmap, simple features can be further grouped into spatial and raster types.
  - Simple features that contains attributes:
    - Classes that start with “Spatial” and include the phrase “DataFrame”.
    - Classes that start with “Raster”.
  - Simple features with no attributes:
    - The rest.
  - Like the plot function in the ggplot2 package, we can use the function qtm to quickly plot out our choropleth map.
  - The map can also be interactive if needed using the function tmap_mode.
  - tmap_shape: specifies the shape object
    - Takes a Shapefile or a SFO as input.
    - Also includes a bounding box input to control the zoom level of the map.
  - tm_polygons: draw polygons
    - A wrapper of tm_fill and tm_border.
  - tm_symbols: draw symbols
  - tm_lines: draw polylines
  - tm_raster: draw a raster
  - tm_text: add text labels
  - Layers (note that you must call tm_shape first to create the shapes before you can manipulate the shapes with tm_fill, etc.) (use these functions if you want more flexibility for customisation)
    - tm_fill: fills the polygons
```
tm_fill(col=color)
```
    - tm_borders: draws polygon borders
      - lwd: border line width (default: 1)
      - alpha: transparency number between 0 (totally transparent) and 1 (totally opaque) (default: 1)
      - col: border colour
      - lty: border line type (default: "solid")
    - tm_bubbles: draws bubbles
    - tm_squares: draws squares
    - tm_dots: draws dots
    - tm_markers: draws markers
    - tm_iso: draw iso/contour lines
  - Furniture
    - tm_compass: draws a compass
    - tm_scale_bar: draws a geographic scale bar
    - tm_grid: draws a map grid
  - Ways to create multiple small Choropleth maps (facet maps)
    - assigning multiple values to at least one of the aesthetic arguments (useful for showing multiple attributes given the same geographical area)
      - defining ncols in tm_fill
        
        tm_shape(mpsz_pop2020)+ tm_fill(c("YOUNG", "AGED"), style = "equal", palette = "Blues") + tm_layout(legend.position = c("right", "bottom")) + tm_borders(alpha = 0.5) + tmap_style("white")
    - assigning multiple values to at least one of the aesthetic arguments (useful for showing multiple attributes given the same geographical area)
```
tm_shape(mpsz_pop2020)+ 
  tm_polygons(c("DEPENDENCY","AGED"),
          style = c("equal", "quantile"), 
          palette = list("Blues","Greens")) +
  tm_layout(legend.position = c("right", "bottom"))
```
    - tm_facets group-by variable (useful for showing multiple geographical areas given the same attribute)
```
tm_shape(mpsz_pop2020) +
  tm_fill("DEPENDENCY",
          style = "quantile",
          palette = "Blues",
          thres.poly = 0) + 
  tm_facets(by="REGION_N", 
            free.coords=TRUE, 
            drop.shapes=TRUE) +
  tm_layout(legend.show = FALSE,
            title.position = c("center", "center"), 
            title.size = 20) +
  tm_borders(alpha = 0.5)
```
      This groups by "REGION_N".
    - multiple standalone maps using tmap_arrange (useful for showing multiple attributes given the same geographical area)
```
youngmap <- tm_shape(mpsz_pop2020)+ 
  tm_polygons("YOUNG", 
              style = "quantile", 
              palette = "Blues")

agedmap <- tm_shape(mpsz_pop2020)+ 
  tm_polygons("AGED", 
              style = "quantile", 
              palette = "Blues")

tmap_arrange(youngmap, agedmap, asp=1, ncol=2)
```
  - You can use the selection function to only choose certain geographical areas you want to map out.
```
tm_shape(mpsz_pop2020[mpsz_pop2020$REGION_N=="CENTRAL REGION", ])+
  tm_fill("DEPENDENCY", 
          style = "quantile", 
          palette = "Blues", 
          legend.hist = TRUE, 
          legend.is.portrait = TRUE,
          legend.hist.z = 0.1) +
  tm_layout(legend.outside = TRUE,
            legend.height = 0.45, 
            legend.width = 5.0,
            legend.position = c("right", "bottom"),
            frame = FALSE) +
  tm_borders(alpha = 0.5)
```
Iterating over data-frame rows for data wrangling
- filter: filter rows by predicate
```
popdata %>% filter(Time == 2020)
```
- group_by: group by columns
  - It groups elements by the first field, and then subsequent fields.
  - It does not do any data aggregating.
  - Specifies a scope whereby subsequent queries apply to each group separately. If you no longer want operations to apply for each group but each row, use the ungroup function as a pipe operation.
```
popdata %>% group_by(PA, SZ, AG)
```
- summarise: aggregates rows of data
  - Typically used in conjunction with group_by which aggregates data based on the last field specified by group_by.
```
popdata %>% group_by(PA, SZ, AG) %>%
summarise(`POP` = sum(`Pop`))
```
- mutate: a function from dplyr which is extremely versatile and used to modify existing data-frames by accepting a data-frame as an input and outputting a new modified data-frame without modifying the existing one.
  - Create new columns:
```
# Example data frame
df <- data.frame(
  id = 1:5,
  height = c(150, 160, 170, 180, 190),  # height in centimeters
  weight = c(55, 60, 65, 70, 75)        # weight in kilograms
)

# Use mutate to create a new column 'height_in_meters'
df <- df %>%
  mutate(height_in_meters = height / 100)
```
  - In-place transformation of data:
```
mutate(df, height = height / 100)
```
  - Multiple transformations in a single mutate call:
```
mutate(
    df,
    bmi = weight / (height_in_meters^2),
    bmi_category = case_when(
      bmi < 18.5 ~ "Underweight",
      bmi >= 18.5 & bmi < 24.9 ~ "Normal weight",
      bmi >= 25 & bmi < 29.9 ~ "Overweight",
      TRUE ~ "Obese"
    )
  )
```
  - rowSums: sums up columns in each row
```
popdata %>% mutate(A = rowSums(.[7:11]) + rowSums(.[13:15]))
```
    Remember that ranges in R are inclusive.
- pivot_wider: make each unique row be a column
  - Let’s say a column known as “AG” contain the values "a" and "b", each one only occurring once. There is also another column named “POP” filled with numbers. This function creates columns “a” and “b” and applies the “POP” value as the value for its respective cells.
- select: only include specific fields
  - Similar to the concept of selecting in SQL.
```
popdata %>% select(field1, field2)
```
- mutate_at: applies multiple function operations to multiple columns
```
popdata2020 %>%
  mutate_at(.vars = vars(PA, SZ), 
          .funs = list(toupper))
```
  Mutate columns “PA” and “SZ” by converting them to uppercase. You can apply multiple different kinds of operations but we are only using one. This is useful for joining multiple data-frames.

Making Choropleth maps

Easiest way

tmap_mode("plot")
qtm(mpsz_pop2020, 
    fill = "DEPENDENCY")

Harder way (more customisable)

tm_shape(mpsz_pop2020)+
  tm_fill("DEPENDENCY", 
          style = "quantile", 
          palette = "Blues",
          title = "Dependency ratio") +
  tm_layout(main.title = "Distribution of Dependency Ratio by planning subzone",
            main.title.position = "center",
            main.title.size = 1.2,
            legend.height = 0.45, 
            legend.width = 0.35,
            frame = TRUE) +
  tm_borders(alpha = 0.5) +
  tm_compass(type="8star", size = 2) +
  tm_scale_bar() +
  tm_grid(alpha =0.2) +
  tm_credits("Source: Planning Sub-zone boundary from Urban Redevelopment Authorithy (URA)\n and Population data from Department of Statistics DOS", 
             position = c("left", "bottom"))

The style argument specifies the classification method to be used. Here is a list of them:

quantile
equal (make sure the data is not skewed)
jenks

You can also manually specify the breakpoints:

tm_shape(mpsz_pop2020)+
  tm_fill("DEPENDENCY",
          breaks = c(0, 0.60, 0.70, 0.80, 0.90, 1.00)) +
  tm_borders(alpha = 0.5)

The palette argument specifies the fill colour scheme to be used. Using a - sign before the colour scheme makes the smaller values be represented with darker colour than the greater values, e.g. "-Greens".

Besides colour, you can also specify the style of the map with tmap_style which affects aspects such as the background colour of the map and the font, etc. This is independent of what colour each polygon is filled with.

tm_shape(mpsz_pop2020)+
  tm_fill("DEPENDENCY", 
          style = "quantile", 
          palette = "-Greens") +
  tm_borders(alpha = 0.5) +
  tmap_style("classic")

The default style is "white".

Adding additional map complications

Histogram

tm_shape(mpsz_pop2020)+
  tm_fill("DEPENDENCY", 
          style = "jenks", 
          palette = "Blues", 
          legend.hist = TRUE, 
          legend.is.portrait = TRUE,
          legend.hist.z = 0.1) +
  tm_layout(main.title = "Distribution of Dependency Ratio by planning subzone \n(Jenks classification)",
            main.title.position = "center",
            main.title.size = 1,
            legend.height = 0.45, 
            legend.width = 0.35,
            legend.outside = FALSE,
            legend.position = c("right", "bottom"),
            frame = FALSE) +
  tm_borders(alpha = 0.5)

Compass, scale bar, and grid lines

tm_shape(mpsz_pop2020)+
  tm_fill("DEPENDENCY", 
          style = "quantile", 
          palette = "Blues",
          title = "No. of persons") +
  tm_layout(main.title = "Distribution of Dependency Ratio \nby planning subzone",
            main.title.position = "center",
            main.title.size = 1.2,
            legend.height = 0.45, 
            legend.width = 0.35,
            frame = TRUE) +
  tm_borders(alpha = 0.5) +
  tm_compass(type="8star", size = 2) +
  tm_scale_bar(width = 0.15) +
  tm_grid(lwd = 0.1, alpha = 0.2) +
  tm_credits("Source: Planning Sub-zone boundary from Urban Redevelopment Authorithy (URA)\n and Population data from Department of Statistics DOS", 
             position = c("left", "bottom"))