ggdiagram

https://wjschne.github.io/ggdiagram
Admin
ggdiagram is an R package that provides an object-oriented approach to creating diagrams and...
Tokens:137,671
Snippets:825
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup: Load required libraries

Source: https://wjschne.github.io/ggdiagram/articles/equations.html

Loads the necessary packages for the examples in this article: ggplot2, ggdiagram, tibble, dplyr, purrr, and ggarrow.

```R
library(ggplot2)
library(ggdiagram)
library(tibble)
library(dplyr)
library(purrr)
library(ggarrow)
```

--------------------------------

### Setup: theme and base plot (bp)

Source: https://wjschne.github.io/ggdiagram/articles/polygons.html

Defines the color palette and theme used throughout the examples, and creates the base ggdiagram plot object 'bp' with custom axes.

```R
# my_colors <- viridis::viridis(2, begin = .25, end = .5)
my_colors <- c("#3B528B", "#21908C")

theme_set(
  theme_minimal(
    base_size = my_font_size,
    base_family = my_font) +
    theme(axis.title.y = element_text(angle = 0, vjust = 0.5)))

bp <- ggdiagram(
  font_family = my_font,
  font_size = my_font_size,
  point_size = my_point_size,
  linewidth = .5,
  theme_function = theme_minimal,
  axis.title.x =  element_text(face = "italic"),
  axis.title.y = element_text(
    face = "italic",
    angle = 0,
    hjust = .5,
    vjust = .5)) +
  scale_x_continuous(labels = signs_centered,
                     limits = c(-4, 4)) +
  scale_y_continuous(labels = signs::signs,
                     limits = c(-4, 4))
```

--------------------------------

### bind examples

Source: https://wjschne.github.io/ggdiagram/reference/bind.html

Examples of binding point and circle objects.

```R
bind(c(ob_point(1,2), ob_point(3,4)))
#> 
#> ── <ob_point> 
#> # A tibble: 2 × 2
#>       x     y
#>   <dbl> <dbl>
#> 1     1     2
#> 2     3     4
bind(c(ob_circle(ob_point(0,0), radius = 1),
       ob_circle(ob_point(1,1), radius = 2)))
#> 
#> ── <ob_circle> 
#> # A tibble: 2 × 3
#>       x     y     r
#>   <dbl> <dbl> <dbl>
#> 1     0     0     1
#> 2     1     1     2
```

--------------------------------

### Example: set and restore default arrowhead

Source: https://wjschne.github.io/ggdiagram/reference/arrowhead.html

Demonstrates getting the default arrowhead, setting a new one with ggarrow::arrow_head_wings(offset = 25), and restoring the default. Output shows the matrix structure.

```R
arrowhead()
#> 
#> ── <class_arrowhead> 
#> A matrix with 2 columns and 200 rows. First 6 rows:
#>          x    y
#> [1,] -0.39 0.00
#> [2,] -0.39 0.02
#> [3,] -0.39 0.04
#> [4,] -0.40 0.06
#> [5,] -0.40 0.08
#> [6,] -0.40 0.10
# Set new default
set_default_arrowhead(ggarrow::arrow_head_wings(offset = 25))
arrowhead()
#> 
#> ── <class_arrowhead> 
#> A matrix with 2 columns and 4 rows.
#>          x     y
#> [1,]  1.00  0.00
#> [2,] -0.48  0.69
#> [3,]  0.00  0.00
#> [4,] -0.48 -0.69
# restore default
set_default_arrowhead()
arrowhead()
#> 
#> ── <class_arrowhead> 
#> A matrix with 2 columns and 200 rows. First 6 rows:
#>          x    y
#> [1,] -0.39 0.00
#> [2,] -0.39 0.02
#> [3,] -0.39 0.04
#> [4,] -0.40 0.06
#> [5,] -0.40 0.08
#> [6,] -0.40 0.10
```

--------------------------------

### latex_color Example

Source: https://wjschne.github.io/ggdiagram/reference/latex_color.html

An example showing how to color a mathematical expression red.

