Algorithms and Hardware for Data Compression in Point Rendering Applications
ABSTRACT The high storage requirements associated with point rendering applications make the utilization of data compression techniques interesting. Point rendering has been proposed only recently and, consequently, no compression strategies have yet been developed. In this paper we present compression algorithms for two specific data distributions widely used in point rendering: a naive distribution with no specific sorting of the points and a layer distribution which is suitable for incremental algorithms. In this last case points are sorted in layers and the connectivity among them is encoded. The algorithms we propose have a high compression rate (5.0 bits/point for the naive distribution and 7.7 bits/point for the layer distribution). Additionally we present the hardware implementation for the decompression of both algorithms. Both algorithms are implemented in a single hardware unit providing a control to select between them.
- [Show abstract] [Hide abstract]
ABSTRACT: We propose a lossless compression algorithm for three-dimensional point data in graphics applications. In typical point representation, each point is treated as a sphere and its geometrical and normal data are stored in the hierarchical structure of bounding spheres. The proposed algorithm sorts child spheres according to their positions to achieve a higher coding gain for geometrical data. Also, the proposed algorithm compactly encodes normal data by exploiting high correlation between parent and child normals. Simulation results show that the proposed algorithm saves up to 60% of storage space.IEEE Transactions on Multimedia 01/2006; · 1.75 Impact Factor
Page 1
Algorithms and Hardware for Data Compression in Point
Rendering Applications
P. N. Mall´ on1
M. B´ oo1
M. Amor2
J.D. Bruguera1
1Department of Electronic and Computer Eng., University of Santiago de Compostela, Spain
E-mail: {paulanm, mboo, bruguera}@dec.usc.es
2Department of Electronic and Systems, University of A Coru˜ na, Spain
E-mail: margamor@udc.es
ABSTRACT
The high storage requirements associated with point rendering applications make the utilization
of data compression techniques interesting. Point rendering has been proposed only recently and,
consequently, no compression strategies have yet been developed.
In this paper we present compression algorithms for two specific data distributions widely used in
point rendering: a naive distribution with no specific sorting of the points and a layer distribution
which is suitable for incremental algorithms. In this last case points are sorted in layers and the
connectivity among them is encoded. The algorithms we propose have a high compression rate
(5.0 bits/point for the naive distribution and 7.7 bits/point for the layer distribution).
Additionally we present the hardware implementation for the decompression of both algorithms.
Both algorithms are implemented in a single hardware unit providing a control to select between
them.
Keywords: Data compression, point rendering, graphics hardware
1Introduction
The storage requirements associated with current
3D models are increasingly growing due to im-
proved design and the need of higher accuracy.
The management of high volumes of information
involves an important bottleneck in the transmis-
sion of data from CPU to GPU. One common
strategy for reducing the transmission problems
is the utilization of compression techniques. In
this context, different proposals have been devel-
oped for the compression of some representations
commonly employed in 3D graphics, as for exam-
ple triangle meshes [Gumho98] [Rossi99] [Mall´ o02]
and tetrahedral meshes [Szymc99] [Gumho99].
However, there are recently proposed represen-
tations for which no compression strategies have
been developed. Among these representations, the
most promising is point rendering [Alexa03].
Point based rendering techniques have recently
become a promising alternative for high quality
rendering of complex scenes [Pfist00] [Rusin00]
[Zwick01] [Wand01] [Ren02]. Specifically, in point
based applications, the objects are modelled as a
dense set of surface point samples and the point
rendering algorithms reconstruct a continuous im-
age from this set of samples.
Most of the recently developed out–coming al-
gorithms in point rendering [Pfist00] [Ren02]
[Zwick01] [Amor02] are based on a regular sam-
pling of the scene and the utilization of a hier-
archical structure to store it. The scene is rep-
resented with an octree, where each node stores
a cubic section of the scene. Each node stores a
subsampled version of its children [Pfist00].
Basic
[Pfist00] [Zwick01] [Ren02] [Rusin00] do not em-
ploy any specific sorting of the points inside each
octree node. Incremental strategies have been sug-
gested [Gross98] as a way to reduce the computa-
tional requirements of the algorithms to generate
the final image in the GPU. An efficient imple-
mentation of these strategies requires a previous
sorting of the points in the CPU [Amor02].
point renderingalgorithms [Wand01]
Complex scenes require several millions of points
to be represented and a high computational
Page 2
rate: up to one thousand million points per sec-
ond [Wand01].This suggests the utilization of
compression techniques to reduce the transmission
bandwidth between CPU and GPU. The compres-
sion is carried out in the CPU while the decom-
pression would be implemented in specific hard-
ware in the GPU.
In this paper we propose two compression algo-
rithms and the corresponding hardware units for
the decompression processes. The first algorithm,
we call Cell Identification Algorithm (CI), is ade-
quate for those point rendering proposals where
no specific point sorting is required.
the second one, Extended Cell Identification Algo-
rithm (ECI), permits the compression of the scene
for sorting proposed in [Amor02] for incremental
point rendering algorithms.
Whereas
These algorithms reduce the transmission require-
ments by about 83% for the CI and 20% for the
ECI with respect to reference implementations
without compression. On the other hand, both
hardware decompression units can be easily inte-
grated in a single module.
2Data Distribution in Point
Rendering
In this section we summarize the data distribution
usually employed in point rendering: Naive repre-
sentation and layer representation. In the naive
representation no specific sorting of the points in-
side each octree node is mandatory. In the layer
representation [Amor02], the points are sorted to
permit an efficient implementation of incremen-
tal algorithms. In the following we assume that
the result of the regular sampling of the scene are
cubes of 32×32×32 positions. Extension to other
sizes is straightforward.
2.1 Naive Distribution
No specific sorting of the points is predefined in
naive data distributions, so the points can be or-
ganized in such a way that the compression rate
can be optimized. The coordinates of each point
inside the cube are (i,j,k) with {i,j,k} ∈ [0,31].
2.2Layer Distribution
Incremental algorithms exploit the regular distri-
bution of the points in space in such a way that
0
5
3
4
2
1
49
56
48
50
59
43
47
63
29
27
26
25
21
30
31
37
16
17
20
14
28
24
42
32
33
35
34
10
54
X
Z
Y
51
(a)
Layer 2
Layer 1(0,5)
(3,8) (5,5) (2,0) (4,0) (1,0)
Layer 3
(24,0) (42,2) (32,0) (33,0) (34,0) (35,0)
(28,11) (21,2) (14,0) (10,0) (16,0) (20,0) (17,0)
Layer 4
(56,1) (49,1) (43,0) (29,0) (25,0) (51,0) (26,0) (30,0)
(31,0) (27,0) (59,0) (48,0) (50,0) (37,0) (47,0)
(63,0) (54,0)
Label
Connectivity
Layer 5
(b)
Figure 1: Layer Distribution (a) 4 × 4 × 4
Cube Example (b) Layer Representation
part of the computations can be reemployed for
the processing of neighbor points. According to
this, points have to be sorted before sending to
the GPU. The data sorting that we summarize in
this section was proposed in [Amor02]. It is based
on the identification of layers of neighbor points
and the specification of the connectivity among
them. The layers can be iteratively built start-
ing from a random point. The first layer is com-
posed of its neighbor points, the second layer of
the neighbor of the first layer points (excluding
points already assigned to a previous layer), and
so on. Figure 1(a) shows an example where each
layer is marked with a different symbol. The first
layer is composed of only one point, point {0}.
The second layer is given by its neighbor points
{3,5,2,4,1} and so on.
A point in a given layer can be used as a “seed” for
a subset of the points in the next layer; this subset
is composed of the neighbors of the seed. In incre-
mental algorithms the computations of the seed
can be partially reemployed for the neighbors in
the following layer. In order to optimize the incre-
mental algorithm efficiency, a data sorting inside
each layer is proposed. Specifically, seed points
Page 3
0
1
6
2
5
4
7
3
X
Z
Y
(a)
3
28
7
5
1
0
2
5
4
3
1
21
16
17
20
10
24
35
32
33
48
56
42
34
14
37
4743
49
63
59
29
27
26
25
30
31
51
54
50
X
Z
Y
4
0
6
2
(1) {1,1,1,1,1,1,0,0}
(1) {0,0,1,0,0,0,1,0}
{10,14} Cell 1
(1) {1,1,1,1,1,1,1,1}
{24,25,26,27,28,
29,30,31} Cell 3
(1) {1,1,0,0,1,1,0,0}
(1) {1,1,1,1,0,1,0,0}
(1) {0,0,1,1,0,0,0,1}
(1) {1,0,0,1,0,0,0,1}
(1) {1,1,1,1,0,0,1,0}
{0,1,2,3,4,5} Cell 0
{16,17,20,21}Cell 2
{32,33,34,35,37}Cell 4
{42,43,47} Cell5
{48,49,50,51,54} Cell 6
{56,59,63} Cell 7
(b)(c)
Figure 2: Cell Identification Algorithm (a)
Point label inside a cell (b) 4 × 4 × 4 Cube
Example (c) Representation
with higher number of neighbors in the next layer
are processed first. Each point is represented by
two numbers (see Figure 1(b)): its label in the
cube and the connectivity with next layer. Note
that the connectivity of a point in a layer k is the
number of neighbors in the following layer k + 1
but still not considered as neighbor of previous a
point of layer k.
3Compression Algorithms
In this section we propose two compression algo-
rithms for the data distribution summarized in the
previous section.
3.1Naive Distribution: Cell
Identification Algorithm (CI)
The algorithm we propose is based on the rep-
resentation of the cube in terms of cells (cube
of 2×2×2 positions) and the identification of the
points inside each cell. The cells are encoded fol-
lowing a specific order and empty cells are encoded
with just one bit. The resulting algorithm is sim-
ple and presents a high compression rate. The
cube is partitioned in non overlapping cells. As
an example, in Figure 2(b) a 4 × 4 × 4 cube with
36 points is presented, where cells are indicated
with solid lines. Eight non overlapping cells are
required for covering all positions. The cells are
processed following the positive Z direction (from
front to back), Y (from bottom to top) and X
(from left to right) axis respectively. The num-
bers inside the cells indicate their processing or-
der. On the other hand, positions inside each cell
are processed according to the labelling shown in
Figure 2(a).
The representation for each cell is:
(Cell Filled){Pos0,...,Pos7}
where Cell Filled indicates if the cell is empty (0)
or has points (1) and Posiindicates if there is a
point in position i (Posi= 1) or not (Posi= 0).
As an example, “cell 0” in Figure 2(b) is repre-
sented as (1) {1,1,1,1,1,1,0,0} that is, there are
six points in the cell in the positions labelled as
{0,1,2,3,4,5}.
The Cell Filled bit allows the increase of the com-
pression rate due to the high number of empty
cells in a scene.These cells can be encoded
with only one bit. Experimental results show
that at least 80% of the cells, corresponding to
non empty cubes, have no points. On the other
hand eight bits are required for encoding the
{Pos0,...,Pos7} list. According to this, the num-
ber of bits per point is in interval [1.125,9] where
1.125 corresponds to the case of a cell with eight
points and 9 for a cell with only one point. Exper-
imental results (Section 6) show that the average
number of bits per point is around 5.0.
(1)
3.2 Layer Distribution: Extended
Cell Identification Algorithm
(ECI)
In this section we present an encoding scheme
for the layer distribution described in Section 2.2.
The basic idea is the encoding of the information
related to each seed and its connectivity.
The encoding for each point we propose is:
(Position Label,ψ,Number Seeds)(2)
where, for a given layer i, Position Label specifies
the relative position of the point with respect to
its seed, ψ is the connectivity of the point with
the following layer i + 1. Among these ψ points,
some of them are also seeds for i + 2 layer; this
is indicated in Number Seeds. To specify a bi-
nary encoding for the Position Label we will re-
fer to Figure 3(a). This Figure shows a generic
seed point that can be surrounded, at most, by
Page 4
3
11
17
15
25
21
20
12
16
6
2
14
8
24
26 13
22
19
10
4
18
1
0
5
9
23
Seed point
(a)
Binary
Coding
Binary
Coding
Binary
Coding
PointPoint Point
0
1
2
3
4
5
6
7
8
0,0,0
0,0,10
0,10,0
0,10,10
10,0,0
10,0,10
10,10,0
Seed
0,0,11
9
10
11
12
13
14
15
16
17
0,10,11
10,0,11
10,10,11
0,11,0
0,11,10
10,11,0
10,11,10
0,11,11
10,11,11
18
19
20
21
22
23
24
25
26
11,0,0
11,0,10
11,10,0
11,10,10
11,11,0
11,11,10
11,0,11
11,10,11
11,11,11
(b)
Figure 3:
positions to a seed (b) Binary Coding
Relative encoding (a) Relative
(101111,8,2) (111011,5,1) (101110) (111010) (101011)
35
(000,5,2)
0
(111111,11,2) (111110,2,0) (111011) (101011) (10110) (11110)
28
14 21
(101110) (101111) (111111,2,0) (11100) (111010) (11110) (111110)
4232
17
24
(111010,1,0) (11100,1,0) (11011) (101011) (01011) (11110)
(111111) (11110)
63
54
33 3435
564943 29
2551
26 30
3127 59
48 50
3747
16
10 20
241
Layer 3
Layer 4
Layer 2
Layer 5
Layer 1
(01110) (101110) (101111) (01111) (111111) (11100) (11110) (1100) (111011)
Figure 4: Layer Encoding in ECI Algorithm
26 points. The x,y,z coordinates of a point can
be obtained from the seed point through incre-
ments/decrements of its coordinates. That is, the
coordinates of the point are obtained by adding
an offset of {+1,0,−1} to the coordinates of the
seed point. This offset is represented with a vari-
able length coding where value −1 is represented
with one bit 0, value 1 is represented with two bits
11 and value 0 also with two bits 10. Figure 3(b)
shows this coding. As an example, a point located
in position 13 is encoded as (−1,1,0) = (0,11,10).
The encoding corresponding to the example of
Figure 1 is shown in Figure 4. Note that those
points that are not seeds are encoded specifying
only the Position Label.
The total number of bits needed for encoding each
point is calculated considering that from 3 to 6 are
required for the Position Label, 5 bits for the con-
nectivity taking into account that the maximum
connectivity is 26 (see Figure 3(a)) and a maxi-
mum of 5 bits for the Number Seeds field. Note
that the number of bits in this last field depends
on the connectivity value ψ. In fact, the number of
bits required for Number Seeds is ?log2ψ?. This
value is in range [1,5]. In summary, the number
of bits per point is in range [3,16]. According to
our simulations an average of 7.7 bits per point
are required (see Section 6).
4Decompression Algorithms
The information, compressed in the CPU, is sent
to the graphics pipeline where it has to be de-
compressed to be processed. In this section we
present the decompression procedure for the Cell
Identification (CI) and Extended Cell Identifica-
tion (ECI) algorithms. As a result, the local coor-
dinates of each point inside the cube (i,j,k) with
{i,j,k} ∈ [0,31] are obtained. Global coordinates
of a point can be easily computed employing its
local coordinates to its cube, the global coordi-
nates of a reference point for the cube and the
grid resolution (grid size of the cube).
4.1CI Algorithm
The decompression algorithm processes the infor-
mation in the same sequential order employed in
the compression procedure. This way, a cell with
points is fully decompressed before starting with
the following non–empty cell. All points inside
this cell are decoded sequentially.
The basic idea is the computation of the coordi-
nates of position labelled as 0 in each cell (see
Figure 2(a)) and the use of this information to
obtain the coordinates of the other points in the
cell by adding an offset to each coordinate. In
order to obtain a unified representation with the
ECI algorithm we call this point Seed. The ba-
sic decompression algorithm is outlined in Fig-
ure 5(a). For each non–empty cell of the cube,
the Seed coordinates are computed from the in-
dex of the cell (line 4). Specifically, the local co-
ordinates of position labelled as “0” (Figure 2(a))
in the cell are computed. To do this, the cell in-
dex is split into three fields (four bits per field for
cubes of 32 × 32 × 32 positions because there are
Page 5
1 Cell Index = 0;
2 for each CELL ∈ CUBE {
3if (Cell Filled = 1) {
4Compute Seed Coord from Cell Index;
5Load List ({ Pos });
for each POINT ∈ CELL {
Position Label = Translate ({Pos});
offset = Decode (Position Label);
6
7
8
9Point Coord = Seed Coord + offset; } }
Cell Index ++;10
11 }
(a)
1 k = 1; Initialize List Seed (layer k);
2 for each LAYER k {
3j=0; /* Index for elements in layer k + 1 */
4 for each SEED in List Seed (layer k) {
Connected = Load points j to j + ψ − 15
of layer k + 1;
6j = j + ψ ;
7for (i=0 ; i < ψ ; i++){
offset = Decode (Connected(i));8
9Point Coord = Seed Coord + offset; }
List Seed(layer k + 1) ← First Number Seeds
points of Connected list; }
11 k ++; }
(b)
Figure 5:Decompression (a) CI (b) ECI
10
only 16 × 16 × 16 non overlapping cells) and the
coordinates of the seed are obtained by multiply-
ing each field by two. As an example, the index
of the cell 67 is 000001000011 so that the coordi-
nates of the seed are 2 × (0000,0100,0011), that
is (00000,01000,00110).
Next, in line 5, the {Pos} list is loaded. For each
point in a cell, its Position Label is obtained from
the {Pos} list (line 7).
i (i ∈ [0,7]) with Posi = 1 is translated to its
Position Label in the cell. As an example cell 0
in Figure 2 is encoded as {Pos}={1,1,1,1,1,1,0,0}.
The first point to consider is Pos0 = “1” and
its corresponding Position Label is “000”. The
following point is Pos1=1 with Position Label =
“001” and so on.
That is, each position
After this, the coordinates of this point are com-
puted from the coordinates of the Seed by adding
the corresponding offset for each coordinate
(lines 8 and 9). The offset can be “1” or “0”.
Specifically offsets are (0,0,1) for point {1}, (0,1,0)
for point {2} and so on.
M
U
X
ECI
CI
(Seedx,Seedy,Seedz)
(Seedx,Seedy,Seedz)
MEMORY
UNIT
(ECI,CI)
New Point
{Position_Label,ψ,
Number_Seeds}
LUT
(ECI)
CONVERSION
MODULE
(CI)
offsety
Input
+
+
+
M
U
X
ECI
CI
M
U
X
ECI
CI
offsetx
offsetz
D
E
M
U
X
ECI
CICell_Filled {Pos}
Figure 6:Decompression Unit
Finally, the index of the cell is updated and a new
cell in the cube is processed. Note that if the cell
is empty the only action is the updating of the
index.
4.2ECI Algorithm
The decompression process for the Extended Cell
Identification Algorithm is carried out layer by
layer. Specifically, for each Seed point in a layer,
all its connected points in the following layer are
decoded, then, the next Seed is considered and so
on. Seed points inside each layer are processed se-
quentially and each layer is fully processed before
starting with the following one.
The basic algorithm is outlined in Figure 5(b).
The process starts with layer k = 1 where the
only point is considered as seed (line 1). For each
layer k two actions are carried out: the neighbors
of each seed of the layer k are decoded and the list
of seeds of layer k + 1 is built.
Seeds of layer k are read from the list of seeds
(line 4). The ψ neighbor points of each seed are
loaded in list Connected (line 5). The process-
ing of the neighbors of each seed is shown in lines
7–9. The coordinates of point in the Connected
list are computed by adding the coordinates of
the Seed point and an offset. This offset is en-
coded in the Position Label of the point and can
be {–1,0,+1} depending on its relative position
to the Seed. This offset, has been encoded as
{0,10,11} respectively (see Figure 3). Once the
points in the connected lists are decoded, the first
Number Seed of them are loaded into the list of
seeds of layer k + 1 (line 10).
Page 6
5Hardware Implementation of the
Decompression Algorithms
In this section we present the architecture for the
decompression algorithms.
and ECI algorithms, can be integrated in the same
hardware unit. Figure 6 shows the block diagram
of the hardware implementation for the decom-
pression algorithms.
Both proposals, CI
The input data stream is delivered towards the
Conversion Module (for CI algorithm) or the
Memory Unit (for ECI algorithm). The offset for
each point is obtained in the Conversion Module,
for the CI algorithm, or using the Memory Unit
and the LUT (Look–Up Table) for the ECI algo-
rithm. The coordinates of the seed for both al-
gorithms are computed in the Memory Unit. Fi-
nally, once the offset and the seed coordinates are
known, the coordinates of the point are computed
in the final adders. In the following, these modules
are described in detail.
5.1Conversion Module
This module (see Figure 7(a)), employed only for
the CI algorithm, computes the offset of each point
from the {Pos} list that represents the positions
of the points inside the cell.
The {Pos} list is stored in the 8–bits input regis-
ter. Specifically, REGistores Posi. Initially, the
priority encoder receives as input the content of
this register and provides the position label corre-
sponding to the first point with Posi= 1. Then,
to process the next point in the list, the bit i of the
register is cleared. This process is repeated until
the last point in the list is detected. Finally, the
offset of each coordinate is spanned to two bits by
concatenating a “0”.
5.2 Memory Unit
The block diagram of this module is shown in Fig-
ure 7(b). The unit computes the seed coordinates
for the CI algorithm and the Position Label and
seed coordinates for the ECI algorithm. It is com-
posed of two shift registers, for the seed and con-
nected list, and a counter to obtain the seed coor-
dinates for the CI algorithm. The data indicated
in the figure corresponds to the first two layers of
Figure 1 (ECI algorithm).
In the Seed List, the coordinates of each seed are
stored. In case of the ECI algorithm these coor-
dinates are obtained in the final adders (see Fig-
ure 6) and stored back. In the CI Algorithm the
seed coordinates are obtained in the “Seed Cal-
culation” unit (line 4 in Figure 5(a)). This mod-
ule consists of a counter to obtain the Cell Index
which is split into three fields. The coordinates of
the seed are obtained concatenating a “0” as least–
significant bit of each field. Each time a new cell
is processed, the counter is incremented and the
coordinates of the new seed are obtained.
The control unit determines if a new seed has to be
loaded in the list and the shifting of the seed list.
The memory unit stores the connected list for the
ECI algorithm. Each point in the connected list is
specified by its position label, its connectivity (ψ)
and the number of seeds in the following layer. In
each cycle the Connected List is shifted so that
the point in the first position is read and a new
point is stored. The control unit determines when
a new point is loaded and the number of bits that
are required for its representation1.
As the Position Label has a variable number of
bits, the Length Adapter Module spans this field
to 6 bits in order to obtain the offset in the LUT.
5.3LUT
As shown in Figure 6, this module obtains the off-
set of each point from its Position Label (ECI al-
gorithm). It is implemented as a 64×6 table. The
position label is employed to address the LUT and
the corresponding offset per coordinate is read.
This offset inputs the adders.
5.4Hardware Requirements
As was shown in the previous sections, the hard-
ware is simple. The main components are a stor-
age system for the seed and connected list, regis-
ter and priority encoder for the decoding of the
CI algorithm, a set of adders to compute the co-
ordinates of each point, and the required control
for the global system. We have shown that both
algorithms can be implemented in a single hard-
ware unit providing the control to select between
the CI or the ECI algorithm.
1Note that the Position Label and the Number Seeds
have been encoded using a variable length code.
Page 7
3:8
DEC
PRIORITY ENCODER
Position_Label
3 bits
Pos7
1 bit
Pos6
1 bit
Pos5
1 bit
Pos4
1 bit
Pos3
1 bit
Pos2
1 bit
Pos1
1 bit
Pos0
1 bit
0 & [2] offsetz
offsety
offsetx
0 & [1]
0 & [0]
REG
7
clear
REG
6
clear
REG
5
clear
REG
4
clear
REG
3
clear
REG
2
clear
REG
1
clear
REG
0
clear
(a)
MEMORY UNIT
(from the ADDER)
M
U
X
ECI
CI
Seedx, Seedy, Seedz
Seed List
0
Load Seed
Shift Seed
Load Connected
Cell_Filled {Pos}
(to the ADDER)
Seedx, Seedy, Seedz
Seed Calculation (CI)
[3:0] & 0
X
[7:4] & 0
Y
COUNTER
Control
12 bits
[11:8] & 0 Z
ControlUnit
Control
Length
Adapter
(to the LUT)
6 bits
{Position_Label, ψ,
Number_Seeds}
Position_Label
Position_Label
ψ
Number_Seeds
Shift Connected
COUNTER Shift
Cell_Filled {Pos} CI
ψ ECI
Connected List
1011118211101151101110111010
101011
2
4
1
3
5
Position_Label
from 3 to 6 bits
{Position_Label,ψ,
Number_Seeds}
(0,0,0)
COUNTER Load
Cell_Filled {Pos} CI
Number_Seeds ECI
Control
(b)
Figure 7: (a) Conversion Module (b) Memory Unit
6Evaluation of the Algorithms:
Compression Ratio
The compression ratio we summarize in this sec-
tion has been obtained after a software simulation
of both algorithms using a set of images. For each
algorithm we compute the number of bits required
to encode the points in the cube and to evaluate
the benefits of our proposals, we compare the re-
sults with two reference implementations.
In both cases we compare the results with a basic
implementation without compression: 1 bit per
position in the naive distribution and 10 bits per
position2(5 for the position label and 5 for the
connectivity) in the layer distribution.
CI Algorithm As explained in Section 3.1,
empty cells are encoded with just 1 bit, and
non–empty cells with 9 bits.
that, for non–empty cells, the number of bits
per point is in [1.125,9], where 9 bits per
point are required when the cell has only one
point, and 1.125 bits per point when the cell
has 8 points.
Our experimental results show that an av-
erage 80% of the cells are empty (for non–
empty cubes). These cells can be encoded
with only one bit (Cell Filled bit).
the other hand, the number of points in
This means
On
2A point is surrounded by 26 points at most.
each non–empty cell is variable and, conse-
quently, the number of bits per point is also
variable: Cells with more points require less
bits per point. On average and for the dif-
ferent images employed, 5.0 bits per point
are used in the CI algorithm.
To evaluate the benefits of our proposal,
a reference algorithm is employed. In this
case, a basic representation with only 1 bit
per position is employed where a 1 indicates
that the position has a point, and 0 oth-
erwise.This means that a cube requires
32 × 32 × 32 bits. On average, the reference
algorithm needs 29.5 bits per point. These
numbers show that the CI algorithm reduces
the communication requirements by about
83%.
ECI Algorithm. As explained in Section 3.2,
the number of bits per point is in the range
[3,16]. This is due to the fact that not all
points are seeds, and that a variable length
code is associated with the Position Label
and Number Seeds fields. 3 bits is the mini-
mum number of bits required for a non–seed
point, whereas 16 bits is the maximum num-
ber of bits required for a seed point. Our
simulations show that the average number
of bits per point is 7.7.
The reference algorithm employed for com-
parison employs 10 bits per point, 5 bits
to specify the relative position of the point
Page 8
to the seed and 5 bits for the connectivity.
Then, the ECI algorithm reduces the com-
munication requirements by about 20%.
7Conclusions
We have presented two encoding schemes for two
different data distributions in point rendering. For
the naive distribution we propose the CI algo-
rithm. This algorithm is based on the splitting
of the cube in non overlapping cells and the ef-
ficient encoding of the points inside each cell. A
specific encoding is proposed for the empty cells,
in such a way that just 1 bit is enough for their
representation. With this technique we obtain a
high compression ratio (5.0 bits/point), which re-
duces the transmission and storage requirements
by about 83% with respect to a reference algo-
rithm proposed for the evaluation.
For a layer distribution, we propose the ECI algo-
rithm. It is based on the identification of layers
of neighboring points and the efficient encoding
of the connectivity among them. The points in-
side a cube are encoded differently depending on
whether they are seeds or not. Moreover, variable
length codes are employed to specify the positions
of the points with respect to their seed. With this
algorithm 7.7 bits per point are required; which
represents a reduction of 20% with respect to a
reference implementation.
We present a unique hardware unit for the de-
compression of both proposals. The resulting ar-
chitecture is simple, regular and suitable for its
hardware implementation.
8Acknowledgements
This work was supported in part by the Ministry
of Science and Technology of Spain under con-
tract MCYT–FEDER TIC2001–3694–C02–01 and
by the Secretaria Xeral I+D of Galicia (Spain) un-
der contract PGIDIT03TIC10502PR.
REFERENCES
[Alexa03] M. Alexa, M. Gross, M. Pauly, M.
Zwicker, H. Pfister, M. Stamminger, and
C. Dachsbacher.
Graphics. In Eurographics Tutorial, 2003.
Point–Based Computer
[Amor02] M. Amor, M. B´ oo, A. del R´ ıo, M.
Wand, and W. Straßer. A New Algorithm
for High Speed Projection in Point Render-
ing Application. In Euromicro 2003. Work-
shop on DSD, pages 136–149, 2002.
[Gross98] J. P. Grossman. Point Sample Render-
ing. In Master’s thesis, Dept. of Electrical
Engineering and Computer Science, 1998.
[Gumho98] S. Gumhold and W. Straßer. Real–
Time Compression of Triangle Mesh Con-
nectivity.In Siggraph’98, pages 133–140,
1998.
[Gumho99] S. Gumhold,
Straßer.
with the Cut–Border Machine. In IEEE Vi-
sualization ’99, pages 51–58, 1999.
S. Guthe,and W.
Tetrahedral Mesh Compression
[Mall´ o02] P.N. Mall´ on, M. B´ oo, M. Amor, and
J.D. Bruguera.Concentric Strips: Algo-
rithms and Architecture for the Compres-
sion/Decompression of Triangle Meshes. In
3D Data Processing Visualization Trans-
mission, pages 380–383, 2002.
[Pfist00] H. Pfister, M. Zwicker, J. van Baar, and
M. Gross. Surfels: Surface Elements as Ren-
dering Primitives. In Siggraph 2000, pages
335–342, 2000.
[Ren02] L. Ren, H. Pfister, and M. Zwicker. Ob-
ject Space EWA Surface Splatting: A Hard-
ware Accelerated Approach to High Quality
Point Rendering. In Eurographics, 2002.
[Rossi99] J. Rossignac.
tivity Compression for Triangle Meshes.
IEEE Trans. on Visualization and Com-
puter Graphics, 5(1):47–61, 1999.
Edgebreaker:Connec-
[Rusin00] S. Rusinkeiwicz and M. Levoy. QSplat:
A Multiresolution Point Rendering System
for Large Meshes. In Siggraph 2000, pages
343–352, 2000.
[Szymc99] A. Szymczak and J. Rossignac. Grow
&Fold: Compression
Meshes. In ACM Symp. on Solid Modeling
and Applications, pages 54–64, 1999.
ofTetrahedral
[Wand01] M. Wand, M. Fischer, I. Peter, F. M.
auf der Heide, and W. Straßer. The Ran-
domized z–Buffer Algorithm:
Rendering of Highly Complex Scenes. In
Siggraph 2001, pages 361–370, 2001.
Interactive
[Zwick01] M. Zwicker, H. Pfister, J. van Baar, and
M. Gross.Surface Splatting.
Fiume, editor, Siggraph 2001, pages 371–
378, 2001.
In Eugene