Motion Recurring Pattern Analysis: A Lossless Representation for Motion Capture Databases

In this paper, we propose the motion recurring pattern analysis (MRPA) method for the lossless representation of a motion database at the segment level instead of the motion degree of freedom (DOF) level. First, we concatenate all the motions into a long sequence in the motion database, and we discover similar posture paths by building a matching trellis structure based on the randomized k-d tree. Second, horizontal segments of paths are suitably refined, based on a self-organizing map, to obtain the optimized segmentation for maximum compression gains. Third, by using the path as a connection agent, these segments are clustered into a forest of trees. With this forest structure, we obtain the prediction residuals (the differences between the nonroot branches and their parents), and the differences between neighboring residuals are encoded under floating-point compression. Relative to previous lossless compression methods, our approach can achieve a higher compression ratio with comparable decompression time costs.


I. INTRODUCTION
With the development of motion capture techniques, human motion data are widely used beyond the conventional fields of games and animation. These data are used in fields such as the automotive industry, arts, sports, virtual reality, and remote interaction in augmented reality. As the vast collections of motion capture data continue to grow, it becomes crucial to efficiently store and transmit these data. Previous works [1]- [20] on motion compression have focused on two types of methods, namely, methods that reduce the redundancy of the time domain and those that reduce the redundancy of the space domain. However, in a large motion database, there is a third way to reduce redundancy: the extraction of recurring similar motion patterns across a large database. These matched motion patterns can make coding more efficient. However, few works have addressed motion compression with motion pattern discovery and analysis.
Furthermore, although most state-of-the-art compression methods have shown satisfactory compression performance, they are based on lossy compression; hence, the original data are modified, resulting in errors. These errors can result in various perceptual artifacts, such as the well-known The associate editor coordinating the review of this manuscript and approving it for publication was Zhaoqing Pan .
foot-skating artifacts [21]. Although inverse kinematics (IK) can be introduced to reduce these errors [1], [2], [14], [17], the residual errors can still degrade the visual quality of the motion data, particularly for motion files undergoing multiple compression and decompression processes. Furthermore, the time-consuming IK process greatly degrades the decompression performance.
To address these problems, we propose in this paper a lossless compression method for a motion database by exploring the recurring pattern analysis in the motion database. Our method is composed of three steps. First, all motions in the database are concatenated into a long sequence. Then, for each node along this sequence, we search for its best matches, such as its nearest neighbors, in the database based on a randomized k-d tree. These matches are listed a column below the node of this sequence row, and a matching trellis is built. We then find continuous similar posture paths through the path growing process in the matching trellis. Second, a similar posture path can map two segments: a horizontal and a vertical segment. All the horizontal segments constitute a segmentation of the database sequence. However, this segmentation is not optimal, and overlaps exist among them. We propose a sequence segmentation method based on the self-organizing map (SOM) using horizontal segments as the input layer and equally split length segments as the output layer. Third, with this optimized segmentation, each segment is either the root of a new tree or a descendant, a segment that is assigned to one branch of a tree based on its similarity with the existing trees. These trees constitute a forest. For each tree, we take the father node as the prediction of its descendants and obtain the prediction residuals as the difference between the prediction and real data. We then encode the residual differences for maximum compression gains. The contribution of our work can be summarized as follows: • We propose a forest structure to best predict the motion segments instead of the motion degrees of freedom (DOFs). Then, the differences of the residuals are encoded with floating-point compression.
• We introduce the randomized k-d tree to find the nearest neighbor matches to improve the efficiency of the trellis building process.
• Based on the SOM, we propose a motion segmentation method that can suitably balance the similar posture paths for maximum compression gains.

II. RELATED WORK
In this section, we briefly summarize existing works on animation compression and floating-point compression.

