Document Sample
Delphi Powered By Docstoc
					       Delphi: Geometry-based Connectivity Prediction
                in Triangle Mesh Compression
VOLKER COORS                                                            JAREK ROSSIGNAC
Stuttgart University of Applied Sciences                                College of Computing, IRIS and GVU Center
Geomatics, Computer Science and Mathematics                             Georgia Institute of Technology
Schellingstr. 24, D-70174 Stuttgart                                     Atlanta, Georgia, USA                                    

Delphi is a new geometry-guided predictive scheme for compressing the connectivity of triangle meshes. Both
compression and decompression algorithms traverse the mesh using the EdgeBreaker state machine. However,
instead of encoding the EdgeBreaker clers symbols that capture connectivity explicitly, they estimate the location
of the unknown vertex, v, of the next triangle. If the predicted location lies sufficiently close to the nearest vertex,
w, on the boundary of the previously traversed portion of the mesh, then Delphi estimates that v coincides with w.
When the guess is correct, a single confirmation bit is encoded. Otherwise, additional bits are used to encode the
rectification of that prediction. When v coincides with a previously visited vertex that is not adjacent to the parent
triangle (EdgeBreaker S case), the offset, which identifies the vertex v, must be encoded, mimicking the Cut-
Border Machine compression proposed by Gumhold and Strasser. On models where 97% of Delphi predictions are
correct, the connectivity is compressed down to 0.19 bits per triangle. Compression rates decrease with the
frequency of wrong predictors, but remains below 1.50 bits per triangle for all models tested.
Categories and Subject Descriptors (according to ACM CCS): I.3.2 [Computer Graphics]: Graphics Systems -
distributed/network graphics; E.4 [Coding and Information Theory]: Data compaction and compression
Keywords: triangle meshes, connectivity coding, geometric prediction, geometry compression

Introduction and overview
Due to improved tools for the design and acquisition of 3D models, to the wider acceptance of 3D technology, and
to the need for higher accuracy, the number and complexity of models that are accessed over Internet connections
are growing faster than network bandwidth. Consequently, it is imperative to continue increasing the terseness of
3D data transmission formats. Although several representations have been proposed for 3D models, triangle
meshes remain the de facto standard for exchanging and viewing 3D models. They may be used directly to
represent polyhedral surfaces or serve as control structure for subdivision surfaces.
A triangle mesh may be represented by its geometry (vertex location data) and by its connectivity (triangle/vertex
incidence table from which triangle/triangle adjacency may be derived). Most compression techniques encode
connectivity independently of geometry. In these schemes, the connectivity and geometry of the previously
decoded portion of the mesh are used to predict the location (geometry) of the next vertex. However, previously
decoded geometry has, so far, not been used to explicitly predict connectivity.
Already of theoretical interest forty years ago24, lossless connectivity encoding has received over the last few years
an increased amount of attention1, 4, 16, 21 because of its practical importance for the transmission of 3D models.
Although several recent schemes focus on progressive transmission2,3,7,10,14,22,28, the reduction of the total number of
bits per triangle remains the primary and the most objective measure of the effectiveness of a compression scheme.
Furthermore, single-resolution connectivity compression retains its strategic importance, because a coarse starting
point of a progressive model must often be transmitted first and because in many situations where high accuracy of
the model is required, single-resolution compression is more effective.
In this paper, we propose a new encoding technique, called Delphi1, for the single-resolution, lossless compression
of the connectivity of triangle meshes. Delphi was originally developed as an improvement of the EdgeBreaker
compression16 described in some details in the next section. However, as explained later, some aspects of it (i.e. the
transmission of the offset) are more aligned with the Cut-Border Machine6 approach. Nevertheless, we use the
EdgeBreaker terminology to explain the details of our approach. In fact, Delphi could be easily incorporated into
other compression schemes, including the Cut-Border Machine6 and also several variants of the valence-based
coding23,1 approaches, originally proposed by Touma and Gotsman. In Delphi, both compression and
decompression perform the same geometric prediction of the location of the tip-vertex of the next triangle. They

 The name Delphi is inspired by the ancient Greek oracle at Delphi. Pythia, the medium of the Oracle, responded to questions in words that
could only be understood by a priest of Apollo, the god of Truth. The priest translated the answers to the seeker.
Coors&Rossignac: Delphi                                                                                                                 1 / 12
estimate triangle connectivity by predicting the location of the tip vertex, v, of the next triangle. If v is too far from
all boundary vertices, Delphi estimates that that the tip vertex is a new vertex (EdgeBreaker C case). Otherwise, it
guesses that v is the closest boundary vertex. If the guess is correct, only the confirmation bit needs to be
transmitted. If not, additional bits are transmitted to rectify the guess. The corrections are encoded using different
bit-length symbols chosen to minimize the entropy. Because most Dephi's guesses are correct (up to 98% in our
experiments), connectivity information is often compressed to a fraction of a bit per triangle, as reported below. For
instance, for a variety of models re-sampled with the Piecewise-Regular Meshes approach26, between 96% and
98% of Delphi’s guesses are correct, resulting in an entropy of 0.3 and 0.4 bits per vertex, or equivalently, 0.15 and
0.2 bits per triangle.