```R
latex_color("X^2", "red")
#> [1] "{\\color[HTML]{FF0000} X^2}"
```

--------------------------------

### Setup ggdiagram environment

Source: https://wjschne.github.io/ggdiagram/articles/bezier.html

Load the necessary libraries for creating diagrams and plots.

```r
library(ggdiagram)
library(ggplot2)
library(dplyr)
library(ggtext)
library(ggarrow)
library(geomtextpath)
```

--------------------------------

### Examples of subscript() and superscript()

Source: https://wjschne.github.io/ggdiagram/reference/subscript.html

Demonstrates the output of subscript() and superscript() with simple inputs, returning markdown-formatted strings.

```r
subscript("X", 1)
#> [1] "X<sub>1</sub>"
superscript("A", 2)
#> [1] "A<sup>2</sup>"
```

--------------------------------

### Set up base plot with custom theme and colors

Source: https://wjschne.github.io/ggdiagram/articles/lines.html

Defines font, point size, colors, and a base plot (bp) with a minimal theme and custom axis labels. This setup is reused across all line examples.

```R
my_font <- "Roboto Condensed"
my_font_size <- 20
my_point_size <- 2


# my_colors <- viridis::viridis(2, begin = .25, end = .5)
my_colors <- c("#3B528B", "#21908C")

theme_set(
  theme_minimal(
    base_size = my_font_size,
    base_family = my_font) +
    theme(axis.title.y = element_text(angle = 0, vjust = 0.5)))

bp <- ggdiagram(
  font_family = my_font,
  font_size = my_font_size,
  point_size = my_point_size,
  linewidth = .5,
  theme_function = theme_minimal,
  axis.title.x =  element_text(face = "italic"),
  axis.title.y = element_text(
    face = "italic",
    angle = 0,
    hjust = .5,
    vjust = .5)) +
  scale_x_continuous(labels = signs_centered,
                     limits = c(-4, 4)) +
  scale_y_continuous(labels = signs::signs,
                     limits = c(-4, 4))
```

--------------------------------

### Example of circle_from_3_points

Source: https://wjschne.github.io/ggdiagram/reference/circle_from_3_points.html

An example demonstrating how to pass three ob_point objects to the function to obtain an ob_circle.

```R
circle_from_3_points(ob_point(1,1),
                     ob_point(2,4),
                     ob_point(5,3))
#> 
#> ── <ob_circle> 
#> # A tibble: 1 × 3
#>       x     y     r
#>   <dbl> <dbl> <dbl>
#> 1     3     2  2.24
```

--------------------------------

### Create multiple ngons

Source: https://wjschne.github.io/ggdiagram/reference/ob_ngon.html

Example showing how to create a sequence of ngons with varying numbers of sides and positions.

```R
ob_ngon(center = ob_point(x = 3:8, y = 0),
        n = 3:8,
        radius = .4)
#> 
#> ── <ob_ngon> 
#> # A tibble: 6 × 5
#>       x     y radius     n angle
#>   <int> <dbl>  <dbl> <int> <dbl>
#> 1     3     0    0.4     3     0
#> 2     4     0    0.4     4     0
#> 3     5     0    0.4     5     0
#> 4     6     0    0.4     6     0
#> 5     7     0    0.4     7     0
#> 6     8     0    0.4     8     0
```

--------------------------------

### Calculate Hierarchy Depth Examples

Source: https://wjschne.github.io/ggdiagram/reference/get_depth.html

Examples demonstrating how to calculate the depth of variables in a simple lavaan model string.

```R
model <- "X =~ X1 + X2"
get_depth("X", model = model)
#> [1] 2
get_depth("X1", model = model)
#> [1] 1
```

--------------------------------

### Create an ob_rectangle instance

Source: https://wjschne.github.io/ggdiagram/reference/ob_rectangle.html

Example of initializing an ob_rectangle centered at the origin with a width of 3 and a height of 2.

