classification of quad-encoding techniques

97

Classification of Quad-encoding Techniques

Andrew Hunter and Philip Willis*

Abstract

Many quad encoding technique have been published previ- ously, using a variety of approaches to the different facets of quad storage, representation and manipulation. We review the major classes and identify three parameters which distinguish them. These are then used explicitly to classify a large number of published methods, with short discussion on each. In doing this we are also able to highlight some new approaches, to identify rare examples which escape the classification, and to suggest approaches to choosing a method to suit a given application.

Keywords: Quadtree, quad-encoding, image-encoding, image-processing,

1. Introduction

A considerable body of literature has arisen around the sub- ject of representing, manipulating and applying quad codes to pixel images. As a result there is a variety of techniques applicable to any given problem and a corresponding range of claims made concerning the efficacy of each. Such claims may at first sight conflict; more often the relationship to the desired problem is not clear. The different goals of the methods make it hard to produce a "consumer report" identifying a best method.

We have found it helpful to look for underlying common approaches and to ask what advantages are associated with which class of solution. On the way, we make some observations and refinements and introduce some useful nomenclature. We then make a classification, based on three parameters, which covers almost all of the published methods. We demonstrate this by classifying a wide sample of techniques in the literature, highlighting the reasons for our failure to classify the few exceptions. The value of the classification is demonstrated by the emergence of several new, highly compact, structures.

In Section 2 we prepare our ground by considering some case studies: four techniques which have been suggested in the literature. These illustrate many of the features in the classification and we will refer back to them as the classification develops.

In Section 3 we introduce most of the classification features: those related to the three parameters. A few other important features are described briefly in Section 4.

Section 5 contains a description of a large sample of published techniques using the new classification; a formal and a short-hand classification are given for each. This demonstrates that the classification is near-universal, only a few techniques escaping complete definition.

In Section 6 we examine coding efficiency and flexibility, two of the strongest factors influencing the use of quad encoding. This leads us to the surprising conclusion that one widely used family of techniques is actually rather inefficient.

1.1. Nomenclature and Observations

Before turning to the case studies we introduce some nomenclature. Different papers use various terms in different ways; we will stick rigorously to the nomenclature defined here. Readers who are unfamiliar with quad encoding are advised to read the case studies first and to refer back to this section as necessary. A quad is a general term for the square, power-of-two objects used in quad- encoding. A node is a record which represents a quad in a quad code; a quad code is a collection of nodes. A quadrant is the area of a picture corresponding to a quad. A coherent quadrant is one where every pixel is the same colour. The root quad is the one representing the whole picture. A leaf is a quad which is not sub-divided into further quads. An internal node is a quad which is sub- divided into further quads. Atomic quads, the smallest possible quads, correspond to individual pixels in the picture. Atomic quads are always leaves. All larger quads are called molecular. An internal node i s sub-divided into four other quads: these are called its children and it is called their parent. The four children of a single parent are called siblings. The parent, its parent, and all other parents up to the root are called the ancestors of a quad. Children of a parent's siblings are called cousins. Other familial rela- tions may be similarly constructed. The depth of a quad is the number of ancestors it has; the root quad therefore has depth 0. The atomic depth or picture depth specifies how big a picture the quad code can represent: picture depth n implies picture size The order of a quad is n if the quad is of size An atomic quad is therefore of order 0; in a depth n quad code the root is of order n.

This paper was presented at the 9th Annual EUROGRAPH- ICs (UK) Conference, Sheffield, UK. April 10-12, 1991.

*Computing Group School of Mathematical Sciences University of Bath Bath BA2 7AY, UK

The following simple observations are used throughout this paper. A depth n quad code has at most

quads. Observing that

North-Holland Computer Graphics Forum 10 (1991) 97-112

http://www.eg.org

http://diglib.eg.org

98 A. Hunter et al. / Classification of Quad-encoding Techniques

we may deduce that the full range may be addressed using fields not less than 2n+1 bits wide. Fractionally over 75% of nodes in a quad code are leaves (to see why, consider the effect of “growing” a tree by replacing a leaf quad with its four children), except when there are only a few nodes.

2. Case Studies

Here we describe four diverse methods of quad encoding which have appeared in the literature. Most other published forms bear a close relationship to one or other of these.

2.1. Case Study 1: the Quadtree

The first form is the oldest: the quadtree’. A quadtree is a tree in which each node is either a leaf or has exactly four children; see figure 1 . Leaves represent coherent quadrants; the colour is stored at the leaf. Internal nodes are not coherent, although they may optionally be assigned a colour which represents an average colour of the quadrant. The root node represents the whole picture. If it is not coherent its four children represent the four quarters of the picture. The quadtree is constructed by recursive decompo- sition of the picture, until only solid leaves are left.

The quadtree is normally implemented by defining a record structure where each record consists of a colour value and four pointers to the child records. Leaf nodes are distinguished from internal nodes by having NULL child pointers. A quadtree constructed in this fashion is often referred to as a Regular quadtree.

2.2. Case Study 2: the Locator Code

The second popular form of quad encoding, devised by Gargantini2, is often called a linear quadtree, although we will refer to it as a locator code. It consists of a pointerless list of a quadtree’s leaves; internal nodes are not stored. Each leaf is described by a fixed-length modified quaternary (base 4) number, which gives exactly the leaf‘s position in the quadtree. Equivalently, the number gives the position and size of the corresponding quadrant in the picture. The quaternary number is modified in the sense that there are five digits: 0, 1, 2, 3, and X. A strict quarternary number is sufficient to define the position of a pixel, normally the corner pixel of the quadrant closest to the origin, but we also need to encode the size of the quad. The number of trailing ‘X’ digits gives the size. If there are none, the leaf is atomic. If there is one, the leaf is molecular and twice the size of an atomic leaf. If there are two it

Figure 1. The regular quadtree

A. Hunter et al. / Classification of Quad-encoding Techniques 99

Figure 2 . The locator code

Figure 3. The depth-first ordered code

is twice as large again. In general, in a depth n quad code, a leaf with x trailing ‘X’ digits is of order x.

