Geometry-Constrained Robust Watermarking for OpenDRIVE High-Definition Maps Exploiting a Similarity-Invariant Curvature–Length Feature

Abstract

Existing watermarking methods for copyright protection of OpenDRIVE high-definition maps have difficulty balancing robustness and geometric accuracy. This study proposes a geometry-constrained robust watermarking algorithm that exploits the parametric representation of OpenDRIVE. From a symmetry perspective, the signed curvature–length feature used by the geometric carriers is invariant under translation, rotation, and ideal positive uniform scaling. This transformation invariance contributes to stable watermark extraction when the map’s global position, orientation, or scale is changed. A multidimensional carrier pool comprising geometric shapes and road attributes is constructed, and absolute quantization index modulation enables orthogonally decoupled embedding across carrier types. Levenberg–Marquardt optimization and topology-aware chain correction are further used to preserve geometric continuity and topological consistency. Experiments show that the algorithm maintains visual imperceptibility and file-size stability while remaining robust to geometric transformations, cropping, and format sanitization. Scenario simulations conducted in esmini revealed no evident degradation of road smoothness in the test scenarios defined in this study, indicating that the algorithm satisfied the map usability criteria under the experimental conditions.

1. Introduction

With the development of intelligent connected vehicles and autonomous driving technologies, high-definition (HD) maps have become an important digital infrastructure for autonomous driving systems. Compared with conventional navigation maps, HD maps provide not only high-precision road geometry but also semantic information such as lane structures, road attributes, traffic facilities, and topological relationships, thereby supporting environmental perception, path planning, decision-making, and control [1,2,3]. ASAM OpenDRIVE, maintained by the Association for Standardization of Automation and Measuring Systems (ASAM), is an Extensible Markup Language (XML)-based open standard for describing static road networks, including road reference lines, lane structures, road attributes, and traffic facilities, and it is widely used in autonomous-driving simulation tests, HD map data exchange, and cross-platform applications [4]. The production of HD maps involves complex processes, including surveying and data acquisition, data modeling, semantic annotation, and quality inspection; consequently, HD maps are costly to produce and have considerable application value [3]. Copyright protection during map distribution has attracted increasing attention.

In practical applications, OpenDRIVE uses readable XML syntax and, without additional encryption, can be directly read, modified, and resaved using general-purpose text editors or XML parsers. Consequently, data in circulation are exposed to risks, including unauthorized copying, redistribution, dissemination of tampered versions, and difficulty in tracing ownership. Conventional encryption can protect data confidentiality during transmission and storage; however, once authorized users decrypt and use the data, it provides limited support for persistent copyright identification and ex post traceability [5]. By contrast, digital watermarking embeds ownership identifiers within the data and subsequently extracts or verifies them, thereby supporting copyright authentication and ownership identification for HD maps [5,6,7,8].

From a data-representation perspective, OpenDRIVE combines the characteristics of geospatial data and structured text. Its road reference lines, lane structures, road attributes, and traffic facilities are jointly described by parametric geometries, semantic attributes, and topological relationships; at the data-organization level, it therefore exhibits the fundamental characteristics of vector geographic data. At the file-representation level, however, OpenDRIVE encodes and stores these objects and attributes using XML syntax and therefore also exhibits the characteristics of structured text. On the basis of this dual nature, studies on copyright protection for OpenDRIVE HD maps can be reviewed along two principal technical routes: (1) vector geographic data watermarking and (2) text watermarking and character-level information hiding.

For vector geographic data watermarking, extensive research has addressed imperceptibility, robustness, and copyright authentication [5,6,7,8]. In terms of the embedding domain, conventional embedding-based watermarking methods for vector geographic data can be divided into transform-domain and spatial-domain methods. Fourier-descriptor-based methods, hybrid methods combining the discrete Fourier transform (DFT) and singular value decomposition (SVD), and methods combining the discrete wavelet transform (DWT) and complex singular value decomposition (CSVD) have been applied to vector-data watermarking [9,10,11]. However, most transform-domain methods target explicit coordinate sequences, whereas OpenDRIVE road geometries are continuously represented by parametric elements such as lines, arcs, spirals, and polynomial curves. Directly transferring such methods makes it difficult to constrain the effects of embedding perturbations on parametric curves and may compromise road smoothness, geometric continuity, and topological consistency.

In the spatial and feature domains, researchers have used coordinate differences, normalized or virtual coordinate representations, and geometric or topological relations. Representative approaches include reversible difference expansion [12], spatial-topological embedding [13], normalized-coordinate features [14], virtual-coordinate reversible embedding [15], self-error-correction-based reversible watermarking [16], invariant-feature zero-watermarking [17], and coordinate-mapping/domain-subdivision schemes [18]. Li et al. [19] embedded watermarks in normalized vertex coordinates within a commutative encryption and watermarking framework for vector maps. Wu et al. [20] proposed robust reversible watermarking using a geometric length ratio derived from virtual triangles and improved quantization index modulation. Although these approaches provide useful mechanisms for reversibility, robustness, or distortion control, most are intended for line and polygon features composed of discrete coordinates in conventional geographic information systems (GISs). They are therefore difficult to apply directly to OpenDRIVE data, which is jointly described by multiple types of parametric geometry, lane structures, and road attributes. Moreover, maps containing long straight roads, simple networks, or few usable geometric features may provide an insufficient number of carriers.

Regarding text watermarking and character-level information hiding, Por et al. [21] proposed UniSpaCh, which hides information using Unicode space characters in text documents. Li et al. [22] proposed an orthogonal-code-based watermarking method for large-scale plain text. Zhang et al. [23] designed an invisible-character-based text watermarking approach that exploits Unicode encoding characteristics for steganographic information hiding. More recently, Lyu et al. [24] proposed an invisible-character-based digital watermarking algorithm for OpenDRIVE HD maps using invisible Unicode characters as carriers. For OpenDRIVE, character-based embedding can leave numerical road-geometry parameters unchanged and, when XML-compatible characters and insertion positions are used, preserve coordinate accuracy and file parseability, as demonstrated in [24]. Nevertheless, because such watermark information depends on the underlying textual representation, it may be removed or lost when OpenDRIVE data undergo format sanitization or conversion, making persistent copyright verification in complex distribution environments difficult.

In summary, existing methods still have difficulty simultaneously accommodating the parametric representation of OpenDRIVE, providing sufficient carrier capacity, preserving geometric usability, and remaining robust to format processing. Robust watermarking for OpenDRIVE HD maps must therefore address two key issues: constructing stable carriers with adequate capacity within parametric road structures and enabling reliable blind extraction after geometric transformations, local cropping, and format processing while preserving geometric continuity, topological consistency, and file parseability.

To address these issues, this study proposes a geometry-constrained robust watermarking algorithm for OpenDRIVE HD maps. The algorithm constructs a carrier pool from OpenDRIVE parametric geometries and road attributes. It applies absolute quantization index modulation (QIM) independently to each carrier type, using type-specific quantization steps and constraints. Local geometric compensation and topology-aware chain correction control the errors introduced by modifying geometric parameters. Keyed hash-based dispersion mapping, error-correcting codes, and weighted voting then improve watermark recovery after geometric transformations, local cropping, and format processing without requiring the original map.

In this study, symmetry is understood as invariance under geometric transformations rather than mirror symmetry of the road layout. Under orientation-preserving planar similarity transformations, translation and rotation leave element length and signed curvature unchanged, whereas positive uniform scaling changes length in proportion to the scale factor and signed curvature inversely; consequently, the signed curvature–length feature remains invariant. This property motivates its use as a geometric watermark carrier for robust extraction after changes in global position, orientation, or scale, while the attribute carriers provide complementary capacity and redundancy.

2. Materials and Methods

2.1. Algorithmic Rationale

The proposed algorithm is designed to construct stable watermark carriers with adequate capacity within the parametric road structure of OpenDRIVE, constrain the influence of watermark embedding on the continuous-curve representation of roads through geometric constraints, and improve watermark recoverability after geometric transformations, local cropping, and format processing. OpenDRIVE describes road reference lines using parametric geometries and represents lane widths, lane offsets, and road markings using scalar attributes or polynomial parameters. On the basis of this structure, geometric and attribute carriers are selected from existing parametric geometries and road attributes, respectively. The stability of geometric carriers under geometric transformations complements the broad availability of attribute carriers: the former strengthens robustness, whereas the latter expands carrier capacity and redundant coverage. Because changing the curvature or length of a geometry element affects its end position, end heading, and subsequent s-coordinate relationships, local geometric compensation and topology-aware chain correction are also performed after geometric-carrier modulation to constrain local geometric errors and preserve downstream associations.

The basic concept of the proposed algorithm is illustrated in Figure 1. During embedding, the two carrier types are first scanned according to deterministic rules, and a key-driven hash mapping disperses the carriers across the watermark bits. According to the numerical scale and constraints of each carrier type, QIM then modifies the corresponding feature values independently, thereby realizing orthogonally decoupled embedding across carrier types. Attribute carriers are written back directly after checks of their physical ranges and maximum allowable changes. Geometric carriers additionally undergo local geometric compensation and topology-aware chain correction to control changes in the current geometry element’s end position and end heading, as well as subsequent s-coordinate relationships. All selected carriers are existing numerical fields in OpenDRIVE; the algorithm does not rely on invisible characters, tag order, or nonstandard XML structures. This design reduces the risk that watermark information will be directly lost during character-level sanitization or XML restructuring.