Previous work
In this section, we review several techniques for the loss-less compression of the connectivity of triangle meshes.
The connectivity of a “simple” mesh (defined as a connected, zero-genus, manifold triangle mesh) may be stored as
a sequence of t triangle descriptors, each triangle been represented by 3 integer labels. Each label identifies one
amongst the v vertices and hence requires log2(v) bits. Organizing triangles into strips5, where each new triangle
shares an edge with the previous one, reduces the above storage by nearly half. The use of a buffer to cache a small
number of labels4 may further reduce the expected cost.
The Topological Surgery method of Taubin and Rossignac21 compresses both a triangle-spanning tree and its dual
vertex-spanning tree by encoding the lengths of consecutive single-child nodes. Both trees suffice to decode the
connectivity of the simple mesh. For complex and reasonably regular meshes, the expected cost of encoding both
trees amounts to less than two bits per triangle. However, the overhead of the run length encoding may result in a
significantly higher average cost for irregular or small meshes.
Rossignac's EdgeBreaker compression scheme16 was the first one to propose a tight linear worst-case bound of the
connectivity compression. The original method guarantees 4 bit per vertex (denoted b/v for simplicity). This
guaranteed upper bound was later improved to 3.67 b/v11 and to 3.60 b/v8. This upper bound on storage does not
rely on statistic-based entropy or arithmetic coding schemes, which are discussed below and, in general, perform
poorly on small or irregular meshes. EdgeBreaker visits all the triangles of a mesh one at a time, walking from a
previously visited triangle to one of its not-yet visited neighbors through their common edge, called the “gate”. For
manifold meshes, the tip of the new triangle is either a “new” vertex (case C) that has not yet been encountered or
an “old” vertex of the boundary separating the previously visited portion of the mesh from the rest. EdgeBreaker
distinguishes four types of “old” vertices, depending on whether they appear in that boundary immediately before
the gate (case L), immediately after the gate (case R), both (case E), or neither (case S). The succession of case
types produced by this traversal are encoded as a succession of symbols from the set {C,L,E,R,S}, called the clers
sequence. These situations and the associated clers symbols are shown in figure 1 (left). The arrow indicates the
direction to the next triangle. Previously visited triangles are not shown. Note that in the case S, EdgeBreaker
moves to the right, using a recursive call, and then to the left. Figure 1 (right) gives an example of the clers
sequence of a small region of a simple mesh. A detailed description of the EdgeBreaker compression and
decompression and extensions to meshes with handles and holes are discussed in16,18,29. Because half of the
triangles correspond to case C in a simple mesh, one may chose to encode them using a single bit (for instance 0),
while the remaining four cases may be unambiguously encoded using 3 bits each (110 for L, 101 for R, 111 for E,
and 100 for S). This simple code guarantees to compress the EdgeBreaker-generated clers sequence of any zero-
genus manifold mesh with exactly 4.0 bits per vertex. The clers sequence of meshes encountered in practice may
be compressed even further, sometimes to less than 1.8 bits per vertex, using variable-length entropy codes17.
When the mesh has a sufficiently large number of vertices and most of them have exactly six neighbors, the clers
sequence can provably be compressed down to 1.62 bits per vertex19.

         v                  v                  v                       R               R
         T                  T                  T
                                                                           L       C               L      E
        L                  C                  R
                   v                   v                                                   S   R
                   T                   T                                           R
                   S                   E

  Figure 1: EdgeBreaker cases and the associated clers symbols for the triangle marked T (left). An
  example of the EdgeBreaker traversal generating the clers sequence: CRSRLECRRRLE

For zero-genus meshes, the clers sequence is sufficient to represent the complete connectivity. It explicitly encodes
the location of the tip vertex for cases C, L, E, R. For the S case, the original EdgeBreaker decompression16
Coors&Rossignac: Delphi                                                                                             2 / 12
computed the offset, i.e. the number of edges that separate the gate from the tip vertex of the new triangle along the
border. The computation was performed by tracking the edge-count changes imposed on the boundary portion
joining the gate to the tip, by the operations that separate the S symbol from the matching E, which makes the edge-
count zero. A more efficient decompression algorithm, called Wrap&Zip17, interprets the clers sequence to build a
simply connected triangulated polygon, obtained by gluing the triangles along the triangle-spanning tree. During
this process, it orients the border edges of that polygon in an upward direction with respect to the vertex-spanning-
tree that is the dual of the triangle-spanning-tree. Each time it finds two border edges that point away from their
common vertex, it zips them into an internal edge. An elegant third alternative, called Spirale Reversi9, processes
the clers sequence from the end, and thus avoids the zipping process.
Although developed independently, EdgeBreaker bears strong similarities with Gumhold and Strasser’s cut-border
machine6. For manifold meshes without holes, the principal difference lies in the fact that cut-border explicitly
encodes an offset with each S symbol, while EdgeBreaker does not.
Similarly to the Topological Surgery, to EdgeBreaker, and to Cut-Border, Touma and Gotsman’s valence
coding23 also encode the vertices along a vertex-spanning tree. However, instead of the five EdgeBreaker cases,
they distinguish only two cases, split and add, which correspond to the EdgeBreaker's cases S and C. Instead of the
other symbols, they encode the valence of each vertex, i.e., the number of incident triangles. Thus, each C symbol
is associated with an integer valence and each S symbol (as in the cut-border machine) is associated with an integer
offset. Their decoder keeps track of the valence defect of all border vertices. When the defect of a vertex v reaches
1, a new triangle is automatically inserted in the star of v, turning it into an interior vertex. Thus L, R, and E
triangles are recovered automatically and need not be encoded. Experimental results show that this approach
compresses connectivity down to less than 0.2 b/v for very regular meshes, and between 2.0 and 3.5 b/v for the less
regular meshes found in practice.
Alliez and Desbrun1 replace the deterministic traversal of Touma and Gotsman’s approach by an adaptive
traversal that attempts to minimize the number of split operations (EdgeBreaker’s S cases). To do so, they choose
the border edge bounded by vertices with the smallest number of free edges as the new gate. This optimized gate
selection was further improved in Angle-Analyzer13, where Lee, Alliez and Desbrun use both connectivity and
geometry to direct the mesh traversal. They select the gate using connectivity and geometry criteria, as the border-
edge having the highest number of incident triangles and also the minimum angle with a neighboring border edge.
The optimal combination of these two criteria dramatically decreases the frequency of S symbols. Thus, by
combining the simplicity of EdgeBreaker with the statistical benefits of valence-based coding, they improve
connectivity compression by 40% over the original valence coding approach23.