Gargantini’s code is designed for binary (black and white) pictures only. Because each leaf is individually identified it is possible to remove all leaves of a particular colour: the background colour. The identity of these leaves is then known by implication: any area not covered by a listed leaf is of the background colour. Since we typically expect about 50% of nodes to be of the background colour in a binary picture, 50% of nodes are removed by this method. It is also unnecessary explicitly to state the colour of listed nodes in a binary picture: they are all foreground by implication. See figure 2.

2.3. Case Study 3: the Ordered Code

The third form of quad encoding we consider is often called a treecode or traversal code, although we will refer to it as an ordered code3.

Pointers are very space-consuming, so storing a traversal of the tree rather than the tree itself will save a considerable amount of space. For a depth-first (in-order) traversal we construct the code for the quadtree as follows.

1 ) Traverse the quadtree depth-first;

2a) if the current quadtree node is not a leaf, write the special value ‘R’, for “Recurse”, then recursively write the lists for its four children;


Figure 4. Woodwark’s configuration code

2.4. Case Study 4: the Colour-mapped Ordered Code

Woodwark4 has suggested an interesting modification of the ordered code in case study 3. The significance of this technique has largely been ignored, although it is men- 2b) if the current quadtree node is a leaf, write its colour. See figure 3. Such a code fully retains the structural information needed to reconstruct the original tree.

tioned by Williams5. The traversal order is unchanged, but the actions are modified:

2a) if the current quadtree node is not a leaf, write a configuration code plus associated colours for its four children;

2b) if the current node is a leaf, do nothing.

The configuration code maps the children exactly, identify-

Figure 5. The colour mapped ordered code


ing which ones are internal nodes and the colours of those which are not: see figure 4. If the same colour is shared by two or more children its value needs to be stored only once, thus producing a space saving: see figure 5. Woodwark4

quotes 65% of the space requirement of Oliver and Wiseman’s3 tree code for a small set of sample colour images.

3. Classification of Quad Codes

We now look at those features of quad encoding techniques which are suitable parameters for classification.

Quad codes are built from nodes, corresponding to quadrants in the picture. A quadrant of uniform colour is said to be coherent and is represented by a leaf node; otherwise it is an internal node which may or may not be coloured.

Thus, there are three basic features of a node:

its location (which encapsulates both position and size);

its type (leaf or internal);

its colour.

These three are promising parameters for a classification. It turns out that location offers the greatest variety of methods and hence it is our primary classifier. The first three case studies illustrate the three main location techniques: pointers, locators and ordering.

The type information can also be held in a number of different ways. For example, we may store a type flag with each node. However, we may decide to improve efficiency by combination of the type with another piece of information, or by separation into an auxiliary list. Type is our secondary classification parameter.

Colour is generally stored directly, sometimes at every node, sometimes at leaves only. It may be combined with other fields, held implicitly, or mapped to effect further compression.

We study each parameter in turn in the following sub- sections. Table 1 summarises the classification; readers may find it useful to refer back to it from time to time.

3.1. Location Method 1: Pointer Codes

Strictly, a pointer is a true memory address. There are also offsets, which give the address relative to some defined point, typically the beginning of the quad code. In general the two work in a very similar fashion and we use the term pointer for both.

We identify two types of pointer: nodal pointers stored within a node; and access pointers stored in some auxiliary data structure. The most common form of nodal pointer is the child pointer, which points to a child of the node. Four such pointers can be used to indicate the four

Table 1: Features used to Classify Quad Encoding Tech- niques

children of each node, as in the Regular quadtree (case study I). We refer to any such structure which contains pointers to the children as a quadtree.

Alternatively, since every parent by definition has exactly four children, the four children may be grouped together with a single brood pointer indicating all four, producing a sibling quadtree. A sibling quadtree contains only 25% of the nodal pointers in a corresponding Regular quadtree: see figure 6.

Another form of nodal pointer is the parent pointer. This has been suggested as an aid to algorithms which need


Figure 6 . The sibling quadtree

to move from one node to another ‘nearby’ (i.e. sharing a close common ancestor). Rather than retracing the whole route from the root of the tree, we may climb up to the common ancestor, then descend. In such situations we have found it far better to maintain an ancestor stack, which contains access pointers to all the ancestors of the current node. The parent is the last element on the stack. This avoids the substantial overhead of one pointer per node inflicted by using parent pointers.

Another form of nodal pointer which has been suggested is the sibling pointer, which allows the next sibling of the current node to be accessed. It is far better to use sibling ordering than this technique with its additional pointer burden. However, a useful variant is the cousin pointer, which points to the next set of four siblings in a sibling code. Cousin pointers allow breadth-first navigation through codes which might otherwise be confined to depth-first navigation, with a fairly low overhead of one pointer per four nodes.

Access pointers exist outside the quad code, but point into it; they are used to access a subset of quadrants quickly. There is little point in using access pointers where similar nodal pointers exist, but they are useful with other forms of quad code, for they increase access flexibility; that is, the ability to reach a given quad quickly. Access flexibility is a great weakness of quad codes which do not have nodal pointers.

3.2. Location Method 2: Locator Codes

In pointer codes the location of nodes is implicit in the

structure. An alternative location method is to record the location explicitly as nodal information. Such a code has certain advantages. It may become disordered without los- ing its meaning. If it is ordered then random access searches such as binary chop may be used to locate particular nodes: this is often faster than an ordered search.

Many schemes can be used to identify a node. All combine the quad’s position and size in some fashion. The simplest method is to list explicitly the coordinates and size of the corresponding quadrant: a coordinate/size locator. The size may be any appropriate measure: the quad area, length of side, depth, or order. Order is usually chosen as it is most generally useful and compact.

Gargantini’s2 scheme has already been described in case study 3. A modified quaternary number is stored with an extra digit (‘X’) as a postfix in place of irrelevant digits, thus combining the coordinate and size information into a single composite value. Such a value is essentially a (restricted) base 5 number. Recognising this fact explicitly, we use the digit 4 in place of ‘ X ’ , and refer to this technique as a 4-postfix locator.