A. ANIMATION COMPRESSION
Animation data are high-dimensional data that often present high spatial and temporal coherence. Nearly all animation compression methods exploit these two types of coherence to reduce the data size. Previous works on animation compression have focused mainly on compressing animated meshes [22]- [28]. These works include [28], which adopted an octree to represent motion capture data; [23], [26], which performed vertexwise motion prediction; [24], [25], which applied the principal component analysis (PCA) technique; [22], which used wavelet coding techniques; and [27], which encoded nonisomorphic animated mesh sequences.
The compression of motion capture data is a relatively new research area. Arican [1] used Bezier curves to represent motion clips and then applied a clustered PCA to reduce the dimensionality. Environmental contacts were encoded separately based on discrete cosine transformation (DCT). Khan et al. [9] proposed using the multidimensional quadratic Bezier curve break-and-fit method to compress motion capture data. Hou et al. [29] first segmented motion data into subsequences. Then, they exploited the strong low-rank characteristics within and among the subsequences of motion capture data to achieve a compact representation. Liu et al. [16] first segmented a motion sequence into subsequences of simple motions and then compressed each subsequence using PCA approximation and further compressed the resulting PCA data by selecting and storing only the keyframes. Vasa et al. [18] proposed combining PCA with Lagrange multipliers techniques to obtain a satisfactory balance of precision and distortion.
Tournier et al. [17] used a principal geodesics analysis (PGA) to build a descriptive model of pose data, keeping only the leading principal geodesics. This model was then used in an IK system to synthesize poses that very closely matched the end-joint constraints and the interior joint positions to the input data. Given this pose model, only the compressed end-joint trajectories and the position and orientation of the root joint need to be stored to recover the motion using IK. Zhu et al. [20] precompressed the motion data using the method proposed by Tournier et al. [17] to compress motion data. Then, they proposed a quaternion space sparse decomposition model that decomposes the rotational motion into the dictionary part and the weight part. Finally, these data were encoded with arithmetic coding. Hou et al. [8] proposed a human motion capture data tailored transform coding method by computing a set of data-dependent orthogonal bases, while Kruger et al. [12] and Hou et al. [30] proposed methods based on tensor decomposition.
Beaudoin et al. [2] adapted standard wavelet compression on joint angles by considering the process of selecting wavelet coefficients to be a discrete optimization problem within a tractable search space adapted to the nature of the data. For contacts with the environment, they used optimized wavelet-based compression and IK correction. This algorithm focuses on short and recomposable animation clips. Lee et al. [13] proposed a human motion compression framework based on a multiresolution wavelet. Firouzmanesh et al. [5] proposed the perceptually guided compression method, which incorporates wavelets with attention stimulating factors.
Chattopadhyay et al. [3] proposed a power-aware algorithm for mobile devices, which exploits the motion data indexing concept. They derived each floating number index from the statistical distribution of the floating-point numbers in the motion matrix. Since this integer index number takes much fewer data bits, the motion capture data can be significantly compressed. Han et al. [7] presented a motion capture compression method based on simple polynomial curve-fitting techniques to efficiently store and transfer motion databases with mobile phones.
Gu et al. [6] proposed a method for compressing human motion capture data based on hierarchical structure construction and motion pattern indexing. They first organized the 3D markers as a hierarchy in which each node corresponds to a meaningful part of the human body and is therefore coded separately. For each meaningful part, the motion pattern database is built, and the sequence of the motion capture data can be efficiently represented as a series of motion pattern indices. Park [31] presented a motion rearrangement method that shares a similar concept with the method proposed by Gu et al. Chew et al. [32] presented a fuzzy clustering algorithm for virtual character animation representation. They proposed mapping a virtual character animation as an image and using a modified motion filter to minimize the visual discontinuity and distortion. VOLUME 8, 2020 Kwak et al. [10] presented their version of low-delay motion capture compression using a reordered data frame and then made predictions from both long-term and short-term reference frames. In 2017, Kwak et al. [11] improved their method by proposing bit allocation to long-term and short-term reference frames and postprocessing of temporal low-pass filtering. Based on the parallelogram predictor [33], [34] in geometric compression, Wang et al. [19], [35] proposed an alpha parallelogram predictor for effectively predicting the DOFs of motion capture data. They stored the alpha parameters with a carefully designed lookup table and the prediction residuals were then encoded using the adapted floating-point compression method [36].
Lin et al. [14] proposed the repeat motion analysis method to achieve a compact representation of motion capture data. Based on the self-distance metric of the match web [37], they extracted primary clips and repeated clips and they also fit the trajectories of the projected coefficient or coefficient differences using Catmull-Rom splines. Because the spline-based approximation at the subspace might not suitably preserve high-frequency motions, such as a foot contacting with the floor, these contact trajectories were recorded separately for subsequent motion decompression with IK.

