Documentation for vtkAssembly

vtkAssembly - create hierarchies of actors

Super Class: vtkActor

Description:

vtkAssembly is an object that groups actors and other assemblies into a tree-like hierarchy. The actors and assemblies can then be transformed together by transforming just the root assembly of the hierarchy. A vtkAssembly object can be used in place of an vtkActor since it is a subclass of vtkActor. The difference is that vtkAssembly maintains a list of actor instances (its "parts") that form the assembly. Then, any operation that modifies the parent assembly will modify all its parts. Note that this process is recursive: you can create groups consisting of assemblies and/or actors to arbitrary depth. Actor's (or assemblies) that compose an assembly need not be added to a renderer's list of actors, as long as the parent assembly is in the list of actors. This is because they are automatically renderered during the hierarchical traversal process. Since a vtkAssembly object is a derived class of vtkActor, it has properties and possibly a mapper. During the rendering process, if a mapper is associated with the assembly, it is rendered with these properties. Otherwise, the properties have no effect (i.e., on the children of the assembly).

 

Caveats:

Collections of assemblies are slower to render than an equivalent list of actors. This is because to support arbitrary nesting of assemblies, the state of the assemblies (i.e., transformation matrices) must be propagated through the assembly hierarchy. Assemblies can consist of hierarchies of assemblies, where one actor or assembly used in one hierarchy is also used in other hierarchies. However, make that there are no cycles (e.g., parent->child->parent), this will cause program failure.

 

See Also:

vtkActor vtkTransform vtkMapper vtkPolyDataMapper

 

Methods:

void vtkAssembly ()
void vtkAssembly ()
static vtkAssembly *New ()
const char *GetClassName ()
void PrintSelf (unknown & ,vtkIndent )
void AddPart (vtkActor *)
void RemovePart (vtkActor *)
vtkActorCollection *GetParts ()
void Render (vtkRenderer *)
void InitPartTraversal ()
vtkActor *GetNextPart ()
int GetNumberOfParts ()
void BuildPaths (vtkAssemblyPaths * ,vtkActorCollection *)
void ApplyProperties ()
float *GetBounds ()
unsigned long GetMTime ()
void UpdatePaths ()
void DeletePaths ()

 

Detailed Method Descriptions:

Add a part to the list of parts.

void AddPart (vtkActor *)

Remove a part from the list of parts,

void RemovePart (vtkActor *)

Return the parts of this asembly.

vtkActorCollection *GetParts ()

Render this assembly and all its parts. The rendering process is recursive. Note that a mapper need not be defined. If not defined, then no geometry will be drawn for this assembly. This allows you to create "logical" assemblies; that is, assemblies that only serve to group and transform its parts.

void Render (vtkRenderer *)

Methods to traverse the parts of an assembly. Each part (starting from the root) will appear properly transformed and with the correct properties (depending upon the ApplyProperty and ApplyTransform ivars). Note that the part appears as an actor. These methods should be contrasted to those that traverse the list of parts using GetParts(). GetParts() returns a list of children of this assembly, not necessarily with the correct transformation or properties. To use these methods - first invoke InitPartTraversal() followed by repeated calls to GetNextPart(). GetNextPart() returns a NULL pointer when the list is exhausted.

void InitPartTraversal ()
vtkActor *GetNextPart ()
int GetNumberOfParts ()

Build assembly paths from this current assembly. Paths consist of an ordered sequence of actors, with transformations properly concatenated.

void BuildPaths (vtkAssemblyPaths * ,vtkActorCollection *)

Recursively apply properties to parts.

void ApplyProperties ()

Get the bounds for the assembly as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).

float *GetBounds ()

Override default GetMTime method to also consider all of the assembly's parts.

unsigned long GetMTime ()