Geometry-Aware CRDTs for Efficient Collaborative Geospatial Editing

Abstract

Maintaining consistency in real-time multi-user editing of planar geospatial features remains challenging for traditional collaborative editing techniques, which are primarily designed for text documents. When applied to spatial data, these methods often yield inaccurate results and cause information loss, while also overlooking the geospatial and topological properties of such features. Moreover, they fail to differentiate processing priorities due to limited spatial awareness, hindering targeted performance optimization. To address these limitations, we propose a geometry-aware collaborative editing algorithm based on Conflict-Free Replicated Data Types (CRDTs), integrating a spatial–semantic data model with spatio-temporal operation merging strategies. As an extension of CRDTs tailored for spatial data, it leverages geometric vector clocks (GVCs) and minimum bounding rectangles (MBRs) to capture temporal and spatial dependencies among editing operations, detects topological anomalies through geometric constraints, resolves conflicts via spatio-temporal metadata encoded in GVCs, and optimizes performance through MBR-based operation classification. Experimental results show that this approach improves editing accuracy, contributes to preserving topological integrity, and maintains strong performance under collaborative editing workloads, with notable efficiency gains for large-scale datasets and visible features. This work provides a novel geometry-aware framework for scalable, accurate multi-user editing of planar geospatial features that helps preserve topological integrity.

1. Introduction

Maintaining consistency in real-time multi-user editing of planar geospatial features has become increasingly important in applications ranging from urban planning to autonomous vehicle navigation. While traditional collaborative editing systems have been extensively studied for text and graphic documents, geospatial features introduces unique challenges due to the inherent geometric and topological relationships among spatial features. Existing approaches, such as Operational Transformation (OT) [1] and Conflict-Free Replicated Data Types (CRDTs) [2], primarily focus on maintaining consistency in linear or hierarchical data structures. However, these methods often fail to account for the spatial dependencies and geometric constraints that are critical in map editing scenarios.

The complexity of collaborative map editing stems from the necessity of jointly handling both temporal and spatial data during synchronization. For instance, when two users simultaneously move vertices of the same polygon, a temporal-only synchronization might incorrectly overwrite one displacement with another, resulting in lost edit intent, or misalign adjacent vertices, creating gaps or overlaps in the polygon boundary. Previous work in distributed collaborative editing systems, such as Ethermap [3] and Logoot-undo [4], has demonstrated the feasibility of real-time collaboration but lacks mechanisms for handling geometric anomalies. Similarly, spatial indexing techniques like R-trees [5] and Minimum Bounding Rectangles (MBRs) [6] have been used for efficient spatial queries, yet their integration with collaborative editing remains underexplored.

To address these limitations, we propose a geometry-aware collaborative editing algorithm built on CRDTs that explicitly models the spatial and temporal aspects of geospatial features. The algorithm introduces Geometric Vector Clocks (GVCs), an extension of traditional vector clocks [7], to track causality while incorporating geometric semantics. By combining GVCs with MBR-based spatial indexing, the algorithm establishes a unified mechanism to handle the spatio-temporal complexities of collaborative map editing. This integration of temporal and spatial components enables conflict resolution that respects both the temporal order of operations and their geometric implications. Another key contribution of our work lies in the novel integration of topological anomaly detection into collaborative map editing, a mechanism explicitly designed for preserving topological integrity [8] through geometric constraint checks and anomaly correction. During the collaborative editing process, this mechanism identifies and resolves topological anomalies such as self-intersections, addressing a gap in prior methods that overlook topological integrity in favor of temporal consistency alone.

Building on the above core designs, the proposed algorithm advances the state of the art in several ways. First, it provides a unified mechanism for handling both temporal and spatial conflicts in collaborative map editing through a tailored CRDT algorithm, a capability absent in prior work. Second, it embeds topological integrity preservation within the editing pipeline, preventing topology anomalies from propagating. Third, it optimizes performance via MBR-based operation classification, making it scalable to large maps with high concurrency. These contributions are validated through extensive experiments, which show significant improvements in both accuracy and performance compared to existing approaches.

The remainder of this paper is organized as follows: Section 2 reviews related work in collaborative editing and spatial data management. Section 3 formalizes the spatial semantics underlying our approach. Section 4 details the proposed algorithm, including conflict resolution. Section 5 presents the simulation experimental setup and results. Section 6 Real-World Case Study. Finally, Section 7 discusses findings, limitations and future work.

2. Related Work

In the field of collaborative editing, Operational Transformation (OT) [1] and Conflict-Free Replicated Data Types (CRDTs) [2] stand as core technologies for maintaining consistency in distributed environments. As a foundational technique for early collaborative systems, OT addresses the challenge of consistency maintenance in real-time group editors by transforming operations to resolve conflicts arising from concurrent edits. In contrast, CRDTs are designed to ensure eventual consistency through commutative, associative and idempotent operations [9], enabling decentralized collaboration without reliance on a central coordinator.

These design principles have made CRDTs a mainstream research focus due to their inherent advantages, including support for offline editing, elimination of complex central coordination, and guarantees of automatic conflict resolution in distributed systems. These strengths also form the technical foundation of our proposed geometry-aware algorithm, as they provide a robust framework for decentralized collaboration, which is more adaptable to large-scale and dynamic collaborative scenarios compared to traditional OT [10], albeit requiring extension to address spatial data’s geometric and topological constraints.

CRDTs have been widely applied in text editing. For instance, RGASS [11], a CRDT-based algorithm supporting string-based operations, reduces time complexity and outperforms traditional OT in computational efficiency. Logoot-undo [4] extends CRDTs with undo capabilities in peer-to-peer networks, enhancing the practicality of collaborative text editing. A state-based CRDT algorithm [12] with LWW registers and CRDT Map structure is used to handle concurrent text edits, enabling conflict-free merging of document states across peers while supporting rich text metadata management. In addition to the aforementioned CRDT-based methods, Replicated Growable Array (RGA) [13] and Yet Another Transformation Approach (YATA) [14] are also notable for their efficiency in handling sequence-based operations in text editing. Both methods, while lacking spatial awareness, remain highly efficient in large-scale concurrent edits, making them representative baselines for evaluating adaptation to spatial data.