B. FLOAT-POINT COMPRESSION
Many kinds of data sets are often represented in floating-point format. If floating-point numbers can be compressed effectively, a higher compression ratio can be achieved. A variety of methods have been developed for compressing and transmitting such numbers in the context of images [38], [39], large-dimensional scientific data [40], audio [41], 3D geometric data [36] and linear streams [42]- [44].
Isenburg et al. [36] proposed a lossless algorithm to encode the floating-point geometry of triangular meshes. In this method, a new position is first predicted by using the parallelogram predictor. The predicted and actual floating-point values are broken into their signs, exponents, and mantissas and then their corrections are then compressed separately with context-based arithmetic coding. Since the prediction quality varies with the exponent, the exponent is used to select different arithmetic contexts. Lindstrom et al. [40] proposed a fast and efficient compression algorithm for large-dimension floating-point data. In this approach, after the predicted position is obtained using the Lorenzo predictor [45], the predicted and the actual floating-point values are mapped to unsigned integers. The correction is then calculated and encoded with an arithmetic coder. Burtscher and Ratanaworabhan [42], [43] and Ratanaworabhan et al. [44] proposed methods for the effective and lossless compression of sequences of 64-bit floating-point data. They first sequentially predicted each value of the data sequence and then performed bitwise operations between the actual and predicted values. These methods are very fast and can meet the high-throughput demands of scientific computing environments.
Our method is fundamentally different from all of the above methods in that we develop a completely lossless compact representation by mining similar segments across a motion database. Our method is mainly inspired by [46] and [6] but is different from those methods in four aspects. First, we propose a forest structure for best predicting motion segments, and encode the residual segments with floating-point compression. Second, we propose a SOM-based motion segmentation method that can suitably balance the similar posture paths for maximum compression gains. Third, instead of searching in the self-distance matrix or locality-sensitive hashing tree, our method introduces randomized k-d trees to accelerate the process. Fourth, our method is completely lossless. Without time-consuming IK during decompression, which occurs with the method proposed by [6], our method can decompress motion segments in real time.

III. COMPRESSION PIPELINE
Our compression pipeline consists of four steps: trellis building and motion path discovery, SOM-based database sequence segmentation refining, forest construction and encoding of forest structure and residuals.