A simple variation on the 4-postfix scheme, suggested by Samet6, is to store the number as an ordinary base 10 integer. For example, the value

We can just store the integer value 14. Values for each digit can be extracted using repeated division by 5 and remainder by 5 operations. We call this a 5-integer locator.

Abel7 defines another variant on the 4-postfix locator by using the digit value 0 as a postfix in irrelevant digits of


Table 2: Various Types of Locator

molecular locators, labelling the four possible quadratic divisions from 1 to 4 rather than from 0 to 3. In our nam- ing scheme this is a 0-postfix locator. Thus, a 0-postfix locator is produced from 4-postfix by a simple cyclic per- mutation; 0 goes to 1, 1 to 2, 2 to 3, 3 to 4, and 4 to 0. For example, 4-postfix 214 is equivalent to 0-postfix 320. 0- postfix has the feature that, if ordered numerically, a list of such codes is in the same order as a depth-first in-order traversal of the corresponding quadtree. In contrast, 4- postfix naturally follows a post-order traversal. Abel7 claims that it is easier to construct algorithms for tasks such as picture merging with an in-order traversal.

An alternative to the coordinate/size scheme uses a simple quaternary number and a separate size value8: a quaternary/size locator.

In a recent paper9 we discussed two further methods which are highly compact. Note that molecular quadrants can be uniquely labelled by their centre points, and therefore by the pixel touching the centre point which is nearest to the origin. If we use a single bit flag to distinguish atomic nodes from molecular ones, a quaternary code can then be used either to locate the node itself (for atomic nodes), or to locate the pixel south-west of centre (for molecular nodes). Adding a single bit-flag to distinguish these two cases forms a quaternary/atomic flag locator.

A slightly more practical scheme is the 3-postfix locator. The bit-flag in the scheme above is replaced with an extra quaternary digit which is added to the end of the locator; this is a 0 for an atomic quad, a 3 for a molecular quad.

More methods can be devised by observing that there is a very simple mapping between standard Cartesian and quaternary coordinates: the quaternary value is simply a bitwise interlace of the x and y coordinate values10. It is often more convenient to store the position in Cartesian form, performing any quaternary operations by bitwise operations on x and y11. This gives us two more forms of locator: the coordinate/atom-flag locator, and the 1 -postfix locator. The latter is analogous to the 3-postfix locator; it is called a 1-postfix locator because the postfix is now a binary 1 in each coordinate rather than a 3 in the quaternary value. A Cartesian version of 4-postfix, 5-integer or 0- postfix is not possible, because these methods do not use a

true quaternary number and so cannot be conveniently mapped to a coordinate value. Table 2 summarises the various locator types.

3.3. Location Method 3: Ordered Codes

Nodes may be located by ordering alone, without pointers or explicit locators (case studies 3 and 4). Such quad codes are often referred to in the literature as traversal codes or tree codes because early papers concentrated on producing such structures by traversing a quadtree. However, they may also be constructed directly from a picture and displayed or otherwise manipulated, without using a tree even as a temporary structure. We will refer to them simply as ordered quad codes. The ordering used is selected to suit the intended application. In depth-first ordering each internal node is followed by the code for each of its children in turn, equivalent to an in-order traversal. All nodes referring to a given quadrant are thus stored contiguously. Depth-first encoding is the most favoured method because the simplest algorithms available use an in-order traversal. In breadth-first encoding nodes are stored level by level. This is particularly useful for progressive transmission11

but the algorithms are slightly more difficult and access pointers need to be added in an auxiliary structure (as a minimum, there must be access pointers to the beginning of each level). Scan-line order is useful when quad codes are to be decoded directly onto a hardware quad-display. Quads are stored in the order that they meet a scanning point, and are used to refresh a line buffer (Milford12, Willis and Milford13). Scan-line order codes are also useful as an intermediate form in conversion algorithms to or from raster pictures.

Sibling order is a useful variant of depth-first. An internal node always has exactly four children: we may therefore group the four together and the positions of each are predictable. This variant only applies to depth-first codes because in a breadth-first code siblings are gathered together anyway, whereas in a scan-line order code they cannot be.

3.4. Combined Location Methods

Often a combination of location techniques is useful. There are two reasons to combine techniques: either because the


techniques allow access in different orders, thus together improving traversal flexibility (overloaded locators); or because either technique alone does not uniquely locate nodes (dual locators).

Ordered locator codes are one example of overloaded location already mentioned (case study 2): rapid search operations such as binary-split may be used to find a required quad, because nodes are both stamped by position and stored in a known order.

Williams’ “Goblin quadtree”5 is another excellent example. In our terminology it is a sibling order code with cousin pointers. The sibling ordering allows sequential depth-first traversal, while the cousin pointers allow breadth-first access. This structure is almost as easy to traverse as a conventional sibling quadtree, but has only a quarter as many pointers.

A sample dual locator code is a form of ordered leaf code. Normally, an ordered code must include internal nodes even if no colour is stored at them, because otherwise the ordering is not fully determined. However, it is possible to omit internal nodes providing that a partial form of locator is included at each (leaf) node. This is the size of the quad. Although neither ordering nor quad size alone are sufficient to locate a node uniquely in an ordered leaf code, together they do.

We now turn to classification by node type, the second of our three major classifiers.

3.5. Type Method 1: Typeless (Leaf Codes)

There are two fundamental node types: internal and leaf. A leaf code is one where internal nodes are omitted. Since all nodes are leaves in such a code a type field is not required.

Ordered and pointer codes require internal nodes to locate leaf nodes but locator codes do not; it is considered one of their advantages. Locator codes are normally also leaf codes (see case study 2).

3.6. Type Method 2: Explicit Nodal Type Field

If each node has a type field then a basic scheme needs 1 bit per node. In practice the type is rarely represented by a bitwise flag since a spare bit is rarely readily available at each node. However, a sibling quadtree can use explicit flags conveniently as four flags can be gathered together into the top half of one byte. If the picture is binary, the other four bits can hold colour; in a colour picture they can be used for a mapping code. Neither of these structures is quite as simple as the conventional sibling quadtree, but the space saving is very large as 75% less pointers are required.

