I recently found some R code in the TidyTuesday repository which pulled data from Kaggle directly into the R console and I thought the idea was incredible! After looking around and seeing that there was no packages that already did this, I was inspired to create the {RKaggle} package which allows users to download datasets from Kaggle directly into the R console.

Installation

Presently, {RKaggle} is only available to be installed from GitHub (there are plans to publish to CRAN). It’s possible to install from GitHub with the {devtools} package or the {remotes} package.

# Install devtools and/or remotes if you haven't already
# install.packages(c("devtools", "remotes"))
# Use devtools
devtools::install_github("benyamindsmith/RKaggle")
# Or use remotes
# remotes::install_github("benyamindsmith/RKaggle")

Basic Usage

Presently {RKaggle} works with getting datasets only (not competitions). Here is some example code for downloading a dataset:

>library(RKaggle)
># Download and read the "canadian-prime-ministers" dataset from Kaggle
>canadian_prime_ministers <- RKaggle::get_dataset("benjaminsmith/canadian-prime-ministers")
>canadian_prime_ministers
# A tibble: 29 × 5
   No.        Name                `Political Party`     `Term Start`     `Term End`      
   <chr>      <chr>               <chr>                 <chr>            <chr>           
 1 1 (1 of 2) John A. Macdonald   Liberal-Conservative  1 July 1867      5 November 1873 
 2 2          Alexander Mackenzie Liberal               7 November 1873  8 October 1878  
 3 1 (2 of 2) John A. Macdonald   Liberal-Conservative  17 October 1878  6 June 1891     
 4 3          John Abbott         Liberal-Conservative  16 June 1891     24 November 1891
 5 4          John Thompson       Liberal-Conservative  5 December 1892  12 December 1894
 6 5          Mackenzie Bowell    Conservative          21 December 1894 27 April 1896   
 7 6          Charles Tupper      Conservative          1 May 1896       8 July 1896     
 8 7          Wilfrid Laurier     Liberal               11 July 1896     10/6/1911       
 9 8          Robert Borden       Government (Unionist) 10/10/1911       7/10/1920       
10 9 (1 of 2) Arthur Meighen      Conservative          7/10/1920        12/29/1921      
#  19 more rows
#  Use `print(n = ...)` to see more rows

Present Scope

{RKaggle} presently only supports the download and loading of the following file formats:

• .csv
• .tsv
• .xlsx
• .json
• .rds
• .parquet
• .ods

There are already some issues open for accommodating other file formats. If you want to get involved submit feel free to submit a pull request!

{mapBliss} is a package initially developed in my attempt to copy the offerings made available by a site (since defunct) called Atlas.co. Recently I was talking about the package in a group chat and someone reached out to me sharing that he traveled to 43 states in the United States and shared with me a list of his journey.

These are the visuals that were made:

In this blog, I share a new dataset available in {mapBliss} – us_travels. This dataset provides an interesting example for plotting more lengthy and complex adventures with {mapBliss}.

Loading the us_travels dataset

To load and preview the us_travels dataset, run the following code:

# Install the mapBliss package from GitHub if you haven't already
# devtools::install_packages("benyamindsmith/mapBliss")

# load the mapBliss library
library(mapBliss)
# load the us_travels dataset
data("us_travels")

# Preview the data
us_travels

# A tibble: 85 × 2
   location                       how  
   <chr>                          <chr>
 1 Mobile, Alabama, USA           car  
 2 Montgomery, Alabama, USA       car  
 3 Phoenix, Arizona, USA          car  
 4 Little Rock, Arkansas, USA     car  
 5 Los Angeles, California, USA   car  
 6 San Francisco, California, USA car  
 7 Oakland, California, USA       car  
 8 Half Moon Bay, California, USA car  
 9 San Diego, California, USA     car  
10 Stamford, Connecticut, USA     car  
# ℹ 75 more rows
# ℹ Use `print(n = ...)` to see more rows

Plotting the us_travels dataset

For plotting the us_travels dataset use the following snippet can be used:

library(mapBliss)
data("us_travels")