Delphi Encoding
In this section, we present Delphi, a new geometry-based predictive connectivity compression scheme for encoding
the clers sequence produced by the EdgeBreaker mesh traversal. For simplicity of the exposition, we focus on
simply connected meshes that are homeomorphic to a sphere. The proposed approach applies to more complex
meshes as well, but the cost analysis and encoding are more complicated.
The Delphi compression does not encode the clers sequence directly. Instead, it tries to guess each clers symbol
and encodes the confirmation and, when necessary, the corrections to these guesses. The guess is based on the
geometry and connectivity of the previously visited triangles.
The Delphi decompression performs the same guesses and decodes a confirmation bit that either confirms that the
guess is right or indicates that it is not, in which case a corrective string of subsequent bits will select the correct
code. For cases where an S case was wrongly guessed, that corrective string will also include an encoding of the
offset. Including the offset explicitly is necessary, because subsequent Delphi guesses rely on connectivity
information that would not be available if one of the EdgeBreaker decompression schemes were used to estimate
the offset by looking ahead along the clers string16, by delaying the zip operations17, or by reading the clers string
backwards9. The sequence of confirmation bits and of corrections is called the Apollo sequence.
In the following, we will explain how to guess the clers symbol of each triangle and how to encode the Apollo-

A corner c is the association of the triangle c.t with one of its bounding vertices, denoted c.v. The next corner
around a triangle in counterclockwise direction (with respect to the outward normal) is denoted c.n, the previous
corner c.p, and the opposite corner c.o. We say that corner b is opposite to c if c.n.v=b.p.v and c.p.v=b.n.v.
The Corner Table proposed in18 encodes all of the connectivity information as an array of tuples (c.v,c.o). Because
entries of c.p, c, and c.n are consecutive in the Corner Table, c.n, c.p, and c.t may be trivially computed from the
integer value of c by using integer division by 3.
The location (i.e. geometry) of the vertex c.v associated with the corner c is denoted c.v.g.
As in the original EdgeBreaker algorithm, we move from a triangle F to an adjacent triangle T at each step of the
mesh traversal. F and T share a common edge, G, called the gate. Let c be the “tip” corner of T that is not incident
upon any one of the vertices of G, as shown in figure 2. Let Length(G) denote the length of the gate. The
Coors&Rossignac: Delphi                                                                                           3 / 12
information transmitted by Delphi must identify the vertex c.v. Let g(c) be the estimate on the location of c.v.g. In
practice, we compute g(c) using the parallelogram rule23: g(c) = c.n.v.g+c.p.v.g–c.o.v.g, but more elaborate
estimates could be used.
Let B denote the set of all border vertices in the boundary of the decoded portions of the mesh. As we have
assumed that the mesh is simply connected, the vertices of B form one or several cyclic chains {c.p.v, Vr, …Vl,
c.n.v}, called hereafter “loops”, along the oriented border. One of these loops contains the gate. We will call it the
“active loop”.
For zero-genus meshes, we know that c.v is either a new vertex or already part of the active loop. Let B’ be the set
of vertices of the active loop excluding the gate vertices c.n.v and c.p.v. Let X be the vertex of B’ that is the closest
to g(c). Let d:=Dist(X,g(c)) denote the distance between them. X is a prime candidate for c.v. We will use the
distance d to decide whether X is our guess or whether we are guessing that c.v is a new vertex (case C).
                              Already traversed area

                                                                        Active loop

                        T                  g(c) d
                                 Vl          c.n c.p               Vr
                                               c.o                        F

                             Figure 2: Connectivity guessed by parallelogram

Connectivity prediction
When the distance d between the predicted location g(c) of the tip of the next vertex and the closest border-vertex,
X, exceeds a threshold, we assume a C triangle. In such a situation, the corrective vector gp = c.v.g – g(c) between
the prediction g(c) and actual vertex location c.v.g will be encoded.
When d is smaller than a threshold, X will be our guess. If that guess is correct, the decompression may
immediately convert it to one of the four cases: L, E, R, or S, depending on whether X is V1, or Vr, or both, or
neither as shown in figure 3:
     • If X = V1 = Vr, then we guess that T is of type E.
     • If X = Vr, then we guess that T is of type R.
     • If X = Vl, then we guess that T is of type L.
     • Otherwise, we guess that T is of type S.
