# 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.

**0**Bookmarks

**·**

**50**Views

- [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

#### View other sources

#### Hide other sources

- Available from Margarita Amor · May 29, 2014
- Available from psu.edu