SpotGraphs: Graph-based analysis of spatially resolved transcriptional data in R

SpotGraphs is an R package that enhances spatial transcriptomics analysis by providing direct, flexible access to spot adjacency graphs via the igraph infrastructure, enabling advanced spatial manipulation and offering performance comparable to Python's SquidPy.

The Gist

Imagine you have a massive, high-resolution map of a bustling city. In the world of biology, this "city" is a slice of tissue from a human body, and the "buildings" are individual cells. Scientists want to know what each building is doing (what genes it's expressing), but they also need to understand how the buildings relate to their neighbors. Are they part of a quiet suburb, a busy downtown, or a construction zone?

For a long time, the tools scientists used in the computer language R to study these maps were a bit like looking at a map through a foggy window. They could see the general shape and color of the neighborhoods, but they couldn't easily walk the streets, count the exact connections between houses, or redraw the roads to see how the city would change if a bridge were closed.

Enter SpotGraphs, a new tool created by researchers Alex Lee and David Sanin. Think of SpotGraphs as a master key and a set of blueprints that lets scientists step out of the fog and walk right onto the streets of their cellular city.

Here is how it works, broken down into simple concepts:

1. Drawing the Roads (Building the Graph)

To understand how cells talk to each other, scientists first need to draw "roads" connecting them. SpotGraphs offers two main ways to draw these roads:

• The Grid Method (Euclidean Distance): Imagine a perfectly laid-out city with square blocks or hexagonal honeycombs. If a house is within a certain walking distance of another, you draw a road between them. This works great for organized tissues (like the 10X Visium data the authors tested).
• The Triangle Method (Delaunay Triangulation): Imagine a city with houses scattered randomly, like a village built on a hill. Instead of a grid, you connect every house to its closest neighbors to form a web of triangles. This is better for messy, irregular shapes.

SpotGraphs is special because it lets you tweak these roads. If a road looks wrong, you can erase it. If you want to see how a neighborhood changes if you remove a specific street, you can do that instantly.

2. Finding the Heart of the Neighborhood (Centers and Boundaries)

Once the roads are drawn, SpotGraphs helps you find the town square and the city limits.

• The Town Square: In a cluster of cells (a neighborhood), which one is the "center"? SpotGraphs uses a clever math trick to find the cell that is most "central" to the group, rather than just guessing the middle of the map. This helps researchers study how gene expression changes as you move from the center of a tumor to its edge.
• The City Limits: It can also easily spot the houses on the very edge of the tissue. These are the cells that have fewer neighbors because they are near the "cliff" where the tissue ends.

3. Cleaning Up the Map (Filtering Bad Data)

Sometimes, the map includes spots that aren't real buildings—they might be trash, debris, or empty space. Usually, scientists have to guess which spots to throw away based on how much "noise" they hear.
SpotGraphs acts like a smart traffic cop. It looks at the road connections. If a "building" has no roads connecting to it (it's isolated), or if it's in a tiny, disconnected island of debris, the tool flags it. This allows researchers to clean their data more accurately, removing the "junk" spots that would otherwise confuse their results.

4. The "Shortest Path" Detour

Sometimes, the straight-line distance between two points isn't the real distance. Imagine a river or a mountain range cutting through your city. You can't walk in a straight line; you have to go around.
SpotGraphs allows scientists to calculate the shortest walking path along the actual tissue, rather than a straight line through the air. This is crucial for understanding how signals travel through a twisted or folded piece of tissue.

The Big Comparison

The authors tested their new tool against a popular tool called SquidPy (which runs on Python). They found that SpotGraphs is just as good, if not better, at drawing these maps. They also discovered a warning: a common method called "Nearest Neighbor" is like trying to connect houses just because they are close, even if a river separates them. This often creates fake roads and leads to wrong conclusions, especially at the edges of the tissue. SpotGraphs avoids this trap.

The Bottom Line

SpotGraphs is like giving a biologist a Swiss Army knife for their cellular maps. Instead of just looking at a static picture, they can now:

• Redraw the roads.
• Find the center of a neighborhood.
• Identify the city limits.
• Calculate the real walking distance between points.
• Clean up the map by removing isolated debris.

It turns a static image of a tissue sample into a dynamic, interactive network that scientists can explore, question, and understand in much greater depth.

Technical Summary

1. Problem Statement

Current spatial transcriptomics (ST) analysis pipelines in R primarily focus on pre-processing and visualization. While they offer "spatially aware" normalization, clustering, and identification of spatially variable genes, they lack direct and flexible mechanisms for analysts to interrogate or adjust the underlying graphs that define spot adjacencies.

• Limitation: Existing methods often treat spatial coordinates indirectly, preventing users from customizing the adjacency definitions (e.g., handling tissue boundaries, filtering debris, or defining specific neighborhoods).
• Gap: While Python's SquidPy library offers a robust graph API, there is a need for equivalent, flexible graph-based infrastructure within the R ecosystem (specifically leveraging igraph) to allow for custom spatial analysis workflows.

2. Methodology

The authors developed SpotGraphs, an R package that interfaces spatial transcriptomics x,y-coordinates with the igraph infrastructure. The core methodology involves:

• Graph Construction (SpotGraph()): The package implements two primary strategies to generate adjacency matrices from coordinates:
  1. Euclidean Distance: Calculates distances between all spots ($n$) and sets a maximum threshold ($d_{max}$) to define neighbors. This is optimized for grid-based data (hexagonal or square arrangements).
  2. Delaunay Triangulation: Uses the interp R package to triangulate points. To prevent non-adjacent long-range connections, edges exceeding a default $d_{max}$ are pruned. This is recommended for non-grid data.
• Neighborhood Analysis (NeighborhoodCenters()):
  • Constructs a network and removes edges connecting spots inside a defined neighborhood to those outside.
  • Computes Eigenvector Centrality scores within the subgraph.
  • Identifies the spot(s) with the maximum centrality score as the geometric/functional "center" of the neighborhood.
• Integration: The package allows users to store graph-derived statistics (e.g., centrality, degree) as metadata in standard R objects like Seurat or SpatialExperiment.

3. Key Contributions

• R-Based Graph Infrastructure: Provides the first direct, flexible graph API for ST data in R, mirroring functionality found in Python's SquidPy.
• Advanced Filtering Tools:
  • Spot-level Filtering: Identifies low-quality spots (e.g., on tissue debris) by detecting isolated nodes or clusters with low connectivity (low degree), which standard count-based QC often misses.
  • Boundary Identification: Automatically identifies tissue boundaries by calculating node degree; spots with degrees lower than the grid maximum (e.g., <6 in a hexagonal grid) are flagged as boundary spots.
• Custom Distance Metrics: Enables the calculation of "shortest path" distances along the tissue topology (using igraph::distances()), which is crucial for distorted tissue samples where Euclidean distance is inaccurate. Users can also manually cut edges (CutEdges()) to redefine connectivity.
• Benchmarking & Comparison: A rigorous comparison between SpotGraphs and SquidPy (via reticulate).

4. Results

• Benchmarking Performance:
  • Grid-based approach: SpotGraphs and SquidPy generated identical adjacency matrices.
  • Delaunay Triangulation: Results were comparable, with minor differences attributed to mathematical ambiguities (e.g., four spots lying on the same circumcircle allowing multiple optimal triangulations).
  • Nearest-Neighbor (NN): Significant discrepancies were found. The NN approach was deemed problematic, particularly at tissue boundaries, where it erroneously overestimates connections (identifying more neighbors than physically adjacent).
• Application Case Studies:
  • Debris Filtering: In Mouse Kidney data, graph clustering successfully identified and allowed the removal of low-quality spots on fragmented tissue sections that passed standard read-count QC.
  • Boundary Detection: Successfully identified tissue edges based on reduced node degree.
  • Path Distance: Demonstrated the ability to calculate distances along tissue contours, correcting for distortions where straight-line Euclidean distance fails.

5. Significance

• Enhanced Flexibility: SpotGraphs empowers R users to move beyond static spatial analyses, allowing for the manual adjustment of adjacency graphs, custom neighborhood definitions, and the identification of topological features (centers/boundaries).
• Methodological Guidance: The study provides critical evidence that Nearest-Neighbor approaches should be avoided for defining spatial adjacencies in ST data due to boundary artifacts. Instead, the authors recommend Euclidean distance (for grids) or Delaunay triangulation (for non-grids).
• Ecosystem Expansion: By bridging the gap between R's igraph capabilities and spatial transcriptomics, SpotGraphs facilitates complex, topology-aware analyses (e.g., shortest path analysis, centrality-based centering) that were previously difficult to implement in R.
• Future Outlook: While currently optimized for grid-based data (like 10X Visium), the package's reliance on Delaunay triangulation suggests applicability to non-grid platforms (e.g., Xenium, Slide-Seq), though further benchmarking is noted as a future direction.

Availability: The package, including installation instructions and vignettes, is available at https://github.com/Sanin-Lab/SpotGraphs.