Extraction does not require the original map. Instead, the carrier set and carrier-to-bit mapping are reconstructed using the same rules as during embedding, and QIM demodulation yields the decision bit and extraction confidence for each carrier. Because a single watermark bit can be redundantly carried by multiple carriers distributed across different roads and structural levels, the remaining carriers can still be used for weighted voting when some carriers are lost or altered by local cropping or format processing; error-correction decoding then recovers the watermark. Thus, the multidimensional carrier pool addresses carrier stability and capacity; local geometric compensation and topology-aware chain correction control the geometric effects of embedding; and hash mapping, redundant embedding, weighted voting, and error-correction decoding improve watermark recovery under complex processing conditions.

2.2. OpenDRIVE Watermark Carriers

Stable carriers are fundamental to robust watermarking of OpenDRIVE HD maps. Relying exclusively on curved geometry elements such as arcs and spirals may result in insufficient carriers in maps dominated by long straight roads, simple networks, or few curved geometries. Conversely, relying only on road attributes does not fully exploit the stability of reference-line geometry under coordinate transformations. Therefore, geometric-shape and road-attribute carriers are jointly selected because their complementary properties balance robustness to geometric transformations, carrier capacity, and geometric impact.

Geometric-shape carriers are derived from arc and spiral geometry elements of OpenDRIVE road reference lines. For an arc, curvature is constant within the geometry element, and the product of curvature and element length equals the signed heading change over that element. For a spiral, curvature varies continuously along the arc length, and the end curvature characterizes the terminal state of the curvature variation. Accordingly, the product of constant curvature and length is used for arcs, whereas the product of end curvature and length is used for spirals. These geometric-carrier features are uniformly expressed as follows:

$$\lambda ={\kappa }_{g}L$$

(1)

In Equation (1), $L$ denotes the geometry-element length, and ${\kappa }_g$ denotes the curvature parameter used to construct the carrier feature. For an arc geometry element, ${\kappa }_g=\kappa$, where $\kappa$ is the constant arc curvature; for a spiral geometry element, ${\kappa }_g={\kappa }_e$, where ${\kappa }_e$ is the spiral end curvature. The subscript g labels this unified parameter, rather than a separate curvature measure.

This feature is independent of the absolute position and orientation of the geometry element; map translation and rotation therefore do not change its value. Under ideal positive uniform scaling, the geometry-element length changes in direct proportion to the scale factor, whereas signed curvature changes inversely, leaving their product unchanged. Accordingly, the signed curvature–length feature is invariant under orientation-preserving planar similarity transformations and provides the transformation-symmetry mechanism exploited by the geometric carriers. Under reflection, signed curvature reverses sign; reflection invariance is therefore not claimed. A line has zero curvature and therefore offers no effective curvature–length modulation space. The shape of a polynomial curve is jointly determined by several coupled coefficients, making it difficult to incorporate into a unified curvature–length modulation and compensation framework. Consequently, arcs and spirals are selected as geometric shape carriers.

Road-attribute carriers include lane width, road-marking width, and lane offset. In OpenDRIVE, lane width and lane offset are generally described by cubic polynomials of the following form:

$$f(\xi )=a+b\xi +c{\xi }^2+d{\xi }^3$$

(2)

In Equation (2), $\xi$ denotes the local distance along the reference line, and $a$, $b$, $c$, and $d$ are polynomial coefficients. The constant term $a$ represents the baseline value at the start of the corresponding attribute record and has a clear semantic interpretation within the road model. Compared with the higher-order coefficients that control how the attribute varies along the road, slightly modulating $a$ does not introduce a higher-order perturbation that grows with local distance and does not alter the variation trend determined by $b$, $c$, and $d$. Therefore, the constant term $a$ is selected for modulating lane width and lane offset.

Road-marking width is generally stored as an independent scalar attribute representing the physical width of the traffic marking. Only road-marking elements with a width attribute explicitly present in the original XML file are selected, thereby avoiding the additional structural differences that would result from inserting new attributes. These attribute values are independent of global coordinate position and remain stable under coordinate transformations such as translation and rotation. Moreover, lane widths, road-marking widths, and lane offsets are broadly distributed in OpenDRIVE files and can provide additional capacity when geometric carriers are insufficient. Nevertheless, modulating attribute carriers can still change lane widths or relative offsets; each modulated value must therefore remain within its prescribed physical range, and the magnitude of the change must not exceed the allowable limit.

The characteristics and roles of the different carriers are summarized in

Table 1. Types and characteristics of OpenDRIVE watermark carriers.

Carrier Type	Object	Feature Value	Source of Stability	Primary Role
Geometric carrier	Arc element	$\kappa L$	Invariant under orientation-preserving planar similarity transformations	Improve robustness to geometric transformations
Geometric carrier	Spiral element	${\kappa }_{e}L$	Invariant under orientation-preserving planar similarity transformations	Improve robustness to geometric transformations
Attribute carrier	Lane width	Constant term $a$	Scalar attribute unaffected by translation or rotation	Expand carrier capacity
Attribute carrier	Road-marking width	Explicit $width$ attribute in the original file	Scalar attribute unaffected by translation or rotation	Expand carrier capacity
Attribute carrier	Lane offset	Constant term $a$	Scalar attribute unaffected by translation or rotation	Increase redundant coverage

. Geometric carriers primarily enhance robustness to geometric transformations, whereas attribute carriers primarily expand watermark capacity and increase redundant coverage.

All carriers selected in this study are existing numerical parameters or attribute fields in OpenDRIVE files and do not rely on invisible characters, tag order, or nonstandard XML structures. For road-marking width, only elements whose width attribute is explicitly present in the original file are selected, thereby avoiding structural differences caused by adding attributes. This design helps preserve XML validity and parseability and reduces the risk that watermark information will be lost during format sanitization or reserialization because of changes in textual representation. The specific screening criteria, quantization steps, and voting weights for each carrier type are presented in Section 2.5.

2.3. Geometric Continuity and Road Smoothness Constraints

An OpenDRIVE road reference line consists of an ordered sequence of continuous geometry elements. Modulating attribute carriers, such as lane width, road-marking width, and lane offset, does not modify the reference-line definition. Physical-range and maximum-change constraints primarily control these attribute changes. By contrast, arcs and spirals are part of the reference-line geometry definition, and changes in curvature or length can affect the current element’s end position and end heading, as well as the s-coordinate relationships of subsequent elements. A geometric carrier cannot therefore be written back as an isolated numerical value; both local geometric and topology-aware chain constraints must be imposed.

Road smoothness depends primarily on the continuity of the reference line within each geometry element and on smooth changes in position, heading, and curvature at junctions between adjacent elements. Taking the watermark-modulated curvature–length feature as the optimization target, local geometric compensation jointly adjusts the relevant geometric parameters to control the element’s end-position error, end-heading error, and curvature variation. This reduces the risk of spatial gaps, abrupt directional changes, and curvature discontinuities at adjacent-element junctions. The basic constraint objective is expressed as follows:

$$\min E=\alpha {‖p_e^{\prime }-p_e^0‖}^2+\beta {\left|{\theta }_e^{\prime }-{\theta }_e^0\right|}^2$$

(3)

In Equation (3), $p_e^0$ and $p_e^{\prime }$ denote the end positions of the geometry element before and after modification, respectively; ${\theta }_e^0$ and ${\theta }_e^{\prime }$ denote the corresponding end headings; and $\alpha$ and $\beta$ are weighting coefficients. The objective is not to leave the geometric parameters unchanged but to keep the end-position and end-heading errors within acceptable ranges while satisfying the watermark modulation and decision requirements. If a curvature-continuity check is enabled, it is applied after optimization as an additional acceptance condition for the candidate solution.

For a spiral geometry element, the end state depends jointly on the start curvature, end curvature, and element length. Nonlinear optimization is therefore used for geometric compensation. For an arc geometry element, curvature remains constant over the entire element; the curvature is held fixed, and the element length is adjusted to modulate the curvature–length feature. The optimization variables, parameter-optimization procedure, error validation, and revalidation of the QIM decision are detailed in Section 2.7.

When the length of a geometry element changes, the longitudinal positions of subsequent geometry elements, lane-related records, road objects, and traffic facilities located using the road-reference-line coordinate $s$ must be updated consistently. If the start s-coordinate of geometry element $i$ is held fixed, the start s-coordinates of element $i$ and each subsequent element $j$ are expressed as follows:

$$s_i^{\prime }=s_i,s_j^{\prime }=s_i+{\displaystyle \sum _{k=i}^{j-1}{L}_k^{\prime }},j>i$$

(4)

In Equation (4), $s_i$ is the original start s-coordinate of geometry element $i$, $s_j^{\prime }$ is the corrected start s-coordinate of element $j$, and $L_k^{\prime }$ is the updated length of element $k$. Associated lane-width, lane-offset, and road-marking records, road objects, and traffic facilities located along the road reference line using the coordinate $s$ must likewise be updated consistently with cumulative length changes in the preceding geometry elements.

Local geometric compensation controls the shape error of the current geometry element, whereas topology-aware chain correction preserves consistency between subsequent geometry elements and associated objects within the reference-line parameterization. Together, they transform geometric carrier embedding from an isolated parameter replacement into a controlled modification performed under constraints on the continuous road-curve representation. These geometric constraints reduce the risk of compromising road smoothness at the model level. Overall map usability must still be validated using curvature discontinuity metrics and scenario simulation experiments.

2.4. Overall Algorithm Workflow

Building on the parametric representation of OpenDRIVE, the multidimensional carrier pool, and the geometric constraints described above, this section presents the implementation of the robust watermarking algorithm. The algorithm comprises watermark embedding and extraction. Embedding takes an original OpenDRIVE HD map file, the copyright information to be embedded, and a key as inputs and outputs a watermarked OpenDRIVE file. Extraction takes the OpenDRIVE file to be tested and the same key as inputs and recovers the copyright information without the original map.

During watermark embedding, deterministic carrier scanning, watermark frame construction, error-correction encoding, key-driven carrier-to-bit mapping, orthogonally decoupled QIM modulation, and parameter write-back are performed in sequence. Each carrier type is independently modulated using its own quantization step and constraints. Attribute carriers are written back after checks of physical ranges and maximum allowable changes. Geometric carriers additionally undergo local geometric compensation, final revalidation of the QIM decision, and topology-aware chain correction. If the effective bit coverage or overall embedding success rate does not meet the requirements, all written modifications are rolled back.

During extraction, the carrier set and carrier-to-bit mapping are reconstructed using the same rules. QIM demodulation is applied to the current feature value of each carrier, and the copyright information is recovered by combining carrier-type weights, extraction confidence, weighted voting, and Bose–Chaudhuri–Hocquenghem (BCH) decoding. Carrier scanning and bitstream construction, QIM embedding, geometric constraint processing, and blind extraction are described in Section 2.5, Section 2.6, Section 2.7 and Section 2.8, respectively.

2.5. Watermark Carrier Scanning and Bitstream Construction

To ensure that consistent carrier sets can be obtained during embedding and extraction without sharing the original map, a deterministic carrier-scanning rule is used. Let $R=r_1,r_2,\cdots ,r_m$ denote the road set obtained after parsing the OpenDRIVE file. For each road, the algorithm traverses the reference-line geometry elements, lane sections, lane-width records, road-marking records, and lane-offset records in sequence and encapsulates each numerical object satisfying the screening criteria as a watermark carrier. Each carrier is represented as follows:

$$c_i=i{d}_i,t_i,v_i,{\Delta }_i,w_i,{\mathsf{\Omega }}_i$$

(5)

In Equation (5), $i{d}_i$ is the unique carrier identifier, $t_i$ is the carrier type, $v_i$ is the feature value to be modulated, ${\Delta }_i$ is the quantization step, $w_i$ is the voting weight used during extraction, and ${\mathsf{\Omega }}_i$ is the set of physical or geometric constraints that the carrier must satisfy.

The unique carrier identifier is constructed from structural information that is unchanged by watermark modulation. For a geometric carrier, the road identifier and the fixed index of the geometry element within the current road’s reference-line geometry sequence are used; the start s-coordinate $s$, which may change during topology-aware chain correction, is excluded. For an attribute carrier, the lane-section index, lane identifier, and index of the corresponding attribute record are combined. Consequently, consistent carrier identifiers can be reconstructed at both ends even after geometry-element lengths and subsequent start s-coordinates change. After scanning, all carriers are deterministically sorted by $i{d}_i$ to avoid synchronization errors caused by different traversal orders.

The physical interpretation and selection rationale for each carrier type were described in Section 2.2. This section specifies only the scanned objects and fields used for modulation. The attribute dimension comprises the constant term width.a of the lane-width polynomial, the roadMark.width attribute explicitly present in the original XML, and the constant term laneOffset.a of the lane-offset polynomial. The geometric dimension comprises arc and spiral geometry elements, whose modulation targets are $\kappa L$ and ${\kappa }_{e}L$, respectively. Objects satisfying the screening criteria in

Table 2. Screening criteria and modulation parameters for watermark carriers.

Carrier Type	Object	Target Feature	Quantization Step	Primary Screening Criteria	Voting Weight
Geometric carrier	Spiral element	λ = κeL	1.0 × 10−5	Element length ≥ 5 m and |λ| ≥ 1.2 × 10−4	1.2
Geometric carrier	Arc element	λ = κL	1.0 × 10−5	Element length ≥ 2 m and |λ| ≥ 1.2 × 10−4	1.2
Attribute carrier	Lane width	width.a	0.01 m	Road length ≥ 5 m and width.a ≥ 0.505 m	1.0
Attribute carrier	Road-marking width	roadMark.width	0.005 m	Road length ≥ 5 m and 0.0525 m ≤ roadMark.width ≤ 0.4975 m	0.8
Attribute carrier	Lane offset	laneOffset.a	0.002 m	Road length ≥ 5 m and |laneOffset.a| ≤ 1.999 m	0.6

are represented using a unified carrier structure.

For geometric carriers, a signed curvature–length composite feature is used as the QIM modulation target. The feature values for arc and spiral elements are defined, respectively, as follows:

$${\lambda }_i={\kappa }_i{L}_i$$

(6)

$${\lambda }_i={\kappa }_{e,i}{L}_i$$

(7)

In Equations (6) and (7), $L_i$ is the length of geometry element $i$, ${\kappa }_i$ is the constant curvature of an arc, and ${\kappa }_{e,i}$ is the end curvature of a spiral. Because the curvature sign represents the turning direction, the sign of ${\lambda }_i$ is retained during QIM modulation. During carrier screening, $\left|{\lambda }_i\right|$ is used to determine whether the magnitude of the geometry element’s curvature–length feature is sufficiently large. This preserves the turning information of the arc or spiral while avoiding unstable carriers caused by excessively small curvature or very short geometry elements.

The modulation parameters and screening criteria for the different carriers are listed in Table 2.

The quantization steps were set to balance the QIM decision margin against the perturbation of the map parameters. For the two target positions in Equation (14), the opposite-bit locations are separated by half a quantization period, and the nominal nearest-decision margin is one quarter of the step. Increasing the step therefore improves tolerance to perturbation but also increases the possible change in the carrier feature; a smaller step has the opposite effect. With the selected steps, the maximum QIM displacement is bounded by three quarters of the step, corresponding to 7.5 × 10⁻⁶ for the dimensionless geometric feature, 7.5 mm for lane width, 3.75 mm for road-marking width, and 1.5 mm for lane offset. The threshold |λ| ≥ 1.2 × 10⁻⁴ excludes geometric features close to zero, for which the same absolute modulation would produce a comparatively large relative change, while the minimum-length requirements exclude short elements for which a local parameter change may have a disproportionate geometric effect.

The attribute-screening bounds provide an initial margin around the prescribed physical ranges; after modulation, the physical-range and maximum-change checks described in Section 2.6 reject any candidate that violates these constraints. The voting weights encode the relative reliability and complementary roles of the carrier types: geometric carriers receive the highest weight because of the signed curvature–length feature’s invariance under orientation-preserving similarity transformations, lane-width carriers provide broad coverage, and road-marking-width and lane-offset carriers provide supplementary redundancy. These fixed engineering parameters were used unchanged for all three datasets and are not claimed to be globally optimal.

After carrier scanning, a watermark frame is constructed for the copyright information to be embedded. Let $M$ denote the copyright information and $B_M$ its binary representation. To enable self-synchronization during extraction without prior knowledge of the original message length, a self-describing watermark frame comprising a flag field, a length field, and a payload field is constructed as follows:

$$B=F\parallel E(L_M\parallel B_M)$$

(8)

In Equation (8), $F$ is the flag field, $L_M$ is the message-length field, $E(\cdot )$ denotes the error-correction encoding function, and $\parallel$ denotes bit-string concatenation. A 12-bit flag field and an 8-bit length field are used. The flag field records whether BCH coding is enabled, whereas the length field records the message length and is used for candidate-frame self-validation during extraction. When the number of carriers satisfies the BCH capacity requirement and reaches the preset activation threshold, the length field and message payload are jointly encoded using BCH(15, 7, 2). If the number of carriers is insufficient to support BCH redundancy, the unencoded length-and-payload bit string is used directly.

Let $N_c$ be the number of carriers and $N_b=\left|B\right|$ the final watermark-frame length. To ensure sufficient redundant coverage of the watermark bits, the average carrier redundancy is defined as follows:

$$\eta ={\displaystyle \frac{N_c}{N_b}}$$

(9)

The average carrier redundancy defined in Equation (9) is used only to determine whether the current map satisfies the preliminary capacity and average-redundancy requirements; it does not guarantee coverage of every watermark bit. In this study, ${\eta }_{\min }=1.5$. Embedding is terminated when $\eta <{\eta }_{\min }$. After the overall capacity check, the actual coverage of every watermark bit is further counted after hash mapping and carrier-constraint screening.

The minimum average redundancy controls whether embedding can proceed; it does not set the number of redundant copies. Similarly, the normalized correlation (NC) threshold is an evaluation criterion and does not enter blind extraction.

2.6. Watermark Embedding Based on Hash Mapping and QIM

After obtaining the multidimensional carrier pool and watermark bitstream, the keyed Fowler–Noll–Vo 1a (FNV-1a) hash function is used for dispersed carrier-to-bit mapping, thereby reducing the risk that sequential embedding will cause contiguous bit losses under local cropping.

$$j_i=H(i{d}_i,t_i,K)\mathrm{mod}{N}_b$$

(10)

In Equation (10), $H(\cdot )$ is the FNV-1a hash function, and $j_i$ is the index of the watermark bit to which carrier $c_i$ is mapped. Because $i{d}_i$, $t_i$, and $K$ jointly enter the hash calculation, carriers of different types can still yield different bit assignments even when they have similar road identifiers or local indices. During extraction, the same mapping can be reconstructed using the same key and carrier-identification rule, without additional synchronization information.

After all carriers have been mapped, the number of carriers assigned to watermark bit $j$ is defined as follows:

$$n_j=\left|\left\{c_i\mid j_i=j\right\}\right|$$

(11)

According to Equation (11), the actual coverage count of every bit position is determined. If

$${\min }_{0\le j<N_b}{n}_j=0$$

(12)

the condition in Equation (12) holds, at least one watermark bit is not carried by any carrier. The current mapping thus fails the complete-embedding requirement, and the current embedding attempt is terminated. Equation (9) controls the average redundancy, whereas Equation (12) ensures that the initial mapping leaves no watermark-frame bit uncovered.

For a carrier mapped to watermark bit $b_{j_i}$, QIM is used to slightly modify its feature value. Let $v_i$ be the original carrier feature and ${\Delta }_i$ the quantization step. The feature is first quantized to the nearest lattice point:

$$q_i=\mathrm{round}\left({\displaystyle \frac{v_i}{{\Delta }_i}}\right){\Delta }_i$$

(13)

Equation (13) quantizes the carrier feature to the nearest lattice point. The target bit then selects one of two offset positions relative to this point:

$$v_i^{*}=\left\{\begin{array}{ll}{q}_i+{\displaystyle \frac{{\Delta }_i}{4}},\hfill & b_{j_i}=0\hfill \\ q_i-{\displaystyle \frac{{\Delta }_i}{4}},\hfill & b_{j_i}=1\hfill \end{array}\right.$$

(14)

In Equation (14), $v_i^{*}$ is the modulated target feature. Bits 0 and 1 are placed on opposite sides of the quantization lattice point. During extraction, $q_i-{\Delta }_i/4$ represents the $3{\Delta }_i/4$ position within the current quantization period; the watermark can therefore be recovered through a nearest-neighbor decision based on wrapped residual distances.

For a road-attribute carrier, embedding mainly consists of directly writing back the target attribute value. For a lane-width carrier, only the constant polynomial term $a$ is modified, while the higher-order terms $b$, $c$, and $d$ remain unchanged. For a lane-offset carrier, only the constant term $a$ of the $laneOffset$ polynomial is modified. For a road-marking-width carrier, only the existing $width$ attribute in the original file is modified. To avoid unreasonable changes in road semantics, range constraints are checked before modifying attribute carriers:

$$|v_i^{*}-v_i|\le {\tau }_i,v_i^{*}\in {\mathsf{\Omega }}_i$$

(15)

In Equation (15), ${\tau }_i$ is the maximum allowable change for this carrier type, and ${\mathsf{\Omega }}_i$ is its prescribed physical range. If the modulated value fails to satisfy either constraint, the carrier is excluded from final embedding. Because attribute carriers do not directly alter the geometry of the road reference line, attribute values that pass both constraint checks can be written directly back to the OpenDRIVE file while preserving the numerical precision and representation used in the original file.

For a geometric carrier, the target feature $v_i^{*}$ is the modulated curvature–length composite feature ${\lambda }_i^{*}$. Changing geometric parameters affects not only the current geometry element but potentially also its end position, end heading, and the s-coordinate relationships of subsequent elements. Therefore, a geometric carrier cannot be written back directly after QIM modulation; it must undergo local geometric compensation, final revalidation of the QIM decision, and topology-aware chain correction.

2.7. Geometry-Constrained Compensation and Topology-Aware Chain Correction

After QIM modulation, an arc or spiral carrier must satisfy the geometric constraints described in Section 2.3. This requires parameter determination, geometric error validation, final revalidation of the QIM decision, and topology-aware chain correction. This section presents the parameter calculations and acceptance procedures for the two geometric-carrier types.

For a spiral geometry element, curvature varies continuously along the arc length, and the local curve shape is jointly determined by the start curvature ${\kappa }_s$, end curvature ${\kappa }_e$, and length $L$. Let the spiral’s end position and end heading before embedding be $p_e^0$ and ${\theta }_e^0$, respectively. The pre-embedding curvature–length feature is given by Equation (16).

$$\lambda ={\kappa }_{e}L$$

(16)

According to the QIM modulation rule, the target feature is expressed as follows:

$${\lambda }^{*}=\mathrm{round}\left({\displaystyle \frac{\lambda }{{\Delta }_{\lambda }}}\right){\Delta }_{\lambda }+{\delta }_b$$

(17)

In Equation (17), ${\delta }_b={\Delta }_{\lambda }/4$ corresponds to embedding bit 0, and ${\delta }_b=-{\Delta }_{\lambda }/4$ corresponds to embedding bit 1. The candidate end curvature is first calculated using the original length, as shown in Equation (18).

$${\tilde{\kappa }}_e={\displaystyle \frac{{\lambda }^{*}}{L}}$$

(18)

Geometric-compensation optimization is then performed with the candidate end curvature ${\tilde{\kappa }}_e$ as the watermark-modulation target. With the start position and start heading of the geometry element held fixed, the element length and start curvature are jointly adjusted. The optimization variables are represented as follows:

$$x={\left[L^{\prime },{\kappa }_s^{\prime }\right]}^T$$

(19)

In Equation (19), $L^{\prime }$ and ${\kappa }_s^{\prime }$ are the optimized geometry-element length and start curvature, respectively. Taking the original start position and start heading as fixed boundary conditions, spiral integration is used to calculate the end position $p_e(x)$ and end heading ${\theta }_e(x)$ under the optimized parameters.

Local compensation minimizes the end-position and end-heading errors:

$${\min }_{x}J(x)=\alpha {‖p_e(x)-p_e^0‖}^2+\beta {\left|{\theta }_e(x)-{\theta }_e^0\right|}^2$$

(20)

In Equation (20), $\alpha$ and $\beta$ are weighting coefficients. The spiral end position and heading are calculated by curve integration and depend nonlinearly on the optimization variables. The Levenberg–Marquardt method is therefore used to solve Equation (20) iteratively. If a curvature-continuity check is enabled, the optimized end curvature of the current element is compared with the start curvature of the subsequent element, and candidates that fail the preset threshold are rejected.

After optimization, the end-position and end-heading errors of the spiral are defined as follows:

$$e_p={‖p_e^{*}-p_e^0‖}_2,e_{\theta }=\left|{\theta }_e^{*}-{\theta }_e^0\right|$$

(21)

In Equation (21), $p_e^{*}$ and ${\theta }_e^{*}$ are the end position and end heading, respectively, of the optimized spiral.

Because geometric compensation changes the spiral length, validating only the position and heading errors cannot guarantee that the embedded bit remains valid. The actual curvature–length feature after compensation must therefore be recalculated using Equation (22).

$${\lambda }_{\mathrm{f}}={\kappa }_{e,\mathrm{c}}{L}^{*}$$

(22)

The final decision bit ${\widehat{b}}_{\mathrm{f}}$ is then obtained using the QIM nearest-neighbor rule described in Section 2.8.

$$e_p\le {\epsilon }_p,e_{\theta }\le {\epsilon }_{\theta },{\widehat{b}}_{\mathrm{f}}=b_i$$

(23)

The embedding result for the spiral carrier is accepted only when the condition in Equation (23) holds; otherwise, the carrier is discarded. Equation (23) prevents compensation-induced length changes from moving the final feature across a QIM decision boundary.

For an arc geometry element, curvature remains constant throughout the element, and the parameter relationship is simpler. Let the arc curvature be $\kappa$ and its length be $L$; the corresponding feature is given by Equation (24).

$$\lambda =\kappa L$$

(24)

The target feature for the arc carrier is obtained using the same QIM rule in Equation (17).

With the arc curvature $\kappa$ held fixed, Equation (25) gives the target length.

$$L^{*}={\displaystyle \frac{{\lambda }^{*}}{\kappa }}$$

(25)

Because ${\lambda }^{*}$ is obtained by slightly modulating the original $\lambda$, $L^{*}$ generally remains positive when the minimum-feature threshold and relative length-change constraint are satisfied. If the calculated $L^{*}$ violates the relative length-change constraint or produces a geometric error above the threshold, the arc carrier is excluded from final embedding. Otherwise, the new length is written back and chain correction is performed.

To apply a consistent acceptance procedure to the two geometric-carrier types, the QIM decision is also revalidated before an arc carrier is written back.

When a geometry-element length changes, the start s-coordinates of subsequent geometry elements on the same road are recursively updated according to Equation (4) in Section 2.3. The cumulative length change of preceding geometry elements is also propagated consistently to the longitudinal positions of associated lane records, road markings, road objects, and traffic facilities referenced to the road-reference-line coordinate $s$. This operation preserves element ordering and the consistency of the associated objects within the road-reference-line parameterization.

After all carriers have been processed, the effective bit coverage provided by the successfully written carriers is counted. Define the carrier write-status variable $e_i$. For carrier $i$, $e_i=1$ if it passes the constraint checks and is successfully written to the file; otherwise, $e_i=0$. The effective coverage count of the watermark bit $j$ is defined by Equation (26).

$$n_j^{\mathrm{eff}}={\displaystyle \sum _{\begin{array}{c}1\le i\le N_c\\ j_i=j\end{array}}{e}_i}$$

(26)

If $n_j^{\mathrm{eff}}=0$ for any watermark bit, that bit has no effective carrier coverage after constraint screening, and all written modifications are rolled back. The changes are committed and a watermarked file is output only when every watermark bit is effectively covered by at least one carrier and the overall embedding success rate meets or exceeds the preset threshold.

Local geometric compensation controls the end state of the current geometry element, whereas topology-aware chain correction preserves parameter consistency for subsequent elements and associated objects. The complete watermark-embedding procedure is summarized in Algorithm 1.

Algorithm 1. Watermark embedding procedure

Input: original OpenDRIVE file $D$, copyright information $M$, and key $K$. Output: watermarked OpenDRIVE file $D_w$. Parse the original OpenDRIVE file $D$. Construct the carrier set $C=c_1,c_2,\cdots ,c_{N_c}$ according to the deterministic carrier-scanning rules (Equations (5)–(7) and Table 2). Construct the watermark frame (Equation (8)) for the copyright information $M$. If the BCH capacity and activation conditions are satisfied, apply BCH encoding to the length-and-payload field; otherwise, retain this field uncoded. The resulting frame constitutes the watermark bitstream $B$. Calculate the average carrier redundancy $\eta$ using Equation (9); terminate embedding if the threshold requirement is not met. Calculate the hash-mapped index $j_i$ for each carrier $c_i$. Use Equation (10). Count the initial coverage of every watermark bit using Equation (11); terminate embedding if Equation (12) holds. Apply QIM to the carrier feature according to $B[j_i]$. Use Equations (13) and (14). If $c_i$ is an attribute carrier, check the modulated value against its physical range and maximum allowable change before writing it back (Equation (15)). If $c_i$ is a geometric carrier, determine the compensated parameters and validate the geometric errors (Equations (16)–(25)). Revalidate the final QIM decision (Equations (29)–(33)) and apply chain correction (Equation (4)). Count the effective bit coverage of successfully written carriers using Equation (26). If any bit is uncovered or the overall embedding success rate is below the preset threshold, roll back all written modifications. Output the watermarked OpenDRIVE file $D_{\mathrm{w}}$.

2.8. Blind Extraction Based on Weighted Voting

Watermark extraction does not require the original OpenDRIVE file. Instead, the carrier set in the file under test is reconstructed using the same carrier-scanning rules as during embedding. Let $D^{\prime }$ be the map under test; the scanned carrier set is given by Equation (27).

$$C^{\prime }=c_{1^{\prime }},c_{2^{\prime }},\cdots ,c_{{N_{c^{\prime }}}^{\prime }}$$

(27)

For each carrier, the unique identifier is reconstructed using the stable-identification rule in Section 2.5. The carrier type and the same key are then used to calculate the watermark-bit index. The carrier-to-bit mapping during extraction is shown in Equation (28).

$$j_{i^{\prime }}=H(i{d}_{i^{\prime }},t_{i^{\prime }},K)\mathrm{mod}{N}_b$$

(28)

Local cropping may remove some carriers, and reserialization may alter the textual form of the XML. Nevertheless, if the structural indices of the remaining carriers are preserved, their watermark-bit indices can still be reconstructed independently from the stable identifiers and key.

For the current feature value $v_{i^{\prime }}$ of each carrier, the extractor first calculates a nonnegative residual within the quantization period. Define

$$r_i=v_{i^{\prime }}\mathrm{mod}{\Delta }_i,r_i\in [0,{\Delta }_i)$$

(29)

In Equation (29), $\mathrm{mod}$ denotes the nonnegative modulo operation. When $v_{i^{\prime }}$ is negative, the residual is still mapped to the interval $[0,{\Delta }_i)$, avoiding periodic ambiguity when demodulating attribute carriers such as lane offsets that may take negative values. This formulation, based on a nonnegative modulo residual, is equivalent to normalization relative to the nearest quantization lattice point; both map the QIM residual into one quantization period for wrapped-distance decisions.

Under the embedding rule, the ideal residual positions for bits 0 and 1 are ${\Delta }_i/4$ and $3{\Delta }_i/4$, respectively. Accounting for the periodic wraparound of the quantizer, the periodic distance function is defined as follows:

$$d_{\Delta }(x,y)=\min (|x-y|,\Delta -|x-y|)$$

(30)

Using Equation (30), the distances from the current carrier to the two ideal embedding positions are

$$d_i^{(0)}=d_{{\Delta }_i}\left(r_i,{\displaystyle \frac{{\Delta }_i}{4}}\right)$$

(31)

$$d_i^{(1)}=d_{{\Delta }_i}\left(r_i,{\displaystyle \frac{3{\Delta }_i}{4}}\right)$$

(32)

Equations (31) and (32) give the distances from the current carrier to the ideal residual positions of bits 0 and 1, respectively. The hard decision for the carrier is obtained using the nearest-neighbor rule:

$${\widehat{b}}_i=1\left(d_i^{(1)}<d_i^{(0)}\right)$$

(33)

In Equation (33), $1\left(\cdot \right)$ denotes the indicator function. When $d_i^{(1)}<d_i^{(0)}$, $\widehat{b}i=1$; otherwise, $\widehat{b}i=0$. When $d_i^{(1)}=d_i^{(0)}$, the hard decision is set to 0. To quantify the reliability of an individual carrier’s demodulation result, the QIM extraction confidence is further defined as follows:

$${\rho }_i=1-\min \left(1,{\displaystyle \frac{\min (d_i^{(0)},d_i^{(1)})}{{\Delta }_i/4}}\right)$$

(34)

In Equation (34), ${\rho }_i\in [0,1]$. When a carrier residual is close to an ideal embedding position, ${\rho }_i$ approaches 1, indicating a reliable demodulation result. When the residual approaches the decision boundary, ${\rho }_i$ approaches 0, indicating that the carrier contributes little to the decision for the current bit.

Because each watermark bit may be redundantly carried by multiple carriers, weighted voting is used for bit recovery. The index set of carriers mapped to watermark bit $j$ is defined by Equation (35).

$${\mathsf{\Omega }}_j=i\mid j_{i^{\prime }}=j$$

(35)

For this bit position, the weighted votes for 0 and 1 are calculated, respectively, as follows:

$$V_j^{(0)}={\displaystyle \sum _{i\in {\mathsf{\Omega }}_j,{\widehat{b}}_i=0}{w}_i}{\rho }_i$$

(36)

$$V_j^{(1)}={\displaystyle \sum _{i\in {\mathsf{\Omega }}_j,{\widehat{b}}_i=1}{w}_i}{\rho }_i$$

(37)

In Equations (36) and (37), $w_i$ is the carrier-type weight. The weights in Table 2 are used: 1.2, 1.0, 0.8, and 0.6 for geometric, lane-width, road-marking-width, and lane-offset carriers, respectively. The final decision for the watermark bit $j$ is given by Equation (38).

$${\widehat{B}}_j=1\left(V_j^{(1)}>V_j^{(0)}\right)$$

(38)

Combining carrier-type weights with QIM confidence reduces the influence of low-confidence carriers on the final decision. Under local cropping, some carriers may be lost, but the surviving carriers can still vote for their corresponding bits. When a small number of carriers are affected by numerical rewriting or format conversion, BCH coding and weighted voting can jointly improve the probability of watermark recovery.

Because the message length is not known initially during extraction, candidate message lengths from 1 to 30 characters are examined. For each candidate length, both the uncoded and BCH-coded frame lengths are evaluated, and carrier mapping, QIM demodulation, and weighted voting are performed for each resulting candidate frame length. In the uncoded mode, the length field is read directly. In the BCH-coded mode, the encoded payload is first BCH-decoded, after which the length field is read from the decoded payload. A candidate is considered self-consistent only if the recovered length equals the assumed candidate length and the flag field agrees with the assumed coding mode. If multiple candidates are self-consistent, the candidate with the highest mean voting confidence is selected as the final output.

After candidate message length detection, QIM demodulation, weighted voting, and error-correction decoding, the blind watermark extraction procedure is summarized in Algorithm 2.

Algorithm 2. Blind watermark extraction procedure

Input: OpenDRIVE file under test $D^{\prime }$ and key $K$. Output: extracted copyright information $\widehat{M}$. Parse the OpenDRIVE file under test $D^{\prime }$. Construct the carrier set $D^{\prime }$ using the same rules as during embedding (Equation (27) and Table 2). For each candidate message length from 1 to 30 characters, determine both the uncoded and BCH-coded candidate frame lengths using the frame structure in Equation (8) and the coding rules in Section 2.5. Calculate the hash-mapped index $j_{i^{\prime }}$ for each carrier $c_{i^{\prime }}$. Use Equation (28). Demodulate each carrier using QIM according to its type to obtain the hard-decision bit ${\widehat{b}}_i$ and confidence ${\rho }_i$. Use Equations (29)–(34). Perform weighted voting among the carriers mapped to the same bit position using Equations (35)–(37). Obtain the candidate watermark bitstream $\widehat{B}$. Use Equation (38). Decode the flag field in Equation (8) and verify that it agrees with the assumed coding mode. For a BCH-coded candidate, apply BCH decoding to the encoded payload before reading the length field; for an uncoded candidate, read the length field directly. Retain the candidate only if the recovered length matches the assumed message length. The frame and BCH coding are specified in Equation (8) and Section 2.5. Output the recovered copyright information $\widehat{M}$.

3. Results

To evaluate the effectiveness of the proposed algorithm, experiments were conducted from three perspectives: map usability, watermark imperceptibility, and robustness against attacks. The experimental data, runtime environment, comparison methods, and parameter settings are first introduced, followed by evaluation metrics for watermark-extraction accuracy, road smoothness, endpoint errors of reference-line geometry elements, and file-size changes. The effects of watermark embedding on OpenDRIVE parsing, road geometry, and simulation use are then analyzed. Finally, the algorithm’s robustness is evaluated under geometric transformations, cropping, and format processing.

3.1. Experimental Data and Settings

3.1.1. Experimental Data and Runtime Environment

Three simulator-derived HD map datasets in OpenDRIVE format were used. Datasets a and b are the Town04 and Town03 road networks from CARLA, respectively, whereas dataset c is an OpenDRIVE export associated with the public LGSVL SanFrancisco environment. The headers of all three input files specify OpenDRIVE 1.4. The datasets differ in file size and usable-carrier composition, enabling evaluation across different OpenDRIVE data characteristics. Visualizations of the original datasets are shown in Figure 2, and their basic characteristics are listed in

Table 3. Basic information on the experimental datasets.

Dataset	Original File Size (KiB)	Available Carriers	Experimental Purpose
Dataset a (Town04)	2065.436	Arc and road-attribute carriers (3142 total)	Usability, imperceptibility, and robustness tests
Dataset b (Town03)	2251.080	Arc and road-attribute carriers (3140 total)	Usability, imperceptibility, and robustness tests
Dataset c (SanFrancisco)	26,721.497	Lane-width carriers only (145,783 total)	Tests of large-scale data handling, file-size change, and robustness

.

Dataset a contains 242 roads, 775 lane sections, 27 junctions, and 1215 plan-view geometry elements (917 lines and 298 arcs). Dataset b contains 279 roads, 617 lane sections, 34 junctions, and 1076 geometry elements (718 lines and 358 arcs). Dataset c contains 1055 roads, 1055 lane sections, 91 junctions, and 4404 geometry elements (2240 lines and 2164 paramPoly3 elements).

After applying the deterministic screening rules in Table 2, dataset a provided 0 spiral, 291 arc, 1427 lane-width, 763 road-marking-width, and 661 lane-offset carriers (3142 in total); the corresponding counts for dataset b were 0, 319, 1481, 1060, and 280 (3140 in total). Dataset c provided 145,783 eligible lane-width carriers and no eligible carriers of the other four types. Its plan-view geometries comprise line and paramPoly3 elements rather than eligible arc or spiral elements, and its road-mark records do not contain an explicit width attribute. Dataset c therefore tests whether attribute carriers can support watermark embedding and extraction when geometric carriers are unavailable, whereas datasets a and b are used to evaluate joint geometric-and-attribute embedding.

The experiments were conducted on a 64-bit version of Windows 11. The algorithm was implemented in C++20 using Visual Studio 2022. OpenDRIVE files were visualized using the online odrviewer (https://odrviewer.io/), and scenario simulations were performed using esmini 2.55.0.

3.1.2. Watermark Parameters and Experimental Design

The watermark-embedding and extraction methods described in Section 2 were used. The screening criteria, quantization steps, and voting weights for all carrier types were set as listed in Table 2.

The watermark message was “copyright”, and each method used fixed embedding parameters. The geometric-transformation experiments included translation, rotation, and uniform scaling, with translations of 20, 40, 60, 80, and 100 m, rotation angles of 60°, 120°, 180°, 240°, 300°, and 360°, and uniform scale factors of 1.2, 1.4, 1.6, 1.8, and 2.0. The cropping ratios were 20%, 40%, 60%, 80%, and 90%. Format-processing experiments comprised format sanitization and OpenDRIVE import/export conversion using Truevision Designer.

Methods [19,20,24] were selected for comparison. For [19,20], road reference lines were sampled at 1.0 m intervals with geometry endpoints retained, and watermarked vertices were written as OpenDRIVE line geometries. The embedding and extraction rules were unchanged. Method [19] used a coordinate-index exponent of 8 and a quantization interval of 5 × 10⁻¹⁰. Method [20] used a coordinate scaling factor of 10⁸, an exponent of −8, and 4 bits per symbol, giving a quantization interval of 10⁻¹⁰. These settings were fixed across the robustness experiments. Repeated embedding was used for [24] in the storage-overhead comparison.

3.2. Evaluation Metrics

3.2.1. Watermark-Extraction Accuracy

Normalized correlation (NC) was used to evaluate agreement between the extracted and original watermarks. Because the watermark is a binary bit sequence, NC was calculated as the bit-agreement rate. Let the original watermark be $W=w_1,w_2,\dots ,w_n$ and the extracted watermark be $\widehat{W}={\widehat{w}}_1,{\widehat{w}}_2,\dots ,{\widehat{w}}_n$; then

$$NC={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n\left[1-\left(w_i\oplus {\widehat{w}}_i\right)\right]}$$

(39)

In Equation (39), XOR denotes the exclusive-OR operation. NC ranges from 0 to 1, with NC = 1 indicating complete watermark recovery. All methods were evaluated using the 72 original payload bits, with unrecovered bits counted as mismatches. Independent, unbiased binary sequences have an expected agreement of 0.5. Following [24], NC ≥ 0.7 was adopted as the effective-extraction criterion, providing a margin above random agreement without specifying a calibrated false-positive rate.

3.2.2. Map Usability and Road Smoothness

To evaluate the influence of watermark embedding on map usability, the watermarked maps were tested in esmini. The test-scenario pass rate, maximum lateral jerk, and maximum curvature discontinuity were selected as evaluation metrics.

Let $N_s$ denote the number of test scenarios in which the vehicle successfully completes the preset trajectory and $N_t$ the total number of test scenarios. The test-scenario pass rate is given by Equation (40).

$$P={\displaystyle \frac{N_s}{N_t}}\times 100\%$$

(40)

A test scenario was classified as failed if the map could not be loaded, the vehicle visibly departed from the lane, a collision occurred, or the simulation terminated abnormally.

Lateral jerk is the rate of change of lateral acceleration with time. Let $a_{\mathrm{lat},k}$ denote the lateral acceleration at sampling instant $k$, and let $\Delta t$ denote the interval between adjacent sampling instants. The discrete lateral jerk is given by Equation (41).

$$j_{\mathrm{lat},k}={\displaystyle \frac{a_{\mathrm{lat},k}-a_{\mathrm{lat},k-1}}{\Delta t}},k=2,3,\dots ,K$$

(41)

If the simulation contains $K$ valid sampling instants, the maximum lateral jerk is given by Equation (42).

$$j_{\mathrm{lat},\max }={\max }_{2\le k\le K}\left|j_{\mathrm{lat},k}\right|$$

(42)

The threshold for maximum lateral jerk was set to 8.0 m/s³.

$$j_{\mathrm{lat},\max }\le 8.0$$

(43)

When Equation (43) holds, the maximum lateral jerk in the test scenario is considered to be within the experimental threshold adopted in this study.

Curvature discontinuity is used to characterize curvature continuity at the junction of adjacent road-geometry elements. Let the curvatures immediately before and after geometry-element junction $k$ be ${\kappa }_k^{-}$ and ${\kappa }_k^{+}$, respectively. The curvature discontinuity at that junction is defined by Equation (44).

$$\Delta {\kappa }_k=\left|{\kappa }_k^{+}-{\kappa }_k^{-}\right|$$

(44)

If the test route contains $K$ geometry junctions, the maximum curvature discontinuity is given by Equation (45).

$$\Delta {\kappa }_{\max }={\max }_{1\le k\le K}\Delta {\kappa }_k$$

(45)

The threshold for maximum curvature discontinuity was set to 0.02 m⁻¹.

$$\Delta {\kappa }_{\max }\le 0.02$$

(46)

When Equation (46) holds, the maximum curvature discontinuity along the test route is considered to be within the experimental threshold adopted in this study.

3.2.3. Geometric Imperceptibility and Storage Overhead

Watermark imperceptibility was evaluated in terms of visual appearance, endpoint displacement of reference-line geometry elements, and file-size change.

The structural similarity index (SSIM) evaluates similarity in local luminance, contrast, and structure between the original and watermarked map renderings [25]. Values closer to 1 indicate greater similarity. This study adopts SSIM > 0.99 as the criterion for high structural similarity of the rendered maps.

Each map pair was rendered as 2048 × 2048 grayscale images using identical top-down views, spatial extents, and rendering settings for lane surfaces and road markings. SSIM was calculated using an 11 × 11 Gaussian window with a standard deviation of 1.5, K₁ = 0.01, and K₂ = 0.03, and averaged over valid windows. When rendering dataset c, paramPoly3 curves without a specified pRange were evaluated over the normalized parameter interval [0, 1] in both maps.

Let a geometric evaluation point $i$ in the original map be defined by Equation (47).

$$p_i=(x_i,y_i,z_i)$$

(47)

Equation (48) defines the corresponding evaluation point in the watermarked map.

$$p_i^{\prime }=(x_i^{\prime },y_i^{\prime },z_i^{\prime })$$

(48)

The three-dimensional displacement of this evaluation point is then given by Equation (49).

$$e_i=\sqrt{{\left(x_i^{\prime }-x_i\right)}^2+{\left(y_i^{\prime }-y_i\right)}^2+{\left(z_i^{\prime }-z_i\right)}^2}$$

(49)

The mean spatial error over all evaluation points is given by Equation (50).

$$\overline{e}={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n{e}_i}$$

(50)

The maximum spatial error is given by Equation (51).

$$e_{\max }={\max }_{1\le i\le n}{e}_i$$

(51)

To evaluate error separately along each coordinate direction, the mean absolute error in the $x$ direction, for example, is given by Equation (52).

$$\overline{\Delta x}={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n\left|x_i^{\prime }-x_i\right|}$$

(52)

The maximum absolute error in the $x$ direction is given by Equation (53).

$$\Delta x_{\max }={\max }_{1\le i\le n}\left|x_i^{\prime }-x_i\right|$$

(53)

The mean and maximum absolute errors in the $y$ and $z$ directions are calculated analogously.

The file-size change rate quantifies the change in file size after watermark embedding. Let $S_0$ and $S_w$ denote the original and watermarked file sizes, respectively. The file-size change rate is given by Equation (54).

$$\gamma ={\displaystyle \frac{S_w-S_0}{S_0}}\times 100\%$$

(54)

The closer $\gamma$ is to 0, the smaller the storage overhead introduced by watermark embedding.

3.3. Results and Analysis

3.3.1. Map Usability and Visual Consistency

OpenSCENARIO files were first generated for the roads under test, and vehicles were configured to travel along the lane centerline at an initial speed of 60 km/h. The simulations were then executed in esmini’s headless mode with a time step of 0.01 s. Vehicle trajectories, headings, lateral accelerations, and road curvatures were recorded. The experimental setup is illustrated in Figure 3.

All three original datasets and the corresponding maps processed by the proposed method and the method in [24] were parsed successfully by esmini, and all preset test scenarios passed (a 100% pass rate). No map-loading failures, visible lane departures, collisions, or abnormal terminations occurred. Because these results were identical across these methods,

Table 4. Results of the map-usability analysis.

Dataset	Evaluation Metric	Original Data	Method in [24]	Proposed Method
Dataset a	Maximum curvature discontinuity/m−1	0.000000	0.000000	0.000000
	Maximum lateral jerk/m/s3	0.000000	0.000000	0.000000
Dataset b	Maximum curvature discontinuity/m−1	0.000000	0.000000	0.000000
	Maximum lateral jerk/m/s3	0.000000	0.000000	0.000000
Dataset c	Maximum curvature discontinuity/m−1	0.012275	0.012275	0.012275
	Maximum lateral jerk/m/s3	6.277778	6.277778	6.277778

further reports the two quantitative metrics: maximum curvature discontinuity and maximum lateral jerk.

As shown in Table 4, the maximum curvature discontinuity and maximum lateral jerk were both 0 for datasets a and b under all processing conditions. For dataset c, the corresponding values were 0.012275 m⁻¹ and 6.277778 m/s³, both below the experimental thresholds of 0.02 m⁻¹ and 8.0 m/s³. The results produced by the proposed algorithm were identical to those for the original data and the method in [24]. Thus, under the tested roads and simulation conditions, watermark embedding introduced no additional abrupt road-curvature changes or vehicle lateral-motion fluctuations detectable by these two metrics, and the watermarked maps retained their usability under the tested conditions.

The maps before and after watermark embedding were further compared visually using odrviewer (Figure 4). At a conventional display scale, the road reference lines, lane structures, and road connectivity in the watermarked maps were consistent with those in the original maps, with no visible road-shape distortion or structural misalignment.

The SSIM values for datasets a, b, and c were 0.996264, 0.992578, and 0.999875, respectively. All exceeded the threshold of 0.99 adopted in this study, indicating high structural similarity between the original and watermarked map renderings, consistent with Figure 4.

Visual comparison reflects only macroscopic road shape and cannot replace quantitative geometric-error assessment. The next subsection therefore quantifies coordinate displacements of the geometric evaluation points before and after embedding.

3.3.2. Errors at Geometric Evaluation Points

OpenDRIVE road reference lines are described by parametric geometry elements. Comparing only the explicitly stored start coordinates in the XML file does not fully characterize the geometric effects of changes in curvature and length. The three-dimensional endpoint of each reference-line geometry element was therefore used as an evaluation point. Points before and after embedding were matched using the road identifier and geometry-element index, and absolute displacements along the $x$, $y$, and $z$ directions, as well as the three-dimensional Euclidean distance, were calculated. The results are presented in

Table 5. Error statistics for the geometric evaluation points.

Dataset	a	b	c
Maximum absolute x-coordinate error (m)	2.096 × 10−3	2.949 × 10−3	0
Maximum absolute y-coordinate error (m)	3.371 × 10−3	1.341 × 10−3	0
Maximum absolute z-coordinate error (m)	3.210 × 10−5	1.550 × 10−5	0
Maximum spatial error (m)	3.371 × 10−3	2.949 × 10−3	0
Mean absolute x-coordinate error (m)	2.322 × 10−5	2.316 × 10−5	0
Mean absolute y-coordinate error (m)	2.503 × 10−5	1.866 × 10−5	0
Mean absolute z-coordinate error (m)	2.573 × 10−7	8.993 × 10−8	0
Mean spatial error (m)	4.109 × 10−5	3.616 × 10−5	0

.

Scientific notation is used for small nonzero values in Table 5, whereas 0 denotes an exact zero. The maximum spatial errors for datasets a and b were 0.0034 m and 0.0029 m, respectively, and their mean spatial errors were 4.109 × 10⁻⁵ m and 3.616 × 10⁻⁵ m. Thus, under the current parameter settings, the reference-line endpoint displacements introduced by geometric-carrier embedding were on the millimeter scale. Dataset c had an exact zero error at the reference-line evaluation points because it contained no eligible spiral or arc carriers; its watermark was embedded in lane-width parameters, leaving the road-reference-line position unchanged.

3.3.3. File-Size Change

The method in [24] improves watermark extraction under cropping through repeated embedding, but repeated embedding also increases file size. The effective-extraction criterion used in this study was $NC\ge 0.7$. To compare storage overhead, file sizes before and after watermark embedding were recorded for the method in [24] and the proposed method. The results are shown in

Table 6. File-size changes after watermark embedding.

Dataset	Original File Size (KiB)	Method in [24]		Proposed Method
		File Size (KiB)	Increase Relative to Original File Size (%)	File Size (KiB)	Increase Relative to Original File Size (%)
a	2065.436	2347.566	13.660	2065.750	0.015
b	2251.080	2497.953	10.967	2251.210	0.006
c	26,721.497	32,710.580	22.413	26,758.540	0.139

.

Table 6 shows that the file-size growth rates produced by the method in [24] were 13.660%, 10.967%, and 22.413% for datasets a, b, and c, respectively, whereas those produced by the proposed algorithm were 0.015%, 0.006%, and 0.139%. The method in [24] creates watermark redundancy by repeatedly adding invisible characters, so its file size increases with the number of embedding cycles. The proposed algorithm primarily modulates existing numerical fields in the OpenDRIVE file; its file-size change arises solely from changes in the character representations of a small number of numerical fields that are rewritten.

These results show that the proposed algorithm achieved effective watermark extraction after a 90% cropping attack while yielding a substantially lower file-size growth rate—and thus less storage overhead—than the method in [24].

3.3.4. Robustness to Geometric Transformations

Translation, rotation, and uniform scaling are common geometric operations during coordinate transformation, projection processing, and editing of HD maps. Figure 5 compares the mean NC values across the three datasets for methods [19,20,24] and the proposed algorithm under these operations.

As shown in Figure 5, the proposed algorithm and methods [20,24] maintained NC = 1.000 under all tested translations, rotations, and uniform scale factors. Method [19] also maintained NC = 1.000 under translation and uniform scaling, but its mean NC ranged from 0.449 to 0.556 for rotations of 60–300° and returned to 1.000 at 360°. The proposed algorithm therefore outperformed method [19] at rotations of 60–300°.

The proposed algorithm is robust because the $\lambda ={\kappa }_{g}L$ feature defined in Section 2.2 is independent of the global position and orientation of a geometry element, so translation and rotation do not change its value. Under ideal uniform scaling, the geometry-element length is proportional to the scale factor, while the curvature is inversely proportional; their product therefore remains unchanged. In the scaling experiments, the attribute fields for lane width, road-marking width, and lane offset were not re-estimated, so the watermark information in the attribute carriers was also preserved.

3.3.5. Robustness to Cropping Attacks

Cropping removes map content and reduces the number of available watermark carriers.

Table 7. Watermark-extraction results under cropping attacks, expressed as normalized correlation (NC).

Cropping Ratio (%)	Method in [19]	Method in [20]	Method in [24]	Proposed Method
20	0.937	0.970	1.000	1.000
40	0.812	0.964	1.000	1.000
60	0.682	0.936	1.000	1.000
80	0.561	0.810	0.886	0.984
90	0.529	0.668	0.474	0.782

compares the mean NC values across datasets a, b, and c at cropping ratios of 20%, 40%, 60%, 80%, and 90%.

As the removal proportion increased, NC generally decreased for all methods. The proposed algorithm maintained $NC=1.000$ at cropping ratios of up to 60%. At an 80% cropping ratio, its mean NC decreased to 0.984.

At a 90% cropping ratio, the mean NC values of methods [19], [20], and [24] were 0.529, 0.668, and 0.474, respectively, compared with 0.782 for the proposed algorithm. Only the proposed algorithm remained above the effective-extraction threshold of 0.7, demonstrating its advantage under extensive carrier loss in this comparison.

This advantage arises from dispersed hash mapping and redundant embedding across roads and attribute types, which reduce the risk that local deletion removes all carriers associated with particular watermark bits. Weighted voting combines the decisions from surviving carriers, and BCH decoding corrects some remaining bit errors. These mechanisms improve watermark recovery after substantial carrier loss.

3.3.6. Robustness to Format Sanitization and Conversion

During transfer among editors, databases, and simulation platforms, OpenDRIVE files may undergo format sanitization or conversion. Such operations generally preserve road geometry and semantic content but can change invisible characters, whitespace formatting, numerical text representations, and the underlying XML structure, thereby damaging watermarks that depend on invisible characters or text layout.

For format sanitization, the input file was normalized using navi-sanitize 0.2.1, parsed with lxml 6.0.2, and reserialized in UTF-8. For format conversion, the file was imported into Truevision Designer and re-exported as XODR. Neither workflow targeted watermark fields or embedding locations. After each operation, blind watermark extraction was performed, and file validity was checked through XML validation, road structure statistics, and loading tests in esmini 2.55.0. The results are summarized in

Table 8. Experimental results after format sanitization and conversion, expressed as normalized correlation (NC).

Operation	Method in [24]	Proposed Method
Format sanitization	0.000	1.000
Format conversion	0.000	1.000

.

Under the format-sanitization and format-conversion workflows used in this study, the NC obtained by the method in [24] decreased to 0 in both cases, indicating that its invisible characters were filtered out or not preserved during processing. The proposed algorithm maintained $NC=1.000$ after both operations. This is because the watermark is embedded in existing numerical fields in OpenDRIVE and does not depend on whitespace, invisible encodings, attribute order, or additional XML tags. Provided that the processing preserves the corresponding numerical semantics and carrier identifiers, the extractor can reconstruct the carrier-to-bit mapping and perform QIM demodulation.

These results show that, under the two format-processing workflows used in this study, numerical-carrier watermarking exhibited greater adaptability to format processing than invisible-character watermarking.

4. Discussion

4.1. Mechanisms and Performance Trade-Offs

By jointly using geometric-shape and road-attribute carriers, the proposed method mitigates the limitations in stability and capacity associated with reliance on a single carrier type. The geometric-carrier feature $\lambda ={\kappa }_{g}L$ is independent of the global position and orientation of a geometry element and is scale-stable under ideal uniform scaling; it therefore primarily enhances robustness to geometric transformations. Attribute fields such as lane width, road-marking width, and lane offset are widely distributed in OpenDRIVE files and can supplement carrier capacity when few arcs and spirals are available. Dataset c, which lacked eligible geometric carriers, still supported watermark embedding and extraction through lane-width carriers, indicating that the multidimensional carrier pool improves adaptability to different carrier compositions. Nevertheless, the number of carriers of each type is jointly determined by map structure, attribute-field completeness, and screening thresholds. Therefore, neither a sufficient number of usable carriers nor satisfaction of the specified redundancy requirement can be guaranteed for every OpenDRIVE file.

Watermark recoverability under different processing conditions results from the combined action of several mechanisms. Robustness to geometric transformations mainly derives from the stability of $\lambda ={\kappa }_{g}L$ under translation, rotation, and ideal uniform scaling. Adaptability to format processing arises because the watermark is embedded in existing OpenDRIVE numerical fields rather than whitespace, invisible codes, or XML formatting. Under local cropping, carriers distributed across roads and structural levels carry watermark bits through key-driven hash mapping, reducing the risk that deletion of local objects will remove contiguous blocks of watermark bits. Weighted voting uses surviving carriers to make bit decisions, and BCH decoding further corrects some erroneous bits. Nevertheless, watermark-extraction performance declines as the cropping ratio increases, indicating that cropping robustness is jointly constrained by the distribution of surviving carriers, effective per-bit coverage, and error-correction capacity. The method mitigates local carrier loss but cannot completely eliminate information loss caused by extensive cropping.

The results under translation, rotation, and the tested uniform-scaling operation are consistent with the similarity invariance of the signed curvature–length geometric feature. This mechanism should not be generalized to reflections, nonuniform scaling, curve refitting, or road re-segmentation; moreover, attribute carriers are not intrinsically scale-invariant if their physical values are rescaled.

A necessary trade-off also exists between watermark robustness and map usability. Directly modulating existing numerical fields avoids adding XML tags or invisible characters and therefore limits file-size growth. However, changes in the curvature and length of geometric carriers can affect the end state of the current geometry element and the s-coordinate relationships of downstream elements. Local geometric compensation constrains changes in the current element’s end position and end heading, whereas topology-aware chain correction preserves the consistency of subsequent elements and associated objects within the reference-line parameterization. The endpoint errors of reference-line geometry elements, maximum curvature discontinuities, and esmini simulation results are consistent with these design objectives. Under the parameter settings and test scenarios used here, the fully constrained embedding process kept the influence of watermark modulation on road geometry and simulation use within the experimental thresholds.

4.2. Applicability and Limitations

The experimental conclusions have explicit conditions of applicability. The geometric-transformation experiments mainly considered translation, rotation, and uniform scaling without refitting road parameters. The format-sanitization and conversion experiments required preservation of the numerical semantics of the carrier fields and the structural identifiers used to reconstruct the carrier-to-bit mapping. Processing that truncates numerical precision, re-segments roads, refits curves, deletes attribute fields, or changes structural indices may alter both carrier features and identifiers, thereby affecting synchronization of the hash mapping and QIM decisions. The present results therefore demonstrate adaptability to conventional processing that preserves the parameter semantics and principal structure of OpenDRIVE; they do not imply resistance to arbitrary data reconstruction.

This study has several limitations. First, only three OpenDRIVE datasets were used, and their carrier compositions differed substantially. They are insufficient to comprehensively characterize carrier distributions across road structures, data sources, and modeling tools. Second, geometric errors were evaluated primarily at the endpoints of reference-line geometry elements; the effects of lane-width and lane-offset modulation on complete lane boundaries were not continuously evaluated along the road. Third, the quantization steps, voting weights, and carrier-screening thresholds were set mainly according to road semantics, numerical scale, and experimental experience, and their optimal combination and behavior near the capacity boundary require further investigation. The experiments also focused mainly on the complete algorithm and did not separately quantify the contributions of local geometric compensation, topology-aware chain correction, weighted voting, and BCH error correction. Future work should include OpenDRIVE datasets from more sources and over a wider range of scales, calculate continuous lane-boundary errors at fixed intervals along the reference line, and conduct ablation and parameter-sensitivity analyses of the key modules. Watermark stability under stronger reconstruction operations, including road re-segmentation, curve refitting, and reduced numerical precision, should also be investigated.

5. Conclusions

To address the difficulty of adapting existing watermarking methods to the parametric representation of OpenDRIVE while balancing watermark robustness and map usability, this study proposed a geometry-constrained robust watermarking algorithm for OpenDRIVE HD maps. The method embeds watermarks using a multidimensional carrier pool and absolute QIM and combines local geometric compensation, topology-aware chain correction, dispersed hash mapping, weighted voting, and BCH decoding to control geometric effects while enabling watermark extraction without the original map. The main conclusions are as follows:

(1)

The multidimensional carrier pool improved adaptability to different carrier compositions. Watermark embedding and blind extraction were successfully completed for all three datasets. Although dataset c contained no eligible arc or spiral carriers, lane-width carriers still carried the watermark, demonstrating that road-attribute carriers can supplement watermark capacity and provide redundant coverage when geometric carriers are insufficient.

(2)

Under the parameter settings and test scenarios used here, watermark embedding had little effect on map geometry, scenario simulation, or file size. The maximum spatial errors at reference-line geometry-element endpoints were 0.0034 m and 0.0029 m for datasets a and b, respectively, and the reference-line position in dataset c remained unchanged. All three map datasets were parsed successfully by esmini, with a test-scenario pass rate of 100% for each dataset. The maximum curvature discontinuity and maximum lateral jerk remained below their respective preset thresholds, and the file-size growth rate did not exceed 0.139%.

(3)

The proposed algorithm was robust under the attack conditions considered here. NC was 1.000 after translation, rotation, uniform scaling, format sanitization, and format conversion. For the geometric carriers, the results under the three tested geometric operations are consistent with the orientation-preserving similarity invariance of the signed curvature–length feature. At a 90% cropping ratio, the mean NC was 0.782 and remained above the effective-extraction threshold of 0.7.

Overall, the proposed method preserved OpenDRIVE file parseability and basic map usability under the experimental conditions while enabling reliable watermark extraction after several common processing operations. It can therefore support copyright identification and traceability during the distribution of OpenDRIVE HD maps. Future work will expand the experimental datasets, add continuous lane-boundary assessment, conduct ablation and parameter-sensitivity analyses of key modules, and investigate watermark stability under stronger data-reconstruction conditions.