A. TRELLIS BUILDING AND MOTION PATH DISCOVERY
Our goal is to find continuous paths through an efficient tree-growing process to effectively exploit the recurring patterns in a motion database. Furthermore, we need an efficient k-nearest neighbor search method for trellis building. Based on this trellis structure, we can start the process of motion path discovery.
As defined in [47], there are two forms of the nearest neighbor search based on the randomized k-d tree structure: the k-nearest neighbor search and the radius nearest neighbor search. The former returns the predefined k neighboring frames, while the latter returns the neighboring frames where the distance is smaller than a predefined threshold radius. Because we wish to obtain the nearest neighbors that are similar within a predefined threshold, we adopt the radius nearest neighbor method and the Manhattan distance similar to that presented in [47], as shown in Equation (1).
where Dis(m, n) is the distance between frame m and n, as shown in Equation (2): where J = 32 in our test set. Similar to the approach taken in [48], w k is set to 0.7 for important joints, such as the hip, lower back, upper back, humerus, radius and femur, whereas w k is set to 0.3 for supplementary joints, such as toes, feet, and fingers. Based on the randomized k-d tree structure and frame distance definition, a trellis structure is built. In this structure, the top row is the database sequence, while the columns are their best matches found in the database by using the randomized k-d tree nearest neighbor searching method [47]. In the following text, we call the top row of the trellis top row and the columns of the trellis columns.
Tree growth initiates at the 1 st column of the trellis. One node i in the column can find the nodes of the neighboring columns within the interval [i, i+2]. As shown in Figure 1, the same-color continuous solid arrows constitute a path, while the dotted-line arrows indicate invalid paths, which are either not long enough or do not have the least average distance. Each path is described by root, depth, path distance, where the path distance is the accumulated distances of the matched pairs in the path; the root is the path start frame number, which corresponds to a node in the columns of the trellis; and the depth is the path length along the top row. This path information is stored in the current leaf nodes of the growing tree and passed to their descendants with the updated values. In Figure 1, the red path {560, 60, 980} is stored in 617. Then, this information is passed to 618 (the second column) and further to 619 or 618 (the third column). We can obtain the updated path information as {560, 62, 1080} and {560, 62, 1106}.
Different from the previous method presented in [46], the path distance is added to the path information to evaluate the average distances for paths that share the same start frame number. For these paths, we keep only the ones with the least average distance and the largest depth. As shown in Figure 1, for two red paths {560, 62, 1080} and {560, 62, 1106}, the former has the lower average distance and is kept.
Another example is the two paths starting from 120. One is the purple path with {120, 5, 180}, and the other is the light blue path with {120, 5, 220}. The purple one has the lower average distance in the current situation. However, since the two paths might extend beyond frame 685 along the top row, we cannot determine which one should be kept at this stage.
After the path growing process, we keep only valid paths, which are the paths whose depth values are greater or equal to the threshold ValidPathThr. We collect all the paths from the database sequence into a path set as follows: where and h i2 are temporal indices from the nodes of the top row of the trellis, as shown in Figure 1. They denote the start and end frame of a segment of the i th paths. We call this kind of segment an h-segment, which corresponds to each of the horizontal lines in Figure 2. Moreover, v i1 and v i2 are the counterpart temporal indices from the nodes of the columns of the trellis in Figure 1. They denote the start and end frame of a segment of i th paths. We call this kind of segment a v-segment, which corresponds to each of the vertical lines in Figure 2. Different from the previous method, in our path growing process, we follow the rule that the h-segment h i and the v-segment v i cannot overlap. That is, either h i2 < v i1 or v i2 > h i1 . Assuming that the red path in Figure 1 represents the ith paths in the database, we obtain h i1 = 682−62 = 620, h i2 = 682, v i1 = 560, and v i2 = 619. Node 619 in the third column has the descendant 620. However, this sequence stops extending to the next column because such an extension would violate the rule that the h-segment and the v-segment cannot overlap.

