calculation-of-tight-bounding-volumes-for-cyclic-csg-graphs.pdf

免费下载

1

calculation of tight bounding volumes for cyclic csg-

graphs

*

christoph traxlermichael gervautz

institute of computer graphics

technical university of vienna

karlsplatz 13/186-2

1040 wien

austria

email:traxler@cg.tuwien.ac.atgervautz@cg.tuwien.ac.at

abstract

cyclic csg graphs are a memory safe representation of objects with a very complex, recursive

structure. this class of objects are defined by csg-pl-systems, an adaption of the well known

parametric lindenmayer systems (pl-systems) to the csg concept. they are a powerful tool to

model natural phenomena like plants, clouds or fractal terrain but also linear fractals or any objects

with a repetitive structure. csg-pl-systems are directly translated into csg graphs, which are a

proper object representation for ray tracing. a derivation and geometric interpretation of strings is

no longer necessary. because csg graphs are as compact as the csg-pl-systems the memory

usage is low, so that restrictions of the complexit y of the scene are avoided. to be effici ent as well

it is very important to adapt conventional optimization techniques to csg graphs. for csg trees a

hierarchy of bounding volumes is buildt up by a simple recursive algorithm. a straight forward

transition of this algorithm to csg graphs yields to very huge and thus useless bounding volumes.

in this paper we introduce an algorithm which calculates tight bounding volumes for the nodes of

cyclic csg graphs. this method can also be applied to csg trees with explicit transformation

nodes or csg dags.

key words: csg graphs, bounding volumes, ray tracing

*

this project is supported by the “f ond zur förderung der wissenschaftliche n forschung (fwf)”, austri a,

(project number: p09818)

2

1 introduction

cyclic csg graphs are a memory safe representation of recursive objects, which are defined by

parallel rewriting systems. they are an extention to conventional csg trees and thus can directly be

used for ray tracing. csg graphs emerge from csg-pl-systems, which are an adaption of the well

known parametric lindenmayer-systems (briefly pl-systems). the main difference between pl-

systems, which are fully described in [lind90], and csg-pl-systems are their formal languages.

while the derived strings of the first are command sequences for a virtual construction tool called

turtle, the derived strings of the last are a subset of the infinite set of all valid csg expressions.

instead of running a derivation process and building up a large csg tree out of the resulting string,

the rules of the grammar are directly transformed into a cyclic csg-graph, which is traversed by the

rays to visualize the object.

for that purpose, we extended the csg concept to three new nodes. selection nodes, briefly s-

nodes, join all the rules for one grammar symbol and are associated with a selection function. this

function controls the flow by selecting a proper rule and passing the rays to it. the rules themselves

are translated into csg trees and attached as successors to the s-node. for each occurrence of a

grammar symbol in the right hand side of a rule an edge is spanned to the corresponding s-node.

this yields to a graph with cycles, wherby s-nodes are the only targets of cyclic edges.

like with conventional csg trees, the rays are mapped from the world coordinate frame into the

object coordinate frame, because this is much more efficient than mapping the primitive objects. in

csg graphs this is done by special nodes, called transformation nodes or briefly t-nodes. they can

be seen as unary operators and thus have only one successor. the same is true for calculation

nodes, briefly c-nodes, which evaluate a finite set of arithmetic expressions to modify global

parameters. their values effect flow control, i.e. the selection of rules, and transformations. all

other nodes, i.e. csg operators and primitive objects are handled as in csg trees. the csg graphs

introduced so far are as compact as the describing data set. an explicit representation of the scene

(like with csg trees) is avoided and therefore no restrictions of the complexity of the scene or the

approximation accuracy of objects must be considerated. a related method was introduced in

[kaji83] for the ray tracing of fractal terrains and in [hart91] for the ray tracing of objects

defined by iterated function systems (ifs). fig.1.1a shows a csg-pl-system, that generates a

simple sympodial branching structure and fig.1.1b the corresponding csg graph. a full description

of this approach we gave in [gerv95].

initialization of the parameters

{cnt = 8;// order of the branching structure

trunk = 2,// number of t runk segments (cycl es of rule with index 2)

ftr = 0.96;// scaling factor for trunk segments

gamma = -72.0;// divergence angle

alpha1= -60.0;// branching angles

alpha2 = 20.0;

fbr1 = 0.73;// scaling factors for left and right branches

fbr2 = 0.67;

noleaves = 3;// if cnt is less than noleaves the limbs bear leaves

segments = 2;// number of segments for a limb with leaves

fxsg = 1/7;// scaling factors for segment cylinders

fysg = 1/7;

dsg = 1/segments;// height of a segment cylinder

flv = 0.6;// scaling factor for leaves

} tr// the start node

of 10

免费下载

【米乐app官网下载的版权声明】本文为墨天轮用户原创内容，转载时必须标注文档的来源（墨天轮），文档链接，文档作者等基本信息，否则作者和墨天轮有权追究责任。如果您发现墨天轮中有涉嫌抄袭或者侵权的内容，欢迎发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

下载排行榜

## 评论