The threshold for d is proportional to the length of the gate G. More precisely, if d>τ*Length(G), we guess that T is
of type C. We have established experimentally that the setting τ=0.6 consistently resulted in the most correct
guesses across all models that we tested.
A single confirmation bit in the transmission stream suffices to indicate whether our guess is correct. If so, we
know the code of T (i.e., we have decoded its EdgeBreaker symbol using one bit), but we also know which vertex it
is (even for S cases) and can thus zip the border immediately during decompression, avoiding the zip delays
introduced in17 and not requiring the transmission of offsets that are associated with S triangles6, 23 to identify the
tip-vertices of S triangle.
If the confirmation bit indicates that the guess is wrong, we may need additional information to rectify it. Note that
a false guess does not necessarily indicate a wrong symbol. We might wrongly guess c.v as X and concluded an S
situation, when in fact, we do have an S case, but with a different tip vertex.
In the following, we explain how we encode the rectification for each wrongly guessed symbol. The encoding
depends on the guessed symbol and on the edge-count in the active border. We start with the case where we
wrongly guessed a C as shown in figure 4. Then we discuss the cases where we wrongly guessed L, R, S, or E (see
figure 5).

Coors&Rossignac: Delphi                                                                                            4 / 12
Wrong C guess
If we guessed a C and in fact c.v is a vertex in B’, the confirmation bit in the transmission stream indicates that our
guess was wrong. The subsequent bits specify the correct case (L, E, R, or S).
    • If the vertex-count, |B’|, of the active loop (not counting the gate’s vertices) is 1, the new triangle is of
         type E.
    • If |B’|=2, only two possible symbols {L, R} have to be distinguished. Thus a single bit is sufficient.
    • Otherwise, E situation is impossible and we only need to distinguish between the three remaining cases: L,
         R, or S. In an S case, we need at most log2(|B’|) additional bits to encode the offset necessary to locate
         c.v along the border. However, experimental results have shown that in most cases the offset is 2 or 3 (see
         also6) and thus can be encoded compactly.

                    Guess C in

                                          X                             X
                          g(c)                          g(c)

                     Situation R                   Situation L

                                   g(c)              g(c)

                     Situation S                   Situation E

                    Figure 4: Situations wrongly guessed as a C case.

Wrong E guess
If we wrongly guessed that the next triangle is of type E, we must be in a situation where the active loop has only 3
edges, i.e., X=V1 and X=Vr, because an E is guessed only with |B’|=1. Hence, the correct guess must be a C
situation. The confirmation bit is sufficient and no additional bits are necessary to rectify the guess.

Wrong R guess
If we wrongly guessed that the next triangle is of type R (X=Vr), the subsequent bits are used to distinguish
between the three remaining symbols {L, C, S}. An E symbol is not possible here. When the rectified symbol is an
S, the offset must also be encoded.

Wrong L guess
If we wrongly guessed that the next triangle is of type L (X=V1), we must distinguish between the remaining
symbols {R, C, S}. An E symbol is not possible. When the rectified symbol is an S, the offset must be encoded.

Wrong S guess
If we wrongly guessed that the next triangle is of type S, the four remaining symbols {C, L, R, S} are possible. (An
E symbol is not possible here, because an E situation occurs only with | B’|=1. In which case, we would have
guessed C or E, but not S.) Even if S is the correct guess, the tip-vertex might not be X. So, when the correction
states that the guess of S is correct but the tip is wrong, additional bits must be transmitted to identify the correct
tip-vertex in the active loop. These situations are rare because the number of S cases is relatively small and many of
them are correctly identified.

Impossible cases
Taking into account the current length of the active border |B’|, some cases are not possible.

Coors&Rossignac: Delphi                                                                                          5 / 12
- If |B’|=1, only cases C and E are possible. |B’|=1 implies V1=Vr. L, R and S situations are not possible. In this
  case, the validation bit suffices to distinguish between the two possible cases: C or E.
- If |B’|=2, then B’ only contains the vertices V1 and Vr. Neither an E nor an S situation are possible in this case.
  If the guess is wrong, one additional bit is sufficient to rectify the situation. For example, in case of a wrongly
  guessed R, one bit indicates that the guess is wrong, and an additional bit distinguishes between a C and L
- Finally, when |B’|=3, there is only one vertex in the active border besides V1 and Vr and thus that vertex is the
  only acceptable tip-vertex for an S case. There is no need to send corrective bits to identify the tip in a wrongly
  guessed S triangle. Furthermore, a wrongly guessed S case cannot be an S with a different tip-vertex.

              Guess wrong R

                               g(c)                           g(c)                        g(c)
                                        X                            X                           X

              Situation L                     Situation C                  Situation S

                 Guess wrong L

                   g(c)                             g(c)                         g(c)
               X                                X                            X
              Situation R                      Situation C                  Situation S

             Guess wrong S

                                X                             X                           X                        X
                   g(c)                          g(c)                         g(c)                        g(c)

            Situation R                     Situation L                  Situation C                 Situation S

              Guess wrong E


                          Situation C

          Figure 5 Wrongly guessed non-C triangles. The gray triangle shows the actual situation. The yellow
          triangle visualizes the parallelogram prediction.