3.7. Type Method 3: Combined Typing

It is possible to combine the type information with another nodal field, by using a redundant or reserved value. Most ordered or pointer codes in the literature employ such a device.

3.7.1. Type Combined with Locator

The Regular quadtree (case study 1) and many other quadtrees use NULL pointers to signal leaves. This combines the type with the locator information. Although popular, this method is extremely wasteful: 75% of nodes are leaves and so 75% of pointers are employed merely to denote node type, which theoretically requires only a single bit per node.

3.7.2. Type Combined with Colour

We may assign a reserved colour to indicate internal nodes, as in case study 2. Here it is the internal nodes which are marked by a special value, in contrast to the previous case. Only 25% of the nodes are internal, so there are fewer nodes containing the reserved value. Colour values typically require fewer bits than pointers, so combination with colour tends to be more efficient than combination with pointers. Even so it requires more storage than simple bit flags unless the colour occupies 4 bits or less. For example, with an eight bit colour range this method requires an average of 2 bits/node (25% of all 8 bit colour values are actually node-type flags). It also limits the colour range, which is inconvenient in some applications and totally unacceptable in others.

3.8. Type Method 4: Independent Type Information

One way around the awkwardness of single bit nodal type flags is to store them in a separate, parallel list. This is particularly effective in ordered or offset codes. A simple implementation requires one bit per node, the same as for nodal type flags.

The scheme can be further improved in an ordered code. Atomic quads are always leaves. It is therefore unnecessary to store flags for atomic quads if the type and node lists are read in parallel - as they are in an ordered code. The proportion of nodes which are atomic may vary between 0% and 75%, so the saving varies from picture to picture. In the authors’ field of research, using fairly detailed pictures, the mean proportion of leaves was slightly above 55% and the overhead for type flags was reduced accordingly.

The authors believe this scheme to be the most compact quad encoding scheme available, with the possible exception of the colour-mapped ordered variants.

We now turn to the third of our three classifiers, colour.

3.9. Colour Method 1: Leaf Codes and Structured Leaf Codes

To fully define a quad encoded picture it is not necessary to store colour values at internal nodes (although we stress that it i s often useful and therefore widely practised). Further compression may be effected by omitting this


information from quad codes. We mentioned leaf codes in section 3.5. Internal nodes are entirely omitted, which has the welcome effect of removing internal node colours and all node type flags.

Internal nodes cannot be entirely removed from most quadtree or ordered structures because they are used to locate the leaf nodes.

In a structured leaf code both internal and leaf nodes are in fact stored, but colour information is held only at leaves. Case studies 3 and 4 are both structured leaf codes.

3.10. Colour Method 2: Implicit Colour (Background Omission)

In locator codes, a particular colour may be defined as the background colour and omitted from the quad code (as in case study 2). Areas of the picture not covered in the code are then background by implication. This is not possible with ordered or quadtree codes because background nodes must be listed in order to locate other nodes. This is particularly useful in a binary picture, where about 50% of the nodes are thus removed and no colour value need be recorded for the remaining nodes: they all are the samecolour. Background-omitted quad codes are less useful in a full colour picture where there is not, in general, a standard background colour which can be guaranteed to predominate and a colour field would still be necessary.

3.11. Colour Method 3: Sibling Mapping

If a sibling technique is being used (that is, one where each

Figure 7 . Simple colour mapping configuration codes

brood of four siblings is stored together) it is possible to recode the set of four colours into a potentially more compact form. This consists of a configuration code which gives a map of the layout of the four colours, together with however many colours are actually used. The reasoning is

Figure 8. Simple colour mapped code


that a set of four siblings are unlikely to have four entirely different colours (since quad encoding is typically used only for fairly coherent pictures) and so less colours need to be listed.

Case study 4 showed Woodwark's approach in the case of a sibling order code4, where a colour mapping code is combined with the node-type information to produce a single configuration code requiring six bits of storage. With this technique, internal nodes are not assigned a colour.

It is easy to define a set of sibling configuration codes which simply gives the mapping of the four sibling colours, irrespective of type. There are fifteen such codes, plus one special value to indicate that the four siblings are identi- cally coloured leaves: a degenerate case which occurs at the root when the picture is simply a solid block of one colour. The total of sixteen codes is represented exactly in four bits, which may be stored in half a byte. See figure 7 . The other four bits can be used for the type flags for the four siblings. See figure 8.

This new technique is more general than Woodwark's4 combined node-type/colour-mapping code because it allows internal nodes to be assigned a colour. Of course, Woodwark's technique theoretically requires only six bits, as opposed to eight for the more general method, but in practice his codes will typically be stored in one byte, with the excess two bits being lost. The new technique can still be used when internal nodes do not have colours assigned, in which case the internal node siblings are ignored in selecting or interpreting configuration codes. The new codes are also somewhat easier to interpret. Highly compact quadtree structures can be formed by this technique, listing only as many colours and brood pointers after the configuration/type byte as are needed. If offsets are used rather than true pointers such quadtrees are more compact than locator codes.

4. Other Issues

There are a few other features not directly related to the three classification parameters which we have nevertheless found useful to include in our scheme. We give a brief summary here.

4.1. Incomplete Codes

A quad code naturally represents an area of pixels, where n is the depth of the code. However, although dimensions are common in computer graphics (many display devices have such dimensions), not all pictures have them: in our own experimental data set, very few indeed. This fundamental restriction is often glossed over in the literature.

We define an incomplete quad code to be one representing a picture which is not This is easily

achieved by considering the picture to be embedded at the origin of a molecular quadrant just big enough to contain it.

In ordered and locator codes we may simply omit nodes which lie outside the picture area; in pointer codes these values are left as undefined. Molecular nodes which span the boundary of the picture are understood to be clipped to it.

