Selectively hiding geometry using texture maps

The main problem in post-processing of crash-worthiness simulations is the analysis of tracked data. The aim of visualization applications is to aid the user in understanding the data, for example, by mapping scalar values as colors directly onto the underlying geometry. But for particular tasks the models are too complex to spot all the regions with critical values at once. This means that an application should provide a mechanism to restrict the visualization for the 'interesting' areas.

One way would be the use of clipping planes which can be interactively positioned inside the model. But this mechanism hides the geometry regardless of its corresponding values. We wanted the geometry rendering to depend on the mapped variables. Therefore, we employ 1D α-texture maps and the alpha test to influence the visibility of geometry in correspondence to the mapped parameters. This technique is used in several scenarios:

• Visualization of oscillating parameters
  During crash-worthiness simulation parameters can be tracked which heavily deviate for adjacent elements. For example, only a few elements contain critical values and they are distributed all over the model. The only way to check, where those elements are positioned, is to hide all the geometry pertaining to values inside the tolerance range.
• Comparison of different variants
  Due to the introduction of independently meshed car body parts it is now easier to exchange several parts by variants. The effects of replacement can only be evaluated in detail if it is possible to visualize the comparison, for example, of coordinates or parameter values of corresponding elements. Peaks of deviations are easily detectable by using the presented mapping method.
• Flange visualization
  Another aim of this texture mapping and alpha testing technique is the visualization of potential flanges. Combined with distance visualization the engineer is able to restrict the rendering to that geometry which has a previously specified distance to another surface.

On the left the thinning of a car component during stamping is mapped per element. The buckling rate of a longitudinal structure during rear crash is visualized on a per vertex basis in the right image.

The parameters are tracked for each time step either per vertex or per element. Two examples are shown in the previous images. The engineer specifies a range for the chosen variable and the number of colors that should be used for visualization. The values are read or calculated and then mapped into the range [0.0 , 1.0]. The results are used as texture coordinates into a one-dimensional texture map which represents the color scale. Regarding to memory efficient scene graph design we have to distinguish two cases:

• Vertex based parameters can be visualized by storing the mapped texture coordinates and duplicating them for those vertices which lie on a Gouraud edge like we did for the csCoordSet in our scene graph design. Here, the csIndexSet referring the texture coordinates can be shared with normals and coordinates.
• Element based variables require a separate csIndexSet. Its length is four times the number of elements and it contains quadruples each of four times the same index. In the element based case the csTexCoordSet stores just one value per element.

The advantage of texture mapping for vertex based scalar visualization as opposed to vertex coloring is the rendering of contour lines crossing the elements. If we additionally utilize the alpha channel by applying a four channel texture map to the geometry employing the texture environment GL_DECAL we are able to restrict the parameter visualization to those areas of interesting values. For example, if initial penetrations should be visualized, the colored texture representing the minimal vertex distance to an adjacent car body part is visible only for a small tolerance range. For larger distance values the texture map is totally transparent, α = 0.

These images show parts of the back compartment of a car. The illustration in the middle visualizes the minimum distance from each node to the closest surface of another car body part up to 50mm. On the right the same values are mapped to hide all geometry where this distance is more than 2mm using the texture subsystem and the alpha test. The rendered geometry show potential flanges.

Changing the texture environment to GL_MODULATE combined with the alpha test enabled allows the restriction of geometry rendering. Then the α-component of the texture map influences the appearance of the fragment. Those fragments assigned to an α-value below the alpha test reference value will not be rendered.

In order to modify the restriction we apply an index texture map in combination with a texture color lookup table. The implemented texture color table editor allows for the interactive justification of the transfer function for each channel separately. The scene graph data remains unmodified and the user gets immediate response.