Coors&Rossignac: Delphi                                                                                            6 / 12
Using a careful analysis of these situations and exploiting the restrictions described above, we hade devised and
evaluated several variable length schemes for encoding the corrective string of bits.
Dephi encodes the clers sequence as a series of entries, one per symbol. An entry may have one, two, or three
fields. The first field is always the confirmation bit. Hence the entry (t) indicates that the Delphi guess was right.
As explained earlier, in some cases, a wrong guess may be rectified by the decompression without any additional
information, thus, some entries may be of the form (f), indicating a wrong guess. Other wrong guesses may require
sending the correct clers symbol, and hence will have two fields, for example (f,C) will indicate that the guessed
symbol was wrong and that the correct symbol is a C. We use the notation RS to refer to the second field, which
indicates how to rectify the symbol.
Finally, in some cases, when the guess was wrong and the correct symbol is an S, one may also need to transmit the
offset for identifying the tip of an S triangle. In such cases, the entry will have 3 fields: (f,S,o).
Thus, we have only four possible forms for an entry: (t), (f), (f,S,o), or (f, RS), where RS stands for C, L, E, R, or S.
Such a sequence of entries is called the Apollo sequence and is used by the Delphi decompression to interpret the
connectivity guess. Figure 6 shows the Apollo sequence of the example introduced above, in figure 1.

Performance and improvements of connectivity prediction
In this section the complexity of the compression and decompression algorithm will be analyzed. The traversal of
the mesh during compression and its reconstruction during decompression are extremely fast, especially when
implemented on a Corner Table, which limits the recursive calls to only S cases and does not perform any dynamic
heap storage allocation. The standard parallelogram geometric prediction is straightforward and equally
inexpensive. Hence, the only cost increase due to the Delphi extension over the standard EdgeBreaker
implementation lies in the computation of the vertex X of the current border loop that is the closest to the predicted
location g(c) of the new tip vertex. The implementation described above requires visiting all of the vertices of the
current border loop for each triangle. If k is the maximum length of the active border, this nearest neighbor search
has worst case complexity of O(k). Usually, the length of the active border is small compared to the number of
triangles t in the mesh. However, worst case complexity of the Delphi compression and decompression is O(k*t)
and, since k may be proportional to t, it is O(t2).
This quadratic worst case complexity can be avoided by restricting the search for X to a constant number N of
neighbors of the gate in each direction along the active border, rather than the entire border.
This simplification reduces the cost of the search for the best match to constant complexity O(1) and results in a
linear worst case complexity O(t) of compression and decompression algorithm. Our experiments show that this
variation has a negligible effect on compression results.
Figure 6 shows the effect of the restricted search for X on the horse model (96966 triangles, see figure 8).

Figure 6: Effect of restricted search for X on quality of prediction (left), number of wrongly predicted S situations
(middle) and runtime (right).Runtime was measured on Toshiba Satellite Notebook, Pentium 4 1.2 GHz,512 MB
RAM,Delphi implemented in Java using JDK 1.4.2

Surprisingly, the overall prediction is improved by restricting the search to a few vertices to the left and right of the
gate. As you can see in figure 6 (left), best predictions are achieved with only looking at the vertices left and right
of the gate. However, the number of wrongly predicted S situations drastically increases in this case (figure 6
middle). In particular, the limited search increases the number of S symbols wrongly predicted to be C and
decreasing the number of C symbols wrongly predicted to be S. The runtime of the restricted search is given in the
right diagram of figure 6. As expected, compared to the search of X on the entire active border, the restricted search
is much more efficient.
As rectified S are expensive due to the additional offset information, the number of wrongly predicted S situations
should be minimized. However, due the runtime performance gain, we recommend to restrict the search for X to 4
or 5 vertices left and right to the gate.
Statistical analysis on the example of the Horse model
We analyze the frequency of right and wrong guesses and of the various corrections we use the example of a
typical mesh with 96966 triangles and 48485 vertices that represents a horse shown in figure 8.

Coors&Rossignac: Delphi                                                                                            7 / 12
To gain a better understanding of the various statistics, we have also collected, for each step of the compression:
the guessed symbol GS and the current length |B’| of the active loop. We report statistics for the various
combinations of guessed symbol, GS, correct symbol, RS, and loop length, |B’|.
Table 1 shows the distribution of correctly and wrongly guessed triangles as a function of the length of the active
loop. A total of 17% of the guesses are wrong.
Out of these, 98% happen when the active loop has more than 3 vertices, in addition to the vertices that bound the
gate. Hence, treating short loops as special cases does not have a significant impact.

                                                 P(f)            0.1710
                                                 P(|B’|=1|f )    0.0162
                                                 P(|B’|=2|f )    0.0025
                                                 P(|B’|>=3|f)    0.9813
 Table 1: Probability of wrong guesses (top) and conditional probability of the edge-count |B’| of the border loop
                                   for wrong guesses is given for short loops.

The next table shows the probability PXY of encountering a wrongly guessed symbol GS=X and its rectification
RS=Y in cases where an active border length is greater than 2
                                PXY     RS=C       RS=L         RS=R      RS=S     Sum
                                GS=C    --         0.0033       0.5209    0.0143   0.5385
                                GS=L    0.0082     --           0.0067    0.0004   0.0153
                                GS=R    0.2751     0.0013       --        0.0163   0.2927
                                GS=S    0.0580     0.0003       0.0932    0.0020   0.1535
                                Sum     0.3413     0.0049       0.6208    0.0330   1.0000
                          Table 2 Probability of guessed and rectified symbols combinations.

Figure 8: Delphi compression of the horse model (96966 triangles). Correctly predicted triangles are colored
green, wrong ones red. About 83% of the connectivity is correctly guessed leading to a bit rate of 1.47 b/v.