Incomplete codes add a certain amount of complexity to traversal algorithms, but not an unacceptable amount; such algorithms are vital for sophisticated applications.

An alternative method of dealing with inconveniently sized pictures is to use differential scaling of the quad code. The power-of-two quad code square is scaled onto the rec- tangular picture area. The algorithms for differential scaling are somewhat more complex than those for embedded pictures.

4.2. Degenerate Codes

A degenerate code is one which contains a node or nodes disobeying the normal rules of quad coherency. The quad coherency rules may be stated as:

1) no internal node may correspond to a quadrant which is coherent in colour;

2) no four sibling leaves may share the same colour.

Normally, degenerate codes only occur during the alteration or building of quad codes. The removal of coherent siblings and their replacement with a leaf parent is called merging. The code in case study 2 may be degenerate.

4.3. Overlapped Codes

An overlapped code is one which disobeys the normal quad exclusivity rule. The quad exclusivity rule may be stated as:

1 ) no two leaves may correspond to overlapping quadrants.

This normally occurs only during the alteration or overlay- ing of locator leaf codes, as in case study 2.

4.4. Maximal Codes

A maximal quad code is one where every leaf node is atomic. Maximal quad codes are of interest because:

1) they are the worst case, from the point of view of compression;

2) they are predictable in size.

5. Classification of Published Techniques

Many quad encoding techniques can be categorised using the above features. To demonstrate this we have applied the classification to a number of published methods. A formal definition and a brief definition is given for each.


Some cannot be conveniently or fully described and their departure from the classification is analysed.

We use the various authors’ own terminology in the section titles, rather than our own, to aid readers in finding a favoured method.

5.1. Regular Quadtrees (Case Study 1) Hunter and Steiglitz 1; Samet6; Grosky and Jain 14 .

Location: Child pointer. Type: NULL pointer at leaf. Colour: Nodal; either binary or colour,

A binary regular quadtree, or a colour regular quadtree; NULL pointer internal node mark.

NOTES: Often used as a standard of comparison by later researchers.

5.2. Virtual Quadtrees Jones and Iyengar 1 5 .

Location: Brood pointer, cousin pointer, father pointer. Type: NULL pointer at leaf. Colour: Nodal, colour.

Binary sibling quadtree with parent pointers and cousin pointers.

NOTES: The cousin pointers are essentially unnecessary since they can be found rapidly by using the parent pointer. Of course, the parent pointer can itself be replaced by an ancestor stack.

5.3. Autumnal Quadtrees Fabbrini and Montani 16.

Location: Brood pointer. Type: NULL pointer at leaf. Colour: Binary, combined with pointer.

Binary sibling quadtree with colour/pointer combination.

NOTES: Pointer range is restricted by using the top bit of the pointer word to represent binary colour, as well using NULL to indicate leaves. This is a combination of colour, type and pointer into one value. The combination of colour and pointer can be extended to multi-bit colours, providing the code can be guaranteed to remain in the bounds of the pointer range remaining (or a smaller offset can be used).

5.4. The 1-4 Structure Stewart 17.

Pointer code. Escapes classification.

NOTES: Nodes in the code are sets of sixteen cousins, with four pointers to the possible offspring. There are problems with leaves appearing amongst the cousins; it is necessary to use both NULL pointers and reserved colour values to represent leaves. Also, parts of the cousin-block may be redundant: this can be avoided only by including extra information on the number of cousins.

In essence, the technique is an extension of sibling coding to effect a further four-fold reduction in pointers; however, unlike sibling coding, it adds extra complexity in comparison to the Regular quadtree.

5.5. Treecode (1) (Case Study 3) Oliver, King and Wiseman 18 .

Location: Depth-first order. Type: Reserved colour for internal-node mark. Colour: Structured leaf code.

Colour depth-first structured leaf code; reserved value for internal node mark.

NOTES: They demonstrate how to construct a sextree in order easily to traverse in scan-line order without ordering the code in that way.

5.6. Treecode (2) Oliver, King and Wiseman3.

Location: Depth-first order. Type: Explicit flag. Colour: nodal, colour.

Colour depth-first code; explicit type.

NOTES: This paper considers the case where the colour range is four bits, which leaves some spare bits for use as type flags.

5.7. DF Expressions Kawaguchi and Endo 19.

Location: Depth-first order. Type: Reserved colour internal node mark. Colour: Binary, structured leaf code.

Binary depth-first structured leaf code with reserved node- type value.

NOTES: Using a reserved value for node-type requires two bits/node, which can be bettered by separating node-type and colour lists and omitting atomic level node-type flags. However, with three symbols an attempt at entropy coding is possible, if one colour predominates sufficiently. Also of interest because they describe the technique via a genera- tive Grammar.

/

Location: Breadth-first order + access pointers to given level. Type: Separate type list; atomic flag omission. Colour: Colour, nodal.

Colour breath-first code with separate type list and access pyramid.

NOTES: highly compact and reasonably flexible. The Access Pyramid provides pointers down to a depth chosen

5.8. Breadth-first Ordered Code Hunter and Willis 11


so that the overhead is less than 5%. This is sufficient to provide an adequate zoom facility.

5.9. Goblin Quadtree Williams 5.

Location: Sibling order + cousin pointers. Type: Combined with sign bit of colour. Colour: Colour, nodal.

Depth-first sibling traversal code with cousin pointers.

NOTES: He points out that sibling colour mapping can be used to further improve this highly efficient and flexible structure.

5.10. Explicit Quadtree Woodwark20.

Location: Depth-first order, special. Type: Implicit, special. Colour: Nodal. Special: Maximal degenerate code.

A depth-first maximal degenerate code.

NOTES: All pixels are represented as atomic leaves, irrespective of picture coherency. This makes the structure very large, but the size is fully determinate. The type and position of a quad can be determined without traversing the code, so random access is possible.

5.11. Display Ordered Quadtree Milford, 12 Willis and Milford13.

Location: Scan-line order + access pointers. Type: Reserved colour internal node mark. Colour: Nodal, colour. Special: Degenerate. A scan-line ordered degenerate code with access pointers,