locations <- us_travels$location
# The how argument needs to be one 
# less than the number of the locations
how <- us_travels$how[-1] 

plot_hybrid_route_flex(
    addresses = locations, 
    how = how,
    radius = 1,
    label_text = ""
  )

This yields the following leaflet map:

The map themes be visually altered by changing the mapBoxTemplate argument.

Conclusion

The us_travels dataset provides a nice example for how the {mapBliss} package can be used to make beautiful maps of your travels around the world from the R console with minimal effort.

For framing these maps, I presently recommend using a platform like Canva. I additionally recommend checking out the {starBliss} package for making custom star maps of the night sky.

Here is a visual I made for a print of a trip this past summer with {mapBliss}, {starBliss} and Canva:

There are some GitHub issues open related to making ready to use frames (which have had some success) but there’s still some considerable effort required to accomplish the desired goal. If you think you can do it, feel free to open a pull request!

Introduction

Social network analysis examines individual entities and their relationships among them. The data is represented as a “graph” where individual entities are referred to as “nodes” and their relationships between them as “edges. A primary area of study in SNA is the analysis of interconnectivity of nodes, called ”communities” and identification of clusters through the use of algorithms called ”community detection algorithms”.

I was lucky enough to develop an community detection algorithm with Tyler Pittman under the supervision of Dr. Wei Xu and which proved to offer “more descriptive” community identification in certain settings when compared to other algorithms – such as the Girvan-Newman and Louvain algorithms. To make the algorithm readily available for other users, the {ig.degree.betweenness} R package was created. If you want to learn about the setting for which the algorithm was originally developed, check out the arXiv preprint here.

The {ig.degree.betweenness} package provides an implementation of the “Smith-Pittman” community detection algorithm for igraph users in R. It can be installed directly from CRAN by running:

install.packages("ig.degree.betweenness")

Alternatively, it can be installed from the GitHub repository with the {devtools} package:

# Install the devtools package if you haven't installed it
# install.packages("devtools")
devtools::install_github("benyamindsmith/ig.degree.betweenness")

The Smith-Pittman Algorithm

The algorithm can be thought of as an extension of the Girvan-Newman algorithm that also considers both degree centrality – a.k.a the number of connections possessed by each individual node in the network and edge-betweenness – a.k.a. the number of shortest paths that pass through each individual edge in the network.

The steps for the algorithm are:

1. Identify the node with the highest degree-centrality in the network (the “most popular” node)
2. Select the subgraph of the node with the highest degree centrality. Remove the edge possessing the highest calculated (network-wide) edge-betweenness in the subgraph.
3. Recalculate the degree centrality for all nodes in the network and the betweenness for the remaining edge in the network.
4. Repeat from step 2.

Conceptually, this algorithm (similar to Girvan-Newman and Louvain) can be specified to terminate once a pre-determined number of communities has been identified (based on the remaining connected nodes). However, the intention for using this algorithm is meant to be used in an unsupervised, modularity maximizing setting, where the grouping of nodes is decided on the strength of the connected clusters.

Application of the Smith-Pittman algorithm

The Smith-Pittman algorithm thrives in certain settings where other methods fail. In particular the Smith Pittman algorithm appears to do well in identifying communities of descriptive value in settings where there is strong “popularity-hierarchy” present in terms of nodes in the network. The following are is an example where Smith-Pittman appears to fair better in terms of identifying descriptive communities than the Girvan-Newman and Louvain community detection algorithms.

TidyTuesday – “Monster Movies” dataset

The “Monster Movies” dataset, made available by the TidyTuesday project presents an interesting example for applying SNA and the Smith-Pitman algorithm to the interaction between genres in “monster” titled movies. To plot a “simplified” network with node sizes corresponding to the number of connections, the following code is used:

# Install relevant libraries
# pkgs <- c("dplyr","tibble","tidyr","tidygraph", 
#           "igraph","ig.degree.betweenness")
# install.packages(pkgs)
# Load data
tuesdata <- tidytuesdayR::tt_load(2024, week = 44)
monster_movie_genres <- tuesdata$monster_movie_genres