B. SOM-BASED DATABASE SEQUENCE SEGMENTATION
In the preceding section, we obtained the path set for the database sequence. However, overlaps exist among h-segments, resulting in increased memory overhead. Furthermore, overlaps mean that we did not obtain the best segmentation that can balance all paths. Figure 2 shows an example of a path set, where h-segments [63-183], ,  and  overlap. We seek an optimal segmentation based on these h-segments to achieve the maximum compression gains. We propose refining the motion sequence segmentation based on the SOM by taking all h-segments as the input layer and an evenly segmented segmentation as the output layer. In Figure 2, the horizontal lines are the h-segments and the vertical lines are the v-segments. The dotted lines are major segment points in the horizontal direction. Here, we use evenly tilted lines to VOLUME 8, 2020 indicate different paths. First, we find the longest segment among the h-segments and denote its segment number as t. The database sequence is then equally divided into m segments as Equation (4) shows.
where l is the size of the database (i.e., the total number of frames of this database). We designate this segment set as follows: where s j = (s j1 ,s j2 ) and s j1 , s j2 are the start and end frame numbers of the j th segment, respectively. Second, for each h-segment h i from P, we search for a segment s j from S that has the largest IoU (intersection over union) with h i . This IoU is a similarity metric as shown in Equation (6).
Third, we adjust the length of the segment of the output layer by moving its start and end point. That is, In Figure 3, because h i2 − s j2 is negative, s j2 decreases.
A new segment is formed with frames from updated s j2 + 1 to s (j+1)1 − 1. If the length of this segment, s (j+1)1 − s j2 − 1, is larger than or equal to a threshold LengthThr, then the segment is added to S as a new segment. Otherwise, it is combined into s j+1 . Moreover, if h i2 − s j2 is positive, then segment s j+1 decreases. If s (j+1)2 − s (j+1)1 + 1 is less than the threshold LengthThr, this segment is combined into s j+2 . We iterate the second and third steps through all h-segments. We decrease the learning rate adaptively for more iterations until k is equal to or smaller than zero, and we obtain the optimal refined segmentation set S.

C. FOREST CONSTRUCTION
For efficiently exploiting the recurring patterns among the paths in the path set, we need to cluster the h-segments in S from the SOM into many trees. Typically, each tree has a primary segment (the root) and many similar segments (the branches). Since each path has an h-segment and a v-segment, we use the path as a connection agent for organizing these segments into a forest structure.
First, we insert the longest h-segment into F, and this segment becomes the root of the first tree in F. Second,  assuming that F already contains trees, as Figure 4 shows, for a specific h-segment s j in S, we either insert it into one tree of F, or take it as the root of a new tree, as indicated by the blue arrow in Figure 4. We iterate the second step for each h-segment in S until all segments of S are processed. In the final step, we evaluate the tree similarity according to Equation (6) between any pair segments and merge the trees when there is a pair whose similarity values are larger than the threshold IoUThr.
In this paragraph, we will provided the detailed process of the second step. For an h-segment s i in F, we obtain an h-segment h j , which has the largest IoU(h j , s i ) with h-segment s i , according to Equation (6). Then, the counterpart segment of h j , e.g., the v-segment v m , is obtained by looking up the path set P (as indicated by the green arrow in Figure 4). The same process is applied to s j in S, as Figure 4 shows, and the counterpart segment is noted as v n . We can obtain the similarity metric between v m and v n as IoU(v m , v n ) from Equation (6).
We iterate all the nodes in F and evaluate their similarity with s j and keep the node that has the largest IoU(v m , v n ). We denote this h-segment as s max. If the largest IoU(v m , v n ) is larger than or equal to the threshold IoUThr, s j is inserted into the tree that s max belongs to as a descendant segment. Otherwise, s j forms the root of a new tree.

D. ENCODING OF THE FOREST STRUCTURE AND RESIDUALS
After the above tree construction process, we obtain a forest structure. Based on this forest structure, we obtain the prediction residuals (the differences between the nonroot branches and their parents). Finally, the differences between neighboring residuals are encoded by introducing a floating-point compression method [36]. The root frame data are encoded by employing a nonprediction mode of float-point compression. For the tree structure, we just save the temporal frame indices of the h-segment, the number of the trees children for the nonleaf node and frame indices for leaf nodes according to the width-first policy.

IV. RESULTS AND DISCUSSION
In this section, we present the experimental results to demonstrate the performance of the proposed method. Our focus is to show the relationships between compression ratios under different parameter values. We also demonstrate the comparison results with previous studies. In this paper, we define the compression ratio as the original file size divided by the compressed file size.
All the data in our experiment are from the CMU Graphics Lab Motion Capture Database, which has 2605 trials in 6 categories and 23 subcategories. We use the five motion database (run, modern dance, jumping, salsa dance, various activities) and three steps Climb and Walk on uneven terrain. Before we present our results, we first define some terms that we used for evaluation. The first term is the compression ratio, which is defined as the original file size before compression divided by the compressed file size, including motion data and index data. The second term is the predicted frame number, which is defined as the number of frames predicted in the hierarchal tree structure. The last term is the index entry number, which is defined as the number of parent/child pair indices need to be saved to maintain the tree structure. For the best compression gains, we expect a larger predicted frame number and a smaller index number for better compression performance.