NOTES: The code is degenerate in the sense that quads above a certain size (128x128; are not allowed (i.e. the picture is tiled, each tile being a quad code with an access pointer to find it). Codes for the upper levels are then omitted. This approach allows a zoom facility to be implemented, the zoom area being constrained to the tiling boundaries. Coupled with scan-line ordering, this allows a near-instant hardware zoom, where the display is refreshed directly from the quad code.

Both leaf and internal nodes are coloured to permit true detail-revealing zoom and to give anti-aliased over- view images. The authors point out that internal colours need not relate directly to leaf colours, allowing different symbology in different layers of the tree.

5.12. Compressed Quadtrees (Case Study 4) Woodwark4.

Location: Sibling order Type: Configuration code.

Colour: Structured leaf code; remapped by configuration code.

Depth-first colour mapped structured leaf code.

5.13. Linear Quadtrees (Case Study 2) Gargantini2.

Location: 4-postfix locator [ + ordering ] Type: Leaf code. Colour: Binary leaf code; background-omitted. Special: May be degenerate, overlapped.

A binary 4-postfix locator background-omitted code.

NOTES: offers algorithms and operations on both ordered and disordered codes.

5.14. In-order Linear Quadtree Abel7.

Location: 0-postfix locator [ + ordering ]. Type: Leaf code. Colour: Binary leaf code; background-omitted. Special: May be degenerate, overlapped.

A binary 0-postfix locator background-omitted code.

5.15. Modified Linear Quadtree Davis and Wang 8 . Location: Quaternary/size locator [ + ordering ] Type: Leaf code. Colour: Binary leaf code; background-omitted. Special: May be degenerate, overlapped.

Binary quaternary/size locator background-omitted code.

5.16. Leaf Code Oliver and Wiseman 10. Location: Depth-first order, quaternary/size locator. Type: Leaf code. Colour: Binary, nodal.

Ordered quaternary/size locator code.

NOTES: they also mention background omission and claim good compression for sparse line drawings on a uniform background. They quote a 15% overhead compared with their tree code for such pictures.

5.17. P-compressed Quadtrees Anedda and Felican21.

Location: quaternary locator (special). Type: Leaf code. Colour: Binary, background omission. Special: Maximal degenerate.

Maximal degenerate binary locator code, background- omitted; special locators.

NOTES: the code is degenerate in that all atomic foreground nodes are stored as leaves, even when they could be


merged into molecular ones. The locators are essentially quaternary numbers, each split into a prefix and postfix value, the position of the prefix/postfix split being chosen to maximise efficiency. A given prefix is then stored together with a count of the number of codes having that prefix, followed by the postfixes. They claim good results for documents having sparse foreground patterns, such as text. A primitive form of progressive transmission is possible with such a structure.

5.18. Forests of Quadtrees (1) Raman and Iyengar22.

Location: Quaternary/size locators + depth-first order. Type: Leaf Code. Colour: Background omitted, special. Special: Special nodal child pointer to secondary structure:

Location: Child-pointer. Type: NULL pointer at leaf. Colour: Nodal, binary.

Binary depth-first quaternary/size locator “leaf‘ ’ code, background-omitted. The “leaves” of the ordered list contain pointers to binary regular quadtrees rather than colours.

NOTES: the forest is constructed by locating dense subtrees (i.e. subtrees with many foreground leaves: they give an appropriate metric), the idea being to save space by background-omission, whilst retaining some features of a normal quadtree.

5.19. Forests of Quadtrees (2) Samet23.

Classification as above, but first Location is:

Location: 5-integer locators + breadth-first order.

Binary breadth-first 5-integer locator “leaf” code, background-omitted. The “leaves” of the ordered list contain pointers to binary regular quadtrees rather than colours.

NOTES: similar to Raman and Iyengar’s technique, except for the breadth-first ordering and 5-integer locators. The combination of these two allows a form of progressive transmission.

6. Comparison of Techniques

Which of the many features studied in the classification are desirable? The proponents of the various types of quad codes base their claims to attention primarily on two factors: 1 ) Compression ;

2) We shall study the relative coding efficiencies of the various techniques in some detail, since this is a relatively certain enterprise. The suitability of a form of quad encoding for an application depends very much on what algorithms are required. We do not claim sufficient knowledge of

Flexibility of traversal and manipulation.

quad encoding applications outside our own area to com- ment with absolute certainty on the relative merits of techniques for other applications. However, we have taken the liberty of listing briefly, without detailed justification, our own impression of such merits. Other authors will no doubt take issue with us on some of these points.

6.1. Compression Efficiency

To compare the compression performance of various quad encoding techniques we must first define a suitable metric. The metric must, as far as is possible, be independent of any particular picture which might be encoded. We actually find it more sensible to devise two metrics. This is because some forms of quad encoding include colours at internal nodes while others do not. Those without internal node colour information - leaf codes and structured leaf codes - are more space-efficient, but are not suitable for some applications which actually require internal node colours (e.g. progressive transmission). Also, locator codes may improve efficiency by omitting background coloured quads, such quads being known by implication only. The efficiency measure must take account of this. In order to produce a valid comparison of all techniques, efficiency is described in bits/leaf for codes where internal node colours are not required: leaf codes and structured leaf codes. The value quoted includes all leaves even where some are actually omitted, as in background-omitted codes. For structured leaf codes, the overhead caused by storing structural information at internal nodes is included in the bits/leaf efficiency measure, thus allowing direct comparison with leaf codes. For codes where internal node colours are required, efficiency is described in bitsinode. Again, account i s taken of background omission. Initially, we assume that bit-fields of arbitrary width are available.

We first determine the size of the overhead of each technique; that is, the cost per node not including the cost of encoding the colour.

Pointers. An absolute pointer is typically a four-byte (32 bit) value. The most basic form of pointer code is the regular quadtree, which has four pointers per node; NULL pointers are used to indicate leaf nodes. This has a 128 bits/node overhead, which is highly inefficient. However, this scheme may be significantly improved upon. The most efficient simple type of quadtree is a sibling quadtree with pointers for internal nodes only; types are flagged separately. This has an overhead of only one pointer per internal node plus one type-flag per node. Since only 25% of nodes are internals, this is 9 bits/node overhead.