Note that 62% of the mistakes are R-type triangles. 84% of them are wrongly guessed as a C triangle. The next
major source of mistakes are C-type triangles, which account for 34% of all wrong guesses. 80% of them are
mistaken for R-type triangles.
Thus, when a guessed C (GS=C) proves to be wrong, the correct symbol is usually R, and vice versa, in case of a
wrong guess GS=R, most rectified symbols are C. An entropy encoder may exploit this bias.
Another interesting fact is that a rectified symbol S occurs in only 3% of wrong guesses. Thus, when the
probability of a wrong guess is 0.17, the combined probability of a wrongly guessed S symbol is only 0.51%.
Therefore, the offset needs to be encoded for only one half of a percent of the triangles. Table 3 shows the
distribution of that offset. The offset is 2 in 90% of the cases and is 3 in 6% of the cases. Using an arithmetic coder,
the offsets are encoded with less than 1.1 bits each in these cases.

Coors&Rossignac: Delphi                                                                                           8 / 12
                                                2                  0.90
                                                3                  0.06
                                                >3 (max 560)       0.04

                                       Table 3 Offset distribution in case of RS=S
The remaining 4% of the offsets are greater than 3. For the models we have tested, the offset did not exceed 560
and hence can easily be encoded with less than 10 bits each. Given that offsets longer than 3 need to be encoded for
only 0.02% of the triangles, the amortized cost of encoding these longer offsets is only 0.002 bits per triangle.

Figure 7: Example Apollo encoding: The first triangle was correctly guessed to be of type C. Thus, the
Apollo sequence starts with the entry (t). The parallelogram rule predicts the tip of the next triangle to be
at g(c), as shown top left. Since g(c) is too far from the active border (red line), we guess that the second
triangle is also of type C. Unfortunately, that guess is wrong. The correct triangle, shown in gray, is of
type R. Hence, the second Apollo entry is (f,R). The third triangle is correctly guessed to be of type S with
the correct tip. Hence the third entry is (t). The complete Apollo sequence is ((t), (f,R), (t), (t), (t), (t), (t),
(t), (t), (f,R), (t), (t), (t)).

Compressing the Apollo sequence
A fixed- format encoding
In this sub-section, we describe a simple, fixed-format, encoding of the Apollo sequence that is not based on
entropy or arithmetic codes. We analyze its performance for a typical mesh.
Our simple encoding uses one confirmation bit per triangle, plus 0, 1, 2 or 3 bits for encoding RS, depending on
whether the wrong guess was an S or not and depending on the length of the active loop, plus between 2 and 11 bits
for the offsets, 1 bit indicating whether the offset is short (2 or 3) or long.
For the example of the horse, 83% of the entries will be encoded with a single bit, because they correspond to the
correct guess, (t).
For 14% of the triangles (0.17*0.85) the wrong guess is not an S. In these cases, have to distinguish 3 symbols. We
use 1 bit (say 0) to encode the symbol with highest probability. We use 2 bits (say 10 and 11) to encode the other
two symbols.
In the worst case, when all three symbols have identical probabilities, this encoding will require an average of 1.67
bits (1/3 * 1 Bit + 2/3 * 2 Bit = 1.67 Bit)
This corresponds to an amortized cost of 0.241 bits per triangle.
Coors&Rossignac: Delphi                                                                                                9 / 12
When we wrongly guessed an S, we need to distinguish between 4 symbols (remember than an E is not possible in
this case). We use 2 bits to encode RS. This adds an amortized cost of 0.051 bits per triangle (0.17*0.15*2 bits).
Finally, we need to encode offsets for 0.51% of the cases. If we use 1 bit to indicate whether the offset is 2 or not,
we encode 90% of the offsets with 1 bit. The amortized cost is 0.005 bits per triangle. Finally, the 10% of the
longer offsets will be encoded using 11 bits (one bit to indicate that they are not equal to 2 and 10 bits to encode an
offset of up to 1024). The amortize cost of the long offsets amounts to 0.006 bits per triangle.
In summary, the naïve encoding described above would produce, for the horse model, the following contributions
amortized in bits per triangle:
   - 1.000 bit: Confirmation bit
   - 0.241 bit: Rectify a wrong C, L, R guess
   - 0.051 bit: Rectify a wrong S guess
   - 0.005 bit: Short offsets (o=2)
   - 0.006 bit: Long offsets (o>2)
The total is 1.30 bits per triangle, which improves significantly upon the simple codes of 2.0 and 1.8 bits per
triangle compression previously achieved by using fixed-format encodings for connectivity.

Statistical encoding
The naïve fixed-format encoding described above may be significantly improved using a more optimal variable
length coding that exploits the statistical distribution of the symbol frequencies. To do so, the streams of
confirmation bits, symbol-rectification codes, and offset values are decomposed into separate layers and
compressed separately using an adaptive entropy encoder, such as the range encoder used in Alliez and Desbrun1
for example. However, compression results vary using different encoders. Therefore, we adhere to the current
practice in the Geometry Compression Community and report the entropy of the Apollo sequence as the sum of the
entropy of these three streams. A good arithmetic encoder comes close to this entropy measure.
The confirmation bit layer is a sequence of symbols in{t, f}, one per triangle. The entropy of that stream is
–plog2(p)–(1–p)log2(1–p), where p is the probability of a correct guess. For instance, when p=0.83, the entropy of
the confirmation bit layer is 0.66 bits per triangle.
The symbol rectification layer contains the sequence of correct symbols, RS, for all wrong guesses. In the case of
wrong guesses may be compressed by combining two observations: (1) some of the cases are impossible in
particular combinations of guessed symbol and loop length and (2) more importantly, the majority of rectified
symbols may be guessed correctly, because they are a C when the wrong guess was R and vice versa.
Each rectification sub-layer is treated independently leading to the following entropies:
     • Sub-layer GS=C : Entropy 0.2290 (-(0.006*log20.006 + 0.9675* log2 0.9675 + 0.0265 * log2 0.0265))
     • Sub-layer GS=L : Entropy 1.1409
     • Sub-layer GS=R : Entropy 0.3476
     • Sub-layer GS=S : Entropy 1.0398