```R
ob_rectangle(center = ob_point(0,0), width = 3, height = 2)
#> 
#> ── <ob_rectangle> 
#> # A tibble: 1 × 7
#>       x     y width height angle color fill 
#>   <dbl> <dbl> <dbl>  <dbl> <dbl> <chr> <chr>
#> 1     0     0     3      2     0 black NA   
```

--------------------------------

### Example of creating a squircle with redefault

Source: https://wjschne.github.io/ggdiagram/reference/redefault.html

This example demonstrates creating a new function 'squircle' from 'ob_ellipse' with a default 'm1' value of 4, then calling it with 'a = 3'.

```R
squircle <- redefault(ob_ellipse, m1 = 4)
squircle(a = 3)
#> 
#> ── <ob_ellipse> 
#> # A tibble: 1 × 7
#>       x     y     a     b angle    m1    m2
#>   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#> 1     0     0     3     3     0     4     4
```

--------------------------------

### Create multiple paths with ob_path

Source: https://wjschne.github.io/ggdiagram/reference/ob_path.html

Example from the documentation showing how to create an ob_path with two paths using a list of ob_point objects and different colors.

```r
ggdiagram() +
 ob_path(list(ob_point(c(0, 0, 4), c(0, 1, 4)),
              ob_point(c(1, 2, 5, 6), c(0, 1, 2, 0))), color = c("red", "blue"))
```

--------------------------------

### equation() examples with ob_line and ob_circle

Source: https://wjschne.github.io/ggdiagram/reference/equation.html

Example usage of equation() on a circle and a line. Creates a line with slope 2 and intercept 4, and a circle with radius 3. The output for the circle is "*x*<sup>2</sup> + *y*<sup>2</sup> = 3<sup>2</sup>" and for the line is "*y* = 2*x* + 4".

```r
l1 <- ob_line(slope = 2, intercept = 4)
c1 <- ob_circle(radius = 3)
equation(c1)
#> [1] "*x*<sup>2</sup> + *y*<sup>2</sup> = 3<sup>2</sup>"
equation(l1)
#> [1] "*y* = 2*x* + 4"
```

--------------------------------

### nudge object example

Source: https://wjschne.github.io/ggdiagram/reference/nudge.html

Demonstrates shifting a circle using nudge and compares it with an alternative point addition method.

```R
ob_circle() |> nudge(x = 2)
#> 
#> ── <ob_circle> 
#> # A tibble: 1 × 3
#>       x     y     r
#>   <dbl> <dbl> <dbl>
#> 1     2     0     1
# Alternative to nudge:
ob_circle() + ob_point(2, 0)
#> 
#> ── <ob_circle> 
#> # A tibble: 1 × 3
#>       x     y     r
#>   <dbl> <dbl> <dbl>
#> 1     2     0     1
```

--------------------------------

### Create and connect diagram objects

Source: https://wjschne.github.io/ggdiagram/index.html

This example demonstrates creating a circle and a rectangle, placing them with a specified separation, and connecting them with an arrow.

```R
library(ggdiagram)
c1 <- ob_circle(radius = 1 / sqrt(pi)) 
r2 <- ob_rectangle() |>
  place(from = c1,
        where = "right", 
        sep = .5)

ggdiagram() +
  c1 +
  r2 +
  connect(c1, r2, resect = 1)
```

--------------------------------

### Creating and operating on angles

Source: https://wjschne.github.io/ggdiagram/reference/ob_angle.html

Examples showing how to create angles using different units and perform arithmetic or trigonometric operations on them.

```R
# Three Different ways to make a right angle
## 90 degrees
degree(90)
#> [1] "90°"

## half pi radians
radian(.5 * pi)
#> [1] "0.5π"

## A quarter turn
turn(.25)
#> [1] ".25"

# Operations
degree(30) + degree(20)
#> [1] "50°"
degree(350) + degree(20)
#> [1] "10°"
degree(30) - degree(30)
#> [1] "0°"
degree(30) - degree(50)
#> [1] "−20°"

degree(30) * 2
#> [1] "60°"
degree(30) / 3
#> [1] "10°"

radian(1) + 1 # added or subtracted numbers are radians
#> [1] "0.64π"
degree(10) + 10 # added or subtracted numbers are degrees
#> [1] "20°"
turn(.25) + .25 # added or subtracted numbers are turns
#> [1] ".50"

# Trigonometric functions work as normal
sin(degree(30))
#> [1] 0.5
cos(degree(30))
#> [1] 0.8660254
tan(degree(30))
#> [1] 0.5773503
```

--------------------------------

### Load required packages for ggdiagram examples

Source: https://wjschne.github.io/ggdiagram/articles/lines.html

Loads ggdiagram and supporting packages (ggplot2, dplyr, ggtext, ggarrow) needed for the examples in this article.

```R
library(ggdiagram)
library(ggplot2)
library(dplyr)
library(ggtext)
library(ggarrow)
```

--------------------------------

### Install ggdiagram development version

Source: https://wjschne.github.io/ggdiagram/index.html

Use this command to install the development version of the package from R-universe.

```R
install.packages("ggdiagram", repos = "https://wjschne.r-universe.dev")
```

--------------------------------

### Examples of perpendicular point operators

Source: https://wjschne.github.io/ggdiagram/reference/perpendicular_point.html

Demonstrates finding a point perpendicular to two points using vertical (%|-% ) and horizontal (%-|% ) orientation.

```R
x <- ob_point(0,0)
y <- ob_point(1,1)
# Find point perpendicular to x and y going vertically first
x %|-% y
#> 
#> ── <ob_point> 
#> # A tibble: 1 × 2
#>       x     y
#>   <dbl> <dbl>
#> 1     0     1
# Find point perpendicular to x and y going horizontally first
x %-|% y
#> 
#> ── <ob_point> 
#> # A tibble: 1 × 2
#>       x     y
#>   <dbl> <dbl>
#> 1     1     0
```

--------------------------------

### Define and render a single Bézier curve

Source: https://wjschne.github.io/ggdiagram/articles/bezier.html

Defines start, end, and offset points, binds them into a path, and renders both the control path and the resulting Bézier curve.

```R
# start and end of control points
p_start <- ob_point(-4,-2)
p_end <- ob_point(4, 2)
# Offset ob_point from the endpoints
p_offset <- ob_point(5,6)

# Make list of points and bind them into a single ob_point
p <- c(p_start, 
       p_start + p_offset, 
       p_end - p_offset, 
       p_end) |> 
  bind() 

bp + 
  ob_path(p, 
       linetype = "dashed", 
       color = "gray",
       linewidth = .25) +
  p + 
  ob_bezier(p, 
          label = ob_label("Labels can follow the path of the bézier curve."))
```

--------------------------------

### Create multiple paths with ob_path

Source: https://wjschne.github.io/ggdiagram/articles/paths.html

Creates three paths at once by passing a list of point objects to `ob_path`. Each path gets a different color and label.

```r
bp +
  ob_path(c(p_curve, 
         p_curve * .5 + ob_point(2,-2),
         p_curve * .5 + ob_point(-2,2)), 
       color = c("orchid4",
                 "dodgerblue3",
                 "firebrick4"),
       label = c(".52", ".42", ".61"))
```

--------------------------------

### Initialize Plotting Environment

Source: https://wjschne.github.io/ggdiagram/articles/segments.html

Sets up the color palette and ggplot2 theme for the diagrams.

```R
my_colors <- c("#3B528B", "#21908C")

theme_set(
  theme_minimal(base_size = my_font_size, base_family = my_font) +
    theme(axis.title.y = element_text(angle = 0, vjust = 0.5))
)

bp <- ggdiagram(
  font_family = my_font,
  font_size = my_font_size,
  point_size = my_point_size,
  linewidth = .5,
  theme_function = theme_minimal,
  axis.title.x =  element_text(face = "italic"),
  axis.title.y = element_text(
    face = "italic",
    angle = 0,
    hjust = .5,
    vjust = .5
  )
) +
  scale_x_continuous(labels = signs_centered, limits = c(-4, 4)) +
  scale_y_continuous(labels = signs::signs, limits = c(-4, 4))
```

--------------------------------

### Install ggdiagram from CRAN

Source: https://wjschne.github.io/ggdiagram/index.html

Use this command to install the stable version of the package from CRAN.

```R
install.packages("ggdiagram")
```

--------------------------------

### ggdiagram example with circle and rectangle

Source: https://wjschne.github.io/ggdiagram/reference/ggdiagram.html

Example usage of ggdiagram with custom font size, font family, and line width, adding a circle and a rectangle. The example shows how to combine ggdiagram with ob_circle and ob_rectangle.

```R
ggdiagram(font_size = 20, font_family = "serif", linewidth = 3) +
   ob_circle(label = "Circle") +
   ob_rectangle(label = "Rectangle", x = 3, width = 3)
```

--------------------------------

### ob_arc with start and end degrees

Source: https://wjschne.github.io/ggdiagram/reference/ob_arc.html

Creates an arc object with start angle 0 and end angle 60 degrees. The output is a tibble with columns x, y, radius, start, end, n, and type.

```r
ob_arc(start = degree(0), end = degree(60))
#> 
#> ── <ob_arc> 
#> # A tibble: 1 × 7
#>       x     y radius start   end     n type 
#>   <dbl> <dbl>  <dbl> <dbl> <dbl> <int> <chr>
#> 1     0     0      1     0    60   360 arc  
```

--------------------------------

### ob_path constructor usage

Source: https://wjschne.github.io/ggdiagram/reference/ob_path.html

Shows the full signature of the ob_path() constructor with all arguments and defaults.

```r
ob_path(
  p = S7::class_missing,
  label = character(0),
  label_sloped = TRUE,
  alpha = numeric(0),
  arrow_head = S7::class_missing,
  arrow_fins = S7::class_missing,
  arrowhead_length = numeric(0),
  length_head = numeric(0),
  length_fins = numeric(0),
  color = character(0),
  fill = character(0),
  lineend = numeric(0),
  linejoin = numeric(0),
  linewidth = numeric(0),
  linewidth_fins = numeric(0),
  linewidth_head = numeric(0),
  linetype = numeric(0),
  resect = numeric(0),
  resect_fins = numeric(0),
  resect_head = numeric(0),
  stroke_color = character(0),
  stroke_width = numeric(0),
  style = S7::class_missing,
  id = character(0),
  ...
)
```

--------------------------------

### ob_wedge with start and end degrees

Source: https://wjschne.github.io/ggdiagram/reference/ob_arc.html

Creates a wedge object with start angle 240 and end angle 300 degrees. The output tibble includes color and fill columns, with fill defaulting to black.

```r
ob_wedge(start = degree(240), end = degree(300))
#> 
#> ── <ob_arc> 
#> # A tibble: 1 × 9
#>       x     y radius start   end color fill      n type 
#>   <dbl> <dbl>  <dbl> <dbl> <dbl> <chr> <chr> <int> <chr>
#> 1     0     0      1   240   300 NA    black   360 wedge
```

--------------------------------

### ob_circular_segment with start and end degrees

Source: https://wjschne.github.io/ggdiagram/reference/ob_arc.html

Creates a circular segment object with start angle 120 and end angle 180 degrees. The output tibble includes additional columns color and fill compared to ob_arc.

```r
ob_circular_segment(start = degree(120), end = degree(180))
#> 
#> ── <ob_arc> 
#> # A tibble: 1 × 9
#>       x     y radius start   end color fill      n type   
#>   <dbl> <dbl>  <dbl> <dbl> <dbl> <chr> <chr> <int> <chr>  
#> 1     0     0      1   120   180 NA    black   360 segment
```

--------------------------------

### class_color usage example

Source: https://wjschne.github.io/ggdiagram/reference/class_color.html

Demonstrates creating a `class_color` object from "blue", displaying its hex code, and using the `@transparentize`, `@lighten`, and `@darken` methods. The output shows the resulting hex codes and the printed object structure.