Offsets. If offsets are used rather than true pointers there may be a worthwhile saving. Since the maximal quad code of depth n has less than nodes, using a sibling ordering which gathers nodes into groups of four there are at most sibling blocks in the code. Assuming that the code is stored contiguously, the offsets therefore need only


2n-1 bits, giving an efficiency value of bits/node (typically n<12; that is, picture dimen-

sions are less than 2048x2048).

Ordered codes. An ordered code has a 1 bit/node overhead, using separate node-type flags.

Locators. A node locator requires at least 2n+1 bits, as we showed in a recent paper9. 2n+2 is a more sensible value; 2n+4 and 3n are the values commonly used. How- ever, we will assume the lowest value. If every node has a locator there is a 2n+1 bits/node overhead. However, using locators allows us to omit background quads: in binary pictures we may assume that these represent approximately 50% of the picture, which gives a n + 0.5 bits/node overhead in the binary case. In general, background omission is of little benefit in colour pictures; we assume it is not used.

If internal node colours are required, and the colour range is c bits, then the bits/node costs are as follows:

pointer: 9 + c bits/node.

offset: 0.5n + 1.25 + c bits/node.

traversal: 1 + c bits/node.

locator (binary): n + 0.5 bits/node;

locator (colour): 2n + 1 + c bits/node.

If internal node colours are not required, the bitsfleaf cost of locator codes is easy to calculate as only leaves are stored. However, the pointer, offset and ordered equivalents are structured leaf codes: they contain structural information for internal nodes in addition to leaves. To work out the overhead per leaf for structured leaf codes, we multiply the overhead per node by 1.33 (4+3), since 0.75 (3-4) of nodes are leaves. The best efficiency values for codes without internals node colours are therefore:

If atomic level type flags are omitted the efficiency of pointer, offset and ordered codes can be increased. The improvement is variable: between 0 and 0.75 bits/nodes reduction in the overhead: a typical reduction is 0.45 bits/node (see section 7.3). In the structured leaf codes, this corresponds to a reduction in cost of between 0 and 1 bitsfleaf, with a typical value being 0.6 bitsfleaf. This saving is particularly significant for binary picture traversal codes, where it represents an average reduction of approximately 25% in the total code size. For larger colour ranges the reduction is smaller but still significant: in the 8 bit case the average saving is approximately 5.5%. We have also declined to mention the effects of colour mapping which can be carried over equally to pointer, offset and ordered codes; Woodwark’s4 results suggest a 35% reduction in the

pointer: 12 + c bitsfleaf.

offset: 0.66n + 1.65 + c bitsfleaf.

traversal: 1.33 + c bitsfleaf.

locator (binary): n + 0.5 bitsfleaf;

locator (colour): 2n + 1 + c bitsfleaf.

Table 3: Optimal Compression Rates for Various Types of Quad Code

space used for colour values is possible. Colour mapping of locator codes does not seem to be of practical value, since the imposition of sibling ordering does not mesh with background-omission and disordered codes. The figures given above are theoretical lower bounds, which can be achieved only if values may be stored as any appropriate number of bits. In reality, values will normally be constrained to byte boundaries. Table 3 gives the costs for the best variants of the various types with four colour ranges: 1 bit, 4 bit, 8 bit and 24 bit. These are the ranges most commonly used in computer graphics. The formats used are described below.

Pointers and offsets. A sibling quadtree. Each block of siblings consists o f one byte containing the four type flags; pointers or offsets for each sibling which is an internal node; colours of each node (or each leaf only, if a structured leaf code). There are four bits unused in the type flag byte; these are used to hold the colour values in binary pictures.


Ordered code. Node-type flags are stored separately from node colours in a bitwise list. The two lists are read in parallel. In binary pictures, the two lists can optionally be combined into one with node-type flag and colour stored together. Any order is acceptable.

Locator code. Quaternary/atom-flag locators are stored followed by their colours. In binary pictures the background quads are omitted and no colour field is required for listed nodes: they are all foreground by implication.

Clearly, an ordered code offers far superior compression to the other techniques. Interestingly, the much maligned quadtree actually outperforms the popular locator code. However, these figures must be treated with an amount of caution. Further improvements in colour ordered codes and quadtrees can possibly be achieved by using colour mapping. The locator codes may actually per- form better than indicated if background quads account for more than 50% of the total; for example, in sparse line drawings. Also, as the size of the colour field increases the overhead of pointers and locators becomes less critical - the less efficient methods are more easily justified for large colour fields. Colour fields greater than 24 bits are practi- cally unknown.

6.2. Flexibility of Traversal and Manipulation

Quad codes are used in a wide variety of applications. If the only requirement for the quad code is that it is possible to traverse the whole code in the order most natural to it (normally to display it), flexibility is no problem: this can be done with any form. However, if we wish to access only certain parts of the code (for example, only the upper levels, or only a particular quad), or to manipulate it (for example by rotating, shifting, reflecting, inverting, adding new features, or superimposing several pictures) then we must choose our technique with care. The following general observations can be made.

Quadtrees. Quadtrees are very flexible. Random quadrants can be accessed rapidly and directly. If an ancestor stack is maintained, neighbours can be located swiftly. By adding or removing pointers, alterations can be made easily. Geometric transformations are simple; so is picture merging.

Ordered codes. Ordered codes are inflexible. Ran- dom quadrants can be accessed only by first traversing all preceding nodes. Some geometric operations are simple; others not. However, picture merging is simple. Other alterations are difficult. Neighbours can be located only if they appear later in the code; otherwise the code must be re-traversed from the beginning. However, the flexibility of traversal codes can be increased to some extent by maintaining access pointers to certain quadrants, which may then be accessed directly, or by adding cousin pointers.