Beyond text editing, CRDTs have been extended to various domains. For instance, CRDTs have been applied to enable real-time collaboration in peer-to-peer virtual reality environments, where a prototype leveraging CRDTs addresses ultra-low latency demands for virtual presence and explores decentralized coordination challenges in dynamic shared virtual spaces [15]. Additionally, collaborative techniques applied in CAD/CAE cloud services effectively address multi-user design needs [16]. Furthermore, CRDTs have been successfully utilized in opportunistic networks, as demonstrated in the study on delta-state-based synchronization of CRDTs, which highlights their efficiency in synchronizing replicas during transient node contacts [17]. This expansion of CRDT applications illustrates their versatility and effectiveness across different collaborative environments, paving the way for further innovations in distributed systems.

In map editing, CRDTs and related collaborative techniques have been explored. Early research on real-time map collaboration noted limitations in handling spatial dependencies while emphasizing its value in scenarios like disaster mapping [18]. Building on this, Ethermap [3], an open-source web application, enables real-time collaborative map editing with features like activity highlighting and change review. However, it still relies on a centralized server and lacks geometry-aware conflict resolution mechanisms. Another traditional approach, spatial operation dependence graphs, maintains synchronous consistency in collaborative mapping but limits concurrency due to locking mechanisms [19]. A lightweight version-based collaborative geospatial editing approach for urban planning focuses on data size reduction and unconstrained asynchronous editing, but does not explicitly integrate real-time geometric or topological consistency mechanisms [20]. While these approaches have advanced collaborative map editing, they still suffer from key challenges, including the lack of geometric awareness in conflict resolution, which in turn can cause violations of topological integrity [8], as well as inefficient synchronization performance.

Approaches from both graphical editing and geospatial collaboration have informed our approach to addressing topological integrity challenges. A CRDT-based algorithm for real-time collaborative graphical editing considers complex constraints between graphics and uses dynamic rule libraries to manage operations [21]. SVGDoc [22], a CRDT tailored for vector graphics, has shown how to handle concurrent edits while preserving update integrity during concurrent deletions, underscoring the value of context-aware operation processing for graphical data. Within the geospatial domain, the Tentative Operations proposed in [23] combine CRDTs with OpenLayers to incorporate geometry-aware mechanisms that effectively preserve topological integrity in collaborative map editing. However, as they are not integrated into the CRDT core, they require extra synchronization processes. Inspired by these efforts, especially the Tentative Operations, this paper introduces a geometry-aware data model and embeds topological integrity preservation into map editing, drawing on mechanisms from standalone GIS tools such as GRASS GIS [24] and QGIS [25] to enhance spatial integrity. Although the current implementation does not yet achieve complete topological integrity in all cases, it provides an integrated, algorithm-level framework that offers a solid foundation for future enhancements.

In addition to preserving geometric and topological integrity, performance optimization is another major challenge, encompassing computational efficiency, memory usage, and interactive responsiveness. Empirical studies on high-responsiveness CRDTs [26] show that, despite strong convergence guarantees, upstream latency and limited interface feedback speed can hinder user experience under high-frequency concurrent updates. RGASS [11] reduces the time complexity of CRDTs, improving efficiency in large-scale editing, but remains limited to text-based operations without considering spatial dependencies. Metadata management optimization in operation-based CRDTs reduces memory overhead by leveraging causal stability [27], yet mainly targets backend scalability rather than interactive responsiveness. Eg-walker [28] enhances CRDT performance in document loading and merging for peer-to-peer systems, but still focuses on text editing and adds implementation complexity. An optimization of Tentative Operations [29] batches remote operations during large-scale edits to reduce GUI redraws and improve rendering efficiency, though the added batching layer, which leaves the underlying CRDT algorithm unchanged, incurs extra overhead. While effective in certain application contexts, such as sequential data editing or moderate-size collaborative graphical projects, these approaches have limited impact in large-scale, high-concurrency collaborative map editing, where many users simultaneously edit different parts of an extensive spatial dataset and each viewport covers only a small fraction of the map. To address this, we introduce an operation-classification mechanism based on Minimum Bounding Rectangle (MBR) [5] and R-tree [6] indexing, which prioritizes edits within the current viewport and defers offscreen updates, thereby reducing unnecessary rendering and balancing geometric consistency with interactive responsiveness.

Summary and Research Gap. As summarized in Table 1, existing approaches to collaborative map editing have clear strengths as well as limitations in three core dimensions. In terms of spatial semantics, most CRDT-based or OT-based methods emphasize logical or textual consistency but do not explicitly model spatial semantics, which makes it difficult to process operations with geometric dependencies. Regarding topological integrity preservation, many solutions achieve it through external modules or post-processing steps instead of integrating it into the consistency maintenance framework. With respect to performance optimization, prior work often targets metadata reduction or message compression, while spatially aware prioritization, particularly the use of visibility and locality, has received little systematic investigation. This research addresses these gaps by developing a geometry-aware collaborative editing model that integrates spatial semantics, topological integrity preservation, and visibility-driven operation management within a unified CRDT algorithmic framework. The next section (Section 3) presents the conceptual design of this algorithm and establishes the theoretical basis for the mechanisms detailed in Section 4.

Table 1. Comparison of core technical paths for collaborative map editing.

Method Class	Spatial Semantics	Topological Integrity Preservation	Performance
Transform (OT [1])	None	None	Moderate—depends on causal delivery; limited scalability
Identifier-sequence CRDT (RGA [13], YATA [14])	None	None	High—efficient under high concurrency; no spatial optimization
Server/locking/ dependence-graph [19]	Weak—spatial deps via op graph	Moderate—consistency via dependency control	Low—serialization reduces concurrency
Version-based replication [20]	None—no spatial modeling	Weak—conflicts resolved after sync	Moderate—smaller data size; reduced real-time
Spatial heuristic (Tentative Operations [23,29])	Strong (external)—handled via range/projection	Very strong—precise for complex polygons	Moderate—efficient for small-scope edits; less responsive for large-extent edits
Geometry-aware CRDT (Proposed)	Strong (integrated)—semantics in CRDT logic	Strong—partial topology preservation under concurrency	Strong—viewport-driven; scalable sync and responsiveness