By multiplying the entropy of each sub-layer by the probability of each sub-layer and adding the results and
multiplying by the probability of having to use a rectification (0.17*(0.2290*0.5385 + 1.1409*0.0153 +
0.3476*0.2927 + 1.0398*0.1535) ), we obtain an entropy for the symbol rectification layer of 0.0684 bits per
As stated above, the offset layer has an entropy of 0.011 bits per triangle.
Adding all thee (0.66 + 0.0684 + 0.011), we obtain a total entropy of 0.74 bit per triangle for the horse model.

Comparative analysis
The first order entropy compression discussed above leads to 0.74 bits per triangle for the horse model of figure 8.
The corresponding clers sequence produced by EdgeBreaker has a first order entropy of 0.88 bits per triangle.
Thus, Delphi’s geometry-based prediction yields an entropy improvement of 15%.

Experimental results
To put the above horse example in perspective, a series of meshes (figure 9) have been tested with the Delphi
compression. The connectivity compression results (Table 4) are given in bits per triangle of the calculated first
order entropy encoding. The results are compared with the first order entropy of the corresponding EdgeBreaker
clers sequence (EB).
The results show that a good connectivity guess improves EdgeBreaker clers sequence compression. For very good
connectivity guesses like the Mannequin model, the Apollo encoding improves EdgeBreaker by a factor of 3.
When the probability of a wrong guess exceeds 40%, the Delphi encoding stops being advantageous.

Coors&Rossignac: Delphi                                                                                         10 / 12
                                 Model       #V     #T     Delphi bpt (p(t)) EB
                                 Horse       48485 96966 0.74 (83%)        0.88
                                 Cow         2904   5804   0.80 (83%)      1.13
                                 Body        711    1396   1.13 (65%)      1.30
                                 Mannequin 11704 23402 0.19 (97%)          0.60
                                 Venus       8268   16532 1.42 (59%)       1.43
                                 Neferiti    299    562    1.09 (69%)      1.29
                                 David       24085 47753 1.45 (58%)        1.40
Table 4 Compression results (in bits per triangle). The percentage of correct guesses is given for the Delphi

Figure 9: 3D meshes used for bit-rate measurements.

Conclusion, discussion, and future work
In this paper, we described a lossless, single-resolution connectivity encoding technique called Delphi. In contrast
to the early connectivity compression schemes, Delphi uses the previously decoded geometry and connectivity to
predict the location of the tip-vertex of the next triangle. The geometry prediction, which is based on the
parallelogram rule, is not affected by the Delphi encoding and thus has identical characteristics to previously
reported schemes23 for geometry compression.
Although implemented as a simple variation of the EdgeBreaker code, Delphi encodes the offset of wrongly
guessed S triangles, and thus, in these cases, follows the approach of the Cut-Border Machine.
The significant improvements made in connectivity compression have reduced the cost of transmitting connectivity
to less than 15% of the cost of transmitting geometry. So, the strategic importance of incremental improvements to
connectivity compression, such as the one proposed here, could be questioned. However, these improvements are
not negligible and worth taking advantage of. Furthermore, recent advances in the re-sampling of triangle meshes25,
26, 27
       have reduced the cost of encoding geometry to one scalar corrector per vertex. For instance, SwingWrapper27
partitions the surface of an original mesh M into simply connected regions, called triangloids. From these, it
generates a new mesh M’. Each triangle of M’ is a linear approximation of a triangloid of M. By construction, each
vertex of M’ is restricted to lie on a circle that is completely defined by the border edge of a previously visited
adjacent triangle. Thus, the geometry may be encoded using a single correction parameter per vertex, which
reduces the cost of geometry to less than 6 bits per vertex. Similarly, the Normal Mesh approach25 restricts each
vertex to lie along a line estimated from a previously decoded version of the mesh. The PRM approach26 snaps two
coordinates of each vertex to a regular grid, which makes their prediction (using the parallelogram rule) extremely
consistent. Delphi predicts the connectivity of the resulting meshes with an accuracy ranging between 96% and
98%, resulting in an entropy of 0.3 and 0.4 bits per vertex.
Finally, we expect that the cost of encoding wrongly guessed S triangles may be further reduced by combining
Delphi with a selection of the gate that attempts to avoid S cases, such as the one proposed by Lee, Alliez and
Desbrun in Angle-Analzyer13.

Coors&Rossignac: Delphi                                                                                      11 / 12
1. P. Alliez, and M. Desbrun, “Valence-Driven Connectivity Encoding for 3D Meshes”. Eurographics 2001 Conference
    Proceedings, 2001.