```r
mycolor <- class_color("blue")
mycolor
#> 
#> ── <ggdiagram::class_color> ────────────────────────────────────────────────────
#> @ color: chr "#0000FFFF"
#> Other props: transparentize, lighten, darken, saturation, hue,
#>              brightness, alpha, red, green, blue, mean, tex, id
# Display html hexcode
c(mycolor)
#> [1] "#0000FFFF"
# Set transparency
mycolor@transparentize(.5)
#> 
#> ── <ggdiagram::class_color> ────────────────────────────────────────────────────
#> @ color: chr "#0000FF80"
#> Other props: transparentize, lighten, darken, saturation, hue,
#>              brightness, alpha, red, green, blue, mean, tex, id
# Lighten color
mycolor@lighten(.5)
#> 
#> ── <ggdiagram::class_color> ────────────────────────────────────────────────────
#> @ color: chr "#8282FFFF"
#> Other props: transparentize, lighten, darken, saturation, hue,
#>              brightness, alpha, red, green, blue, mean, tex, id
# Darken color
mycolor@darken(.5)
#> 
#> ── <ggdiagram::class_color> ────────────────────────────────────────────────────
#> @ color: chr "#000082FF"
#> Other props: transparentize, lighten, darken, saturation, hue,
#>              brightness, alpha, red, green, blue, mean, tex, id
```

--------------------------------

### Load ggdiagram package

Source: https://wjschne.github.io/ggdiagram/articles/colors.html

Loads the ggdiagram library for use in subsequent examples.

```r
library(ggdiagram)
```

--------------------------------

### ob_arc @tibble

Source: https://wjschne.github.io/ggdiagram/reference/ob_arc.html

Gets a tibble or data.frame containing parameters and styles used by ggarrow::geom_arrow.

```APIDOC
## ob_arc @tibble

### Description
Gets a tibble::tibble or data.frame containing parameters and styles used by ggarrow::geom_arrow.

### Method
@tibble

### Returns
- **tibble** (tibble::tibble or data.frame) - The tibble or data.frame with parameters and styles.
```

--------------------------------

### Get Segment Endpoints

Source: https://wjschne.github.io/ggdiagram/articles/segments.html

Retrieves segment endpoints by specifying midpoints at positions 0 and 1.

```R
bp +
  s1 +
  s1@midpoint(c(0, 1))
```

--------------------------------

### Style circles and connectors with labels

Source: https://wjschne.github.io/ggdiagram/articles/circles.html

Demonstrates applying custom colors, labels, and connector styling to circles and paths.

```R
bp +
  {cthis <- ob_circle(
    ob_point(-2, 2),
    radius = 1,
    fill = my_colors[1],
    color = NA,
    label = ob_label(
      "This",
      color = "white",
      fill = NA,
      size = 35
    )
  )} + 
  {cthat <- ob_circle(
    ob_point(1.5, -1.5),
    radius = 1.5,
    fill = my_colors[2],
    color = NA,
    label = ob_label(
      "That",
      color = "white",
      fill = NA,
      size = 55
    )
  )} +
  connect(cthis, cthat, 
       resect = 2, 
       label = ob_label("Causes", size = 20, vjust = 0),
       color = "black")
```

--------------------------------

### Create and Connect Diagram Variables

Source: https://wjschne.github.io/ggdiagram/articles/automation.html

Demonstrates creating multiple rectangle objects and connecting them using a loop and the connect function.

```R
# Number of variables
k <- 8L

# Make k variables
x <- ob_rectangle(ob_point(rep(0, k), rep(0, k)),
                  label = ob_label(
                    label = paste0("*X*~", 1:k, "~"),
                    vjust = .6,
                    size = 20,
                    family = "Roboto Condensed"
                  ))



# Place even variables to the right and 
# odd variables below the previous variables
for (i in 2:k) {
  x[i] <- place(x[i], x[i - 1], ifelse((i %% 2) == 0, "right", "below"))
}

# Plot
ggdiagram() + 
  x +
  # paths between variables ahead by 1 and by 2
  connect(x[c(seq(1,k - 1), seq(1, k - 2))], 
          x[c(seq(2,k),     seq(3, k)),
          resect = 2)
```