3. Conceptual Design for Geometric-Aware Collaborative Editing

The integration of geometric semantics into collaborative map editing systems built on CRDTs requires a fundamental understanding of how spatial relationships influence consistency maintenance. Unlike linear text documents where operations are strictly ordered, geospatial features exhibit complex interdependencies that arise from their geometric properties, especially coordinate positions and topological integrity. Traditional CRDT algorithms, which primarily focus on preserving intention and temporal order in text operations, must be extended to account for these spatial dimensions.

3.1. Spatial Entities and Operations

Spatial entities, also termed geometric primitives in geometric contexts, are abstract representations of geospatial features, conceptually defined by their core geometric and spatial-temporal properties. They provide a formal yet conceptual abstraction for representing and reasoning about spatial features in collaborative map editing. Each entity includes an associated extension field that captures spatial-temporal information, building upon established mechanisms such as logical clock [30] (linked to CRDTs’ causality tracking), geohash [31], and minimum bounding rectangle (MBR) [5]. A point entity represents a spatial feature defined by its 2D coordinates, while a line entity is defined by an ordered sequence of vertices. These entities form the foundational building blocks for operations in collaborative map editing.

Editing actions can be abstracted as transformations applied to these spatial entities. Each operation is designed to satisfy CRDTs’ requirement for commutative behavior, where changes are recorded with both spatial and temporal information to ensure consistency across distributed edits.

The implementation of spatial entities and atomic operations, which integrate spatial and temporal information, will be detailed in Section 4.1.

3.2. Operation Preservation and Topological Integrity

The precision of geometric editing systems directly impacts the reliability of spatial data, which can be analyzed through two core dimensions: completeness of operation preservation during translation and the topological integrity in graphics.

In terms of translation operations, ensuring that all atomic edits are accurately preserved is crucial for maintaining the accuracy of spatial entities’ final states. When multiple users perform concurrent translation operations on the same geometric primitive, it is essential that all concurrent translation parameters are faithfully preserved and integrated, including both spatial offsets and associated temporal information. For example, if user A translates a point entity by $(d{x}_1,d{y}_1)$ at time $t_1$ and user B further translates it by $(d{x}_2,d{y}_2)$ at time $t_2$, the combined result conceptually corresponds to the cumulative effect as $(d{x}_1+d{x}_2,d{y}_1+d{y}_2)$. This conceptual accumulation avoids information loss and ensures that the final state of the spatial entity accurately reflects the intent of all users.

Topological integrity focuses on the validity of topological relationships during collaborative editing, which is crucial for maintaining the correctness of graphic structures. In our approach, we integrate real-time topological checks directly within the editing process, allowing for dynamic detection of potential topological conflicts. Our current topological maintenance adopts a distance-based node reordering method, which can effectively preserve topological relationships in most cases. Although it has not yet resolved all issues, the results have verified the feasibility and effectiveness of this algorithm-level solution. In future work, we will continue to optimize and extend the method to enhance its applicability in more complex scenarios.

The specific algorithmic implementation of these concepts will be detailed in Section 4.4 and Section 4.5.

3.3. Visibility, Spatial Locality, and Performance

A critical geometric consideration in collaborative editing lies in the visibility of operations within the current viewport. Geospatial features exhibit strong spatial locality, meaning users typically work within adjacent or overlapping spatial regions. Activities outside the user’s viewport, especially those in distant areas, are likely irrelevant to the user’s immediate objectives. This characteristic enables targeted optimization: off-viewport operations may be deferred, while local consistency is preserved by CRDTs, thus reducing real-time processing overhead. Building upon the Minimum Bounding Rectangle (MBR) [5], spatial relevance is modeled through bounding relationships between entities and the viewport. To further optimize performance in handling deferred operations, an R-Tree [6] index is employed to efficiently manage deferred operations, ensuring that relevant edits are processed as the viewport changes.

The algorithm’s implementation of this optimization strategy will be detailed in Section 4.3.

4. Geometric-Aware Collaborative Editing Algorithm

Building upon the conceptual framework established in Section 3, The proposed algorithm, built on CRDTs, introduces a systematic approach to handling concurrent map editing operations through a framework comprising a geometry-aware data model, a topological integrity preservation mechanism, operation classification, and operation merging strategies.

4.1. Geometric-Aware Data Model

The geometry-aware data model unifies the representation of spatial entities, their intrinsic properties, and editing operations, with class relationships visualized in Figure 1. This model embeds spatial-temporal metadata to enable context-aware processing in collaborative map editing scenarios with topological integrity preservation. At its core, the GeoNode base class encapsulates shared properties across all spatial entities. These include a unique identifier id for global reference across collaborative sessions; a Geometric Vector Clock (GVC), denoted as $(V,H)$, which links logical time (V) with geospatial information (H) where V is a VClock that stores logical time for conflict resolution in the temporal dimension, and H is a Geohash utilized in spatial search and proximity detection tasks [32,33]; a dynamically updated Minimum Bounding Rectangle (MBR) to support efficient spatial relationship detection; and status flags (isDeleted and topoError).

Figure 1. UML Diagram of the Geometric-Aware Data Model.

Two specialized entity types are derived from GeoNode to handle distinct geometric characteristics: PointNode for representing discrete spatial features with $x,y$ coordinate attributes; and LineNode, which can model both linear features (e.g., roads) and polygon features (e.g., lakes) via the isPath field. The LineNode structure includes an ordered vertex set $\mathcal{V}=\{v_1,...,v_n\}$, where each vertex $v_i$ is formalized as $(x_i,y_i,i{d}_i,{\mathrm{origin}}_i)$, with $i{d}_i$ serving as a unique vertex identifier and ${\mathrm{origin}}_i$ recording the reference vertex ID at insertion time, specifically the ID of the node that the insertion is intended to follow.

Editing operations are structured to include a logical clock $V_o$, target entity identifier, and operation-specific geometric parameters. Key atomic operations supported by the model are: $\mathsf{Create}\left(g\right)$, which initializes new entities with their GVC and MBR; $\mathsf{Delete}\left(g\right)$, which marks the node as deleted by setting the isDeleted status flag; $\mathsf{Move}(g,\Delta ,\mathcal{S})$, which translates specified points or vertices $\mathcal{S}$ by displacement vector $\Delta$; and $\mathsf{Insert\; Vertex}(g,v,p)$, which adds a new vertex v after reference vertex p while updating the vertex set $\mathcal{V}$ and MBR accordingly.