Locator codes. Locator codes are reasonably flexible. If the code is also ordered, then random quadrants can be accessed quite swiftly by binary split. Geometric transformations and merging are easy. Other alterations are tolerably easy providing that they consist only of adding foreground detail and that it does not matter if the code is disordered and degenerate (the new detail is simply added on the end of the code). Note that this neutralises the ability to locate random quadrants quickly, however. Neighbour finding is tolerably easy (providing the code is ordered) and has been quoted as an advantage of locator techniques. Neighbour finding occurs in two stages: first, determine the quaternary code for the neighbour; second, search back- wards or forwards until the correct node is found (it will generally be 'close to' the starting point). However, deter- mining the quaternary code of a neighbour (the first part of the task in a locator code) is analogous to a tree walk back up to a common ancestor and down to the neighbour; therefore, neighbour finding is always faster in a quadtree with an ancestor stack.

In summary, quadtrees are by far the most flexible form, particularly if an ancestor stack is maintained. Ordered codes are acceptable only if a very low degree of manipulation is intended: then they are far superior because of the very high compression rate offered. Locator codes offer some flexibility, but not at the level offered by quadtrees. The original justification given for using locator codes by Gargantini2 was that they were more compact than quadtrees while maintaining sufficient flexibility to be manipulated easily. However, our research shows that a sibling quadtree with explicit type flags, with colours listed only for leaves and offsets only for internal nodes, offers slightly better compression than a locator code. This leads us to conclude that users of locator codes (concentrated in image-processing applications) might be better advised to use such a quadtree.

7. Concluding Remarks

Classification is a useful process in any field; we have derived significant benefits from the process. We have devised new, highly compact versions of all major types of quad code: the quadtree mentioned in the previous section, the 3-postfix locator, the node-type separated ordered code, and the new colour mapped versions of the ordered and quadtree codes. We have also realised the benefits of maintaining access pointers outside the main quad code: as an ancestor stack to aid algorithmic access of quadtrees, and as an access pyramid" to speed up random access in ordered codes.

We have also discovered that there are limitations to our approach. Several published techniques elude classification by this method; consequently we may have failed to discover many more useful enhancements. We hope that other researchers will find this preliminary


attempt useful in constructing a more complete images,” Ph.D. Thesis, The University of Bath, Eng- classification of quad encoding techniques. land. (1984).

13. Willis, P.J. and Milford, D.J., “Browsing high definition colour pictures,” Computer Graphics Forum 4, pp. 203-208 (1985). References

1 .

2.

3.

4.

5.

6.

7.

8.

9.

10.

1 1 .

12.

Hunter, G.M. and Steiglitz, K., “Operations on images using quad trees,” IEEE Transactions on Pattern Analysis and Machine Intelligence PAMI-

Gargantini, I., “An effective way to represent quadtrees,” Communications of the ACM 25(12),

Oliver, M.A. and Wiseman, N.E., “Operations on quadtree encoded images,” The Computer Journal

Woodwark, J.R., “Compressed quad trees,” The Computer Journal 27(3), pp. 225-229 (1984).

Williams, R., “The Goblin quadtree,” The Computer Journal 31(4), pp. 358-363 (1988).

Samet, H., “An algorithm for ‘converting rasters to quadtrees,” IEEE Transactions on Pattern Analysis and Machine Intelligence PAMI-3( 1), pp. 93-95 (1981).

Abel, D.J., “Some elemental operations on linear quadtrees for geographic information systems,” The Computer Journal 28( 1), pp. 73-77 (1985).

Davis, W.A. and Wang, X., “A new approach to linear quadtrees,” Graphics Interface, pp. 195-202 (1985).

Hunter, A. and Willis, P.J., “A note on the optimal labelling of quadtree nodes,” The Computer Journal

Oliver, M.A. and Wiseman, N.E. , “Operations on quadtree leaves and related image areas,” The Com- puter Journal 26(4), pp. 375-380 (1983).

Hunter, A. and Willis, P.J., “Breadth-first quad encoding for networked picture browsing,” Comput- ers and Graphics 13(4), pp. 419 - 432 (1989).

Milford, D., “The display of quadtree encoded

1(2), pp. 145-153 (1979).

pp. 905-910 (1982).

26(1), pp. 83-91 (1983).

33(5), pp. 398-401 (1990).

14.

15.

16.

17.

18.

19.

20.

21.

22.

23.

Grosky, W. I. and Jain, R., “Optimal Quadtrees for Image Segments,” IEEE Transactions on Pattern Analysis and Machine Intelligence PAMI-5( 1),

Jones, L.P. and Iyengar, S.S., “Space and time efficient virtual quadtrees,” IEEE Transactions on Pattern Analysis and Machine Intelligence PAMI-

Fabbrini, F. and Montani, C., “Autumnal quadtrees,” The Computer Journal 29(5), pp. 472-474 (1986).

Stewart, I.P., “Quadtrees: storage and scan conversion,” The Computer Journal 29(1), pp. 60-75 (1986).

Oliver, M.A., King, T.R. and Wiseman, N.E., “Quadtree scan conversion in Bo, K. and Tucker, H.A. (editors),” Eurographics ’ 8 4 , pp. 267-276 (1985).

Kawaguchi, E. and Endo, T., “On a method of binary-picture representation and its application to data compression,’ ’ IEEE Transactions on Pattern Analysis and Machine Intelligence PAMI-2( 1),

Woodwark, J.R., “The Explicit quadtree as a structure for computer graphics,” The Computer Journal

Anedda, C. and Felican, L., “P-compressed quadtrees for image storing,” The Computer Journal

Raman, V. and Iyengar, S.S., “Properties and applications of forests of quadtrees for pictorial data representation,” BIT 23, pp. 472-486 (1983).

Samet, H., “Data structures for quadtree approxima- tion and compression,’’ Communications of the ACM

pp. 77-83 (1983).

6(2), pp. 244-247 (1984).

pp. 27-35 (1980).

25(2), pp. 235-238 (1982).

31(4), pp. 353-357 (1988).

28(9), pp. 973-993 (1985).

classification of quad-encoding techniques

Documents