--------------------------------

### Create equivalent angles

Source: https://wjschne.github.io/ggdiagram/articles/angles.html

Demonstrates creating angle objects using degree, turn, and radian functions.

```R
degree(90)
#> [1] "90°"
turn(1 / 4)
#> [1] ".25"
radian(pi / 2)
#> [1] "0.5π"
```

--------------------------------

### Example: ob_covariance with ob_circle and ob_label

Source: https://wjschne.github.io/ggdiagram/reference/ob_covariance.html

Creates a ggdiagram with a circle and a covariance arrow between two points, labeled 'A'.

```R
ggdiagram() +
  {x <- ob_circle(ob_point(c(-2, 2), 0))} +
  ob_covariance(x = x[1],
                y = x[2],
                label = ob_label("A"))
```

--------------------------------

### Calculate bounding box for ob_point

Source: https://wjschne.github.io/ggdiagram/articles/points.html

Demonstrates how to create an ob_point object with specific coordinates and retrieve its bounding box.

```R
bp +
  {pts <- ob_point(x = 1:4, 
                   y = c(3, 3, 4, 2))} +
  pts@bounding_box
```

--------------------------------

### distance() examples

Source: https://wjschne.github.io/ggdiagram/reference/distance.html

Demonstrates calculating distances between various object types: two points, endpoints of a segment, a point and a line, and the edges of two circles. Outputs are shown as comments.

```r
# Distance between two objects
p1 <- ob_point(0, 0)
p2 <- ob_point(3, 4)
distance(p1, p2)
#> [1] 5

# Distance between the endpoints of a segment
s1 <- ob_segment(p1, p2)
distance(s1)
#> [1] 5

# Distance between a point and a line
l1 <- ob_line(slope = 0, intercept = 1)
distance(p1, l1)
#> [1] 1

# Shortest distance between the edges of 2 circles
c1 <- ob_circle(p1, radius = 1)
c2 <- ob_circle(p2, radius = 2)
distance(c1, c2)
#> [1] 2
```

--------------------------------

### Load ggdiagram and ggplot2 libraries

Source: https://wjschne.github.io/ggdiagram/articles/ggdiagram.html

Initial setup required to use the ggdiagram package alongside ggplot2.

```R
library(ggplot2)
library(ggdiagram)
```

--------------------------------

### Example: Plotting points with ob_point and ob_polar

Source: https://wjschne.github.io/ggdiagram/reference/ob_point.html

Demonstrates how to add Cartesian points and polar points to a ggdiagram plot.

```R
ggdiagram(theme = ggplot2::theme_minimal) +
  ob_point(x = -1:1, y = -1:1, color = "red") +
  ob_polar(theta = degree(seq(0, 330, 30)), r = 2, color = "blue")
```

--------------------------------

### Render multiple Bézier paths

Source: https://wjschne.github.io/ggdiagram/articles/bezier.html

Creates a list of point objects and renders a separate Bézier curve for each object in the list.

```R
control_point_list <- c(
      ob_point(
        x = c(-4, -3, 4), 
        y = c(.1,  4, .1), 
        color = my_colors[1]),
      ob_point(
        x = c(-4, 3, 4), 
        y = c(-.1, -4, -.1), 
        color = my_colors[2] )
      )
bp + 
  ob_bezier(control_point_list) +
  ob_path(control_point_list, linetype = "dashed", linewidth = .25) +
  bind(control_point_list)
```

--------------------------------

### Define an arc with ob_arc

Source: https://wjschne.github.io/ggdiagram/articles/arcwedges.html

Creates an arc object by specifying the center point, start and end angles, and radius.

```R
ob_arc(center = ob_point(1,2), 
    start = 25, 
    end = 75, 
    radius = 3)
#> 
#> ── <ob_arc>
#> # A tibble: 1 × 7
#>       x     y radius start   end     n type 
#>   <dbl> <dbl>  <dbl> <dbl> <dbl> <dbl> <chr>
#> 1     1     2      3    25    75   360 arc
```
Tokens:
Raw