This hierarchical model ensures consistent geometric semantics throughout the editing process, establishing a foundational framework for the topological integrity preservation and conflict resolution detailed in subsequent sections.

4.2. Conflict Resolution and Operation Processing Framework

In collaborative map editing scenarios, concurrent operations from multiple users can lead to conflicts, inconsistent states, and inefficient processing if not properly orchestrated. To address these challenges within CRDT-based algorithms, the core lies in a robust operation processing framework that incorporates conflict resolution, ensuring concurrent operations can be merged systematically without compromising consistency. To achieve this, an efficient and systematic operation processing framework integrating the geometry-aware data model is proposed. As illustrated in Figure 2, the processing pipeline follows four stages.

Figure 2. The operation processing framework of the proposed algorithm.

1.

Operation generation: When a user performs an edit, the client generates an atomic operation according to the user’s behavior.

2.

Operation propagation: Operations are broadcast to all collaborating clients through a decentralized network. Each client maintains an operation cache that stores incoming operations before processing. By decoupling propagation from immediate application, this stage ensures operations are uniformly disseminated while allowing clients to handle them asynchronously. This is critical for managing high-frequency edits in large-scale collaborative sessions.

3.

Visibility Classification: The framework classifies operations as visible or non-visible based on whether the MBR of their target primitive intersects with the current viewport. Visible operations (affecting actively viewed areas) are processed immediately to maintain real-time interactivity, while non-visible operations are deferred to a low-priority queue. This temporal prioritization balances user responsiveness with efficient resource allocation by leveraging strong spatial locality of the geospatial features.

4.

Operation application: Operations are classified and then applied to local primitives via integrated operation merging strategies. These strategies embed geometric constraint checks, and when violations are detected, they attempt topological anomaly correction. If an operation cannot be corrected automatically, it is marked for subsequent manual resolution. This integration ensures that the edited map remains semantically and topologically consistent.

4.3. MBR-Based Operation Visibility Classification

4.3.1. Baseline MBR Visibility Classification

To improve the spatial responsiveness and computational efficiency of real-time collaborative editing, we propose an MBR-based operation visibility classification mechanism. Within the CRDT synchronization framework, this component provides a unified geometric reference for spatial visibility filtering and deferred operation management.

The Minimum Bounding Rectangle (MBR) of a geometric primitive is defined as the smallest axis-aligned rectangle that fully encloses it, where $(x_1,y_1)$ and $(x_2,y_2)$ represent the bottom-left and top-right corners of the rectangle, respectively (Figure 3). For consistency across all primitives, each MBR is standardized according to the coordinate convention shown in Figure 1, and denoted as $(x_1,y_1,x_2,y_2)$.

Figure 3. MBR for a LineNode: the smallest axis-aligned rectangle enclosing all vertices.

The MBR computation varies with the type of primitive. For a PointNode $(x,y)$, the MBR degenerates to $(x_1=x_2=x,y_1=y_2=y)$. For a LineNode${\left\{(x^{\left(i\right)},y^{\left(i\right)})\right\}}_{i=1}^n$, the extreme vertex coordinates define the MBR:

$$\left\{\begin{array}{cc}{x}_1=min(x^{\left(1\right)},x^{\left(2\right)},\dots ,x^{\left(n\right)}),\hfill & x_2=max(x^{\left(1\right)},x^{\left(2\right)},\dots ,x^{\left(n\right)})\hfill \\ y_1=min(y^{\left(1\right)},y^{\left(2\right)},\dots ,y^{\left(n\right)}),\hfill & y_2=max(y^{\left(1\right)},y^{\left(2\right)},\dots ,y^{\left(n\right)})\hfill \end{array}\right.$$

(1)

Operations are classified according to whether the MBR of their target primitive intersects the current viewport (Figure 4). For example, operations on a visible primitive whose MBR overlaps the viewport (e.g., primitive2) are processed immediately, whereas operations on a non-visible primitive (e.g., primitive1) are deferred in a pending buffer, awaiting reactivation by idle-time scheduling. Formally, the visibility condition for a primitive g is:

$$\mathrm{MBR}\left(g\right)\cap \mathrm{Viewport}\ne \varnothing \iff \neg (x_2<v_{x1}\vee x_1>v_{x2}\vee y_2<v_{y1}\vee y_1>v_{y2}),$$

(2)

where $(v_{x1},v_{y1})$ and $(v_{x2},v_{y2})$ mark the viewport corners. This rectangular intersection test avoids full geometry comparisons, reducing computational overhead and improving interactive responsiveness.

Figure 4. Operation Visibility classification based on MBR intersection: (a) correct classification case, primitives 1 and 2; (b) special case where baseline logic fails, primitive 3.

4.3.2. Special Cases and Limitations of Baseline Visibility Logic

Although the MBR-based filtering mechanism improves efficiency, two special cases can lead to missed real-time processing when non-visible primitives become visible:

• Scenario 1 (operation-driven): An editing operation modifies a primitive’s coordinates, causing its MBR to move into the viewport (Figure 4b). Since the operation was initially classified as non-visible, it remains deferred even though the primitive is now visible.
• Scenario 2 (viewport-driven): When the viewport is panned or zoomed, some previously non-visible primitives enter the visible region. However, as their geometry is unchanged, no operation is triggered to reclassify them.

Both scenarios result in missed render updates, degrading user interactivity and temporal consistency.

4.3.3. R-Tree–Based Deferred Operation Management

To address these special cases, we introduce a unified R-tree–based visibility management mechanism. All deferred operations are maintained in an R-tree [5], enabling spatial updates to be captured through lightweight MBR recalculation according to Equation (1), without invoking full rendering or synchronization.

• For Scenario 1: When an operation updates a primitive’s coordinates, its new MBR is inserted into the R-tree. An immediate intersection check with the current viewport determines whether the deferred operation should be reclassified and executed instantly.
• For Scenario 2: When the viewport changes via panning or zooming, an event-driven R-tree range query retrieves primitives whose MBRs newly intersect the viewport, triggering execution of their deferred operations.

This dual-trigger design explicitly distinguishes between operation-driven and viewport-driven visibility changes, ensuring timely reactivation of relevant operations while avoiding redundant periodic scanning. As a result, the system achieves real-time spatial responsiveness, low computational overhead, and consistent visual coherence across concurrent editing sessions.

The overall workflow of this mechanism, integrating baseline classification and event-triggered activation, is summarized in Algorithm 1. The pseudocode outlines the sequential process of visibility evaluation, deferred operation management, and R-tree–based reactivation.

Algorithm 1: MBR-Based Operation Visibility Processing Mechanism

4.4. Geometric Constraints and Topological Integrity Preservation

Topological integrity preservation is achieved through real-time geometric constraint checking and topological anomaly correction during operation merging. The proposed algorithm employs two fundamental geometric constraints:

• Rule 1: Vertex Count Constraint
  This constraint applies to both line segments and polygons, defining the minimum vertex count required for a primitive to be geometrically valid. Specifically, a valid line segment must consist of at least 2 distinct vertices; a valid polygon must contain at least 3 vertices to enclose a non-empty area, distinguishing it from lines or points. Validation is implemented during operation merging for primitive creation or modification, where the algorithm verifies vertex count via a simple cardinality check ($\left|\mathrm{vertices}\right|\ge 2$ for lines, $\left|\mathrm{vertices}\right|\ge 3$ for polygons).
• Rule 2: Simple Polygon Constraint For polygon primitives, topological simplicity is enforced by ensuring edges intersect only at shared vertices. This constraint preserves the polygon’s ability to represent a single connected region with well-defined interior/exterior. Validation uses a sweep-line algorithm that checks all edge pairs for intersections, with a time complexity of $O(nlogn)$ for n edges. For vertex insertion operations, this checking is restricted to the modified edges and their adjacent neighbors to optimize performance.

Both constraints are formalized as geometric predicates that collectively define topological integrity:

$$\mathrm{valid}\left(g^{\prime }\right)=\underset{\mathrm{Rule}1}{\underbrace{\mathrm{vertexCount}\left(g^{\prime }\right)\ge k}}\wedge \underset{\mathrm{Rule}2(\mathrm{polygons}\mathrm{only})}{\underbrace{\underset{1\le i<j\le n}{\bigwedge }\neg \mathrm{intersects}(e_i,e_j)}}$$

(3)

where $k=2$ for lines and $k=3$ for polygons; $g^{\prime }$ denotes the modified primitive, with $e_i$ representing its edges; and $\mathrm{intersects}(e_i,e_j)$ evaluates edge crossings. This predicate is implemented via cross product calculations: for line segments $e_i=(p_1,p_2)$ and $e_j=(p_3,p_4)$, the intersection check uses sign changes in the cross products of vectors $\overrightarrow{p_1{p}_3}\times \overrightarrow{p_1{p}_2}$, $\overrightarrow{p_1{p}_4}\times \overrightarrow{p_1{p}_2}$, $\overrightarrow{p_3{p}_1}\times \overrightarrow{p_3{p}_4}$, and $\overrightarrow{p_3{p}_2}\times \overrightarrow{p_3{p}_4}$ to determine if segments cross.

4.5. Spatio-Temporal Operation Merging Strategies

In traditional CRDT algorithms, operation merging primarily focuses on temporal consistency for concurrent actions. In contrast, the proposed algorithm adopts spatio-temporal operation merging strategies that integrate both spatial geometric properties and temporal ordering, with rules varying by operation type:

1.

Create operations: Different Create operations are designed to generate distinct geometric primitives with unique identifiers, so there is no merging conflict in Create operations.

2.

Move operations: For concurrent Move operations targeting the same geometric primitive g (each denoted as $\mathsf{Move}(g,{\overrightarrow{d}}_k,\mathcal{S})$, where ${\overrightarrow{d}}_k$ is the displacement vector of the k-th operation and $\mathcal{S}$ is the fixed set of target vertices/points of g), the proposed algorithm computes the cumulative displacement of $\mathcal{S}$ through sequential merging of individual operations. In each merging step, the current cumulative displacement vector (denoted as ${\overrightarrow{d}}_{\mathrm{cum}}$) is updated by direct addition with the incoming ${\overrightarrow{d}}_k$. For clarity in 2D map, let ${\overrightarrow{d}}_{\mathrm{cum}}=(d{x}_{\mathrm{cum}},d{y}_{\mathrm{cum}})$ and ${\overrightarrow{d}}_k=(d{x}_k,d{y}_k)$ (where $dx,dy$ respectively represent displacement components along the longitude and latitude directions); the update follows:

$${\overrightarrow{d}}_{\mathrm{cum}}^{\mathrm{new}}={\overrightarrow{d}}_{\mathrm{cum}}^{\mathrm{old}}+{\overrightarrow{d}}_k=\left(d{x}_{\mathrm{cum}}^{\mathrm{old}}+d{x}_k,d{y}_{\mathrm{cum}}^{\mathrm{old}}+d{y}_k\right)$$

(4)

Ultimately, it converges to the sum of all individual displacement vectors from concurrent operations:

$${\overrightarrow{d}}_{\mathrm{res}}=\sum _{k=1}^n{\overrightarrow{d}}_k=\left(\sum _{k=1}^{n}d{x}_k,\sum _{k=1}^{n}d{y}_k\right)$$

(5)

This merging approach ensures the preservation of all users’ edit intent while maintaining the geometric consistency of g, aligning with the decentralized consistency guarantees required for collaborative editing scenarios.

3.

Insert Vertex operations: When merging an Insert Vertex operation, the proposed algorithm first restricts the traversal scope to nodes sharing the same reference vertex to locate the target insertion position, thereby avoiding unnecessary traversal of irrelevant nodes and optimizing efficiency. Throughout this merging process, the VClock (introduced in Section 4.1) of the inserting node is maintained in ascending order to ensure temporal consistency. As illustrated in Figure 5, vertices Vc and Va are both inserted with V2 as their reference vertex; At this stage, vertex Vb is also to be inserted targeting V2. Due to the VClock attribute relationship of these vertices—where vClock1 (of Vc) < vClock2 (of Vb) < vClock3 (of Va)—Vb is integrated into the existing vertex sequence between Vc and Va.

Figure 5. Merge Insert Vertex operation according to logical clock.

4.

Delete operations: The proposed algorithm maintains a tombstone record for deleted primitives instead of deleting them directly, ensuring that subsequent operations can be properly recorded to enable potential rollback functionality in the future.

Both Move and Insert Vertex operations share a topological integrity preservation workflow. As illustrated in Figure 2, after operation merging, geometric constraint checking is performed; if constraints are violated, the proposed algorithm attempts automatic correction by reordering vertices based on spatial proximity—computed using the geohash of GVC nodes—to eliminate edge crossings. If such spatial reordering fails to resolve the topological issues, the primitive is marked as having a topological anomaly.

The overall workflow of the operation merging strategy with topological integrity preservation is summarized in Algorithm 2. The pseudocode outlines the sequential steps for merging different types of operations while ensuring spatial consistency and handling topological anomalies.

However, the current distance-based vertex reordering method for topological integrity preservation has limitations in handling certain topological anomalies, as shown in Figure 6a. This known limitation will be addressed in future work, where we plan to explore an angle-based algorithm as a potential solution (shown in Figure 6b, where vertices are reordered by angle) to further enhance precision topological integrity.

Algorithm 2: Spatio-Temporal Operation Merging

Figure 6. (a) Limitations of Distance-Based Solution. (b) Potential Angle-Based Solution.

4.6. CRDT Correctness Discussion

The merging strategies collectively satisfy three critical algebraic properties required for CRDT correctness [9]:

1.

Commutativity: Operation processing order does not affect final states. For Move operations, vector addition is order-independent (${\overrightarrow{d}}_1+{\overrightarrow{d}}_2={\overrightarrow{d}}_2+{\overrightarrow{d}}_1$). For Insert Vertex operations, the predefined temporal total order ensures consistent results regardless of processing sequence. For Delete operations, their precedence over modifications guarantees the same deleted state whether they are processed before or after other operations. During topological integrity preservation, spatial reordering follows fixed proximity rules, ensuring consistent correction outcomes regardless of processing order.

2.

Associativity: Grouping of operations does not alter outcomes. For Move operations, this property is satisfied through transitive vector summation ($({\overrightarrow{d}}_1+{\overrightarrow{d}}_2)+{\overrightarrow{d}}_3={\overrightarrow{d}}_1+({\overrightarrow{d}}_2+{\overrightarrow{d}}_3)$), leveraging the mathematical associativity of vector addition. For Delete operations, the tombstone mechanism guarantees associativity: once a primitive is marked as deleted, additional deletions or grouped processing yield the same final state with no further modifications permitted. For Insert Vertex operations and topological integrity preservation, associativity is inherently preserved by the invariant total ordering framework based on GVCs, which in turn ensures grouping differences do not affect final outcomes.

3.

Idempotency: Repeated application of the same operation does not change the result beyond the first application. The proposed algorithm assigns all operations unique identifiers, which enables it to detect and filter duplicate operations during merging and thus ensures each operation is processed only once.

These properties ensure that regardless of network delays, processing order, or repeated operation propagation, all collaborating clients eventually converge to identical geometric states.

5. Simulation Experiments

5.1. Experimental Setup

To evaluate the effectiveness of our geometry-aware collaborative editing algorithm, we conducted comprehensive experiments comparing it against conventional CRDT approaches. The experiments were designed to assess three key aspects: (1) operation merging efficiency in translation scenarios, (2) topological integrity preservation capability during concurrent edits, and (3) overall system performance under increasing workloads.

Given the challenges of reliably reproducing large-scale, concurrent node editing scenarios with real-world collaborative map data, we adopted simulated datasets to allow controlled and repeatable experimental conditions. As a complement, a real-world case study is presented in Section 6 to assess practical applicability.

5.1.1. Baseline Methods

We compared our algorithm against two established CRDTs collaborative editing approaches: Yet Another Transformation Approach (YATA) [14] implemented using yjs, which represents the state-of-the-art for text-based collaborative editing, and Replicate Growable Array (RGA) [13] implemented using automerge, which provides strong eventual consistency guarantees.

Both baselines were adapted to handle spatial data by treating geometric coordinates as array elements, though they lack explicit geometric awareness. This comparison allows us to isolate the benefits of our geometry-aware approach from general collaborative editing mechanisms.

5.1.2. Hardware and Software Configuration

All experiments were conducted on a standardized test platform with the following specifications:

• Processor: AMD Ryzen 5 5600 (6 cores, 12 threads);
• Memory: 16 GB DDR4 @ 3200 MHz;
• Storage: 1 TB NVMe SSD;
• Software Stack: Node.js v22.18.0 [34], Amap v1.4 [35].

The test environment simulated a distributed collaborative scenario with multiple clients communicating through a centralized server. Network latency was artificially introduced following a normal distribution with $\mu$ = 50 ms and $\sigma$ = 10 ms to mimic real-world conditions.

5.1.3. Dataset and Test Scenarios

1.

Translation Merging Test

This scenario evaluates the algorithm’s ability to accurately merge concurrent translation operations without information loss:

• Participants: 10 simulated clients;
• Test Data: 100 randomly generated points uniformly distributed in a 10 km × 10 km area;
• Procedure: Randomly select 2 clients and 1 node to perform random translations $(x,y\in [-1\mathrm{km},1\mathrm{km}\left]\right)$;
• Iterations: 200 test cycles;
• Metrics: position deviation, operation latency.

2.

Topological Integrity Preservation Test This scenario assesses topological integrity preservation during concurrent vertex edits:

• Participants: 10 simulated clients;
• Test Data: Lake contour polygon with 10 vertices;
• Procedure: Randomly move vertices 3, 5, 7 with offset distance in $(0,20\mathrm{km}]$;
• Iterations: 100 test cycles;
• Metrics: Topological Anomaly Fix Rate, Topological Anomaly Mark Rate, Operation Latency.

3.

Performance Benchmark This scenario evaluates system performance and responsiveness under high-concurrency, spatially distributed editing tasks:

• Participants: 500 simulated clients.
• Test Data: Spatial dataset containing a fixed composition of entity types: point entities (30%), polyline vertices (30%), and polygon vertices (40%), across varying total node counts (2000–10,000). The higher proportion of polygon vertices was intentionally chosen to create a more demanding workload for scalability evaluation. The map covers an area of 20 km × 20 km, and each client’s viewport is a randomly assigned and spatially dispersed 1 km × 1 km region. This spatial distribution of viewports naturally activates our MBR-based operation visibility classification mechanism, as most operations only affect a subset of client viewports.
• Procedure: Randomly execute Move Point, Move Vertex, Insert Vertex (1000 × each) in 10 s.
• Metrics: Operation latency, memory usage, CPU utilization.

5.1.4. Evaluation Metrics

We employed quantitative metrics to assess algorithm performance across different experimental scenarios:

1.

Geometric Accuracy Metrics:

• Position Deviation (PD): Measures the spatial difference between actual and expected geographic positions of geometric primitives after operation merging. For latitude–longitude coordinates, this is calculated as the spherical distance between the actual and expected geographic points to account for Earth’s curved surface.

2.

Topological Metrics:

• Topological Anomaly Correction Rate (TACR): The percentage of detected topological anomalies that are successfully corrected.
• Topological Anomaly Mark Rate (TAMR): The percentage of topological anomalies that cannot be corrected and are marked as erroneous.

3.

Performance Metrics:

• Operation Latency (OL): The time interval from when an operation is generated by a client to when it is successfully applied by the system.
• Memory Usage (MU): The amount of heap memory allocated by the system during operation processing, particularly under varying workloads.
• CPU Utilization (CU): The percentage of processor capacity used during peak operation periods.

All metrics were collected at 1 s intervals during test execution and aggregated for analysis. Statistical significance was verified using two-tailed t-tests with $\alpha =0.05$.

5.2. Experimental Results

The experimental evaluation demonstrates significant improvements in both geometric accuracy and system performance compared to conventional collaborative editing approaches. The results are organized into three subsections corresponding to our test scenarios, followed by a comprehensive analysis of the findings.

5.2.1. Translation Merging Accuracy

When evaluating the algorithm’s ability to merge concurrent translation operations, our geometry-aware approach achieved high accuracy with a positional deviation of only 12 m. This stands in sharp contrast to baseline methods, as detailed in Table 2.

Table 2. Accuracy comparison for translation merging.

Algorithm	PD (m)	OL (ms/op)
YATA	472	95
RGA	537	120
Proposed	12	102

The proposed algorithm’s superior accuracy stems from its explicit geometric awareness and specialized merging strategy, which involves treating geometric primitives as integral spatial entities and aggregating displacement vectors via vector summation (Section 4.5) to ensure lossless merging of concurrent translations. While its latency (102 ms/op) is slightly higher than YATA’s (95 ms/op), this minimal overhead is justified by the significant reduction in positional deviations compared to baselines.

5.2.2. Topological Integrity Preservation Capability

The topological integrity preservation tests evaluated the algorithm’s ability to maintain valid topological relationships during concurrent geometric edits. As summarized in Table 3, the proposed method demonstrated distinct advantages in handling topological anomalies compared to baseline approaches.

Table 3. Topology error handling comparison.

Algorithm	TACR	TAMR	OL (ms/op)
YATA	0%	0%	106
RGA	0%	0%	125
Proposed	70.8%	29.2%	151

The proposed algorithm’s high TACR of 70.8% stems from its topological integrity preservation mechanism. It detects anomalies according to the geometric constraints (Section 4.4), then applies spatial proximity principles to achieve automatic topology correction for common issues. The TACR value demonstrates the framework-level effectiveness of embedding integrity preservation directly into the CRDT merge process, while its moderate TAMR of 29.2% highlights current limitations in automatically resolving certain categories of topological anomalies, which are instead marked for manual review and left for future extension. The proposed algorithm’s slightly higher OL is a necessary tradeoff for real-time topological integrity preservation, critical for maintaining data usability in map-based collaborative systems.

5.2.3. Scalability and Performance

The performance benchmarks under increasing workloads revealed several noteworthy characteristics of the proposed algorithm. Figure 7 illustrates the trends in operation latency and resource utilization as the number of nodes scales from 2000 to 10,000.

Figure 7. Latency and resource consumption trends across varying node scales (error bars: ±1 STD).

In latency performance, our MBR-based visibility classification (Section 4.3) reduced visible node latency by roughly 45% compared to YATA and 38% compared to RGA, achieved through prioritizing visible operations and deferring non-visible ones. As a tradeoff, non-visible operations incurred a 16% latency increase relative to YATA and 12% relative to RGA, which is an acceptable result of the low-priority processing strategy.

For memory usage, our algorithm exhibited the highest consumption across scales due to additional geometric metadata maintenance: approximately 10–20% higher than RGA and 15–25% higher than YATA. Notably, memory growth remained linear alongside node counts for all three methods, indicating consistent scalability in terms of memory usage.

In terms of CPU utilization, our hierarchical operation processing alleviated peak pressure significantly, maintaining 14–21% utilization across scales. This represented a 60–75% reduction compared to YATA and a 60–70% reduction compared to RGA.

6. Real-World Case Study

To further verify the applicability and robustness of the proposed CRDT-based, geometry-aware collaborative framework in practical scenarios, we conducted a real-world case study on multi-user map editing. The evaluation focused on the framework’s responsiveness, its capacity to manage processing load through deferred conflict resolution, and its ability to preserve topological integrity under realistic collaborative conditions.

6.1. Scenario and Setup

The case study was conducted on the Amap [35] platform, into which the proposed algorithm was integrated, using real geospatial data for an urban area of approximately 400 km² (centered at [118.88, 31.867]).

Fifteen participants were invited to collaboratively annotate and modify map features, including roads, building boundaries, and natural regions. They were divided into five groups of three participants, with each group assigned a distinct, non-overlapping region (Regions 1–5), as shown in Figure 8. Within their assigned regions, each group jointly marked three point features, two polygons, and two line segments (an example result from Group 2 is shown in Figure 9a). This spatial partitioning was designed to emulate real-world collaborative workflows—such as city infrastructure maintenance or disaster mapping—where multiple teams operate simultaneously in separate geographic areas.

Figure 8. Real-world collaborative editing scenario: Fifteen participants (five groups) edited five distinct non-overlapping regions concurrently on the Amap platform.

Figure 9. Group 2’s edits in the third trial: (a) final region view, including two polygons, two line segments, and three point features; (b) enlarged view of Polygon 2 showing two residual topological errors.

In addition to the previously defined performance metrics, Operation Latency (OL) and Topological Anomaly Correction Rate (TACR), we also measured the Delayed Operation Ratio (DOR), defined as the number of operations requiring deferred conflict resolution divided by the total number of received remote operations. This metric reflects the effectiveness of the MBR-based operation classification in filtering out non-overlapping edits before merge processing. The experiment was repeated five times to ensure statistical reliability.

6.2. Results and Analysis

As summarized in Table 4, the proposed framework achieved three notable outcomes during the real-world trials.

Table 4. Performance of the proposed framework during real-world collaborative editing sessions.

Metric	Mean	Std. Dev.
OL (ms/op)	108	14
TACR	68.6%	11.1%
DOR	81.2%	11.9%

First, the average operation latency remained below 110 ms, indicating consistently high responsiveness in collaborative editing sessions. Second, the MBR-based operation classification deferred 81.2% of incoming remote operations from immediate merge processing, as these edits lay outside the spatial bounding rectangles of the active region. By postponing conflict resolution for spatially non-overlapping edits, this mechanism helped smooth processing load over time and avoid short-term performance spikes. Although the modest scale of the real-world trials prevented us from presenting statistically validated results as in Section 5.2.3, the observation that 81.2% of operations were deferred supports the inference that the mechanism contributed substantially to load smoothing and spike avoidance. Third, the Topological Anomaly Correction Rate (TACR) reached 68.6%, showing that the current topological integrity preservation algorithm successfully resolved most detected anomalies. However, as illustrated in Figure 9b, complex polygon geometries still produced residual self-intersections that the algorithm could not fully correct.

Overall, these findings confirm that the proposed framework is both theoretically sound and practically effective for distributed, spatially partitioned map editing. Even with a modest participant group, the deferred conflict resolution provided by MBR-based classification helped maintain smooth responsiveness while reducing processing overhead. At the same time, the persistence of geometric anomalies highlights the need to enhance the topology-preservation algorithm to handle complex, fine-scale geometries more reliably.

7. Discussion and Future Work

7.1. Findings

This study proposes a geometry-aware collaborative editing algorithm based on CRDTs, designed for real-time editing of planar geospatial features, aiming to address the shortcomings of traditional collaborative editing techniques in handling spatial data. The algorithm integrates a geometry-aware data model with spatio-temporal operation merging, utilizing Geometric Vector Clocks (GVCs) to track both temporal causality and spatial dependencies of editing operations, Minimum Bounding Rectangles (MBRs) for efficient spatial indexing and operation classification, geometric constraints to detect topological anomalies, and geohash-based vertex reordering to resolve topological anomalies. Experimental results demonstrate the algorithm’s superiority in three key aspects. Geometric accuracy is achieved through a vector summation strategy for displacement vectors, resulting in negligible position deviation in concurrent translation operations and making a significant improvement over traditional CRDT algorithms. Regarding topological integrity, the algorithm embeds real-time validation via geometric constraints, handling common anomalies effectively while marking complex ones for review, a capability that traditional algorithms do not possess. Practically, MBR-based visibility classification improves processing efficiency by lowering visible-node latency and sustaining low CPU utilization in large-scale, high-concurrency collaborative editing of planar geospatial features.

7.2. Limitations

Despite its advantages, the proposed algorithm has several notable limitations. First, while the MBR-based visibility classification improves visible node performance, non-visible operations incur an increase relative to traditional algorithms, which may affect user experience in scenarios with frequent viewport switches requiring rapid synchronization of off-viewport edits. Second, the geometry-aware data model, which maintains additional metadata such as GVC, MBR, resulting in higher memory usage than traditional algorithms, potentially restricting its application in resource-constrained devices like low-power edge devices used for field editing of planar geospatial features. Third, the automatic topological anomaly correction mechanism, which relies on spatial proximity reordering of vertices, is effective for simple anomalies but struggles with complex cases such as multi-edge intersections, leading to a non-negligible 29.2% topological anomaly mark rate that requires manual intervention, increasing user burden in high-complexity editing scenarios. Finally, the current design is limited to planar geospatial features and does not yet support 3D geometric primitives, which constrains its applicability to fully three-dimensional geospatial collaboration scenarios.

7.3. Future Work

To address these limitations and extend the algorithm’s applicability, future work will focus on several key directions. First, optimize non-visible operation handling by developing adaptive scheduling strategies, such as predictive preprocessing based on user behavior patterns to reduce latency [36,37]. Second, reduce memory overhead through lightweight geometric metadata management, explore compact encoding schemes for the GVC and MBR and leverage hardware acceleration to mitigate computational costs associated with metadata maintenance. Third, enhance topological anomaly correction capabilities by incorporating advanced computational geometry techniques and machine learning models trained on topological anomaly correction cases to improve automatic resolution of complex anomalies, thereby reducing the topological anomaly mark rate and minimizing manual intervention [23,38,39]. Fourth, extend the algorithm to support 3D scenarios by generalizing Minimum Bounding Rectangles (MBRs) into 3D bounding boxes for indexing 3D primitives, acknowledging the significantly higher geometric and topological complexity, which will be addressed in future work. Finally, conduct large-scale field tests in practical applications to evaluate the algorithm’s performance in real-world network conditions and user collaboration patterns, refining the design based on empirical feedback to strengthen its robustness, efficiency, and generality.

8. Patents

A patent covering the core methodology of geometry-aware collaborative editing for planar geospatial features, which is basically consistent with this paper’s research, has been filed. Details are as follows:

• Title: A Geometry-Aware Collaborative Editing Method for Planar Geospatial Features
• Status: Accepted (pending examination)
• Application No.: 202511047561.1
• Filing Date: 29 July 2025
• Inventors: Pengcheng Zhang, Chao Zhang
• Assignee: Nanjing University of Industry Technology