A. COMPRESSION PERFORMANCE WITH DIFFERENT PARAMETERS
Our algorithm has three associated parameters: ValidPathThr, LengthThr and IoUThr. ValidPathThr is a threshold for determining whether a path is collected into a path set as defined in subsection III-A. LengthThr is a threshold for determining whether a new interval can be a new segment or combined into a neighboring segment, as defined in subsection III-B. Finally, IoUThr is a threshold for determining whether a segment will form the root of a new tree or contribute branches to an existing tree, as defined in subsection III-C. We discuss the trade-off between these parameters and show the results of the compression ratio under different parameter value combinations.

1) COMPRESSION PERFORMANCE UNDER DIFFERENT ValidPathThr
If ValidPathThr is smaller, then there will be more paths and, hence, more segments in the input layer of the SOM. This condition will lead to a tree with more branches. In contrast, if ValidPathThr is larger, then there will be fewer paths, and therefore, we will obtain a tree with fewer branches.   Clearly, the prediction performance is poor with a very small ValidPathThr because we cannot fully exploit the recurring similar motion patterns in the motion database. The smallest value of ValidPathThr is 1. In this case, the compression method cannot find the recurring patterns in the motion database at all. However, if we have a very large ValidPathThr, then we cannot obtain enough paths for the tree structure; hence, the predicted frames will be unsatisfactory. Furthermore, ValidPathThr is inversely proportional to the number of input segments of the SOM. We give an example of 344 frames of walking motion in Table 1. A larger number of input segments of the SOM typically implies a larger tree. Figure 5 shows the index entry number for ValidPathThr. The index entry number decreases with ValidPathThr because larger parameter values are associated with more branches in the tree. Figure 5 also shows the predicted frames number against the parameter ValidPathThr. The relationship is consistent with our discussion above. For the trade-off, the best value for ValidPathThr might fall in the interval of 55-60. The curve of the compression ratio with the parameter supports our choice, as shown in Figure 6.

2) ANALYSIS AND DISCUSSION FOR LengthThr
In our experiment, we find that the parameter LengthThr has little impact on the compression performance as shown in Table 2, because the reason is that the main segment set remains the same regardless of what value we set for Length-Thr.     layer mainly determines the resulting segment set, although the value of LengthThr might result in little change. However, this change has nearly no influence on the compression ratio as shown in Table 3. In this paper, we set LengthThr to 30 to reduce the computation costs.

3) COMPRESSION PERFORMANCE UNDER DIFFERENT IoUThr
For the third parameter, IoUThr, a smaller IoUThr value might result in a tree having more branches. However, a very small IoUThr might result in collecting segments that are not very similar. This condition leads to poor compression performance. On the other hand, a significantly larger IoUThr will cause the tree to have significantly fewer branches, and the predicted frame number will be small, which also results in poor compression performance. Figure 7 shows the curve of the predicted frame with different IoUThr values. Figure 8 shows the relation between the compression ratio and IoUThr. A value of 0.6 is very favorable for IoUThr.
Note that IoUThr has no impact on the index size, which is mainly determined by ValidPathThr. Therefore, we did not characterize its relationship with its index entry number as ValidPathThr.