# Prepare data for adjacency matrix
dummy_matrix <- monster_movie_genres |>
  dplyr::mutate(value = 1) |>
  tidyr::pivot_wider(
    id_cols = tconst,
    names_from = genres,
    values_from = value,
    values_fill = 0
  ) |>
  dplyr::select(-tconst) |>
  as.matrix.data.frame()

# Construct adjacency matrix
genre_adj_matrix <- t(dummy_matrix) %*% dummy_matrix
# Setting self loops to zero
diag(genre_adj_matrix) <- 0

# Construct the graph
movie_graph <- genre_adj_matrix |>
  as.data.frame() |>
  tibble::rownames_to_column() |>
  tidyr::pivot_longer(cols = Comedy:War) |>
  dplyr::rename(c(from = rowname, to = name)) |>
  dplyr::rowwise() |>
  dplyr::mutate(combo = paste0(sort(c(from, to)), collapse = ",")) |>
  dplyr::arrange(combo) |>
  dplyr::distinct(combo, .keep_all = TRUE) |>
  dplyr::select(-combo) |>
  tidyr::uncount(value) |>
  tidygraph::as_tbl_graph()

# Resize nodes based on node degree

VS <- igraph::degree(movie_graph) * 0.1

ig.degree.betweenness::plot_simplified_edgeplot(
  movie_graph,
  vertex.size = VS,
  edge.arrow.size = 0.001
)

The edge thickness and annotated numbers correspond to the number of edges shared between listed genres. For plotting the genre clusters in the network as preformed by (a)-Girvan-Newman, (b)-Louvain and (c)-Smith-Pittman the following code is used:

# Cluster Nodes
gn_cluster <- movie_graph |>
  igraph::as.undirected() |>
  igraph::cluster_edge_betweenness()

louvain_cluster <- movie_graph |>
  igraph::as.undirected() |>
  igraph::cluster_louvain()

sp_cluster <- movie_graph |>
  igraph::as.undirected() |>
  ig.degree.betweenness::cluster_degree_betweenness()

# Figure 5
par(mfrow = c(1, 3), mar = c(0, 0, 0, 0) + 1)

ig.degree.betweenness::plot_simplified_edgeplot(
  movie_graph,
  gn_cluster,
  main = "(a)",
  vertex.size = VS,
  edge.arrow.size = 0.001
)

ig.degree.betweenness::plot_simplified_edgeplot(
  movie_graph,
  louvain_cluster,
  main = "(b)",
  vertex.size = VS,
  edge.arrow.size = 0.001
)

ig.degree.betweenness::plot_simplified_edgeplot(
    movie_graph,
    sp_cluster,
    main = "(c)",
    vertex.size = VS,
    edge.arrow.size = 0.001
)

Girvan Newman fails to identify any communities in the network (clustering all genres in one group isn’t really community identification). Louvain might be telling us something in terms of strength of clustering but doesn’t necessarily speak about the reality of “monster” movie genre interactions. Smith-Pittman clustering tells the best story with popular genres forming the primary working group followed by more ambivalent smaller subgroups and outlier nodes.

Limitations

The Smith-Pittman algorithm preforms best in a setting where there are a high number of connections for the number of nodes in the network and a there is a diversity in degree centrality among the nodes. For a comically bad setting can be seen from a screenshot I had from a conversations on Discord:

That being said, there is no specific model which describes exactly what a ”community” is. So where Smith-Pittman “fails”, another community detection algorithm might be more justified.

Conclusions

Thank you to my collaborators for helping develop this method, and thank you to everyone who has taken the time to check out the methodology. If you have used it or plan on using it, please let me know!

Introduction

Recently, I have been reading “Mathematical Statistics” by Professor Keith Knight and I noticed a interesting passage he mentions when discussing finite sample spaces:

*In some cases, it may be possible to enumerate all possible outcomes, but in general such enumeration is physically impossible; for example, enumerating all possible 5 card poker hands dealt from a deck of 52 cards would take several months under the most
favourable conditions. * (Knight 2000)

While this quote is taken out of context, with the advent of modern computing this is a task which is definitely possible to do computationally!

In this blog I show the code I use to list all the possible outcomes of hands dealt in 5 card poker in R!

Setting up the “Card Deck”

To set up the card deck, we need to define our cards (Ace, 1 to 10, Jack, Queen and King) and houses (Hearts, Spades, Diamonds and Clubs). After that, we can create a deck by using two nested for loops.

The code to do this is:

cards <- c(
  "Ace",
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  "Jack",
  "Queen",
  "King"
)

houses <- c("Hearts", "Spades","Diamonds","Clubs")

deck <- c()
for(card in cards){
  for(house in houses){
    deck <- append(deck, paste0(card," of ",house))
  }
}

This leaves us with our deck of cards:

deck

 [1] "Ace of Hearts"     "Ace of Spades"     "Ace of Diamonds"   "Ace of Clubs"     
 [5] "2 of Hearts"       "2 of Spades"       "2 of Diamonds"     "2 of Clubs"       
 [9] "3 of Hearts"       "3 of Spades"       "3 of Diamonds"     "3 of Clubs"       
[13] "4 of Hearts"       "4 of Spades"       "4 of Diamonds"     "4 of Clubs"       
[17] "5 of Hearts"       "5 of Spades"       "5 of Diamonds"     "5 of Clubs"       
[21] "6 of Hearts"       "6 of Spades"       "6 of Diamonds"     "6 of Clubs"       
[25] "7 of Hearts"       "7 of Spades"       "7 of Diamonds"     "7 of Clubs"       
[29] "8 of Hearts"       "8 of Spades"       "8 of Diamonds"     "8 of Clubs"       
[33] "9 of Hearts"       "9 of Spades"       "9 of Diamonds"     "9 of Clubs"       
[37] "10 of Hearts"      "10 of Spades"      "10 of Diamonds"    "10 of Clubs"      
[41] "Jack of Hearts"    "Jack of Spades"    "Jack of Diamonds"  "Jack of Clubs"    
[45] "Queen of Hearts"   "Queen of Spades"   "Queen of Diamonds" "Queen of Clubs"   
[49] "King of Hearts"    "King of Spades"    "King of Diamonds"  "King of Clubs"   

With this deck its possible get all the combinations of hands that can be drawn.

Computing all Combinations

To get all possible hands that can be drawn from the deck, we make use of the combn function. With it we can enumerate all possible hands that can be dealt in 5 card poker:

five_card_combinations<- combn(deck, 5)

# get the total number of combinations 

dim(five_card_combinations)[2]

[1] 2598960

Using the combn function it is possible to list all possible 5 hand combinations. For those of you really interested in getting the output I uploaded the data (transposed and with renamed columns) on Kaggle Datasets. If you work on any computational card counting algorithms do let me know so I can check it out!

Conclusion

Contrary to what Knight wrote, it is possible with the power computation to enumerate all combinations of 5 card poker hands dealt. While this is definitely taken out of context, the ability to write code makes things that were once physically impossible to do possible!

I hope you enjoyed this exercise as much as I did!

Thank you for reading!

Introduction

RMarkdown is a powerful framework for writing a documents that contain a mixture of text, code, and the output of the code. Popular output formats for RMarkdown Documents (.Rmd) include HTML, PDF and Word Documents. It is also possible to output RMarkdown documents as part of a static website using blogdown package and is (still!) possible to publish RMarkdown documents to WordPress sites as well (like this one)!

Recently, I started to look into the possibility of outputting an .Rmd file as a Google Doc, but I was unable to locate any out-of-box solutions. After looking into the issue I developed a small function that makes it possible!

In this blog I share a function that enables users to write an .Rmd file as a Google Doc with the rmarkdown and googledrive packages.

The Code (so far)

The code below essentially takes a the .Rmd file, renders it to a word document and uploads the word document to Google Drive as a Google Doc:

library(googledrive)
library(rmarkdown)


knit2docs<- function(rmd_file, doc_name=".Rmd to Docs"){
  # Temporary File
  temp_file<- tempfile(fileext = ".docx")
  rmarkdown::render(rmd_file, "word_document", output_file = temp_file)
  # Write to docs
  drive_upload(temp_file, 
               name = doc_name,
               type = "application/vnd.google-apps.document")
}

Now lets try this code out with an example .Rmd file:

knit2docs("Test.Rmd" ,doc_name = ".Rmd to Docs")

If we check the output on Google Docs, we can see the output:

Next steps

In the present form, the the knit2docs function does what its supposed to, but it does have its limitations:

1. In its present form, the code is creates a new Google Doc each time the the function is called. It would be helpful to link the .Rmd file to a Google Doc so that each time it would be knit2docs() would be called, it would update a linked Doc (should one be specified).
2. With the above code, the rendered Google Doc is sent to the drive at the top level. It would be helpful to specify the drive location for the file being uploaded.
3. The exported formatting for fonts is default to Microsoft fonts. It would be nice to be able to update these fonts to Google fonts. Its could be that this is something that needs to be specified in the YAML header of the .Rmd file – I’ll have to look into it to see what exactly needs to be done.

To make this function readily available and develop it further, I created a Github Repository of the packaged code here. Add this code to your workflow by installing the knit2docs package! If you notice anything else or want to get involved in development, feel free to reach out!

Conclusion

Knitting .Rmd files to Google Docs is something which is definitely intriguing. I’m surprised that I wasn’t able to find any readily developed solutions that were already made, but I’m happy that I have something basic put together so far! Its my hope that I can get this code and the next steps put together in a fully developed package and hopefully make knitting .Rmd files to Google Docs a part of rmarkdown users’ regular workflow!

Feel free to get involved by checking out the knit2docs repository here and be sure to give it a star for exposure!

Thank you for reading!

Introduction

Recently, I released a R package called starBliss that aimed to replicate the output of a e-commerce site called MapsForMoments – a site which lets users order custom prints of the night sky on the date of their choosing (usually a special occasion such as a birthday, first date, wedding etc.) and allows them to choose a style, and add some custom text. It was a great experience getting to build the package which replicated the MapsForMoments product and I was shocked to see how well it was received when I posted about it- with the Github receiving over 30 stars at the time of writing this blog!

I decided to take this to the next level by trying to build a similar UI in shiny which allows the user to create a custom star map and not need to use the R console. In this blog I share my experience constructing and showcase the “free alternative” to MapsForMoments – starBlissGUI!

Building the App

Building an app for starBliss presented some interesting challenges. For one, the plot output created by the plot_starmap() function is quite unwieldy. Previewing the image requires a user to have a large enough screen size and does not shrink well. The present workaround in the starBliss package is to save the plot as an image that accommodates the appropriate sizing like so:

# install.packages("ggplot2")
# devtools::install_github("benyamindsmith/starBliss")

library(ggplot2)
library(starBliss)

p<- plot_starmap(location= "Toronto, ON, Canada",
             date="2022-01-17",
             style="black",
             line1_text="Toronto",
             line2_text ="January 17th, 2023",
             line3_text="43.6532° N, 79.3832° W")

ggsave('toronto_black.png', plot = p, width = unit(10, 'in'), 
       height = unit(15, 'in'))

For starBlissGUI a temporary image is created in the server and displayed on the preview panel. The only drawback with this approach is that does create some lag on cheaper hardware and on the free tier of Shinyapps.io. You can check out the source code on the Github here and the hosted app on Shinyapps.io here (apologies for the lag, as it is being hosted on the free tier).

Building a Docker Image

Since getting a paid plan from ShinyApps.io was not something that I was particularly interested in perusing if I were to host this app professionally, I decided to explore the Docker route. With the help of Google, Stackoverflow and yes, ChatGPT (lots of prompts!) I was able to put together the following script:

FROM rocker/shiny:latest

RUN apt-get update && apt-get install -y \
    libssl-dev \
    libcurl4-gnutls-dev \
    libxml2-dev \
    libudunits2-dev \
    libgdal-dev

RUN R -e 'install.packages(c("shiny","shinyWidgets","ggplot2","lubridate", "remotes"))'
RUN R -e 'remotes::install_github("benyamindsmith/starBliss")'

COPY app.R /srv/shiny-server/
COPY www /srv/shiny-server/www

EXPOSE 3838

CMD ["R", "-e", "shiny::runApp('/srv/shiny-server/',, host='0.0.0.0', port=3838)"]

One of the things that is important to note if you are installing packages which are hosted on github, you need to make sure that the libudunits2-dev and libgdal-dev libraries are installed in the container otherwise it will not work.

Conclusion

While I played around with shiny before, I never tried to build anything serious with it until now. It was a very useful experience getting to thoroughly build the app. While there is still some functionality that I would like to improve on (like autofill for the location field, optimizing the server side and making a form to collect some user data before downloading the map for free), I am happy to share what I have right now!

Please be sure to check out the starBlissGUI GitHub and give it a star and open an issue if you see anything that you want to have added!

Thank you for reading!

Introduction

Continuing my explorations in developing custom map art, I decided to take a detour from developing the mapBliss package to explore another type of map which is very popular in the map-art space- star and constellation maps! This initially started out as an issue opened on the mapBliss Github. However, I quickly realized the framework required for making star maps is completely different from making regular maps for custom fight paths and road trips.

In this blog I introduce the “cousin” to the mapBliss package – starBliss! While it is still very basic I am very happy how it turned out. The starBliss package creates custom “framed” constellation maps with for a given location and date as well as allowing users to add some custom text as well.

This blog is simply a brief overview of the journey for how this package came to be. For a more technical deep dive regarding how and why this package works, I suggest that you check out Kim Fitter’s and Diego Hernangomez’s blogs on the topic.

If you want to skip straight to using the package, check out the basic usage examples on Github or skip to the code blocks here. But before getting into that, I thought I would share some background on how this package came to be.

Why starmaps are not included in mapBliss

mapBliss aims imitate the product produced by Atlas.co and similar companies which make use of leaflet. Maps produced by mapBliss are dynamic maps which need to be screenshot and converted to .svg files to be usable in a printing setting. The way maps are created with starBliss are static and use ggplot2 and are able to be saved to whatever size desired using ggsave(). Since the approaches to making visuals were so different, I thought it was best make keep the mapBliss and starBliss packages separate in their construction.

That being said, if there is a leaflet -like package for creating star maps, feel free to let me know by commenting here or opening an issue on the mapBliss or starBliss Github repositories!

Exploring Starmaps

I initially was interested in designing star maps after seeing a Facebook ad for a UK based company called MapsForMoments. The maps looked pretty, customizable and frankly easier to make than the maps that I was working on for mapBliss. All I needed to do was get my hands on stars and constellations data and plot it. Conceptually this seemed like it was easy enough, however to actually make it- I needed lots of help!

The journey started with me posting a question on the Astronomy StackOverflow community asking for a library or API that behaved like leaflet but for starmaps.

The answer I got there lead be to Kim Fitter’s blog which introduced me to the D3 Celestial maps data. From her blog I was able to replicate her visual:

While I managed to replicate what Kim did, I wanted to create maps which were similar to MapsForMoments. The problem was that I didn’t know anything about map projections. Which led me to have some email correspondence with Kim and going to StackOverflow to ask the talented folks there what to do. To my surprise I got an incredibly complete answer. Thank you Dr. Allan Cameron!

After learning how to do it, I packaged starBliss and I thought I was ready to start blogging. But before I got to it, Bernardo Lares pointed out some bugs that needed to be addressed and features that would be useful. After taking care of that and getting some more help from the folks at StackOverflow (thank you Diego Hernangomez) I managed to put out a package that is simple and straightforward to use for making custom souvenir star maps!

Using the package

With the help of getting user feedback from Bernardo and others, it is possible now make a star map with a single function and a single argument.

Suppose we want to get a star map of Seoul, South Korea at the time of writing this blog (February 12, 2023) which is fully labelled. To do this all we need is:

#devtools::install_packages("starBliss")

library(starBliss)

plot_starmap("Seoul, South Korea")

Right now there are two styles: “black” – which was just shown and “green”, which can be selected by specifying the “style” argument:

plot_starmap("Seoul, South Korea",style="green")

If you want to change the line texts, the line1_text, line2_text and line3_text arguments can be specified accordingly.

p<- plot_starmap(location="Toronto, ON",
                 style="green",
                 line1_text = "When I first wrote this blog")

p

Now if you want to save your map in print quality form, just use the ggsave() function from ggplot2 as these visuals are all from ggplot2!

library(magrittr)
library(ggplot2)

p %>% ggsave('starBliss_blog.png', 
             plot = ., 
             width = unit(10, 'in'), 
             height = unit(15, 'in'))

And that’s pretty much it!

Conclusion

As stated in the beginning, the starBliss package is a result of a detour in the development of mapBliss. The sky’s the limit as far as other features and designs which could be added. However the package right now works as a “MVP” for quickly visualizing star maps in a artful manner.

Be sure to star the repo and open an issue if you want to see a new feature or work on adding one! I do have some ideas about making a GUI for starBliss in a designated repository but I don’t have a any sort of timeline for getting anything done.

Thank you for reading!

Introduction

The mapBliss package is a R package which I developed which allows for users to make custom souvenir quality maps of their flights, road trips and favorite cities by utilizing the power of the leaflet and other R packages (for a full list, see the Github README here). The goal of the package is to imitate the visualization and print-ability of maps produced by businesses like Atlas.co(my original inspiration), TheLittlePen, Mapiful and MaptracksMe (among many other such businesses).

To get caught up on how this package came to be check out the earlier blogs:

1. I reverse-engineered Atlas.co (well, some of it)
2. Using the MapBox API with Leaflet
3. Plotting Flight Paths on Leaflet Maps
4. Packaging My Route Map Code! Introducing mapBliss
5. Control Individual Label Positions In mapBliss With _flex() Functions

In this blog I share the newest feature in the mapBliss package- frame and custom title support along with the ability to save framed maps as a .svg file for a print quality visuals.

Introducing frame_1() and save_map_svg()

Thanks to the folks at StackOverflow, I was able to figure out how create custom frame and title support. I initially looked into adding a title only, but quickly realized that I needed to incorperate a frame to get to get the desired functionality. This combined with my own trial and error allowed me to come up with the frame_1() and save_map_svg() functions. frame_1() is called such in hope that there will be more custom frames designed along the way (please feel free to add potential designs or share your solutions to on the Github Issues), but for now, there is currently only a standard white frame for maps created.

To preview your map you can just plot a map for your choosing and pipe it to the frame_1() function and add the relevant arguments.

(Since I’m blogging off of WordPress, I posted an image of the result below)

# devtools::install_github("benyamindsmith/mapBliss")
library(mapBliss)
map<-plot_city_view("Jersalem, IL") |>
     frame_1(title_text="Jerusalem",
             subtitle_text="City of Gold",
             subtitle_font="Brush Script MT")

map

If you want to save your map, you can use the save_map_frame_svg() function.

map |>
  save_map_frame_svg("myTestMap.svg")

Listening on http://127.0.0.1:7825
[1] "myTestMap.svg written in F:/"

And that’s pretty much it! With 3 functions its now possible to make a high quality, print ready “framed” and annotated map!

Next Steps/Conclusion

This is a pretty cool breakthrough in the overall progress of mapBliss. Some more ideas where this package can be improved would be with:

• Creating more frames with CSS to have more framing options– if you know of any CSS codes for making nice frames please let me know!
• Build a GUI…eventually…and work on all sorts of things to make that happen. Likely the GUI would be developed in shiny.

Right now I don’t really have a particular timeline for getting any of this done, but its some of the ideas that I have in mind for further development of the mapBliss package.

I really want to get more people to play around with this package and see what they make with it! If you notice any problems or want a new feature, feel free to open an issue on Github and let me know!

Thank you for reading!