Feature request: option for non-centered, left-hand and right-hand, linewidth

[assaron]

I'm using ggplot to plot borders of certain regions using geom_path and have a problem of certain regions sharing a border, resulting in an overlap of lines:

I imagine, that the problem could be fixed by introducing a directional line-width. That is, one that will extend the segments, for example, only to the right-hand side of the line, instead of extending to both, as implemented currently. In that case I can specify the border points in a clock-wise order and make sure that the line will be always on the inside of the region.

I would appreciate thoughts on feasibility of this feature or any potential workarounds.

The code to reproduce the figure:

library(ggplot2)
library(data.table)
load(gzfile("border_example.rda.gz"))

ggplot(data, aes(x=UMAP_1, y=UMAP_2)) + 
    geom_point(color="grey") + 
    geom_path(data=maskTable, aes(group=group, color=cluster), linewidth=1) +
    coord_fixed() + 
    theme_classic()

border_example.rda.gz

[teunbrand]

Hi there, thanks for the request! Just to clarify: you're looking for something akin to 'stroke location' as mentioned in the following SO post: https://stackoverflow.com/a/7273346/11374827 (also known as 'stroke alignment' in other places)?

If not, would you mind explaining or illustrating a bit more?

To simplify the reprex a little bit:

library(ggplot2)

df <- data.frame(
  x = c(1, 2, 2, 1, 2, 2, 3, 2),
  y = c(0.5, 0, 1, 0.5, 1, 0, 0.5, 1),
  group = c("A", "A", "A", "A", "B", "B", "B", "B")
)

ggplot(df, aes(x, y, colour = group)) +
  geom_path(linewidth = 10)

^{Created on 2025-03-20 with reprex v2.1.1}

What should happen to the middle line?

[assaron]

Just to clarify: you're looking for something akin to 'stroke location' as mentioned in the following SO post: https://stackoverflow.com/a/7273346/11374827 (also known as 'stroke alignment' in other places)?

Yes, something like this. I think left/right is a bit more general, compared to inside/outside, since it can be applied to individual segments too, but the general idea is the same.

I would imagine something like this (notice change in the order of the points):

library(ggplot2)

df <- data.frame(
  x = c(1, 2, 2, 1, 2, 3, 2, 2),
  y = c(0.5, 1, 0, 0.5, 1, 0.5, 0, 1),
  group = c("A", "A", "A", "A", "B", "B", "B", "B")
)

ggplot(df, aes(x, y, colour = group)) +
  geom_path(linewidth = 5, stroke_location="right")