B. COMPARISON WITH OTHER LOSSLESS COMPRESSION METHODS
In this section, we compare the performance of our MRPA method with the previous lossless compression method alpha parallelogram predictor (APP) [19] and selected widely used compression tools, namely, Gzip and Rar. We also compare our method with the method that uses our compression pipeline without the SOM-based segmentation (non-SOM) and a lossless deep-learning based image compression method (L3C) [49] by adapting our data to their implementation accordingly. Table 4 compares the six lossless schemes in terms of their compression ratios using different motion databases. Each database has a concatenation of many motions from the CMU motion capture database. Each database is mainly composed of motions labeled by their names. The database ''run'' has 12 motions, ''modern dance'' has 20 motions, ''salsa dance'' has 15 motions, ''jump'' has 32 motions, and ''various activities'' has 15 motions of different activities, such as walking, jumping, squatting, sitting, and punching. Table 4 demonstrates that our method outperforms the APP method, Non-SOM method, L3C method and conventional compression tools in terms of the compression ratio due to the reduction in redundancy at the segment level and the establishment of an efficient index structure.
Although L3C outperforms our method in term of compression ratio, the decompression time of their method is about two order of magnitude more than that of our method, which hinder its use in real-time applications. Please note that experiments on L3C were performed on a PC with Core i7 CPU and 16 GB RAM, while experiments on other methods were performed on a PC with i5 CPU and 8 GB RAM. Motion databases are typically used in computer games, virtual reality, and computer animation, among other applications. In these applications, motion databases are typically stored and transmitted in a compressed form and are decompressed on demand in real time when needed. Therefore, for a compression scheme, the decompression efficiency is much more important than the compression time. From 2011 to 2016, we received successive funding for the development of a compression system for the popular computer game QQ Dance, which has more than 100 million players. All the character motions of this game are from motion capture data. Usually, one player picks a song and the game chooses a couple of dance segments from a compressed motion database and concatenates them into a motion that matches the song. In this application scenario, the decompression time is very important for a smooth experience. Moreover, 33 frames have to be played within one second for a smooth experience. That is, each frame is 33 ms, including data decompression, and decompression must occur in real time. In the game, at most there are 100 characters dancing in the same scene. This maximum scene of a frame has to be decompressed within 3 ms for real-time experience. The decompression rate of our method is 0.022 ms/frame on average, according to Table 5, and can meet the requirement of this kind of system.
The decompression times of our method (MRPA) are comparable to that of the APP and the conventional compression tool Gzip. Please note that we optimized the decompression of the APP method in terms of I/O for a fair comparison. The decompression pipeline of our method is much simpler than the compression pipeline because there are no time-consuming processes, such as path discovery, SOM-based segmentation and the clustering process of the compression process, which is why our decompression is much more efficient than compression.

V. CONCLUSION AND FUTURE WORK
In this paper, we propose a compact representation for a motion database by employing effective recurring pattern discovery and analysis. We have shown that by using our MRPA method, we can reorganize the motion database at the segment level into a forest structure; moreover, the prediction process can be more efficient at this segment level along the tree than prediction processes using conventional DOF prediction methods.
This increased efficiency is one reason why we can feature a very small index size and less decompression time relative to the previous method [19]. We have demonstrated that our method outperforms the APP method, Non-SOM method and conventional compression tools (in terms of the compression ratio) due to the reduction in redundancy at the segment level and the establishment of an efficient index structure. Our method is lossless, while current compression methods are primarily lossy and distort the motion data. We have demonstrated that our method outperforms conventional compression tools in terms of the compression ratio. The decompression complexity of our method is also low, thus resulting in decompression times comparable to those of previous methods.
The compression times of our method are outperformed by that of the previous method because our compression pipeline has to undergo trellis building, the path discovery process and the SOM-based segmentation process. Although we have introduced randomized k-d trees for finding the nearest neighbors instead of the time-consuming self-distance matrix method [14] and the space-consuming locality-sensitive hashing (LSH) method [46], the time complexity of our method is still higher than that of the previous method [19]. The adoption of a more time-efficient SOM method, such as the parallel SOM on a graphic processing unit (GPU) [50]- [52], will be necessary. We plan to explore this issue in the future.