Secure and Reversible Thumbnail-Preserving Encryption for Point Clouds via Spatial Subdivision and Chaotic Perturbation

Abstract

Thumbnail-preserving encryption (TPE) aims to balance data security and usability by allowing encrypted content to retain a coarse visual preview while protecting sensitive details. While existing TPE techniques primarily target 2D images, effective and reversible TPE for 3D point clouds remains underexplored. This paper proposes a thumbnail-preserving encryption framework specifically designed for point clouds, addressing the challenges arising from irregular spatial structure and viewpoint-dependent visualization. The proposed method integrates perception-guided spatial subdivision with key-dependent chaotic perturbation to obfuscate fine-grained geometric details while intentionally preserving coarse structural information under the TPE threat model. A reversible integer-domain design is further incorporated to enable exact recovery of the original point cloud and support reversible data hiding by exploiting coordinate-level redundancy. Extensive experiments conducted on diverse point clouds demonstrate that the proposed framework maintains stable thumbnail fidelity across different viewing conditions, achieving high structural similarity, while guaranteeing perfect reversibility with zero reconstruction error. In contrast to existing image-based TPE frameworks, the proposed method extends the TPE paradigm to 3D point clouds by providing full reversibility, auxiliary message embedding support, and stable thumbnail fidelity under varying viewing conditions. Quantitative results demonstrate that thumbnail-level structural similarity is well preserved, while the original point clouds are exactly recovered after decryption.

1. Introduction

In today’s digital era, as data sharing and transmission grow increasingly frequent, the importance of encryption technology has become ever more pronounced. With the continuous expansion of global information networks, both individuals and enterprises are facing escalating challenges in data protection, making encryption a vital mechanism for safeguarding sensitive information against unauthorized access [1,2,3,4]. Encryption serves not only as a barrier against data breaches, but also as a fundamental pillar for ensuring privacy and data security. In critical sectors such as financial services, governmental agencies, and healthcare systems, encryption guarantees that data remains protected during transmission and storage, shielding it from potential attackers.

However, while traditional encryption methods—such as symmetric and asymmetric encryption—offer robust and comprehensive security, they may impose limitations in scenarios that demand swift access or rapid data preview. For instance, in cloud storage services, users often need to quickly preview encrypted documents to verify their relevance. Similarly, in the healthcare domain, physicians may require immediate access to encrypted patient records for timely diagnosis. In such contexts, the necessity of performing a full decryption for each access instance can severely hinder data availability and compromise operational efficiency. As a result, there is a growing demand for encryption schemes that balance security with real-time usability, enabling secure yet expedient interaction with protected data.

To address this challenge, thumbnail-preserving encryption (TPE) [5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] has emerged as a compelling solution that balances data security with practical usability. This technique enables users to preview encrypted content through a thumbnail representation, without the need to decrypt the entire dataset. By preserving coarse structural or geometric information of the original data, TPE allows for rapid retrieval and assessment, all while maintaining the confidentiality of the underlying content. With TPE, data remains securely encrypted, yet users are able to efficiently identify and filter relevant information without full decryption. This significantly enhances operational efficiency and strengthens data protection simultaneously. As such, TPE is particularly well-suited for environments such as large-scale databases and cloud storage services, where vast amounts of data are accessed frequently and rapidly. The visual effect of applying this technique to images is illustrated in Figure 1.

Figure 1. The visual difference between traditional image encryption and thumbnail-preserving encryption.

In parallel, image encryption has been extensively studied over the past decade, with a wide range of techniques proposed to enhance security, efficiency, and implementation flexibility [20,21,22,23]. Existing approaches typically operate on pixel-level representations and aim to achieve complete visual obfuscation of 2D image content. In recent years, significant advances have been made in chaos-based image encryption, where complex nonlinear dynamics are exploited to achieve strong visual obfuscation and high cryptographic security. Representative studies have investigated encryption schemes based on Hopfield neural networks, memristive systems, and fractional-order chaotic dynamics, demonstrating excellent resistance to statistical and differential attacks, as well as suitability for hardware-oriented implementations in some cases [24,25,26,27].

While chaos-driven approaches are highly effective for full image encryption, their primary objective is complete visual concealment, which differs from that of TPE. TPE intentionally retains coarse visual structure to support usability and preview functionality. As a result, directly adopting advanced chaotic systems designed for full encryption may introduce excessive or uncontrollable distortion, which is incompatible with reversible and view-consistent TPE for 3D point clouds. In this work, chaotic dynamics are therefore employed as a lightweight, deterministic, and bounded perturbation generator rather than as a standalone cryptographic primitive. Recent chaos-based encryption studies nevertheless provide valuable security insights. In the proposed framework, these concepts are reinterpreted in a geometry-aware manner suitable for TPE of point clouds. Instead of pixel-level indistinguishability, security is evaluated by the difficulty of reconstructing fine-grained geometric details without the correct key, while coarse structural information is intentionally preserved. Accordingly, key sensitivity is examined through reconstruction behavior under incorrect keys, and statistical disruption is analyzed using coordinate distribution and geometric deviation metrics. Extending image-based encryption techniques to 3D point clouds remains challenging due to fundamental differences in data representation and visualization. Unlike images, point clouds lack a regular sampling grid and are typically examined under varying viewpoints and scales. Consequently, TPE for point clouds addresses a distinct problem setting, requiring dedicated mechanisms that balance geometric privacy, usability, and exact reversibility.

Although highly effective in the image domain, directly extending such techniques to 3D point clouds remains challenging due to fundamental differences in data representation, spatial structure, and visualization characteristics [28,29]. Unlike images, point clouds lack a regular grid structure and are commonly examined under varying viewpoints and scales. Moreover, the objective of TPE differs fundamentally from that of conventional image encryption. Rather than fully concealing visual content, TPE intentionally preserves coarse structural information to support usability while selectively protecting sensitive geometric details. This work therefore addresses a distinct problem setting and proposes a dedicated solution tailored to the characteristics of 3D point clouds.

Although TPE has achieved notable progress in the field of image processing, its application to 3D models remains an underexplored frontier. As a pivotal form of data representation in modern technology, point clouds [30] have found widespread use in areas such as medical imaging, architectural design, autonomous driving, and virtual reality. These applications demand a high degree of precision and detail, making the balance between data security and usability especially critical. In the medical domain, high-resolution 3D point clouds are essential for accurate diagnosis and surgical planning. Such models often contain sensitive personal health information, necessitating stringent privacy protection. At the same time, healthcare professionals must be able to rapidly access and preview these models to support timely diagnoses and treatment decisions. Similarly, in architectural design and autonomous driving, 3D point clouds play an indispensable role. Designers and engineers rely on these models to foresee structural challenges before construction, while autonomous vehicles depend on highly accurate 3D maps for safe navigation—both scenarios demanding robust security measures to guard against data breaches.

With the rapid development of the Internet of Things (IoT), the need for secure and lightweight 3D data encryption has become increasingly urgent. Devices such as LiDAR sensors, depth cameras, and spatial scanners are now embedded in smart cities, industrial robots, wearable devices, and autonomous vehicles. These IoT nodes continuously generate vast streams of 3D point clouds, often under constrained computing and energy budgets. In such scenarios, traditional encryption schemes may be too computationally heavy or impractical for real-time transmission and edge processing. Therefore, a reversible and lightweight encryption method capable of preserving visual previews while ensuring full data recoverability is critical for next-generation IoT ecosystems. TPE for point clouds offers an effective solution that enables secure transmission, fast visual filtering, and controlled access without sacrificing efficiency or security.

This study presents a TPE framework specifically designed for point clouds. By integrating perception-guided spatial subdivision with key-dependent chaotic perturbation, the proposed method provides an effective mechanism for protecting geometric information against unauthorized access while retaining usability. A central objective of the framework is to preserve a coarse geometric representation of the original model—i.e., a visually meaningful thumbnail—within the encrypted domain, thereby enabling secure preview without exposing sensitive fine-grained details. The proposed approach investigates several key aspects. First, a spatial subdivision strategy tailored to the geometric characteristics of point clouds is developed, and the impact of subdivision thresholds on encryption strength and thumbnail fidelity is analyzed. Second, a key-driven perturbation mechanism is introduced, in which each point is relocated in a controlled manner within its local subspace. This design ensures that the encrypted point cloud is geometrically obfuscated while remaining structurally consistent enough to support thumbnail-level inspection. A reversible decryption process is further formulated to allow authorized users to precisely recover the original model using the correct keys. In addition, the framework supports reversible data hiding by exploiting coordinate-level redundancy, enabling secure embedding and exact extraction of auxiliary information such as timestamps, authentication tokens, or device identifiers—features that are particularly relevant for integrity verification in IoT and cloud-based applications. Experimental results demonstrate that the proposed framework effectively addresses the lack of TPE solutions for point clouds and supports adjustable encryption strength and thumbnail clarity.

The principal contributions of this paper are multifaceted:

(1)

We propose one of the first TPE frameworks specifically designed for 3D point clouds, enabling secure preview through thumbnail-level representations while preserving exact reversibility.

(2)

A uniform grid-based spatial subdivision strategy is introduced to ensure consistent encryption behavior and efficient implementation suitable for real-time and resource-constrained environments.

(3)

A deterministic, key-dependent chaotic perturbation mechanism is developed to obfuscate geometric details while allowing precise recovery of the original point cloud through inverse operations.

(4)

Reversible data hiding capability is integrated by exploiting coordinate-level redundancy, enhancing security, traceability, and integrity verification for point clouds in IoT and cloud-based applications.

The structure of this paper is as follows: Section 2 offers a comprehensive review of the relevant literature, establishing the foundation for the research. Section 3 details the method supporting the proposed algorithm. Section 4 reports the experimental results and provides an in-depth performance analysis. Finally, Section 5 concludes the paper by summarizing the key findings and proposing directions for future investigation.

2. Related Work

This section presents the fundamental knowledge required to complete this study, including the current development of TPE techniques applied to images. Further, it then introduces the approach of using spatial subdivision for multimedia security algorithms in point clouds.

2.1. TPE Techniques for Images

Existing TPE techniques for images [5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] can be broadly classified into two categories: Ideal TPE and Approximate TPE. Ideal TPE techniques aim to generate thumbnails that are visually identical to those of the original images, ensuring high fidelity for applications such as secure preview and content management. For example, Wright et al. [12] proposed an early JPEG-compatible encryption method that allows cloud platforms to extract accurate low-resolution thumbnails directly from encrypted images. This is achieved using block-based permutation and tweakable encryption, which reveal only average pixel values per block while hiding fine details. Building on the pursuit of exact thumbnail preservation, Zhao et al. [19] proposed the TPE2 scheme, which guarantees pixel-level fidelity by retaining three key pixels within each 2 × 2 block. This ensures that thumbnails generated via standard down-sampling remain exactly the same as those of the original image. Similarly, Peng et al. [9] introduced SA-TPE, a selective area-based encryption technique that encrypts only semantically sensitive regions while preserving visually important areas. This method not only maintains thumbnail fidelity but also supports full reversibility and format compliance. Collectively, these ideal TPE approaches offer strong privacy protection while retaining perfect visual usability, making them highly suitable for applications where exact thumbnail reproduction is essential.

Approximate TPE techniques, in contrast, trade strict visual fidelity for enhanced encryption efficiency, flexibility, and broader format compatibility. One such approach is TPEIP by Yang et al. [13], which maintains the sum of pixel values within image blocks to ensure that the encrypted image retains average brightness and block structure, thereby producing visually meaningful thumbnails. Ye et al. [15] proposed a noise-free method that encrypts only the lower bits of pixel values while preserving the most significant bits (MSBs) through MSB prediction, achieving high thumbnail PSNR and reversibility. Additionally, Ye et al. [14] introduced a JPEG-compatible scheme that embeds auxiliary information using data hiding techniques while preserving certain DCT coefficients, ensuring both thumbnail clarity and flexible reconstruction. Meanwhile, Zhang et al. [16] presented HF-TPE, which improves encrypted thumbnail quality by protecting critical DCT coefficients and maintaining JPEG format compliance. Extending the idea of preserving semantic content, Zhao et al. [17] developed PVME, which retains low-frequency DCT components while encrypting high-frequency details to enable coarse but interpretable thumbnails without full decryption.

To address format versatility, Fan et al. [8] proposed U-TPE, a universal and losslessly reversible scheme compatible with formats like JPEG and PNG, which decomposes images into frequency components and applies quantization and perturbation for thumbnail preservation. Chai et al. [7] followed with TPE-AP, which adjusts quantized DC and AC coefficients to flexibly control thumbnail precision and incorporates a time-varying encryption strategy for enhanced key randomness and robustness. In addition, Wang et al. [10] proposed a reversible TPE technique that combines block-based prediction, compensation, and selective region protection to optimize visual quality. From the perspective of access control, Wen et al. [11] introduced MLVPP, a multilevel visual privacy protection framework that uses hierarchical key sharing and selective DCT encryption to preserve usable thumbnails across different user levels. An et al. [5] developed a chaos-based reversible data hiding scheme that integrates TPE, allowing flexible embedding of metadata before or after encryption while improving computational efficiency. In a related effort, An et al. [6] designed a privacy-preserving image retrieval framework that extracts SURF and BRIEF features directly from encrypted images, leveraging TPE to retain structure and enable secure retrieval without decryption. Finally, Zhao et al. [18] proposed PR3, a reversible privacy protection scheme that combines TPE with data hiding to support both usability and authentication. Together, these approximate methods offer a range of design trade-offs between encryption strength, usability, format compatibility, and visual quality. Their versatility and practicality make them especially valuable for cloud storage, secure image sharing, and privacy-preserving multimedia applications.

2.2. Multimedia Security Algorithms in Point Clouds Based on Spatial Subdivision

Spatial subdivision plays a fundamental role in 3D multimedia security algorithms, serving as the structural basis for organizing geometric data and enabling secure, reversible operations. By dividing the spatial domain into manageable regions or subspaces, these techniques facilitate precise control over vertex manipulation, efficient secret embedding, and accurate model reconstruction.

Tsai [31] proposed a secret sharing technique for 3D point clouds that extends to reversible data hiding. The method begins by reading all vertices and identifying boundary points to establish a bounding volume. Vertex coordinates are then encoded as integers, and the number of required cover vertices is estimated. These integer values are used as coefficients in a $\left(t-1\right)$-degree polynomial for secret sharing, generating shares for each participant. In reconstruction, surface sampling increases the cover model’s vertex density to enable share embedding. By converting floating-point operations into integer-based encoding, the approach significantly reduces complexity. Additionally, data hiding enhances the confidentiality of shares, and the final encoding stage supports reversibility, demonstrating the potential of combining secret sharing with data hiding in point clouds. Tsai [32] also proposed a separable and reversible data hiding algorithm for encrypted 3D models, using spatial subdivision and coordinate normalization. A bounding volume is constructed based on boundary vertices, and each coordinate is normalized into the range [0, 1] by referencing the minimum boundary point. The normalized ratios are transformed into binary sequences and XORed with a pseudo-random key sequence to encrypt the model. The bounding space is then partitioned into non-overlapping regions, constraining each vertex to move within its assigned region. These regions are further subdivided and assigned spatial codes, allowing vertices to be relocated according to a secret message. The scheme supports high privacy, separability, reversibility, and efficient embedding, with controllable geometric distortion and low computational cost.

Hou et al. [33] introduced a reversible data hiding technique for encrypted mesh models, combining octree-based spatial partitioning with multiple most significant bit (multi-MSB) prediction. Using Tsai and Lin’s normalization method [34], all vertex coordinates are translated to positive values and scaled to the [0, 1] range, then quantized using a compression threshold to control detail. The mesh is partitioned via an octree, and subspaces are ranked by vertex count. For each subspace exceeding a vertex threshold, one reference vertex is selected while others are marked for embedding. Embedding capacity per vertex is estimated via multi-MSB prediction and encoded into a label map. This auxiliary data, along with vertex counts in each subspace, is compressed via Huffman coding and embedded using bit substitution. Encrypted vertex binaries are XORed with a pseudo-random key. At the receiver side, the Huffman tree is used to extract embedding capacities, and a second key encrypts the hidden message before embedding into available space. The final receiver can recover the model and extract both auxiliary and secret data. Tsai et al. [35] improved Hou’s method by addressing several limitations and enhancing embedding efficiency. Instead of using arbitrary reference vertices, their method selects the geometric center of each subspace, improving prediction accuracy and increasing the number of embeddable vertices. A new axis-wise normalization approach is introduced, optimizing coordinate range for each dimension to expand embedding space. Moreover, an adaptive octree strategy adjusts subdivision depth based on the estimated embedding demand of each subspace, enhancing flexibility. To reduce auxiliary data size, the label map and octree structure are compressed via Huffman coding. This method achieves full reversibility and 100% embedding success, with an average of 39.76 bits per point—up to 13.28% higher than Hou et al.—and demonstrates superior scalability and robustness across various 3D models.

3. Proposed Algorithm

To protect 3D point clouds while retaining limited visual usability, we propose a reversible TPE framework that combines coordinate transformation, spatial subdivision, chaotic perturbation, and reversible data embedding. The framework is designed to balance privacy protection and exact recoverability within a unified processing pipeline. As illustrated in Figure 2, the proposed method consists of two symmetric phases: encryption and decryption. During encryption, the point cloud is sequentially processed through coordinate transformation, spatial subdivision controlled by $T_S$, key-dependent chaotic perturbation governed by $K_E$ and $T_P$, and optional reversible data embedding using $K_D$. During decryption, the same parameters are applied in reverse order to enable exact recovery of both the original geometry and the embedded information. Detailed descriptions of each component are provided in the following subsections. For clarity and reproducibility, the complete encryption and decryption workflows are summarized in structured pseudocode at the end of this section.

Figure 2. Overview of the proposed reversible TPE workflow, illustrating the symmetric encryption and decryption processes.

3.1. Parameter Overview

The proposed TPE framework involves several key parameters that govern spatial subdivision, key-based perturbation, reversible data embedding, and security. To improve readability and facilitate understanding, the principal parameters used throughout the encryption and decryption processes are summarized in Table 1. These parameters are globally defined and remain fixed during encryption and decryption unless explicitly stated otherwise.

Table 1. Overview of key parameters in the proposed reversible TPE framework.

Parameter	Meaning	Role in the Algorithm	Range/Source
$m$	Coordinate precision	Specifies the fixed-point precision used to quantize original point coordinates before encryption	User-defined (e.g., number of decimal bits)
$L$	Coordinate bit length	Determines numeric precision and reversible embedding capacity	Derived from $m$
$T$	Clarity control factor	Controls thumbnail fidelity vs. privacy in view-dependent spatial subdivision	User-defined
$D$	Viewing distance	Represents the observer’s distance used to adapt spatial subdivision granularity	Application- or scenario-dependent
$T_S$	Spatial subdivision threshold	Determines the grid resolution for spatial subdivision of the point cloud	Computed from $T$ and $D$
$T_P$	Perturbation threshold	Controls chaotic displacement granularity within each spatial block	Small integer (e.g., 4–16)
$K_E$	Encryption key	Seeds key-dependent chaotic perturbation for geometric obfuscation	Secret key
$K_D$	Data hiding key	Secures embedded message bits for reversible extraction	Secret key

Let $T$ denote the user-defined clarity control factor and $D$ the viewing distance. These two parameters jointly determine the spatial subdivision threshold $T_S$, which controls the size of the spatial grid used for coarse partitioning of the point cloud. The design of $T_S$ is intended to relate spatial subdivision to perceptual visibility rather than to serve as a theoretically optimal or unique formulation. By adjusting $T_S$, the framework balances thumbnail fidelity and privacy by regulating how much global geometric structure is preserved under typical viewing conditions.

The rationale for linking $T_S$ to the viewing distance is motivated by basic principles of viewing geometry in computer graphics, where the apparent size of geometric details decreases as the viewing distance increases. By incorporating viewing distance into the determination of $T_S$, the subdivision scale adapts to perceptual sensitivity, allowing coarser partitioning when the object is viewed from afar and finer partitioning when closer inspection is required. The proposed formulation therefore serves as a perception-guided design heuristic rather than a strict theoretical optimum. Alternative perception-aware formulations could be employed without altering the overall encryption and decryption structure, provided that consistent grid partitioning and stable thumbnail visualization are maintained.

Within each spatial block defined by $T_S$, a finer subdivision is performed to support key-based perturbation. Specifically, the perturbation threshold $T_P$ determines the granularity of the mini-subspace partition inside each grid cell. Each spatial block is subdivided into $T_P^3$ mini-subspaces, and point relocation during encryption is deterministically constrained within the corresponding mini-subspace using offsets derived from the encryption key $K_E$. This constrained perturbation strategy preserves the coarse geometric structure required for thumbnail visualization while introducing key-dependent displacement at a finer scale.

As a result, $T_P$ directly controls the effective perturbation freedom within each spatial block and acts as a tuning parameter for the usability–privacy trade-off. While the maximum possible displacement of a vertex is bounded by the block size determined by $T_S$, $T_P$ governs the number and size of mini-subspaces inside each block and thus determines the admissible reallocation space for key-based perturbation. In general, a smaller $T_P$ results in fewer and larger mini-subspaces, restricting the reallocation freedom and leading to higher thumbnail stability but weaker geometric obfuscation. Conversely, a larger $T_P$ produces more and finer mini-subspaces, enlarging the reallocation search space and increasing geometric deviation at the cost of thumbnail quality. In this work, a fixed value of $T_P$ is adopted across all experiments to isolate the effect of other parameters and to ensure fair and reproducible evaluation. The selected value is chosen to maintain stable thumbnail visualization while providing nontrivial geometric scrambling.

The coordinate bit length $L$, derived from the original coordinate precision $m$, establishes the fixed-point quantization depth and the upper bound of reversible data embedding capacity. Finally, the data hiding key $K_D$ ensures secure embedding and exact extraction of auxiliary information. Through this parameterization, the proposed framework enables flexible adaptation to different application scenarios while preserving a consistent and reversible algorithmic structure.

In the proposed framework, thumbnail-preserving behavior is governed by a small set of explicit and quantifiable parameters. The spatial subdivision threshold $T_S$ determines the size of coarse grid cells and directly controls how much global geometric structure is retained in the encrypted model. The perturbation threshold $T_P$ defines the granularity of mini-subspace partitioning within each grid cell and regulates the degree of key-dependent point relocation. In addition, the viewing distance parameter $D$ affects perceptual sensitivity and is used to adaptively select $T_S$, while the coordinate precision parameter $m$ influences reversibility and embedding capacity. Together, these parameters provide direct numerical control over the trade-off between thumbnail usability and privacy protection. Their numerical values and ranges are explicitly reported in the experimental section, enabling reproducible evaluation and facilitating comparison with existing TPE schemes.

It is worth noting that dissimilar findings reported in existing encryption studies often stem from different design objectives. In schemes that do not consider thumbnail preservation, parameters controlling subdivision, perturbation, or randomness are typically configured to maximize visual distortion, resulting in encrypted outputs with minimal recognizable structure. In the proposed TPE framework, the same types of controlling factors are employed, but their numerical ranges are deliberately constrained to avoid overwhelming geometric distortion. The selected parameter values therefore reflect a usability-aware operating regime rather than an attempt to achieve full visual obfuscation. This distinction explains why the proposed method exhibits different visual and statistical characteristics compared with non-TPE approaches.

3.2. Coordinate Transformation Process

The coordinate transformation process is a pivotal component of both the encryption and decryption phases, as it ensures spatial consistency and numerical precision throughout point cloud processing. In this work, we adopt the coordinate transformation scheme proposed by Tsai and Liu [34], which enables fixed-precision representation and exact reversibility.

We first determine the bounding volume of the input point cloud by identifying its minimum and maximum boundary vertices, denoted as $B_{min}$ and $B_{max}$, respectively, as shown in Equation (1). Based on these boundary vertices, the spatial extent of the point cloud along the three coordinate axes can be characterized. Let the point cloud consist of $N_V$ points, where each point is represented by three coordinates $\left(x_i,y_i,z_i\right)$, with $i\in \left\{1, 2, \dots , N_V\right\}$.

Based on the bounding volume, all coordinates are first translated into a non-negative range to eliminate negative values, as defined in Equation (2). The translated coordinates are then normalized using a fixed-point representation. Specifically, each coordinate is scaled by a power-of-ten factor determined by the maximum number of digits in the integer part of the original coordinates, such that all relevant decimal digits are preserved deterministically. This process corresponds to a controlled fixed-point conversion rather than iterative floating-point computation, and is exactly invertible under the same precision setting. To control numerical resolution and ensure information-preserving quantization, a precision parameter $m$ is introduced to specify the number of decimal digits retained after normalization. In our implementation, $m$ is selected as the minimum integer that preserves all decimal digits present in the original point cloud coordinates. Under this fixed-point setting, the mapping from the original coordinates to the quantized representation incurs no information loss.

The normalized and quantized coordinates are subsequently converted into fixed-length binary representations to facilitate reversible processing and data embedding. Specifically, the quantized values are encoded into binary sequences of length $L$ using Equations (3) and (4), where the bit length $L$ depends on the selected precision parameter $m$, as defined in Equation (5). After this conversion, all subsequent encryption, perturbation, data embedding, and decryption operations are performed entirely in the integer domain.

Under the above formulation, perfect reversibility in this work refers to the exact recovery of the fixed-point quantized coordinate representation under the same precision parameter $m$. Since the adopted $m$ preserves all decimal digits of the original coordinates in our experiments, the original coordinate values can be exactly reconstructed without numerical ambiguity.

$$B_{min}=\left[\begin{array}{c}{x}_{min}\\ y_{min}\\ z_{min}\end{array}\right]=\left[\begin{array}{c}\underset{i\in \left\{1,2,\dots ,N_V\right\}}{\min }\left(x_i\right)\\ \underset{i\in \left\{1,2,\dots ,N_V\right\}}{\min }\left(y_i\right)\\ \underset{i\in \left\{1,2,\dots ,N_V\right\}}{\min }\left(z_i\right)\end{array}\right],B_{max}=\left[\begin{array}{c}{x}_{max}\\ y_{max}\\ z_{max}\end{array}\right]=\left[\begin{array}{c}\underset{i\in \left\{\mathrm{1,2},\dots ,N_V\right\}}{\max }\left(x_i\right)\\ \underset{i\in \left\{1,2,\dots ,N_V\right\}}{\max }\left(y_i\right)\\ \underset{i\in \left\{1,2,\dots ,N_V\right\}}{\max }\left(z_i\right)\end{array}\right]$$

(1)

$$R_i=\left[\begin{array}{c}\left(x_i-x_{min}\right)/{10}^k\\ \left(y_i-y_{min}\right)/{10}^k\\ \left(z_i-z_{min}\right)/{10}^k\end{array}\right]$$

(2)

$$C_i=\lfloor R_i\times {10}^m\rfloor$$

(3)

$$C_i={\sum }_{p=0}^{L-1}{c}_{i,p}\times 2^p$$

(4)

$$L=\{\begin{array}{cc}\hfill 8,& 1\le m\le 2\hfill \\ \hfill 16,& 3\le m\le 4\hfill \\ \hfill 32,& 5\le m\le 9\hfill \\ \hfill 64,& 10\le m\le 33\hfill \end{array}$$

(5)

3.3. Spatial Subdivision Process

This process aims to subdivide the bounding volume of the point cloud into multiple non-overlapping spatial blocks, thereby enabling fine-grained control over the magnitude and locality of subsequent chaotic perturbations. Such spatial control is critical to maintaining the structural integrity of the model and preserving a recognizable visual outline in the encrypted thumbnail.

In our implementation, we adopt a uniform grid subdivision strategy due to its simplicity, predictability, and low computational cost. The bounding volume is defined by two boundary points $B_{min}$ and $B_{max}$, representing the minimum and maximum values along each axis, respectively. The overall dimensions of the volume—length $L$, width $W$, and height $H$—are then evenly divided along each axis into $T_S$ grid intervals, each with axis size $\left(G_x,G_y,G_z\right)=\left(\lfloor L/T_S\rfloor ,\lfloor W/T_S\rfloor ,\lfloor H/T_S\rfloor \right)$, which can be automatically determined based on application requirements. This process results in a total of $T_S^3$ non-overlapping blocks, each representing a spatial unit for localized perturbation.

To improve the adaptability of the method in view-dependent environments, we provide a dynamic mechanism for computing the subdivision threshold $T_S$. Specifically, the threshold $T_S$ can be automatically derived based on the viewing distance $D$ (shown in Figure 3) and a tunable clarity parameter $T$ shown in Equation (6), where $\Vert B_{min}{B}_{max}\Vert$ is the distance between the boundary vertices $B_{min}$ and $B_{max}$. The formulation of $T_S$ is motivated by viewing geometry rather than a full human visual system (HVS) model. Specifically, it reflects the well-established principle that spatial discriminability decreases monotonically with increasing viewing distance. This abstraction is sufficient for thumbnail-level preview scenarios and avoids the computational overhead and parameter sensitivity associated with more complex HVS-based models.

$$T_S=\lceil {\displaystyle \frac{\Vert B_{min}{B}_{max}\Vert }{D\times T\times {10}^{-5}}}\rceil$$

(6)

Figure 3. The dynamic mechanism for computing the subdivision threshold $T_S$.

Importantly, because the boundaries of each subregion can be directly inferred from the global bounding volume and the threshold $T_S$, there is no need to store or transmit any additional metadata regarding the subdivision structure. The grid configuration can be reconstructed on-the-fly during both encryption and decryption. This stateless and deterministic design enables highly efficient spatial indexing and vertex assignment, making the method especially suitable for low-latency, memory-constrained applications such as edge computing and IoT systems.

3.4. Chaotic Perturbation Process

Note that the chaotic perturbation is an integral part of the encryption process and is not payload-driven. The perturbation deterministically relocates point coordinates within constrained grid cells using offsets derived from the encryption key, and does not encode any secret message. When payload embedding is enabled, it is performed as a separate stage that exploits redundancy in the transformed representation. The chaotic perturbation stage is designed to introduce key-dependent geometric displacement that obfuscates fine-grained spatial details from unauthorized users, while preserving the coarse global structure required for thumbnail visualization. As a result, this operation serves an encryption purpose rather than a data hiding function.

The process begins by further subdividing each spatial subregion into a uniform grid of $T_P^3$ mini-subspaces, where $T_P$ is the perturbation threshold. For each point $V_i=\left(x_i,y_i,z_i\right)$, the indices of its corresponding subspace $\left(n_{ix},n_{iy},n_{iz}\right)=\left(\lfloor x_i/G_x\rfloor ,\lfloor y_i/G_y\rfloor , \lfloor z_i/G_z\rfloor \right)$ are determined, along with the dimensions of each mini-subspace $\left(s_x,s_y,s_z\right)=\left(\lfloor G_x/T_P\rfloor ,\lfloor G_y/T_P\rfloor ,\lfloor G_z/T_P\rfloor \right)$. These values define the local bounds within which the point can be perturbed. Here, $T_S$ determines the maximum admissible displacement range of each vertex by defining the spatial block size, whereas $T_P$ further subdivides each block into finer movable regions that constrain where a vertex can be relocated during chaotic perturbation. As a result, $T_S$ controls the overall perturbation amplitude, while $T_P$ provides finer-grained adjustment of the privacy–usability trade-off within the bounded perturbation range.

To generate the offset values, we adopt the logistic map, a well-known chaotic system defined in Equation (7). For each 3D model, a model-specific chaotic sequence is initialized using the encryption key $K_E$ and a model identifier $ID$. Specifically, the concatenation of $K_E$ and $ID$ is processed by a cryptographic hash function (SHA-256 in this implementation) to produce a 256-bit hash value. Two non-overlapping 32-bit segments, denoted as $H_0$ and $H_1$, are extracted from the hash output and interpreted as unsigned integers. The initial state of the logistic map is obtained by normalizing $H_0$ to the interval (0, 1) as shown in Equation (8). The logistic map is employed solely as a lightweight perturbation generator within a bounded spatial framework, and its chaotic behavior is not relied upon as a standalone cryptographic primitive. The control parameter $r^{ID}$ is derived in the same manner from $H_1$, ensuring that the initial state and control parameter are independently determined from disjoint hash segments. All chaotic iterations are performed using fixed-precision arithmetic consistent with the coordinate quantization parameter $m$, ensuring deterministic and reproducible perturbation during both encryption and decryption.

Although more complex hyper-chaotic systems, including fractional-order Hopfield neural networks and memristive chaotic maps, have demonstrated enhanced cryptographic strength in full-encryption settings, their adoption was carefully considered in this work. Under the TPE paradigm, perturbation magnitude and spatial locality must be tightly controlled to ensure stable thumbnails and exact reversibility. Preliminary evaluation indicated that high-dimensional or strongly chaotic dynamics tend to introduce excessive or less predictable geometric displacement, which may undermine bounded perturbation requirements. Consequently, a one-dimensional logistic map is adopted as a lightweight and controllable perturbation generator, rather than as a standalone cryptographic primitive. To mitigate finite-precision degradation, the chaotic sequence is initialized using a hash-based key derivation strategy and generated under fixed-precision arithmetic consistent with coordinate quantization. This design ensures deterministic behavior, strong key sensitivity, and reproducibility during both encryption and decryption. The integration of more advanced chaotic systems remains a promising direction for future extensions of the proposed framework.

$$x_{n+1}^{ID}=r^{ID}{x}_n^{ID}\left(1-x_n^{ID}\right), 0<x_0^{ID}<1, 3.57<r^{ID}<4$$

(7)

$$\{\begin{array}{cc}\hfill x_0^{ID}=& \left(H_0+1\right)/\left(2^{32}+1\right) \hfill \\ \hfill r^{ID}=& 3.57+0.43\times \left(H_1+1\right)/\left(2^{32}+1\right)\hfill \end{array}$$

(8)

Once initialized, the logistic map is iteratively evaluated to generate a chaotic sequence. For each vertex $V_i=(x_i,y_i,z_i)$, three consecutive chaotic values $({\delta }_{ix}, {\delta }_{iy}, {\delta }_{iz})$ are taken from the sequence and scaled to produce the discrete offsets $\left(d_{ix},d_{iy},d_{iz}\right)$, as defined in Equation (9). These offsets ensure that the perturbed point remains within the bounds of its mini-subspace. The final perturbed coordinates are computed using a deterministic formula shown in Equation (10), where ${∆}_i =({∆}_{ix}, {∆}_{iy}, {∆}_{iz})$ represents the original mini-subspace indices of vertex $i$ within its local subspace, each ranging from 0 to $T_P-1$, and defining the vertex’s relative position among the $T_P$ partitions along the three spatial axes.

$$\left(d_{ix},d_{iy},d_{iz}\right)=\left(\lfloor {\delta }_{ix}\times T_P\rfloor ,\lfloor {\delta }_{iy}\times T_P\rfloor ,\lfloor {\delta }_{iz}\times T_P\rfloor \right)$$

(9)

$$V_i^{\prime }=\left[\begin{array}{c}{x}_i^{\prime }\\ y_i^{\prime }\\ z_i^{\prime }\end{array}\right]=\left[\begin{array}{c}{x}_i+\left(\left({∆}_{ix}+d_{ix}\right) mod T_P-{∆}_{ix}\right)\times s_x\\ y_i+\left(\left({∆}_{iy}+d_{iy}\right) mod T_P-{∆}_{iy}\right)\times s_y\\ z_i+\left(\left({∆}_{iz}+d_{iz}\right) mod T_P-{∆}_{iz}\right)\times s_z\end{array}\right]$$

(10)

Due to the sensitivity of chaotic systems to their initial conditions, the generated perturbation offsets are deterministic yet highly dependent on the encryption key. Given the same encryption key $K_E$ and model identifier $ID$, the same chaotic sequence can be regenerated during decryption, allowing the perturbation offsets to be reproduced in the same order. As a result, the original geometry can be precisely restored by applying the inverse perturbation process.

Taking the 2D subspace in Figure 4 as an example, suppose the space contains a total of five vertices. With the subdivision threshold $T_P$ set to 4, the space is divided into 16 smaller subspaces arranged in a 4 × 4 grid. Among these, one vertex is in each of the subspaces indexed as $(0, 0)$, $(1, 2)$, and $(2, 0)$, while two vertices fall within the subspace indexed as $(1, 1)$. By assigning intermediate offset vectors within each mini-subspace, the perturbation results are illustrated in the diagram on the right, showing how each vertex is randomly shifted yet remains confined within its respective mini-region. This setup ensures both encryption randomness and structural consistency for thumbnail preservation.

Figure 4. Example of chaotic perturbation for five points within one block, where black dots indicate original positions, colored dots denote perturbed positions, and arrows represent the applied offset vectors.

To ensure consistent bounding volume dimensions and to prevent grid misalignment during the encryption and decryption processes, a small subset of vertices located exactly on the boundary of the point cloud is intentionally excluded from perturbation. These boundary points act as spatial references that define the bounding volume and must remain unchanged to guarantee stable coordinate normalization and reliable geometry recovery. The total number of such points is denoted as $N_{BP}$. In addition, during spatial subdivision and chaotic perturbation, certain vertices located on the outermost edges of subdivided blocks or mini-subspaces are also excluded from displacement. These points serve as structural anchors that ensure consistent grid partitioning and unambiguous mini-subspace indexing. Unrestricted perturbation of such edge vertices would destabilize grid boundaries and compromise exact reversibility. We denote the number of spatial subdivision boundary points as ${NE}_1$, and the number of chaotic perturbation boundary points as ${NE}_2$. It is important to note that these non-perturbed vertices do not encode key-dependent information and are determined solely by the spatial configuration and subdivision parameters rather than by the encryption key itself. Consequently, they do not form a deterministic fingerprint that could be exploited to infer the original geometry or weaken security. By selectively excluding these boundary cases, the proposed method improves encryption stability and ensures accurate recovery, while having minimal impact on overall perturbation effectiveness and security.

In the proposed framework, chaotic perturbation is applied to all non-boundary points that satisfy the subdivision and relocation conditions. Boundary points that define the global bounding volume or lie on subdivision edges are intentionally excluded to prevent ambiguity and ensure numerical stability. The indices and total counts of such points are recorded as auxiliary information and reused during decryption. Because all perturbations are generated deterministically from the encryption key and applied within bounded integer-domain constraints, the encryption and decryption processes are perfectly aligned. No numerical accumulation or floating-point drift occurs, and the original point cloud can be exactly recovered.

3.5. Reversible Data Embedding Process

As previously mentioned, to ensure that the proposed technique supports complete recovery of the original model, we first apply a coordinate transformation process to the floating-point coordinate values, converting each dimension—$x$, $y$, and $z$—into binary integers of length $L$. In fact, if the original coordinate is an $m$-digit decimal number, the number of bits actually required to represent it in binary is only $\lceil {\log }_2{10}^m\rceil$. The difference between the fixed bit length $L$ and this actual requirement is defined as the basic embedding length, denoted as ${EL}_B=L-\lceil {\log }_2{10}^m\rceil$, a term introduced in the method by Tsai and Liu [34]. These trailing bits, which are originally zero in the integer coordinates, are considered redundant and thus suitable for embedding auxiliary information, since they can be freely altered and restored to zero during recovery. However, Tsai and Liu’s approach targets encrypted models, in which modifying MSBs during data embedding does not affect the model’s visual appearance due to the destruction of its original geometry. In contrast, our current study focuses on TPE for point clouds, where directly altering MSBs would distort geometric shape and visual features, rendering the embedded model unusable. Therefore, we propose a modified embedding strategy that enables message embedding without compromising the original precision.

The core idea of our method is to embed a secret message into the transformed coordinate value $C_i$ by scaling it with a factor of $2^{{EL}_B}$, as shown in Equation (11). The ${EL}_B$-bit secret message $SM$, represented as a decimal value, is first XORed with a binary sequence generated from the hiding key $K_D$, then inserted into the least significant ${EL}_B$ bits of the coordinate. This operation preserves the MSBs of the original coordinate, ensuring minimal distortion, while using the lower bits for data embedding. The resulting embedded coordinate $C_i^{\prime }$ remains an integer, enabling efficient and reversible processing. During decoding, the original coordinate $C_i$ is recovered by performing integer division of $C_i^{\prime }$ by $2^{{EL}_B}$, as shown in Equation (12), which automatically discards the embedded bits. The secret message can then be extracted via a modulo operation, as in Equation (13), retrieving the embedded bits from the least significant positions.

$$C_i^{\prime }=C_i\times 2^{{EL}_B}+SM$$

(11)

$$C_i=\lfloor C_i^{\prime }/2^{{EL}_B}\rfloor$$

(12)

$$SM=C_i^{\prime } mod 2^{{EL}_B}$$

(13)

In summary, the proposed mechanism provides a simple, reversible, and visually lossless approach to data embedding. Because both embedding and recovery involve only integer arithmetic, the method is computationally efficient and flexible in implementation—particularly suitable for unencrypted 3D models. By leveraging the redundancy in the least significant bits (LSBs) of integer coordinates, our approach ensures robust, reversible embedding with high fidelity and practical utility.

The decryption process is designed to fully recover both the original 3D point cloud and the embedded secret message, ensuring perfect reversibility and data integrity. It comprises three main stages: data extraction, spatial subdivision, and coordinate reversion, as detailed below. The process begins with data extraction. For each encrypted point, the LSBs of its transformed coordinates are extracted to recover the embedded message. Using the same hiding key $K_D$ as in the embedding phase, a pseudo-random binary sequence is regenerated and XORed with the extracted bits, allowing the retrieval of the original secret message. This ensures that only users with the correct key can access the hidden information. Next, the point cloud undergoes spatial subdivision using the same subdivision threshold $T_S$ as used during encryption. The encrypted model’s bounding volume is re-partitioned into uniform subregions, and each point is reassigned to its original block based solely on its coordinates, without the need for auxiliary metadata. This step restores the spatial context required for correct decryption. In the coordinate reversion phase, the encrypted coordinates are restored to their original positions using the inverse of the chaotic perturbation process. For each point, a unique chaotic sequence is regenerated by reinitializing the logistic map with the encryption key $K_E$ and model identifier $ID$ as in the encryption phase. The chaotic sequence is generated once per model and consumed deterministically in the same order during both encryption and decryption. The chaotic parameter $r^{ID}$ and initial value $x_0^{ID}$ are derived as defined in Equation (7), ensuring consistency with the encryption phase. The logistic sequence is then used to reproduce the offset vector $\left(d_{ix},d_{iy},d_{iz}\right)$, which is applied in reverse to accurately recover each point’s pre-encryption position within its corresponding mini-subspace. Finally, in the model recovery stage, the original coordinate values are reconstructed by removing the embedded bits. Since the embedding process involved scaling the coordinates by a factor of $2^{{EL}_B}$, recovery is achieved by performing an integer division (as defined in Equation (12)) to discard the embedded LSBs while preserving the higher-order bits. This operation enables exact restoration of the original point cloud geometry. Through this sequence of steps, the proposed framework guarantees lossless recovery of both the 3D model and embedded data, providing a secure, reversible, and efficient solution for point cloud encryption in applications such as IoT and cloud-based 3D data sharing.

3.6. Pseudocode of the Proposed Encryption and Decryption Algorithms

The complete encryption and decryption procedures of the proposed framework are summarized in pseudocode form in Figure 5 and Figure 6 to improve clarity and reproducibility.

Figure 5. The pseudo code of the proposed encryption procedure.

Figure 6. The pseudo code of the proposed decryption procedure.

3.7. Complexity Analysis

The proposed reversible TPE framework is constructed using localized, per-point operations and does not require global optimization, neighborhood traversal, or iterative refinement. As a result, both the encryption and decryption processes scale linearly with respect to the number of points.

During encryption, coordinate normalization and fixed-precision quantization are applied independently to each point using basic arithmetic operations, yielding linear time complexity. Spatial subdivision assigns each quantized point to a block according to the subdivision threshold $T_S$, which involves simple integer computations and indexing and therefore also scales linearly. Chaotic perturbation is performed within each spatial block in a point-wise manner, where bounded displacements are computed using key-dependent parameters and fixed-precision arithmetic without inter-point dependency. Consequently, the perturbation stage incurs constant computational cost per point. Reversible data embedding and extraction operate directly on the quantized coordinate representation through bit-level manipulation, and the number of operations per point is bounded by the coordinate bit length $L$. Combining these stages, the overall computational complexity of both encryption and decryption is $O\left(N_V\right)$.

In terms of memory usage, the framework stores only the quantized coordinates, embedded data, and a small number of global parameters, without constructing auxiliary structures such as adjacency graphs or spatial trees. Therefore, the memory complexity also grows linearly with the input size. This linear time and space behavior demonstrates that the proposed framework is computationally lightweight and suitable for large-scale point clouds, while preserving reversibility and thumbnail usability.

This linear complexity and low memory footprint make the proposed framework suitable for deployment in resource-constrained IoT and edge computing environments.

4. Experimental Results and Performance Evaluation

This section presents the experimental evaluation and performance analysis of the proposed reversible TPE framework for 3D point clouds. The experiments are designed to assess the proposed method from multiple perspectives, including thumbnail usability, privacy–usability trade-offs, embedding capacity, computational efficiency, and security-related characteristics. Both quantitative metrics and qualitative visual results are reported to demonstrate the effectiveness, robustness, and practicality of the proposed approach under different parameter settings and viewing conditions.

Specifically, the experimental evaluation is organized as follows. First, the experimental setup and datasets are described, including implementation details, test models, and their fundamental properties. Second, the resulting embedding capacity are analyzed to illustrate the reversibility and data hiding capability of the framework. Third, the impact of different subdivision thresholds on thumbnail preservation and visual usability is examined. Fourth, the effectiveness of automatically determined subdivision thresholds under varying viewing distances is evaluated using geometry- and image-based similarity metrics. Fifth, the effect of the perturbation threshold $T_P$ on geometric distortion and thumbnail stability is investigated to analyze its role in controlling bounded perturbation within each subdivision cell. Sixth, the computational efficiency of the proposed framework is analyzed through runtime breakdowns across different processing stages. Seventh, security-oriented evaluations are conducted to examine key sensitivity and resistance to unauthorized reconstruction under the TPE threat model. Eighth, statistical security characteristics are investigated through coordinate distribution and spatial deviation analyses. Finally, a comparative analysis with existing image-based TPE and conventional 3D encryption approaches is provided, followed by a discussion to highlight the advantages, limitations, and applicability of the proposed framework.

4.1. Experimental Setup and Datasets

The algorithm was implemented using MATLAB R2023b and executed on a personal computer equipped with an AMD Ryzen™ 7 9800X3D 4.7 GHz CPU and 64 GB of memory. Twenty distinct point clouds were selected as test cases, with key attributes—such as the number of points $N_V$, and model dimensions—summarized in Table 2. Figure 7 provides visual representations of each point cloud.

Table 2. The relative information for the test models.

Model Name	$\mathit{m}$	${\mathit{N}}_{\mathit{V}}$	Length	Width	Height	${\mathit{N}}_{\mathit{B}\mathit{P}}$	$\mathit{E}\mathit{C}$
Armadillo	9	172,974	127.0002	151.3219	115.4285	6	6
Brain	9	294,012	641.227	560.885	529.196	6	6
Bunny	8	34,834	15.5699	15.43336	12.06733	6	15
Cow	8	46,433	11.49294	14.97753	23.9384	6	15
Dinosaur	6	56,194	11.6532	29.4042	34.7688	6	36
Dragon	8	437,645	409.7804	288.887	183.2436	6	15
DragonFusion	9	450,227	139.3779	178.9935	131.0554	6	6
Elephant	9	19,753	54.6444	71.66026	113.1929	9	6
Gear	8	250,000	93.4989	97.69596	58.25269	6	15
GolfBall	9	122,882	998.982	999.058	999.734	16	6
Hand	8	327,323	132.5423	92.84962	45.5031	93	15
HappyBuddha	9	543,652	203.305	495.0573	203.5445	6	6
Horse	6	48,485	8.4006	18.3342	15.2836	7	36
Lion	9	183,408	117.9447	64.13302	47.84499	6	6
Rabbit	5	67,038	29.724	34.754	70.7	9	45
RockerArm	5	40,177	40.396	23.816	78.464	6	45
Screw	9	44,511	41.35089	101.6667	91.5195	6	6
Teeth	6	116,604	35.452	13.579	26.054	8	36
VenusBody	8	19,847	131.7964	456.6276	132.3554	108	15
VenusHead	6	134,345	13.8224	19.8152	19.8676	7	36

Figure 7. Test models used in our experiments.

In all experiments, the coordinate precision parameter $m$ is selected to be sufficiently large to preserve all decimal digits present in the original point cloud coordinates. After normalization, each coordinate is mapped to a fixed-point integer representation with bit length $L$ derived from $m$, ensuring that no information loss occurs during quantization prior to encryption. Under this setting, all subsequent encryption, perturbation, data embedding, and decryption operations are carried out in the integer domain.

4.2. Embedding Capacity Analysis

Table 2 presents the detailed attributes of the twenty point clouds used for evaluation, including the number of points $N_V$, geometric dimensions (Length, Width, Height), the number of boundary points $N_{BP}$, and the embedding capacity $EC$ per point. As described in Equation (5), the parameter $m$, representing the maximum number of decimal digits in the original coordinates, directly influences the binary length $L$, and consequently affects the available embedding capacity $EC$. According to the embedding scheme introduced in Section 3.4, each point can accommodate between 6 and 45 bits of secret data through reversible data hiding, depending on the value of $m$. The table also highlights the number of boundary vertices, which are essential for constructing the bounding volume during coordinate transformation. Models with more boundary points, such as Hand (93) and VenusBody (108), potentially result in more complex or flexible spatial partitioning during encryption. Additionally, the diversity in model sizes—from compact ones like Horse and Bunny to large-scale models such as GolfBall and Brain—demonstrates the robustness of the proposed method across a wide range of geometric scales and data densities. Notably, high-precision models (e.g., Rabbit and RockerArm) with small $m$ values exhibit higher embedding capacities, reinforcing the method’s adaptability and effectiveness in supporting fine-grained reversible embedding across diverse 3D datasets.

4.3. Impact of Manual Clarity Control T

Figure 8 illustrates the encryption results of four different 3D models under varying threshold settings, highlighting the trade-off between usability and privacy. As the threshold value increases from 1 to 100, the visual fidelity of the thumbnail progressively decreases, demonstrating stronger encryption and higher privacy at the cost of reduced model usability. At a low threshold $T$ (e.g., 1 or 15), the encrypted thumbnails closely resemble the original models, preserving clear geometric structures and enabling effective preview—ideal for scenarios prioritizing usability. As the threshold increases to 30 and 50, visual distortion becomes more noticeable, particularly in finer features, indicating a shift toward better obfuscation. At the highest setting (100), the models are heavily distorted, and most recognizable details are lost, ensuring strong privacy protection. This visual progression confirms the method’s flexibility in balancing visual accessibility and data confidentiality by tuning the threshold parameter, allowing adaptive encryption based on different application needs.

Figure 8. Encryption results with different threshold setting considering usability and privacy.

4.4. View-Distance-Aware Subdivision Results

Table 3, Table 4 and Table 5 present the experimental results of the proposed method under three viewing distances: original, double, and triple. Key indicators include $T_s$ (the subdivision threshold), ${NE}_1$ and ${NE}_2$ (the number of points and coordinates falling on the boundaries of the first and second-level subdivided blocks, respectively), and three metrics for visual quality: Peak Signal-to-Noise Ratio (PSNR), Normalized Root Mean Square Error (NRMSE), and Normalized Hausdorff Distance (NHD), defined in (14), (15), and (16). As the viewing distance increases, the subdivision threshold $T_s$ gradually decreases for most models, indicating that larger viewing distances require less granular partitioning to achieve sufficient thumbnail fidelity. Correspondingly, the number of boundary points ${NE}_1$ and boundary coordinates ${NE}_2$ also decreases, reducing the structural ambiguity introduced by block edges. This trend contributes to significant improvements in visual quality metrics. Specifically, the PSNR value is computed between 2D snapshots rendered from the original and encrypted 3D models under a fixed viewing direction, simulating the visual fidelity of thumbnails. PSNR values increase consistently across all models with growing viewing distances, reflecting reduced noise and improved similarity between encrypted and original models. For instance, HappyBuddha improves from 39.20 dB (Table 3) to 55.13 dB (Table 5), while Teeth reaches an exceptionally high PSNR of 58.84 dB under triple viewing distance. Similarly, NRMSE values remain low across all cases due to normalization to the [0, 1] range, further decreasing as visibility constraints relax. NHD, which evaluates geometric deviation, also shows stable or slightly increasing trends at higher distances. Though these increases appear counterintuitive, they reflect more global but visually tolerable perturbations. Overall, the results confirm that under extended viewing distances, the method achieves better visual consistency (higher PSNR and lower NRMSE), while still maintaining privacy through moderate perturbations. The observed variations in ${NE}_1$ and ${NE}_2$ also highlight the method’s adaptability to model complexity and spatial distribution.

$$NHD\left(M_1,M_2\right)=\mathrm{m}\mathrm{a}\mathrm{x}(h\left(M_1,M_2\right),h\left(M_2,M_1\right))$$

(14)

$$h\left(M_1,M_2\right)=\underset{x\in M_1}{\max }\underset{y\in M_2}{\min }\Vert x-y\Vert$$

(15)

$$NRMSE=\sqrt{\left({\sum }_{i=1}^{N_V}{\Vert v_i^{\left(1\right)}-v_i^{\left(2\right)}\Vert }^2\right)/N_V}$$

(16)

Table 3. The relative information under the original viewing distance.

Model Name	${\mathit{T}}_{\mathit{s}}$	${\mathit{N}\mathit{E}}_1$	${\mathit{N}\mathit{E}}_2$	PSNR	NRMSE	NHD
Armadillo	1691	1	16	37.04	4.35 × 10−4	1.08 × 10−3
Brain	1817	0	12	36.10	3.86 × 10−4	8.43 × 10−4
Bunny	1795	2	36	41.31	4.04 × 10−4	8.98 × 10−4
Cow	1545	0	83	40.53	4.91 × 10−4	1.14 × 10−3
Dinosaur	843	95	1460	40.10	9.35 × 10−4	2.13 × 10−3
Dragon	1891	1	172	34.06	4.02 × 10−4	9.45 × 10−4
DragonFusion	1595	0	44	35.55	4.43 × 10−4	9.93 × 10−4
Elephant	1627	0	9	44.67	4.31 × 10−4	9.19 × 10−4
Gear	1716	0	69	35.44	4.16 × 10−4	9.75 × 10−4
GolfBall	1823	0	0	36.58	3.84 × 10−4	8.33 × 10−4
Hand	1903	54	4574	36.12	3.79 × 10−4	7.95 × 10−4
HappyBuddha	1218	0	18	39.20	5.82 × 10−4	1.31 × 10−3
Horse	1215	171	7343	42.12	5.41 × 10−4	1.25 × 10−3
Lion	1736	0	7	36.27	4.06 × 10−4	9.09 × 10−4
Rabbit	1555	544	35,914	41.51	3.92 × 10−4	9.35 × 10−4
RockerArm	1540	2586	22,049	44.18	3.76 × 10−4	1.00 × 10−3
Screw	967	0	1	41.74	7.51 × 10−4	1.63 × 10−3
Teeth	1204	10,108	2139	40.47	5.59 × 10−4	1.35 × 10−3
VenusBody	1137	0	15	46.65	6.30 × 10−4	1.36 × 10−3
VenusHead	1508	520	10,793	38.23	4.46 × 10−4	9.92 × 10−4

Table 4. The relative information under double the original viewing distance.

Model Name	${\mathit{T}}_{\mathit{s}}$	${\mathit{N}\mathit{E}}_1$	${\mathit{N}\mathit{E}}_2$	PSNR	NRMSE	NHD
Armadillo	846	0	4	42.01	8.89 × 10−4	2.28 × 10−3
Brain	909	0	8	41.09	7.72 × 10−4	1.69 × 10−3
Bunny	898	0	13	42.46	8.03 × 10−4	1.77 × 10−3
Cow	773	2	22	42.99	9.07 × 10−4	1.96 × 10−3
Dinosaur	422	42	1129	44.73	1.67 × 10−3	3.70 × 10−3
Dragon	946	1	67	40.92	7.44 × 10−4	1.65 × 10−3
DragonFusion	798	0	31	45.95	8.80 × 10−4	1.91 × 10−3
Elephant	814	0	1	46.46	8.67 × 10−4	1.83 × 10−3
Gear	858	0	40	41.86	8.18 × 10−4	1.78 × 10−3
GolfBall	912	0	0	39.51	7.68 × 10−4	1.66 × 10−3
Hand	952	18	79	43.75	7.30 × 10−4	1.59 × 10−3
HappyBuddha	609	0	9	49.74	1.15 × 10−3	2.50 × 10−3
Horse	608	57	2113	48.43	1.13 × 10−3	2.44 × 10−3
Lion	868	0	4	41.08	8.18 × 10−4	1.90 × 10−3
Rabbit	778	500	18,189	46.98	7.83 × 10−4	1.77 × 10−3
RockerArm	770	2362	12,502	46.99	7.39 × 10−4	1.79 × 10−3
Screw	484	0	1	43.98	1.46 × 10−3	3.25 × 10−3
Teeth	602	1981	1085	49.17	1.15 × 10−3	2.51 × 10−3
VenusBody	569	0	7	49.18	1.26 × 10−3	2.68 × 10−3
VenusHead	754	209	11,679	45.96	8.88 × 10−4	2.00 × 10−3

Table 5. The relative information under triple the original viewing distance.

Model Name	${\mathit{T}}_{\mathit{s}}$	${\mathit{N}\mathit{E}}_1$	${\mathit{N}\mathit{E}}_2$	PSNR	NRMSE	NHD
Armadillo	564	0	3	49.03	1.27 × 10−3	2.88 × 10−3
Brain	606	0	0	46.03	1.16 × 10−3	2.54 × 10−3
Bunny	599	0	7	44.00	1.20 × 10−3	2.77 × 10−3
Cow	515	0	14	45.68	1.37 × 10−3	2.93 × 10−3
Dinosaur	281	20	1356	51.17	2.46 × 10−3	5.36 × 10−3
Dragon	631	0	25	49.66	1.11 × 10−3	2.38 × 10−3
DragonFusion	532	0	18	54.31	1.32 × 10−3	2.83 × 10−3
Elephant	543	0	2	48.23	1.29 × 10−3	2.65 × 10−3
Gear	572	0	13	48.54	1.23 × 10−3	2.70 × 10−3
GolfBall	608	0	0	43.41	1.15 × 10−3	2.49 × 10−3
Hand	635	19	126	52.76	1.10 × 10−3	2.34 × 10−3
HappyBuddha	406	0	1	55.13	1.73 × 10−3	3.73 × 10−3
Horse	405	82	2169	56.38	1.69 × 10−3	3.57 × 10−3
Lion	579	0	4	48.72	1.21 × 10−3	2.66 × 10−3
Rabbit	519	208	3070	55.68	1.32 × 10−3	3.02 × 10−3
RockerArm	514	1039	8133	51.06	1.20 × 10−3	2.73 × 10−3
Screw	323	0	0	46.77	2.17 × 10−3	4.66 × 10−3
Teeth	402	1671	662	58.84	1.73 × 10−3	3.73 × 10−3
VenusBody	379	0	6	50.95	1.86 × 10−3	4.00 × 10−3
VenusHead	503	229	1923	55.51	1.38 × 10−3	2.99 × 10−3

Figure 9 and Figure 10 offer intuitive visualizations of the proposed method’s effectiveness in adapting to various viewing distances through automatic threshold adjustment. Each figure showcases two representative models and their corresponding encrypted versions under three different view scales (original, double, and triple), along with key evaluation metrics: subdivision threshold $T_s$, PSNR, NRMSE, and NHD. As the viewing distance increases, the subdivision threshold $T_s$ systematically decreases, allowing larger spatial perturbations while still preserving the overall visual appearance of the encrypted models. This trade-off is evident in the PSNR values, which improve significantly with increased distance—from 37.04 dB to 49.03 dB for the Armadillo model and from 34.06 dB to 49.66 dB for the Dragon model. Similarly, Gear and Lion models in Figure 9 show PSNR enhancements from 35.44 dB and 36.27 dB, respectively, to above 48 dB. The NRMSE values also exhibit a steady increase with greater perturbation, while remaining within visually acceptable limits. Meanwhile, NHD reflects how structural differences accumulate as viewing distance increases, rising moderately across all cases but maintaining geometric coherence. These visual results reinforce the method’s adaptability: at closer viewing distances, higher subdivision thresholds ensure finer detail retention, while at further distances, coarser partitions suffice for preserving geometric features in thumbnails. Ultimately, these figures demonstrate that the proposed encryption scheme can effectively balance privacy and usability through view-aware parameter tuning.

Figure 9. Threshold determination under various viewing distances for Armadillo and Dragon models.

Figure 10. Threshold determination under various viewing distances for Gear and Lion models.

4.5. Effect of Perturbation Threshold $T_P$

This subsection examines the influence of the subspace resolution parameter $T_P$ on geometric distortion and visual quality. From a security perspective, this analysis also characterizes how $T_P$ affects privacy strength by increasing reconstruction difficulty under incorrect keys, while preserving thumbnail-level usability. As introduced in Section 3, $T_P$ determines how each $T_S$-defined grid cell is further subdivided, thereby controlling the resolution of the index-based cyclic permutation applied within the cell. While $T_S$ governs the maximum allowable perturbation range, $T_P$ affects only the internal rearrangement granularity.

Table 6 reports the NRMSE and PSNR values obtained under different $T_P$ and clarity factor $T$ settings for Armadillo model with the original viewing distance. These metrics are used here as quantitative indicators of reconstruction error under the TPE threat model, where larger geometric deviation corresponds to stronger privacy protection. When $T_P=1$, no subspace subdivision is performed, and the encryption reduces to an identity mapping, resulting in zero NRMSE and infinite PSNR for all $T$. This confirms the correctness of the baseline behavior.

Table 6. Quantitative evaluation of reconstruction distortion under different spatial subdivision thresholds $T$ and perturbation thresholds $T_P$, measured by NRMSE and PSNR.

	$\mathit{T}$	NRMSE					PSNR
${\mathit{T}}_{\mathit{P}}$		1	15	30	50	100	1	15	30	50	100
1		0.00000	0.00000	0.00000	0.00000	0.00000	Inf	Inf	Inf	Inf	Inf
2		0.00039	0.00542	0.01074	0.01801	0.03602	37.58	35.64	35.94	35.51	34.89
4		0.00042	0.00607	0.01197	0.02011	0.04031	37.14	35.32	35.04	34.80	34.32
8		0.00044	0.00621	0.01227	0.02059	0.04127	37.08	35.26	34.98	34.74	34.17
16		0.00044	0.00626	0.01233	0.02071	0.04148	37.06	35.23	34.97	34.66	34.17
32		0.00045	0.00626	0.01236	0.02072	0.04154	37.01	35.22	34.95	34.66	34.15
64		0.00045	0.00627	0.01237	0.02071	0.04155	37.07	35.21	34.95	34.66	34.14

For $T_P>1$, increasing $T_P$ initially introduces noticeable geometric perturbation. For example, at $T=30$, the NRMSE increases from 0.01074 at $T_P=2$ to 0.01197 at $T_P=4$, while PSNR decreases from 35.94 dB to 35.04 dB. This increase in geometric deviation indicates enhanced resistance to fine-grained geometric reconstruction without the correct key, corresponding to improved privacy strength. However, as $T_P$ continues to increase, both metrics quickly converge. When $T_P\ge 8$, NRMSE and PSNR remain nearly constant under the same $T$, with differences below 0.1 dB in PSNR across all tested cases. This convergence suggests that privacy enhancement reaches a stable upper bound under fixed spatial subdivision, preventing excessive or unpredictable distortion.

This saturation behavior arises from the bounded nature of the proposed perturbation mechanism. Since all vertex displacements are confined within the same $T_S$-determined grid cell, the maximum geometric deviation is limited by $T_S$. Increasing $T_P$ beyond a moderate value only refines the discrete permutation resolution within the cell, without expanding the overall perturbation range.

Across all $T_P$ settings, increasing the clarity factor $T$ leads to larger $T_S$, resulting in higher NRMSE and lower PSNR. In contrast, under a fixed $T$, the influence of $T_P$ becomes marginal once saturation is reached. These results indicate that $T_S$ is the dominant parameter governing the privacy–usability trade-off, while $T_P$ primarily provides fine-grained control over internal rearrangement without compromising thumbnail stability. Accordingly, $T_P$ serves as a secondary control parameter that enhances privacy strength in a predictable and bounded manner, complementing the primary role of $T_S$.

4.6. Runtime Evaluation

Table 7 presents the runtime breakdown of the proposed framework across different point clouds, illustrating the computational cost of each processing stage. The coordinate transformation stage reports two timings depending on whether the coordinate precision parameter $m$ is precomputed in advance or derived dynamically, where precomputation consistently reduces the transformation overhead. Spatial subdivision introduces only a small and stable runtime cost across all datasets, reflecting its reliance on simple index-based operations. The chaotic perturbation stage dominates the overall runtime, as it involves per-point arithmetic driven by key-dependent chaotic sequences. Nevertheless, the measured runtimes increase proportionally with model size and remain consistent across different geometries, confirming the linear scalability predicted by the complexity analysis.

Table 7. Runtime breakdown (in seconds) of the coordinate transformation, spatial subdivision, and chaotic perturbation stages of the proposed reversible TPE framework for different point clouds.

Model Name	Coordinate Transformation	Spatial Subdivision	Chaotic Perturbation
Armadillo	0.007274/0.752707	0.001528	0.110528
Brain	0.008394/1.265979	0.000984	0.182539
Bunny	0.001024/0.148681	0.000353	0.022815
Cow	0.001389/0.189504	0.000369	0.029631
Dinosaur	0.001872/0.235154	0.000465	0.036637
Dragon	0.009335/1.920297	0.001287	0.266061
DragonFusion	0.012631/1.948283	0.001415	0.276468
Elephant	0.000837/0.079061	0.000310	0.013418
Gear	0.005725/1.067641	0.000892	0.154520
GolfBall	0.003898/0.527345	0.000659	0.078343
Hand	0.006904/1.405312	0.001378	0.212224
HappyBuddha	0.014786/2.398113	0.001416	0.331958
Horse	0.001327/0.200894	0.000300	0.031316
Lion	0.005501/0.799270	0.000831	0.112856
Rabbit	0.002087/0.273052	0.000469	0.043068
RockerArm	0.001276/0.163055	0.000491	0.025363
Screw	0.001611/0.194575	0.000348	0.028694
Teeth	0.002819/0.511724	0.000677	0.073380
VenusBody	0.000629/0.073885	0.000294	0.014086
VenusHead	0.003268/0.595780	0.000640	0.083939

4.7. Security-Oriented Evaluation

Under the TPE paradigm, the threat model differs fundamentally from that of conventional cryptographic encryption. In this work, the adversary is assumed to have access to the encrypted point cloud and the encryption algorithm, but not the secret keys. Controlled leakage of coarse structural information is intentionally permitted by design, while security is defined as the inability to accurately reconstruct fine-grained geometry or embedded information without the correct key.

Accordingly, privacy strength is not defined in terms of cryptographic key-space exhaustion or classical indistinguishability, but is formally defined as reconstruction resistance, namely, the inability of an adversary to accurately recover fine-grained geometry or embedded information when an incorrect encryption key is used. Under this definition, privacy strength is quantitatively evaluated using geometry-aware distortion measures, including NRMSE and NHD, which directly reflect reconstruction error under incorrect keys.

This subsection evaluates the security-related characteristics of the proposed framework under the TPE threat model, where limited and controlled visual information leakage is inherent by design. Unlike conventional full encryption schemes that aim at complete visual concealment, TPE explicitly balances privacy protection with visual usability by allowing a coarse geometric representation to remain observable in the encrypted domain. Effective security is achieved when only thumbnail-level structure is revealed, while detailed spatial relationships and embedded data remain protected. Under this interpretation, geometry-aware distortion measures, such as NRMSE and NHD, serve as quantitative proxies for privacy strength, where higher values indicate increased resistance to unauthorized geometric reconstruction.

In the proposed framework, the encryption key $K_E$ is represented as a 32-bit integer selected from the range [0, 2³² − 1]. To initialize the chaotic perturbation process, a cryptographic hash function is applied to the concatenation of the encryption key and a model identifier $ID$, and the fractional part of the hash output is extracted to generate the initial chaotic state using Equation (8). Although the nominal key space is determined by the 32-bit representation of $K_E$, the hash-based initialization enhances key sensitivity and decorrelation of perturbation patterns across different keys and models.

Key sensitivity is evaluated by encrypting the same point cloud using slightly different encryption keys while keeping all other parameters unchanged. Experimental results show that even a minor variation in $K_E$ leads to noticeably different spatial perturbation patterns and distinct encrypted coordinate distributions. Although the overall thumbnail appearance remains visually similar—due to the bounded perturbation design inherent to TPE—the internal point-wise displacements differ significantly. Moreover, decryption with an incorrect key produces large reconstruction errors and fails to recover the original geometry, demonstrating strong key sensitivity under the intended TPE threat model.

To examine whether the proposed encryption effectively disrupts spatial regularity, the statistical characteristics of point coordinates before and after encryption are analyzed. While encrypted point clouds preserve coarse geometric structure for visualization purposes, fine-scale coordinate distributions within each spatial block are significantly altered by the chaotic perturbation process. These perturbations reduce local spatial correlation and introduce key-dependent randomness into coordinate values, making it difficult to infer precise geometric relationships from statistical inspection alone. The extent of statistical dispersion is explicitly governed by the spatial subdivision and perturbation parameters, enabling a controllable trade-off between privacy protection and thumbnail stability.

Quantitative statistics of the retained boundary-related points (${NE}_1$ and ${NE}_2$), as reported in Table 3, Table 4 and Table 5 under different viewing distances, show that their proportion is negligible for the majority of tested models. In most cases, the percentage of ${NE}_1$ points is effectively zero, while ${NE}_2$ points typically account for well below 1% of the total vertices. Higher ${NE}_2$ ratios are observed only in a small number of boundary-dominated models (e.g., Rabbit, RockerArm) under close viewing distances ($D=1$), and decrease rapidly as the viewing distance increases.

This behavior reflects view-dependent boundary exposure rather than a key-independent structural fingerprint. A potential concern is that boundary-related fixed points ($N_{BP}$, ${NE}_1$, and ${NE}_2$) might act as structural fingerprints and leak information about the original geometry. In the proposed framework, these points are deterministically determined by the global bounding volume and subdivision parameters, and do not encode any key-dependent or content-specific information. From an adversarial perspective, the information revealed by such points is limited to coarse outer-shell constraints that are already visible at the thumbnail level and remain invariant across different encryption keys. Importantly, the locations of non-boundary points—which constitute the overwhelming majority of vertices—are perturbed in a key-dependent manner, and reconstruction of fine-grained geometry remains infeasible without the correct key. Therefore, under the TPE threat model, boundary-related fixed points do not constitute an exploitable structural fingerprint, but rather represent an unavoidable and controlled leakage consistent with the intended thumbnail-preserving functionality.

It is noted that, by design, TPE inevitably leaks coarse geometric information that may enable high-level shape recognition or content retrieval. This limitation is inherent to the TPE paradigm and is shared by existing TPE schemes. The proposed method therefore focuses on preventing precise geometric reconstruction and unauthorized data extraction rather than resisting aggressive geometric attacks such as cropping, noise injection, or malicious resampling. Robustness against such adversarial operations is beyond the scope of this work and will be explored in future research.

Overall, the security-oriented evaluation demonstrates that the proposed framework provides effective key-dependent geometric obfuscation, disrupts fine-scale spatial statistics, and maintains deterministic reversibility under the intended TPE threat model, making it suitable for privacy-preserving preview and secure transmission scenarios where controlled visual disclosure is required.

4.8. Statistical Security Analysis

To examine the effect of encryption on coordinate distribution, histograms of the $x$, $y$, and $z$ coordinates are plotted for both the original and encrypted point clouds. Figure 11 illustrates a representative example using the Armadillo model under the setting $T=100$.

Figure 11. Coordinate histogram comparison before and after TPE for Armadillo models.

As shown in Figure 11a, the original point cloud exhibits structured coordinate distributions that reflect the inherent geometric characteristics of the model. In contrast, the encrypted point cloud in Figure 11b demonstrates noticeably altered coordinate histograms across all three dimensions. Although the global coordinate range is preserved to maintain thumbnail-level visualization, the frequency distributions are significantly redistributed due to the grid-based subdivision and key-dependent chaotic perturbation. It is important to emphasize that the observed distributions are not the result of a uniform translation or simple scaling. Instead, the modification arises from localized perturbations within spatial grids, where each point is displaced according to a mini-subspace assignment and chaotic offsets derived from the encryption key. This behavior confirms that the proposed scheme performs structured yet nontrivial statistical scrambling of coordinates, preventing direct inference of precise geometric information from histogram inspection alone.

To quantitatively assess changes in spatial correlation, we adopt the NRMSE difference between the original and encrypted coordinates. NRMSE measures the aggregate geometric deviation between corresponding points and serves as an indicator of how local spatial relationships are altered after encryption. The reported NRMSE values reveal that the degree of geometric deviation is explicitly controlled by the spatial subdivision threshold, i.e., the grid size. When finer grids are employed, NRMSE values remain relatively small, reflecting the intentional preservation of local geometric structure required for thumbnail usability. As the grid size increases, larger NRMSE values are observed, indicating stronger disruption of local spatial relationships. This behavior demonstrates that the proposed scheme does not enforce indiscriminate decorrelation. Instead, it provides a controllable degree of spatial decorrelation, allowing users to adjust the balance between visual usability and statistical obfuscation through the subdivision parameter. Such controllability is a defining characteristic of TPE and distinguishes it from conventional full-obfuscation encryption schemes.

The combined histogram and NRMSE analyses confirm that the proposed encryption method introduces key-dependent, spatially structured statistical modifications that go beyond simple coordinate shifting, while intentionally avoiding complete randomization. This design choice aligns with the objective of TPE, where coarse geometric appearance is preserved for usability, but fine-grained spatial information is concealed from unauthorized access. Consequently, statistical security in the proposed framework should be interpreted as resistance to casual or direct statistical inspection, rather than cryptographic indistinguishability. The results demonstrate that without the correct key and subdivision configuration, recovering precise geometric relationships from the encrypted point cloud remains infeasible, even though a thumbnail-level representation is retained.

4.9. Comparative Analysis and Discussion

Existing 3D point cloud encryption techniques primarily aim at full geometric concealment and are designed to prevent any form of visual interpretation of the encrypted model. Such methods typically disrupt both fine-grained and coarse geometric structures and therefore do not support preview or thumbnail usability. In contrast, the proposed method follows the TPE paradigm, in which limited geometric information is intentionally retained to enable visual preview while preventing precise geometric reconstruction. Due to these fundamentally different design objectives, direct visual fidelity comparisons with conventional 3D encryption schemes are not entirely appropriate. Comparisons with 2D TPE approaches are instead included to highlight the conceptual extension of the TPE principle from images to three-dimensional point clouds, rather than to imply direct metric equivalence. Moreover, commonly used image-based metrics such as PSNR are inherently defined for 2D raster data and lack a standardized formulation for point cloud geometry. Consequently, quantitative evaluation in this work emphasizes geometry-aware distortion measures and runtime analysis, which more accurately reflect the characteristics and processing costs of 3D data.

Table 8 presents a comparative analysis of representative TPE techniques across various dimensions, highlighting key differences between existing image-based methods and the proposed TPE framework for point clouds. In terms of input media, prior works have predominantly focused on 2D JPEG or lossless image formats, while our method is the first to extend TPE to 3D point clouds, thereby addressing a higher-dimensional and more structurally complex domain. Most of the compared methods fall into the approximate TPE category, with the exception of [12], which achieves ideal pixel-level thumbnail fidelity. In contrast, our method also belongs to the approximate class but is uniquely designed to preserve view-consistent thumbnails for 3D models. Regarding security mechanisms, existing methods employ various strategies including permutation [7,12], chaos-based XOR [8], key-based XOR [10], and hybrid substitution–permutation structures [1,14]. Our approach adopts a tailored subdivision and key-driven perturbation strategy that aligns with the spatial nature of 3D data while providing structural obfuscation and reversibility. In terms of data hiding, only a subset of image-based methods [5,7,8,18] support reversible embedding, and typically with limited capacity. Notably, methods [10,12] do not support any form of data hiding, which limits their usability in secure multimedia communication scenarios. The embedding capacity in most image-based techniques remains low, whereas our proposed method achieves high embedding capacity by leveraging redundant coordinate bits and spatial structures within the point clouds. Finally, with respect to lossless recovery, only [12] lacks this ability, while all other methods, including ours, support full recovery of the original media and embedded information. Overall, this comparison demonstrates that our proposed 3D TPE framework offers a balanced combination of security, high-capacity reversible data hiding, and full recovery, while also addressing a new application domain previously unexplored by existing TPE research.

Table 8. A comparative analysis of representative TPE techniques across various dimensions.

	[7]	[12]	[8]	[10]	[5]	[18]	Proposed
Input Media	JPEG Images		Lossless Format				Point Clouds
TPE Type	Approximate	Ideal	Approximate				Approximate
Security	Permutation		Chaos-based XOR	Key-based XOR	Substitution & Permutation		Subdivision & Perturbation
Data Hiding	Reversible	No	Reversible	No	Reversible		Reversible
Embedding Capacity	Low	N.A.	Medium	N.A.	Low	Low	High
Lossless Recovery	Yes	No	Yes	Yes	Yes	Yes	Yes

The comparative results presented in the previous section indicate that differences between existing TPE approaches and the proposed framework primarily stem from distinct problem formulations rather than incremental algorithmic variations. Most existing TPE techniques were developed under assumptions tailored to 2D image data, where regular pixel grids and fixed viewing conditions allow thumbnail fidelity to be defined at the pixel or block level. When the same assumptions are applied to point clouds, which lack a regular sampling structure and are inherently view-dependent, preserving a meaningful thumbnail becomes significantly more challenging.

From this perspective, the proposed framework adopts a geometry-aware design that explicitly accounts for the spatial and perceptual characteristics of point clouds. The use of spatial subdivision enables coarse geometric structure to be retained consistently across viewpoints, while constrained key-driven perturbation provides fine-grained obfuscation without disrupting global shape cues. This design choice explains why the proposed method exhibits different visual and statistical behavior compared with image-based TPE approaches, even when operating under the same approximate TPE paradigm.

Another important observation is that the performance of TPE is governed by a usability–privacy trade-off rather than a single optimal configuration. Increasing geometric perturbation strength inevitably improves privacy protection but degrades thumbnail interpretability, whereas excessive preservation of structure weakens obfuscation. The proposed framework explicitly parameterizes this trade-off, allowing the encryption behavior to be adjusted according to application requirements. Importantly, the selected operating range avoids overwhelming distortion and reflects a usability-aware regime rather than an attempt to achieve full visual concealment.

Finally, the controlled information leakage observed at the thumbnail level should be understood as an inherent and intentional property of TPE rather than a limitation. In application scenarios such as cloud-based preview, content filtering, and IoT-edge data inspection, the ability to rapidly assess encrypted content without full decryption is often essential. By preserving coarse geometric cues while protecting fine-grained details and embedded information, the proposed framework provides a practical balance between security and usability, extending the applicability of TPE to 3D point clouds.

5. Conclusions and Future Work

This paper has presented a TPE framework tailored for 3D point clouds, aiming to bridge the gap between visual usability and data security in high-dimensional geometric representations. By integrating perception-guided spatial subdivision with key-dependent perturbation, the proposed method obfuscates fine-grained point distributions while preserving view-consistent thumbnail fidelity. In addition, the incorporation of reversible data hiding enables auxiliary message embedding without compromising exact model recovery. Experimental results demonstrate that the proposed framework achieves effective thumbnail preservation, nontrivial embedding capacity, and full reversibility, making it suitable for privacy-preserving storage, sharing, and transmission of point clouds.

Several promising directions emerge from this study. First, we plan to extend the proposed framework to support other 3D representations such as meshes and voxels, which involve different data structures and visual characteristics. Second, adaptive perturbation strategies based on semantic saliency or viewpoint importance will be explored to enable finer-grained control over the trade-off between thumbnail usability and privacy protection. In addition, more comprehensive HVS models, such as contrast sensitivity or perceptual threshold models, may be explored as optional extensions for application-specific scenarios where fine-grained perceptual calibration is required, provided that the lightweight and reversible nature of the proposed framework is preserved. Third, integrating TPE with authentication or watermarking mechanisms could further enhance content protection and traceability. In addition, while the current implementation adopts a lightweight chaotic perturbation mechanism for efficiency and reproducibility, alternative keystream generators—such as cryptographically secure pseudo-random number generators or higher-dimensional chaotic systems—may be considered to better accommodate specific application requirements. Owing to the modular design of the proposed framework, such extensions can be achieved without altering the reversible processing pipeline or the thumbnail-preserving property. Lastly, we intend to investigate lightweight versions of the proposed method for real-time or resource-constrained environments, such as mobile devices or embedded IoT systems.