The code above should produce image like this (I've kept your plot as a reference, and bright red/blue colors are for the expected output):

And for the same order, but "left" location:

ggplot(df, aes(x, y, colour = group)) +
  geom_path(linewidth = 5, stroke_location="left")

[assaron]

I think this can be implemented by moving the path points to appropriate locations: shifting the endpoints orthogonally to the segment by width/2 to the right/left and adjusting the intermediate points to lay on the intersection of the corresponding segments parallel-shifted by width/2.

[teunbrand]

Thanks for the clarification! I can see why this would be useful, but I don't see a clean path to how this would be implemented. Some of the issues that came about when it was proposed that the 'stroke-align' property becomes part of the svg specifications are still relevant today: https://svgwg.org/specs/strokes/#SpecifyingStrokeAlignment (e.g. dashes, self-intersections).

Aside from these more fundamental issues, there are also practical issues in that {grid}, the package that underpins the graphics produced by ggplot2, does not natively allow setting strokes this way. There may be packages that can help setting strokes this way, but it is unlikely that ggplot2 will take on an additional dependency for this feature.

The development of ggplot2 is underpinned by covering the basics, improving the system as a whole and expanding infrastructure of the project. The extension system was build so that anyone with more particular needs could implement their own layers. For these reasons, I'd suggest the way to get this implemented is by making this feature an extension.

[assaron]

Maybe the better way to frame is not as a stroke option, but as a position_ modifier?

With the help of ChatGPT I drafted the following function:

offset_polyline_miter <- function(x, y, width) {
    n <- length(x)
    if (n < 2) stop("Polyline must have at least 2 points")
    
    # Function to compute unit vector and normal
    unit_vector <- function(p1, p2) {
        v <- c(p2[1] - p1[1], p2[2] - p1[2])
        v / sqrt(sum(v^2))
    }
    
    normal <- function(v) c(-v[2], v[1])
    
    # Function to compute intersection of two lines: p + t*d1 = q + s*d2
    line_intersect <- function(p, d1, q, d2) {
        A <- matrix(c(d1, -d2), ncol = 2)
        b <- q - p
        t <- solve(A, b)
        p + t[1] * d1
    }
    
    w <- width / 2
    offset_pts <- list()
    
    # First segment (cap with straight offset)
    v1 <- unit_vector(c(x[1], y[1]), c(x[2], y[2]))
    n1 <- normal(v1)
    offset_pts[[1]] <- c(x[1], y[1]) + w * n1
    
    # Middle points with miter joins
    for (i in 2:(n - 1)) {
        p0 <- c(x[i - 1], y[i - 1])
        p1 <- c(x[i], y[i])
        p2 <- c(x[i + 1], y[i + 1])
        
        v_prev <- unit_vector(p0, p1)
        v_next <- unit_vector(p1, p2)
        n_prev <- normal(v_prev)
        n_next <- normal(v_next)
        
        p1a <- p1 + w * n_prev
        p1b <- p1 + w * n_next
        
        miter_pt <- line_intersect(p1a, v_prev, p1b, v_next)
        offset_pts[[i]] <- miter_pt
    }
    
    # Last segment (cap with straight offset)
    vn <- unit_vector(c(x[n - 1], y[n - 1]), c(x[n], y[n]))
    nn <- normal(vn)
    offset_pts[[n]] <- c(x[n], y[n]) + w * nn
    
    # Return as data frame
    do.call(rbind, offset_pts) |> 
        as.data.frame() |> 
        setNames(c("x", "y"))
}

Then I can do the following:

library(ggplot2)

df <- data.frame(
    x = c(1, 2, 2, 1),
    y = c(1, 0, 2, 1)
)

offset_df <- offset_polyline_miter(df$x, df$y, 0.1)

ggplot(offset_df, aes(x, y)) +
    geom_path(linewidth = 10, color="cyan") +
    geom_path(linewidth = 0.5, color="blue") + 
    geom_path(linewidth = 0.5, color="red", data=df) + 
    coord_fixed()

The result look like this (red line is the original, blue is shifted, cyan is the stroke for the shifted line):

I'm not sure exactly how position_ modifiers work, can this feature be implemented on that level? I can't do it on the data level, since the shift should be done in the graphical device coordinates. Also, some corner cases should be handled on top of this, such as around small segments and sharp turns, where the segment should basically disappear.

[assaron]

After reading a bit more about it, it seems that it should be implemented at Geom level, which has access to the device coordinates.

Do you think it can be done as a on option for geom_path? Or should I just create a custom Geom as an extension?

[assaron]

Actually, I think I found a solution for my purposes in ggforce:

library(ggplot2)
library(ggforce)

dfc <- data.frame(
    x = c(1, 2, 2),
    y = c(1, 0, 2)
)

ggplot(dfc, aes(x, y)) +
    geom_shape(linewidth=10, color="red", fill=NA, expand=unit(-10, "pt")) +
    geom_polygon(linewidth = 0.5, color="black", fill=NA)

There seem to be some minor problem with exact expand/shrink size, but I don't think it matters for me that much.

I think this issue can be closed then. Thank you!

[teunbrand]

Actually, I think I found a solution for my purposes in ggforce:

Ah yes, good find!

I think this issue can be closed then

Alright, glad you find something akin to what you were looking for!