Web-mapping -> web mapping, see #1115

02-spatial-data.Rmd

@@ -77,7 +77,7 @@ We will introduce the theory behind each data model and the disciplines in which
 The *vector data model* represents the world using points, lines and polygons.
 These have discrete, well-defined borders, meaning that vector datasets usually have a high level of precision (but not necessarily accuracy as we will see in Section \@ref(units)).
 The *raster data model* divides the surface up into cells of constant size.
-Raster datasets are the basis of background images used in web-mapping and have been a vital source of geographic data since the origins of aerial photography and satellite-based remote sensing devices.
+Raster datasets are the basis of background images used in web mapping and have been a vital source of geographic data since the origins of aerial photography and satellite-based remote sensing devices.
 Rasters aggregate spatially specific features to a given resolution, meaning that they are consistent over space and scalable (many worldwide raster datasets are available).
 
 Which to use?

09-mapping.Rmd

@@ -945,25 +945,25 @@ if (knitr::is_latex_output() || knitr::is_html_output()){
 \index{map-making!mapping applications}
 The interactive web maps demonstrated in Section \@ref(interactive-maps) can go far.
 Careful selection of layers to display, basemaps and pop-ups can be used to communicate the main results of many projects involving geocomputation.
-But the web-mapping approach to interactivity has limitations:
+But the web mapping approach to interactivity has limitations:
 
 - Although the map is interactive in terms of panning, zooming and clicking, the code is static, meaning the user interface is fixed
 - All map content is generally static in a web map, meaning that web maps cannot scale to handle large datasets easily
-- Additional layers of interactivity, such a graphs showing relationships between variables and 'dashboards', are difficult to create using the web-mapping-approach
+- Additional layers of interactivity, such a graphs showing relationships between variables and 'dashboards', are difficult to create using the web mapping-approach
 
 Overcoming these limitations involves going beyond static web mapping and toward geospatial frameworks and map servers.
 Products in this field include [GeoDjango](https://docs.djangoproject.com/en/4.0/ref/contrib/gis/)\index{GeoDjango} (which extends the Django web framework and is written in [Python](https://github.com/django/django))\index{Python}, [MapServer](https://github.com/mapserver/mapserver)\index{MapServer} (a framework for developing web applications, largely written in C and C++)\index{C++} and [GeoServer](https://github.com/geoserver/geoserver) (a mature and powerful map server written in Java\index{Java}).
 Each of these is scalable, enabling maps to be served to thousands of people daily, assuming there is sufficient public interest in your maps!
 The bad news is that such server-side solutions require much skilled developer time to set up and maintain, often involving teams of people with roles such as a dedicated geospatial database administrator ([DBA](https://wiki.gis.com/wiki/index.php/Database_administrator)).
 
-Fortunately for R programmers, web-mapping applications can now be rapidly created with **shiny**.\index{shiny (package)}
+Fortunately for R programmers, web mapping applications can now be rapidly created with **shiny**.\index{shiny (package)}
 As described in the open source book [Mastering Shiny](https://mastering-shiny.org/), **shiny** is an R package and framework for converting R code into interactive web applications [@wickham_mastering_2021].
 You can embed interactive maps in shiny apps thanks to functions such as <!--`tmap::renderTmap()` and -->[`leaflet::renderLeaflet()`](https://rstudio.github.io/leaflet/shiny.html).
-This section gives some context, teaches the basics of **shiny** from a web-mapping perspective, and culminates in a full-screen mapping application in less than 100 lines of code.
+This section gives some context, teaches the basics of **shiny** from a web mapping perspective, and culminates in a full-screen mapping application in less than 100 lines of code.
 
 **shiny** is well documented at [shiny.posit.co](https://shiny.posit.co/), which highlights the two components of every **shiny** app: 'front end' (the bit the user sees) and 'back end' code.
 In **shiny** apps, these elements are typically created in objects named `ui` and `server` within an R script named `app.R`, which lives in an 'app folder'.
-This allows web-mapping applications to be represented in a single file, such as the [`CycleHireApp/app.R`](https://github.com/geocompx/geocompr/blob/main/apps/CycleHireApp/app.R) file in the book's GitHub repo.
+This allows web mapping applications to be represented in a single file, such as the [`CycleHireApp/app.R`](https://github.com/geocompx/geocompr/blob/main/apps/CycleHireApp/app.R) file in the book's GitHub repo.
 
 ```{block2 shiny, type = 'rmdnote'}
 In **shiny** apps these are often split into `ui.R` (short for user interface) and `server.R` files, naming conventions used by `shiny-server`, a server-side Linux application for serving shiny apps on public-facing websites.
@@ -993,7 +993,7 @@ server = function(input, output) {
 shinyApp(ui, server)
 ```
 
-```{r lifeApp, echo=FALSE, message=FALSE, fig.cap="Screenshot showing minimal example of a web-mapping application created with shiny.", fig.scap="Minimal example of a web-mapping application."}
+```{r lifeApp, echo=FALSE, message=FALSE, fig.cap="Screenshot showing minimal example of a web mapping application created with shiny.", fig.scap="Minimal example of a web mapping application."}
 # knitr::include_graphics("https://user-images.githubusercontent.com/1825120/39690606-8f9400c8-51d2-11e8-84d7-f4a66a477d2a.png")
 knitr::include_graphics("images/shiny-app.png")
 ```
@@ -1014,7 +1014,7 @@ The example contains some of the components of a web mapping application impleme
 
 The `CycleHireApp/app.R` script contains **shiny** functions that go beyond those demonstrated in the simple 'lifeApp' example (Figure \@ref(fig:CycleHireApp-html)).
 These include `reactive()` and `observe()` (for creating outputs that respond to the user interface --- see `?reactive`) and `leafletProxy()` (for modifying a `leaflet` object that has already been created).
-Such elements are critical to the creation of web-mapping applications implemented in **shiny**.
+Such elements are critical to the creation of web mapping applications implemented in **shiny**.
 A range of 'events' can be programmed including advanced functionality such as drawing new layers or subsetting data, as described in the shiny section of RStudio's **leaflet** [website](https://rstudio.github.io/leaflet/shiny.html).
 
 ```{block2 shinynote, type='rmdnote'}
@@ -1024,12 +1024,12 @@ For RStudio users, the simplest way is probably to click on the 'Run App' button
 You can also launch apps from a Unix command line with the command `Rscript -e 'shiny::runApp("CycleHireApp")'`.
 ```
 
-Experimenting with apps such as `CycleHireApp` will build not only your knowledge of web-mapping applications in R, but also your practical skills.
+Experimenting with apps such as `CycleHireApp` will build not only your knowledge of web mapping applications in R, but also your practical skills.
 Changing the contents of `setView()`, for example, will change the starting bounding box that the user sees when the app is initiated.
 Such experimentation should not be done at random, but with reference to relevant documentation, starting with `?shiny`, and motivated by a desire to solve problems such as those posed in the exercises.
 
 **shiny** used in this way can make prototyping mapping applications faster and more accessible than ever before (deploying **shiny** apps, https://shiny.posit.co/deploy/, is a separate topic beyond the scope of this chapter).
-Even if your applications are eventually deployed using different technologies, **shiny** undoubtedly allows web-mapping applications to be developed in relatively few lines of code (86 in the case of CycleHireApp).
+Even if your applications are eventually deployed using different technologies, **shiny** undoubtedly allows web mapping applications to be developed in relatively few lines of code (86 in the case of CycleHireApp).
 That does not stop shiny apps getting rather large.
 The Propensity to Cycle Tool (PCT) hosted at [pct.bike](https://www.pct.bike/), for example, is a national mapping tool funded by the UK's Department for Transport.
 The PCT is used by dozens of people each day and has multiple interactive elements based on more than 1000 lines of [code](https://github.com/npct/pct-shiny/blob/master/regions_www/m/server.R) [@lovelace_propensity_2017].
@@ -1039,7 +1039,7 @@ One potential problem with the ease of developing prototypes with **shiny** is t
 For that reason, despite advocating **shiny**, we recommend starting with the longer established technology of a pen and paper as the first stage for interactive mapping projects.
 This way your prototype web applications should be limited not by technical considerations, but by your motivations and imagination.
 
-```{r CycleHireApp-html, echo=FALSE, message=FALSE, fig.cap="CycleHireApp, a simple web-mapping application for finding the closest cycle hiring station based on your location and requirement of cycles. Interactive version available online at: r.geocompx.org.",fig.scap="Cycle Hire App, a simple web-mapping application.", eval=knitr::is_html_output(), out.width="690"}
+```{r CycleHireApp-html, echo=FALSE, message=FALSE, fig.cap="CycleHireApp, a simple web mapping application for finding the closest cycle hiring station based on your location and requirement of cycles. Interactive version available online at: r.geocompx.org.",fig.scap="Cycle Hire App, a simple web mapping application.", eval=knitr::is_html_output(), out.width="690"}
 knitr::include_app("https://shiny.robinlovelace.net/CycleHireApp/")
 ```
 

16-synthesis.Rmd

@@ -77,7 +77,7 @@ As of 2024, there are more than 160 packages mentioned in the Spatial [Task View
 # how? see:
 # vignette("selectorgadget")
 stv_pkgs = xml2::read_html("https://cran.r-project.org/web/views/Spatial.html")
-pkgs = rvest::html_nodes(stv_pkgs, "#reading-and-writing-spatial-data---gis-software-connectors+ ul li , #geographic-metadata+ ul li , #raster-data+ ul li , #specific-geospatial-data-sources-of-interest+ ul li , #data-processing---general+ ul li , #data-cleaning+ ul li , #data-processing---specific+ ul li , #spatial-sampling+ ul li , #base-visualization-packages+ ul li , #thematic-cartography-packages+ ul li , #packages-based-on-web-mapping-frameworks+ ul li , #building-cartograms+ ul li , p+ ul li , #spatial-data---general+ ul li")
+pkgs = rvest::html_nodes(stv_pkgs, "#reading-and-writing-spatial-data---gis-software-connectors+ ul li , #geographic-metadata+ ul li , #raster-data+ ul li , #specific-geospatial-data-sources-of-interest+ ul li , #data-processing---general+ ul li , #data-cleaning+ ul li , #data-processing---specific+ ul li , #spatial-sampling+ ul li , #base-visualization-packages+ ul li , #thematic-cartography-packages+ ul li , #packages-based-on-web mapping-frameworks+ ul li , #building-cartograms+ ul li , p+ ul li , #spatial-data---general+ ul li")
 pkgs_char = rvest::html_text(pkgs)
 length(pkgs_char)
 ```

_09-ex.Rmd

@@ -212,7 +212,7 @@ leaflet(africa4326) |>
   addScaleBar()
 ```
 
-E8. Sketch on paper ideas for a web-mapping application that could be used to make transport or land-use policies more evidence-based:
+E8. Sketch on paper ideas for a web mapping application that could be used to make transport or land-use policies more evidence-based:
 
 - In the city you live, for a couple of users per day
 - In the country you live, for dozens of users per day