2. P. Alliez, and M. Desbrun, “Progressive Encoding for Lossless Transmission of 3D Meshes”. SIGGRAPH 2001 Conference
    Proceedings, 2001.
3. D. Cohen-Or, D. Levin, and O. Remez, “Progressive Compression of Arbitrary Triangular Meshes”. Visualization 99
    Conference Proceedings, pp 67-72, 1999.
4. M. Deering, “Geometry Compression”, Computer Graphics, Proceedings SIGGRAPH'95, 13-20, August 1995.
5. F. Evans, S. Skiena, and A. Varshney, “Optimizing Triangle Strips for Fast Rendering”, Proceedings, IEEE
    Vizualization'96, pp. 319--326, 1996.
6. S. Gumhold and W. Strasser, “Real Time Compression of Triangle Mesh Connectivity”, Proc. ACM SIGGRAPH, pp. 133-
    140, July 1998.
7. H. Hoppe, “Progressive Meshes”. Siggraph 96 Conference Proceedings, pp 99-108, 1996
8. S. Gumhold, “Towards optimal coding and ongoing research”, 3D Geometry Compression Course Notes, SIGGRAPH
9. M. Isenburg and J. Snoeyink, “Spirale Reversi: Reverse decoding of the EdgeBreaker encoding”, Computational Geometry,
    vol. 20, no. 1, pp. 39-52, October 2001.
10. A. Khoddakovsky, P. Schroeder, and W. Sweldens, “Progressive Geometry Compression”. Siggraph 2000 Conference
    Proceedings, pp 271-278, 2000.
11. D. King and J. Rossignac, “Guaranteed 3.67V bit encoding of planar triangle graphs”, 11th Canadian Conference on
    Computational Geometry (CCCG'’99), pp. 146-149, Vancouver, CA, August 15-18, 1999.
12. D. King and J. Rossignac, "Connectivity Compression for Irregular Quadrilateral Meshes" Research Report GIT-GVU-99-
    29, Dec 1999.
13. H. Lee, P. Alliez, and M. Desbrun, “Angle-Analyzer: A Triangle-Quad Mesh Codec”, Eurographics 2002.
14. R. Pajarola, and J. Rossignac, “Compressed Progressive Meshes.” IEEE Transactions on Visualization and Computer
    Graphics, pp 47-61, 1999.
15. J. Rossignac and D. Cardoze, “Matchmaker: Manifold Breps for non-manifold r-sets”, Proceedings of the ACM Symposium
    on Solid Modeling, pp. 31-41, June 1999.
16. J. Rossignac, "EdgeBreaker: Connectivity compression for triangle meshes", IEEE Transactions on Visualization and
    Computer Graphics, 5(1), 47-61, Jan-Mar 1999.
17. J. Rossignac and A. Szymczak, "Wrap&Zip decompression of the connectivity of triangle meshes compressed with
    EdgeBreaker", Computational Geometry, Theory and Applications, 14(1/3), 119-135, November 1999.
18. J. Rossignac, A. Safonova, and A. Syzmczak, "3D Compression Made Simple: EdgeBreaker on a Corner-Table", Invited
    lecture at the Shape Modeling International Conference, Genova, Italy, May 2001.
19. A. Szymczak, D. King, J. Rossignac, “An EdgeBreaker-based Efficient Compression Scheme for Connectivity of Regular
    Meshes”, Special issue of Journal of Computational Geometry: Theory and Applications, Vol 20, No 2, Oct 2001.
20. H. Tzschach, and G. Haßlinger, Codes für den störungsfreien Datentransfer, Oldenburg 1993 (in German).
21. G. Taubin and J. Rossignac, "Geometric Compression through Topological Surgery", ACM Transactions on Graphics,
    17(2), 84-115, April 1998.
22. G. Taubin, A. Gueziec, W. Horn, F. and Lazarus, “Progressive Forest Split Compression”. SIGGRAPH 98 Conference
    Proceedings, pp 123-132, 1998.
23. C. Touma and C. Gotsman, “Triangle Mesh Compression”, Proceedings Graphics Interface 98, pp. 26-34, 1998.
24. W. Tutte, “A Census of Planar Triangulations”. Canadian Journal of Mathematics, 14:21-38, 1962.
25. I. Guskov, K. Vidimce, W. Sweldens, and P. Schroeder, “Normal meshes,” in Siggraph’2000 Conference Proceedings, July
    2000, pp. 95–102.
26. A. Szymczak, J. Rossignac, and D. King. “Piecewise Regular Meshes: Construction and Compression.” To appear in
    Graphics Models, Special Issue on Processing of Large Polygonal Meshes, 2002.
27. M. Attene, B. Falcidieno, M. Spagnuolo, J. Rossignac, “SwingWrapper: Retiling Triangle Meshes for Better EdgeBreaker
    Compression”, Genova CNR- IMA Tech. Rep. No. 14/2001. To appear in the ACM Transactions on Graphics. Volume 22,
    No. 4, October 2003.
28. S. Valette, J. Rossignac, R. Prost. “An efficient subdivision inversion for Wavemesh-based progressive compression of 3d
    triangle meshes”, Submitted for publication. 2003.
29. H. Lopes, J. Rossignac, A. Safanova, A. Szymczak and G. Tavares. “A Simple Compression Algorithm for Surfaces with
    Handles”, ACM Symposium on Solid Modeling, Saarbrücken. June 2002.

Coors&Rossignac: Delphi                                                                                              12 / 12

Shared By: